3502 lines
120 KiB
JavaScript
3502 lines
120 KiB
JavaScript
import axios from 'axios';
|
|
import { createStore } from 'vuex';
|
|
import {
|
|
ADMIN_ADD_ORDER_NOTES_API,
|
|
ADMIN_ADMIN_SAVE_API,
|
|
ADMIN_BOOK_APPOINTMENT_API,
|
|
ADMIN_DELETE_ROLES_BY_ID_API,
|
|
ADMIN_DELETE_SINGLE_NOTE_API,
|
|
ADMIN_DELETE_SUBCRIPTION_API,
|
|
ADMIN_EDIT_ORDER_API,
|
|
ADMIN_GET_ANALYTICS_ORDERS_API,
|
|
ADMIN_GET_ANALYTICS_OVERVIEW_API,
|
|
ADMIN_GET_ANALYTICS_OVERVIEW_ORDER_API,
|
|
ADMIN_GET_AVAILABLE_SLOTS_API,
|
|
ADMIN_GET_ITEM_BY_ORDER_API,
|
|
ADMIN_GET_ORDERS_FILTERS_API,
|
|
ADMIN_GET_ORDER_API,
|
|
ADMIN_GET_ORDER_COUNT,
|
|
ADMIN_GET_ORDER_DETAIL_API,
|
|
ADMIN_GET_ORDER_LABKIT_API,
|
|
ADMIN_GET_PATIENTS_INITIAL_API,
|
|
ADMIN_GET_PATIENTS_SEARCH_API,
|
|
ADMIN_GET_PERMISSION_ROLE_API,
|
|
ADMIN_GET_PRODUCTS_ANALYTICS_API,
|
|
ADMIN_GET_PRODUCTS_LIST_API,
|
|
ADMIN_GET_ROLES_API,
|
|
ADMIN_GET_ROLES_BY_ID_API,
|
|
ADMIN_GET_ROLES_SAVE_API,
|
|
ADMIN_GET_SINGLE_NOTE_API,
|
|
ADMIN_GET_SITE_SETTING,
|
|
ADMIN_GET_SUBCRIPTION_API,
|
|
ADMIN_ITEM_STATUS_UPDATE_ORDERS_API,
|
|
ADMIN_LAB_KIT_ADD_API,
|
|
ADMIN_LAB_KIT_DELETE_API,
|
|
ADMIN_LAB_KIT_LIST_API,
|
|
ADMIN_LAB_KIT_UPDATE_API,
|
|
ADMIN_LOGIN_DETAIL,
|
|
ADMIN_ORDER_DELETE_PERCRPTION_API,
|
|
ADMIN_ORDER_DETAIL_DELETE_PERCRPTION_API,
|
|
ADMIN_ORDER_DETAIL_SAVE_PERCRPTION_API,
|
|
ADMIN_ORDER_DETAIL_SINGLE_PERCRPTION_API,
|
|
ADMIN_ORDER_DETAIL_UPDATE_PERCRPTION_API,
|
|
ADMIN_ORDER_GET_ID_PERCRPTION_API,
|
|
ADMIN_ORDER_GET_PERCRPTION_API,
|
|
ADMIN_ORDER_PAYMENT_DETAILS_API,
|
|
ADMIN_ORDER_SAVE_PERCRPTION_API,
|
|
ADMIN_ORDER_UPDATE_PERCRPTION_API,
|
|
ADMIN_PATIENT_DETAIL_API,
|
|
ADMIN_PATIENT_PROFILE_API,
|
|
ADMIN_PROCESS_PAYMENT_API,
|
|
ADMIN_PROVIDER_DETAIL_API,
|
|
ADMIN_PROVIDER_REPORT_API,
|
|
ADMIN_PROVIDER_REPORT_POST_API,
|
|
ADMIN_ROLES_LIST_API,
|
|
ADMIN_SINGLE_API,
|
|
ADMIN_STORE_ORDER_API,
|
|
ADMIN_SUBCRIPTIONS_ADD_API,
|
|
ADMIN_SUBCRIPTIONS_LIST_API,
|
|
ADMIN_UPDATE_API,
|
|
ADMIN_UPDATE_APPOINTMENT_API,
|
|
ADMIN_UPDATE_ORDER_API,
|
|
ADMIN_UPDATE_PASSWORD,
|
|
ADMIN_UPDATE_PERMISSION_API,
|
|
ADMIN_UPDATE_ROLES_BY_ID_API,
|
|
ADMIN_UPDATE_SINGLE_NOTE_API,
|
|
ADMIN_UPDATE_SITE_SETTING,
|
|
ADMIN_UPDATE_SUBCRIPTION_API,
|
|
ADMIN_USER_LIST_API,
|
|
APPOINTMENT_DETAILS_API,
|
|
DASHBOARD_API,
|
|
LABS_DELETE_API,
|
|
LABS_LIST_API,
|
|
LABS_UPDATE_API,
|
|
MEDICINE_ADD_QUESTIONERIES_EXCEL_API,
|
|
MEDICINE_DELETE_API,
|
|
MEDICINE_LIST_API,
|
|
MEDICINE_SAVE_API,
|
|
MEDICINE_SINGLE_PRODUCT_API,
|
|
MEDICINE_UPDATE_API,
|
|
MEETING_NOTES_API,
|
|
MEETING_PRESCREPTIONS_API,
|
|
PATIENT_ADD_API,
|
|
PATIENT_DELETE_API,
|
|
PATIENT_FILTER_LIST_API,
|
|
PATIENT_GET_BY_ID_API,
|
|
PATIENT_LABKIT_LIST_API,
|
|
PATIENT_LABKIT_STATUS_UPDATE_API,
|
|
PATIENT_LIST_API,
|
|
PATIENT_MEETING_LIST_API,
|
|
PATIENT_PRESCRIPTION_STATUS_UPDATE_API,
|
|
PATIENT_UPDATE_API,
|
|
PROFILE_UPDATE_API,
|
|
PROVIDER_ADD_API,
|
|
PROVIDER_DELETE_API,
|
|
PROVIDER_FILTER_LIST_API,
|
|
PROVIDER_LIST_API,
|
|
PROVIDER_MEETING_LIST_API,
|
|
PROVIDER_SINGLE_PROVIDER_API,
|
|
PROVIDER_UPDATE_API,
|
|
SUBCRIPTIONS_LIST_API
|
|
} from './constants.js';
|
|
|
|
|
|
export default createStore({
|
|
state: {
|
|
orderPaymentDetails: null,
|
|
isLoading: false,
|
|
isTonalSnackbarVisible: false,
|
|
isErrorMsg: false,
|
|
isSuccessMsg: false,
|
|
patientList:[],
|
|
patientMeetingList: [],
|
|
patientLabKitList:[],
|
|
providerMeetingList:[],
|
|
providersList: [],
|
|
providersReportFilter: [],
|
|
providersReportData: [],
|
|
singlePatient: null,
|
|
singleProvider: null,
|
|
singleProduct: null,
|
|
permissionUser:null,
|
|
singleUser: null,
|
|
singlePrescription:null,
|
|
adminUserList: null,
|
|
orderPrecriptionList: null,
|
|
orderDetailPrecriptionList:null,
|
|
labsList:[],
|
|
overviewOrders:[],
|
|
overviewOrdersData:[],
|
|
overviewOrderChartData:[],
|
|
overviewOrderChartDate:[],
|
|
overviewChartData:[],
|
|
overviewChartDate:[],
|
|
analyticsOverviewOrder:[],
|
|
subcriptions:[],
|
|
subcriptionData:[],
|
|
patientDataTable:[],
|
|
patientLabKitStatus:'',
|
|
patientPrescriptionStatus:'',
|
|
singlePatientAppointment: null,
|
|
patientPrescription: null,
|
|
permissionsRole:null,
|
|
patientNotes: null,
|
|
medicineList: [],
|
|
questioneriesList: [],
|
|
adminDetail: null,
|
|
siteSetting: null,
|
|
showMessage: null,
|
|
timeout: null,
|
|
checkLoginExpire: false,
|
|
labKitList: [],
|
|
analyticsOrder:[],
|
|
patientDetail: null,
|
|
providerDetail:null,
|
|
patientAnswers: null,
|
|
orderList: null,
|
|
patientOrderDetail: null,
|
|
orderLabKit: null,
|
|
orderCount:null,
|
|
analyticsOverview: {
|
|
chart:{
|
|
chart_data:[],
|
|
chart_dates:[],
|
|
},
|
|
orders:[],
|
|
totals: [],
|
|
patient_stats:{
|
|
new_users:[],
|
|
returning_users:[],
|
|
},
|
|
},
|
|
orderFilters: {
|
|
chart:{
|
|
chart_data:[],
|
|
chart_dates:[],
|
|
},
|
|
orders:[],
|
|
totals: [],
|
|
},
|
|
dashboardData: {
|
|
totals: {
|
|
total_patints: 0,
|
|
total_orders: 0,
|
|
total_amount: null,
|
|
total_products_sold:0,
|
|
},
|
|
graph_data:{
|
|
data:{
|
|
total_sales: [],
|
|
total_meetings: [],
|
|
},
|
|
dates:[],
|
|
},
|
|
orders_data:[],
|
|
completed_meetings: [],
|
|
patient_reg_activity: [],
|
|
products: [],
|
|
},
|
|
orderFilters: {
|
|
chart:{
|
|
chart_data:[],
|
|
chart_dates:[],
|
|
},
|
|
orders:[],
|
|
totals: [],
|
|
},
|
|
productsList:[],
|
|
productsAnalytics: {
|
|
orders: [],
|
|
totals: [
|
|
{
|
|
total_orders: 0,
|
|
sales_amount: 0,
|
|
products_sold: 0
|
|
}
|
|
],
|
|
chart: {
|
|
chart_dates:[],
|
|
chart_data:[],
|
|
},
|
|
},
|
|
permissions: {},
|
|
singleRole: null,
|
|
rolesList: null,
|
|
available_slots: null,
|
|
selectedTimezone: null,
|
|
bookAppointment: {
|
|
status:null,
|
|
agent_name: null,
|
|
appiontmentId: null,
|
|
appointment_date: null,
|
|
appointment_time: null,
|
|
end_time: null,
|
|
timezone: null,
|
|
slot_time: null,
|
|
items:null
|
|
},
|
|
subcriptionData:[],
|
|
itemByOrder:[],
|
|
orderList:[],
|
|
orderNote:[],
|
|
filter_date:'',
|
|
},
|
|
mutations: {
|
|
setOrderPaymentDetails(state, payload) {
|
|
state.orderPaymentDetails = payload
|
|
},
|
|
setLoading(state, payload) {
|
|
console.log('payload');
|
|
state.isLoading = payload
|
|
},
|
|
setIsTonalSnackbarVisible(state, payload) {
|
|
state.isTonalSnackbarVisible = payload;
|
|
},
|
|
setOrderFilters(state, payload) {
|
|
state.orderFilters = payload
|
|
},
|
|
setOverviewOrder(state, payload) {
|
|
console.log('payload');
|
|
state.overviewOrders = payload
|
|
},
|
|
setOverviewOrderData(state, payload) {
|
|
console.log('payloadaSI',payload);
|
|
state.overviewOrdersData = payload
|
|
},
|
|
|
|
|
|
setAnalyticsOrder(state, payload) {
|
|
console.log('payload');
|
|
state.analyticsOrder = payload
|
|
},
|
|
setPtientListDataTable(state, payload) {
|
|
console.log('payload');
|
|
state.patientDataTable = payload
|
|
},
|
|
|
|
setOverviewChartData(state, payload) {
|
|
console.log('payload');
|
|
state.overviewChartData = payload
|
|
},
|
|
setOverviewOrderChartData(state, payload) {
|
|
console.log('payload');
|
|
state.overviewOrderChartData = payload
|
|
},
|
|
|
|
|
|
setOverviewChartDate(state, payload) {
|
|
console.log('payload');
|
|
state.overviewChartDate = payload
|
|
},
|
|
|
|
setOverviewOrderChartDate(state, payload) {
|
|
console.log('payload');
|
|
state.overviewOrderChartDate = payload
|
|
},
|
|
|
|
setCheckLoginExpire(state, payload) {
|
|
console.log('payload');
|
|
state.checkLoginExpire = payload
|
|
},
|
|
setPermissionUser(state, payload) {
|
|
console.log('payload');
|
|
state.permissionUser = payload
|
|
},
|
|
|
|
setErrorMsg(state, payload) {
|
|
console.log('payload');
|
|
clearTimeout(state.timeout)
|
|
state.isErrorMsg = payload
|
|
state.timeout = setTimeout(() => {
|
|
state.isErrorMsg = false
|
|
}, 5000)
|
|
},
|
|
setSuccessMsg(state, payload) {
|
|
console.log('payload');
|
|
clearTimeout(state.timeout)
|
|
state.isSuccessMsg = payload
|
|
state.timeout = setTimeout(() => {
|
|
state.isSuccessMsg = false
|
|
}, 5000)
|
|
},
|
|
setShowMsg(state, payload) {
|
|
console.log('payload');
|
|
state.showMessage = payload
|
|
|
|
},
|
|
setSubcriptions(state, payload) {
|
|
state.subcriptions = payload
|
|
},
|
|
setPatientDetail(state, payload) {
|
|
console.log('payload');
|
|
state.patientDetail = payload
|
|
},
|
|
setProviderDetail(state, payload) {
|
|
console.log('payload');
|
|
state.providerDetail = payload
|
|
},
|
|
setProvidersReportFilter(state, payload) {
|
|
console.log('payload');
|
|
state.providersReportFilter = payload
|
|
},
|
|
|
|
setProviderMeetingList(state, payload) {
|
|
console.log('payload');
|
|
state.providerMeetingList = payload
|
|
},
|
|
|
|
setPtientList(state, payload) {
|
|
state.patientList = payload
|
|
},
|
|
setPtientMeetingList(state, payload) {
|
|
state.patientMeetingList = payload
|
|
},
|
|
setPtientMeetingList(state, payload) {
|
|
state.patientMeetingList = payload
|
|
},
|
|
setPatientLabKitList(state, payload) {
|
|
state.patientLabKitList = payload
|
|
},
|
|
setProvidersList(state, payload) {
|
|
state.providersList = payload
|
|
},
|
|
setLabsList(state, payload) {
|
|
state.labsList = payload
|
|
},
|
|
setLabKitList(state, payload) {
|
|
state.labKitList = payload
|
|
},
|
|
setPrescription(state, payload) {
|
|
state.patientPrescription = payload
|
|
},
|
|
setSinglePatientAppointment(state, payload) {
|
|
state.singlePatientAppointment = payload
|
|
},
|
|
setPatientNotes(state, payload) {
|
|
state.patientNotes = payload
|
|
},
|
|
setOrderSingaleNote(state, payload) {
|
|
state.orderNote = payload
|
|
},
|
|
|
|
setMedicineList(state, payload) {
|
|
state.medicineList = payload
|
|
},
|
|
setAdminUserList(state, payload) {
|
|
state.adminUserList = payload
|
|
},
|
|
setQuestionersList(state, payload) {
|
|
state.questioneriesList = payload
|
|
},
|
|
setAdminDetail(state, payload) {
|
|
state.adminDetail = payload
|
|
},
|
|
setSiteSetting(state, payload) {
|
|
state.siteSetting = payload
|
|
},
|
|
setPatientLabKitStatus(state, payload) {
|
|
state.patientLabKitStatus = payload
|
|
},
|
|
setPatientPrescriptionStatus(state, payload) {
|
|
state.patientPrescriptionStatus = payload
|
|
},
|
|
setPatientAnswers(state, payload) {
|
|
state.patientAnswers = payload
|
|
},
|
|
|
|
setProvidersReportData(state, payload){
|
|
state.providersReportData= payload
|
|
},
|
|
setOrderList(state, payload){
|
|
state.orderList= payload
|
|
},
|
|
setSubcriptionData(state, payload){
|
|
state.subcriptionData= payload
|
|
},
|
|
setPatientOrderDetail(state, payload) {
|
|
state.patientOrderDetail = payload;
|
|
},
|
|
setOrderLabKit(state, payload) {
|
|
state.orderLabKit = payload;
|
|
},
|
|
setAnalyticsOverview(state, payload) {
|
|
state.analyticsOverview = payload;
|
|
},
|
|
|
|
setAnalyticsOverviewOrder(state, payload) {
|
|
state.analyticsOverviewOrder = payload;
|
|
},
|
|
|
|
setOrderCount(state, payload) {
|
|
state.orderCount = payload;
|
|
},
|
|
setSinglePatient(state, payload) {
|
|
state.singlePatient = payload;
|
|
},
|
|
setSingleProvider(state, payload) {
|
|
state.singleProvider = payload;
|
|
},
|
|
setSingleProduct(state, payload) {
|
|
state.singleProduct = payload;
|
|
},
|
|
setSingleUser(state, payload) {
|
|
state.singleUser = payload;
|
|
},
|
|
|
|
setDashboardData(state, payload) {
|
|
state.dashboardData = payload;
|
|
},
|
|
setProductsList(state, payload) {
|
|
state.productsList = payload;
|
|
},
|
|
setProductsAnalytics(state, payload) {
|
|
state.productsAnalytics = payload;
|
|
},
|
|
setPermissions(state, payload) {
|
|
state.permissions = payload;
|
|
},
|
|
setSingleRole(state, payload) {
|
|
state.singleRole = payload;
|
|
},
|
|
setSinglePrescription(state, payload) {
|
|
state.singlePrescription = payload;
|
|
},
|
|
setPermissionsRole(state, payload) {
|
|
state.permissionsRole = payload;
|
|
},
|
|
setRolesList(state, payload) {
|
|
state.rolesList = payload;
|
|
},
|
|
setSelectedTimezone(state, payload) {
|
|
state.selectedTimezone = payload;
|
|
},
|
|
setAvailableSlots(state, payload) {
|
|
state.available_slots = payload;
|
|
},
|
|
updateBookAppointment(state, payload) {
|
|
state.bookAppointment.agent_name = payload.agent_name;
|
|
state.bookAppointment.appiontmentId = payload.appiontmentId;
|
|
state.bookAppointment.appointment_date = payload.appointment_date;
|
|
state.bookAppointment.appointment_time = payload.appointment_time;
|
|
state.bookAppointment.timezone = payload.timezone;
|
|
state.bookAppointment.end_time = payload.end_time;
|
|
state.bookAppointment.status = payload.appointment_status;
|
|
state.bookAppointment.slot_time = payload.slot_time;
|
|
state.bookAppointment.order_id = payload.order_id;
|
|
state.bookAppointment.items = payload.items;
|
|
},
|
|
setOrderPrecriptionList(state, payload) {
|
|
state.orderPrecriptionList = payload;
|
|
},
|
|
setItemListByOrder (state, payload) {
|
|
state.itemByOrder = payload
|
|
},
|
|
setOrderList(state, payload){
|
|
state.orderList= payload
|
|
},
|
|
setOrderDetailPrecriptionList(state, payload){
|
|
state.orderDetailPrecriptionList= payload
|
|
},
|
|
setCurrentDate(state,payload){
|
|
state.filter_date = payload
|
|
}
|
|
|
|
},
|
|
actions: {
|
|
async updateErrorMessage({ commit }, payload) {
|
|
|
|
commit('setErrorMsg', true)
|
|
|
|
commit('setShowMsg', payload)
|
|
},
|
|
|
|
async SaveCurrentDate({ commit }, payload) {
|
|
commit('setCurrentDate', payload)
|
|
},
|
|
async updateIsLoading({ commit }, payload) {
|
|
commit('setLoading', payload)
|
|
},
|
|
async updateIsTonalSnackbar({ commit }, payload) {
|
|
commit("setIsTonalSnackbarVisible", payload);
|
|
},
|
|
async updateSuccessMsg({ commit }, payload) {
|
|
commit("setSuccessMsg", payload);
|
|
},
|
|
async updateIsTonalSnackbarMsg({ commit }, payload) {
|
|
commit("setShowMsg", payload);
|
|
},
|
|
async updateCheckToken({ commit }, payload) {
|
|
commit('setCheckLoginExpire', payload)
|
|
},
|
|
async patientListDataTable({ commit }, payload) {
|
|
console.log("dpayload", payload)
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(PATIENT_LIST_API, {
|
|
plan: payload.plan ? payload.plan: 'all' ,
|
|
gender: payload.gender ? payload.gender: 'all',
|
|
state: payload.state? payload.state :'all',
|
|
start:payload.startL,
|
|
length:payload.endL,
|
|
// search:payload.search,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response DataTable patinet:', response.data);
|
|
// let dataArray =[]
|
|
// for (let data of response.data.patients) {
|
|
// let dataObject = {}
|
|
// dataObject.name = data.first_name + ' ' + data.last_name
|
|
// dataObject.first_name = data.first_name
|
|
// dataObject.last_name = data.last_name
|
|
// dataObject.gender = data.gender
|
|
// dataObject.email = data.email
|
|
// dataObject.state = data.state
|
|
// dataObject.dob = data.dob
|
|
// dataObject.phone_no = data.phone_no
|
|
// dataObject.avatar = '',
|
|
// dataObject.id = data.id,
|
|
// dataArray.push(dataObject)
|
|
// }
|
|
// console.log(dataArray)
|
|
commit('setPtientListDataTable',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async patientList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(PATIENT_LIST_API, {
|
|
plan: 'all' ,
|
|
gender: 'all',
|
|
state: 'all',
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data.patients);
|
|
let dataArray =[]
|
|
for (let data of response.data.data) {
|
|
let dataObject = {}
|
|
dataObject.name = data.first_name + ' ' + data.last_name
|
|
dataObject.first_name = data.first_name
|
|
dataObject.last_name = data.last_name
|
|
dataObject.gender = data.gender
|
|
dataObject.email = data.email
|
|
dataObject.state = data.state
|
|
dataObject.dob = data.dob
|
|
dataObject.phone_no = data.phone_no
|
|
dataObject.avatar = '',
|
|
dataObject.id = data.id,
|
|
dataArray.push(dataObject)
|
|
}
|
|
console.log(dataArray)
|
|
commit('setPtientList',dataArray)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async PatientFilter({ commit,state }, payload) {
|
|
commit('setLoading', true)
|
|
|
|
await axios.post(PATIENT_FILTER_LIST_API, {
|
|
plan: payload.plan ? payload.plan: 'all' ,
|
|
gender: payload.gender ? payload.gender: 'all',
|
|
state: payload.state? payload.state :'all',
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response Patient:', response.data.patients);
|
|
let dataArray =[]
|
|
for (let data of response.data.patients) {
|
|
let dataObject = {}
|
|
dataObject.name = data.first_name + ' ' + data.last_name
|
|
dataObject.first_name = data.first_name
|
|
dataObject.last_name = data.last_name
|
|
dataObject.email = data.email
|
|
dataObject.gender = data.gender
|
|
dataObject.state = data.state
|
|
dataObject.dob = data.dob
|
|
dataObject.phone_no = data.phone_no
|
|
dataObject.avatar = '',
|
|
dataObject.id = data.id,
|
|
dataArray.push(dataObject)
|
|
}
|
|
console.log(dataArray)
|
|
commit('setPtientList',dataArray)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getSubcriptions ({commit,state},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(SUBCRIPTIONS_LIST_API, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response Subcriptions:', response.data);
|
|
commit('setSubcriptions',response.data);
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
commit('setPrescription',null)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async patientMeetingList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(PATIENT_MEETING_LIST_API+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Meeting Response:', response.data.patients);
|
|
commit('setPtientMeetingList',response.data.patients);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async providerMeetingList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(PROVIDER_MEETING_LIST_API+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Meeting Response:', response.data.patients);
|
|
commit('setProviderMeetingList',response.data.patients);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async patientAdd({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(PATIENT_ADD_API, {
|
|
first_name: payload.first_name,
|
|
last_name: payload.last_name,
|
|
email: payload.email,
|
|
phone_no: payload.phone_no,
|
|
gender:payload.gender,
|
|
password: payload.password,
|
|
dob: payload.dob,
|
|
address:payload.address,
|
|
city: payload.city,
|
|
state: payload.state,
|
|
zip: payload.zip_code,
|
|
country:payload.country
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
if (response.data.data) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg'," patient has been successfully added")
|
|
|
|
}
|
|
console.log('Response:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
if (error.response.data.message) {
|
|
commit('setErrorMsg', true)
|
|
|
|
commit('setShowMsg', error.response.data.message)
|
|
}
|
|
|
|
});
|
|
},
|
|
async patientUpdate({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(PATIENT_UPDATE_API+'/'+payload.id, {
|
|
first_name: payload.first_name,
|
|
last_name: payload.last_name,
|
|
email: payload.email,
|
|
phone_no: payload.phone_no,
|
|
gender:payload.gender,
|
|
password: payload.password,
|
|
dob: payload.dob,
|
|
address:payload.address,
|
|
city: payload.city,
|
|
state: payload.state,
|
|
zip: payload.zip_code,
|
|
country:payload.country
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async patientGETBYID({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(PATIENT_GET_BY_ID_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSinglePatient', response.data.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async productGetByID({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(MEDICINE_SINGLE_PRODUCT_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSingleProduct', response.data.product)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async GetNoteByID({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_GET_SINGLE_NOTE_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setOrderSingaleNote', response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async UpdateNoteByID({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_UPDATE_SINGLE_NOTE_API+'/'+payload.id, {
|
|
note: payload.note,
|
|
note_type: 'Notes'
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.message=='success' && response.status === 200) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg', 'Successfully Updated')
|
|
}
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
if ( error.response.data.status === 500) {
|
|
commit('setErrorMsg', true)
|
|
|
|
commit('setShowMsg', 'somthing wrong!')
|
|
}
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async DeleteSingleNote({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_DELETE_SINGLE_NOTE_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async patientDelete({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(PATIENT_DELETE_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async providersFilterList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
if(payload.state == 'All')
|
|
payload.state = payload.state.toLowerCase();
|
|
if(payload.availabilityFrom == 'All')
|
|
payload.availabilityFrom = payload.availabilityFrom.toLowerCase();
|
|
if(payload.availabilityTo == 'All')
|
|
payload.availabilityTo = payload.availabilityTo.toLowerCase();
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(PROVIDER_FILTER_LIST_API, {
|
|
gender:payload.gender? payload.gender:'all',
|
|
state: payload.state? payload.state:'all',
|
|
availability_from: payload.availabilityFrom ? payload.availabilityFrom:'all',
|
|
availability_to:payload.availabilityTo?payload.availabilityTo : 'all'
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data.patients);
|
|
let dataArray =[]
|
|
for (let data of response.data.patients) {
|
|
let dataObject = {}
|
|
dataObject.name = data.first_name + ' ' + data.last_name
|
|
dataObject.first_name = data.first_name
|
|
dataObject.last_name = data.last_name
|
|
dataObject.email = data.email
|
|
dataObject.gender = data.gender
|
|
dataObject.state = data.state
|
|
dataObject.availability_from = data.availability_from
|
|
dataObject.availability_to = data.availability_to
|
|
// dataObject.dob = data.dob
|
|
dataObject.phone_no = data.phone_number
|
|
dataObject.avatar = '',
|
|
dataObject.id = data.id,
|
|
dataArray.push(dataObject)
|
|
}
|
|
console.log(dataArray)
|
|
commit('setProvidersList',dataArray)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async providersListDataTable({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
if(payload.state == 'All')
|
|
payload.state = payload.state.toLowerCase();
|
|
if(payload.availabilityFrom == 'All')
|
|
payload.availabilityFrom = payload.availabilityFrom.toLowerCase();
|
|
if(payload.availabilityTo == 'All')
|
|
payload.availabilityTo = payload.availabilityTo.toLowerCase();
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(PROVIDER_FILTER_LIST_API, {
|
|
gender:payload.gender? payload.gender:'all',
|
|
state: payload.state? payload.state:'all',
|
|
availability_from: payload.availabilityFrom ? payload.availabilityFrom:'all',
|
|
availability_to:payload.availabilityTo?payload.availabilityTo : 'all',
|
|
start:payload.startL,
|
|
length:payload.endL,
|
|
// search:payload.search,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response DataTable:', response.data);
|
|
// let dataArray =[]
|
|
// for (let data of response.data.patients) {
|
|
// let dataObject = {}
|
|
// dataObject.name = data.first_name + ' ' + data.last_name
|
|
// dataObject.first_name = data.first_name
|
|
// dataObject.last_name = data.last_name
|
|
// dataObject.email = data.email
|
|
// dataObject.gender = data.gender
|
|
// dataObject.state = data.state
|
|
// dataObject.availability_from = data.availability_from
|
|
// dataObject.availability_to = data.availability_to
|
|
// // dataObject.dob = data.dob
|
|
// dataObject.phone_no = data.phone_number
|
|
// dataObject.avatar = '',
|
|
// dataObject.id = data.id,
|
|
// dataArray.push(dataObject)
|
|
// }
|
|
// console.log(dataArray)
|
|
commit('setProvidersList',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async providerGETBYID({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(PROVIDER_SINGLE_PROVIDER_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSingleProvider', response.data.provider)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
// async providersListDataTable({ commit }, payload) {
|
|
// commit('setLoading', true)
|
|
// console.log(localStorage.getItem('admin_access_token'))
|
|
// await axios.post(PROVIDER_LIST_API, {
|
|
// gender: 'all',
|
|
// state: 'all',
|
|
// availabilityFrom: 'all',
|
|
// availabilityTo: 'all'
|
|
// }, {
|
|
// headers: {
|
|
// 'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
// }
|
|
// }) .then(response => {
|
|
// commit('setLoading', false)
|
|
// console.log('Response providersListDataTable:', response.data);
|
|
// // let dataArray =[]
|
|
// // for (let data of response.data.patients) {
|
|
// // let dataObject = {}
|
|
// // dataObject.name = data.first_name + ' ' + data.last_name
|
|
// // dataObject.first_name = data.first_name
|
|
// // dataObject.last_name = data.last_name
|
|
// // dataObject.email = data.email
|
|
// // dataObject.gender = data.gender
|
|
// // dataObject.state = data.state
|
|
// // dataObject.availability_from = data.availability_from
|
|
// // dataObject.availability_to = data.availability_to
|
|
// // // dataObject.dob = data.dob
|
|
// // dataObject.phone_no = data.phone_number
|
|
// // dataObject.avatar = '',
|
|
// // dataObject.id = data.id,
|
|
// // dataArray.push(dataObject)
|
|
// // }
|
|
// // console.log(dataArray)
|
|
// commit('setProvidersList',response.data)
|
|
|
|
// })
|
|
// .catch(error => {
|
|
// commit('setLoading', false)
|
|
// console.error('Error:', error);
|
|
// });
|
|
// },
|
|
async providersList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(PROVIDER_LIST_API, {
|
|
gender: 'all',
|
|
state: 'all',
|
|
availabilityFrom: 'all',
|
|
availabilityTo: 'all'
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data.patients);
|
|
let dataArray =[]
|
|
for (let data of response.data.patients) {
|
|
let dataObject = {}
|
|
dataObject.name = data.first_name + ' ' + data.last_name
|
|
dataObject.first_name = data.first_name
|
|
dataObject.last_name = data.last_name
|
|
dataObject.email = data.email
|
|
dataObject.gender = data.gender
|
|
dataObject.state = data.state
|
|
dataObject.availability_from = data.availability_from
|
|
dataObject.availability_to = data.availability_to
|
|
// dataObject.dob = data.dob
|
|
dataObject.phone_no = data.phone_number
|
|
dataObject.avatar = '',
|
|
dataObject.id = data.id,
|
|
dataArray.push(dataObject)
|
|
}
|
|
console.log(dataArray)
|
|
commit('setProvidersList',dataArray)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async providerUpdate({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(PROVIDER_UPDATE_API+'/'+payload.id, {
|
|
first_name: payload.first_name,
|
|
last_name: payload.last_name,
|
|
email: payload.email,
|
|
password: payload.password,
|
|
home_address: payload.home_address,
|
|
city: payload.city,
|
|
state: payload.state,
|
|
zip_code: payload.zip_code,
|
|
medical_license_number: payload.medical_license_number,
|
|
years_of_experience: payload.years_of_experience,
|
|
specialty: payload.specialty,
|
|
gender: payload.gender,
|
|
practice_state: payload.practice_state,
|
|
phone: payload.phone,
|
|
availabilityFrom: payload.availabilityFrom,
|
|
availabilityTo: payload.availabilityTo
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.message && response.status === 200) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg', response.data.message)
|
|
}
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async providerDelete({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(PROVIDER_DELETE_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async providerAdd({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(PROVIDER_ADD_API, {
|
|
first_name: payload.first_name,
|
|
last_name: payload.last_name,
|
|
email: payload.email,
|
|
password: payload.password,
|
|
home_address: payload.home_address,
|
|
city: payload.city,
|
|
state: payload.state,
|
|
zip_code: payload.zip_code,
|
|
medical_license_number: payload.medical_license_number,
|
|
years_of_experience: payload.years_of_experience,
|
|
specialty: payload.specialty,
|
|
gender: payload.gender,
|
|
practice_state: payload.practice_state,
|
|
phone: payload.phone,
|
|
availabilityFrom: payload.availabilityFrom,
|
|
availabilityTo: payload.availabilityTo
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
if (response.data.user) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg',response.data.message)
|
|
|
|
}
|
|
console.log('Response:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
if (error.response.data.errors) {
|
|
commit('setErrorMsg', true)
|
|
commit('setShowMsg', error.response.data.errors)
|
|
}
|
|
if (error.response.data.message) {
|
|
commit('setErrorMsg', true)
|
|
|
|
const isDuplicateEntryError = /1062 Duplicate entry/.test(error.response.data.message);
|
|
if (isDuplicateEntryError) {
|
|
|
|
|
|
commit('setShowMsg', 'Email already taken!')
|
|
} else {
|
|
commit('setShowMsg', error.response.data.message)
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
},
|
|
async addOrderNote({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ADD_ORDER_NOTES_API+'/'+payload.orderId, {
|
|
note: payload.note,
|
|
note_type: 'Notes',
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
if (response.data.user) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg',response.data.message)
|
|
|
|
}
|
|
console.log('Response:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
if (error.response.data.message) {
|
|
commit('setErrorMsg', true)
|
|
const isDuplicateEntryError = /1062 Duplicate entry/.test(error.response.data.message);
|
|
if (isDuplicateEntryError) {
|
|
|
|
|
|
commit('setShowMsg', 'Email already taken!')
|
|
} else {
|
|
commit('setShowMsg', error.response.data.message)
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
},
|
|
async labsList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(LABS_LIST_API, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
let dataArray =[]
|
|
for (let data of response.data.patients) {
|
|
let dataObject = {}
|
|
dataObject.name = data.name
|
|
dataObject.address = data.address
|
|
dataObject.slot_date = data.slot_date
|
|
dataObject.slot_time = data.slot_time
|
|
dataObject.appointment_id = data.appointment_id
|
|
dataObject.booking_time = data.booking_time
|
|
dataObject.contact_no = data.contact_no
|
|
dataObject.avatar = '',
|
|
dataObject.id = data.id,
|
|
dataArray.push(dataObject)
|
|
}
|
|
console.log(dataArray)
|
|
commit('setLabsList',dataArray)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async labUpdate({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(LABS_UPDATE_API+payload.id, {
|
|
name: payload.name,
|
|
address: payload.address,
|
|
contact_no: payload.contact_no,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async labDelete({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(LABS_DELETE_API+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async patientLabKitList ({commit,state},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(PATIENT_LABKIT_LIST_API+payload.patient_id ,{}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response Labkit:', response.data);
|
|
commit('setPatientLabKitList',response.data)
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async updateLabkitListStatus ({commit,state},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(PATIENT_LABKIT_STATUS_UPDATE_API+payload.cart_id ,{
|
|
status:payload.status
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
commit('setPatientLabKitStatus',response.data);
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async updatePrescriptionStatus ({commit,state},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(PATIENT_PRESCRIPTION_STATUS_UPDATE_API+payload.prescription_id ,{
|
|
status:payload.status
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
commit('setPatientPrescriptionStatus',response.data);
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getAppointmentByIdAgent ({commit,state},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(APPOINTMENT_DETAILS_API+payload.patient_id + '/' + payload.appointment_id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
commit('setSinglePatientAppointment',response.data.data)
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getPrescriptions ({commit,state},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(MEETING_PRESCREPTIONS_API+payload.patient_id + '/' + payload.appointment_id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
let doctor={}
|
|
let itemsPrescriptions=[]
|
|
for (let data of response.data) {
|
|
let dataObject = {}
|
|
dataObject.first_name = data.patient.first_name
|
|
dataObject.last_name = data.patient.last_name
|
|
dataObject.gender = data.patient.gender
|
|
dataObject.dob = data.patient.dob
|
|
dataObject.patient_address = data.patient.address+' '+ data.patient.city+' '+ data.patient.state +' ' +data.patient.country
|
|
dataObject.name = data.prescription.name
|
|
dataObject.brand = data.prescription.brand
|
|
dataObject.from = data.prescription.from
|
|
dataObject.direction_quantity = data.prescription.direction_quantity
|
|
dataObject.dosage = data.prescription.dosage
|
|
dataObject.quantity = data.prescription.quantity
|
|
dataObject.refill_quantity = data.prescription.refill_quantity
|
|
dataObject.actions = ''
|
|
dataObject.id = data.prescription.id
|
|
dataObject.comments = data.comments
|
|
dataObject.direction_one = data.direction_one
|
|
dataObject.direction_two = data.direction_two
|
|
dataObject.doctor = data.telemedPro
|
|
dataObject.status = data.status
|
|
dataObject.date = data.created_at
|
|
dataObject.agent_sign = data.telemedPro.name
|
|
dataObject.medical_license_number = data.telemedPro.medical_license_number
|
|
itemsPrescriptions.push(dataObject)
|
|
|
|
}
|
|
console.log('Response Notes:', response.data);
|
|
|
|
commit('setPrescription',itemsPrescriptions)
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
commit('setPrescription',null)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getHistoryPatientNotes ({commit,state},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(MEETING_NOTES_API+payload.patient_id + '/' + payload.appointment_id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
commit('setPatientNotes',response.data.data)
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async medicineList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(MEDICINE_LIST_API, {
|
|
start: payload.startL,
|
|
length:payload.endL,
|
|
// search:payload.search,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
// let dataArray =[]
|
|
// for (let data of response.data.medicines) {
|
|
// let dataObject = {}
|
|
// dataObject.title = data.title
|
|
// dataObject.slug = data.slug
|
|
// dataObject.price = data.price
|
|
// dataObject.slot_time = data.slot_time
|
|
// dataObject.appointment_id = data.appointment_id
|
|
// dataObject.booking_time = data.booking_time
|
|
// dataObject.contact_no = data.contact_no
|
|
// dataObject.avatar = '',
|
|
// dataObject.id = data.id,
|
|
// dataArray.push(dataObject)
|
|
// }
|
|
// console.log(dataArray)
|
|
commit('setMedicineList',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async medicineUpdate({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(MEDICINE_UPDATE_API+'/'+payload.id, {
|
|
title: payload.title,
|
|
slug: payload.slug,
|
|
list_one_title: payload.list_one_title,
|
|
list_sub_title: payload.list_sub_title,
|
|
list_two_title: payload.list_two_title,
|
|
price: payload.price,
|
|
currency: payload.currency,
|
|
excel: payload.excel,
|
|
image:payload.image
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.message=='success' && response.status === 200) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg', 'Successfully Updated')
|
|
}
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
if ( error.response.data.status === 500) {
|
|
commit('setErrorMsg', true)
|
|
|
|
commit('setShowMsg', 'somthing wrong!')
|
|
}
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async medicineDelete({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(MEDICINE_DELETE_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.message && response.status === 200) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg', 'Successfully Deleted')
|
|
}
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async questioneriesListExcel({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(MEDICINE_ADD_QUESTIONERIES_EXCEL_API, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
commit('setQuestionersList',response.data.medicines)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async medicineAdd({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
// const formData = new FormData()
|
|
// formData.append('title', defaultItem.value.title)
|
|
// formData.append('slug', defaultItem.value.slug)
|
|
// formData.append('list_one_title', defaultItem.value.list_one_title)
|
|
// formData.append('list_sub_title', defaultItem.value.list_sub_title)
|
|
// formData.append('list_two_title', defaultItem.value.list_two_title)
|
|
// formData.append('price', defaultItem.value.price)
|
|
// formData.append('currency', currencySign.value)
|
|
|
|
// formData.append('image', imageBase64.value)
|
|
await axios.post(MEDICINE_SAVE_API, {
|
|
title: payload.title,
|
|
slug: payload.slug,
|
|
list_one_title: payload.list_one_title,
|
|
list_sub_title: payload.list_sub_title,
|
|
list_two_title: payload.list_two_title,
|
|
price: payload.price,
|
|
currency: payload.currency,
|
|
excel: payload.excel,
|
|
image:payload.image
|
|
}, {
|
|
headers: {
|
|
'Content-Type': 'multipart/form-data',
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.message=='success' && response.status === 200) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg', 'Successfully Added')
|
|
}
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async adminDetial({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
|
|
await axios.post(ADMIN_LOGIN_DETAIL, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setAdminDetail',response.data.admin_details)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async siteSetting({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
|
|
await axios.post(ADMIN_GET_SITE_SETTING, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data.settings_data);
|
|
commit('setSiteSetting',response.data.settings_data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async siteSettingUpdate({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
|
|
await axios.post(ADMIN_UPDATE_SITE_SETTING+payload.id, {
|
|
plan_main_title: payload.plan_main_title,
|
|
plan_description: payload.plan_description,
|
|
header_title: payload.header_title,
|
|
footer_text: payload.footer_text,
|
|
domain_name: payload.domain_name,
|
|
logo:payload.logo,
|
|
favicon:payload.favicon//imageBase64.value
|
|
}, {
|
|
headers: {
|
|
'Content-Type': 'multipart/form-data',
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.msg && response.status === 200) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg', response.data.msg)
|
|
}
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async adminPasswordUpadate({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
|
|
await axios.post(ADMIN_UPDATE_PASSWORD, {
|
|
password: payload.password,
|
|
new_password : payload.new_password ,
|
|
confirm_password : payload.confirm_password ,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.status == 'error') {
|
|
commit('setErrorMsg', true)
|
|
console.log('Response:', response.data.msg);
|
|
commit('setShowMsg', response.data.msg)
|
|
|
|
}
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async profileUpdate({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(PROFILE_UPDATE_API, {
|
|
first_name: payload.name,
|
|
last_name:payload.last_name,
|
|
phone_no: payload.phone_no,
|
|
image:payload.image
|
|
}, {
|
|
headers: {
|
|
'Content-Type': 'multipart/form-data',
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async checkLogin({ commit }, payload) {
|
|
//commit('setLoading', true)
|
|
|
|
await axios.post(ADMIN_LOGIN_DETAIL, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
commit('setPermissionUser', response.data.permissions)
|
|
})
|
|
.catch(error => {
|
|
//commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
if (error.response && error.response.status === 401 && error.response.data.error === 'Token has expired') {
|
|
commit('setCheckLoginExpire', true)
|
|
}
|
|
});
|
|
},
|
|
async labsKitList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
|
|
await axios.post(ADMIN_LAB_KIT_LIST_API, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
|
|
|
|
commit('setLabKitList',response.data.labkit)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async labKitUpdate({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_LAB_KIT_UPDATE_API+payload.id, {
|
|
name: payload.name,
|
|
amount: payload.amount,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.message && response.status === 200) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg', response.data.message)
|
|
}
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async labKitAdd({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_LAB_KIT_ADD_API, {
|
|
name: payload.name,
|
|
amount: payload.amount,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.message && response.status === 200) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg', response.data.message)
|
|
}
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async labKitDelete({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_LAB_KIT_DELETE_API+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.message && response.status === 200) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg', response.data.message)
|
|
}
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async patientDetial({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
|
|
await axios.post(ADMIN_PATIENT_DETAIL_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setPatientDetail',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async providerDetial({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
|
|
await axios.post(ADMIN_PROVIDER_DETAIL_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setProviderDetail',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getAgentQuestionsAnswers ({commit},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_PATIENT_PROFILE_API+'/'+payload.patient_id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
})
|
|
.then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data.data);
|
|
commit('setPatientAnswers', response.data.data)
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.log('Error:', error);
|
|
});
|
|
|
|
},
|
|
async providersReportFilter({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_PROVIDER_REPORT_API, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
|
|
commit('setProvidersReportFilter',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async providersReportsFilterList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
if(payload.state == 'All')
|
|
payload.state = payload.state.toLowerCase();
|
|
if(payload.availabilityFrom == 'All')
|
|
payload.availabilityFrom = payload.availabilityFrom.toLowerCase();
|
|
if(payload.availabilityTo == 'All')
|
|
payload.availabilityTo = payload.availabilityTo.toLowerCase();
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_PROVIDER_REPORT_POST_API, {
|
|
gender:payload.gender? payload.gender:'all',
|
|
state: payload.state? payload.state:'all',
|
|
availability_from: payload.availabilityFrom ? payload.availabilityFrom:'all',
|
|
availability_to: payload.availabilityTo ? payload.availabilityTo : 'all',
|
|
specialty: payload.specialty ? payload.specialty : 'all',
|
|
provider_list: payload.provider_list ? payload.provider_list : 'all',
|
|
practice_state: payload.practics_state ? payload.practics_state : 'all',
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
|
|
commit('setProvidersReportData',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getItemListByOrder({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_GET_ITEM_BY_ORDER_API+'/'+payload.order_id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
|
|
commit('setItemListByOrder',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
|
|
async orderListByPatient({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_GET_ORDER_API+'/'+payload.patient_id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
|
|
commit('setOrderList',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async orderList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_GET_ORDER_API, {
|
|
start:payload.startL,
|
|
length:payload.endL,
|
|
// search:payload.search,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
|
|
commit('setOrderList',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async orderEditAgent({ commit, state }, payload) {
|
|
commit("setLoading", true);
|
|
await axios
|
|
.post(
|
|
ADMIN_EDIT_ORDER_API + '/'+payload.id,
|
|
{},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
|
|
.then((response) => {
|
|
commit("setLoading", false);
|
|
console.log(
|
|
"------------------ setPatientOrderDetail ------------------:",
|
|
response.data
|
|
);
|
|
commit("setPatientOrderDetail", response.data);
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
async orderDetailAgent({ commit, state }, payload) {
|
|
commit("setLoading", true);
|
|
await axios
|
|
.post(
|
|
ADMIN_GET_ORDER_DETAIL_API + '/'+payload.id,
|
|
{},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
|
|
.then((response) => {
|
|
commit("setLoading", false);
|
|
console.log(
|
|
"------------------ setPatientOrderDetail ------------------:",
|
|
response.data
|
|
);
|
|
commit("setPatientOrderDetail", response.data);
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
async getOrderLabKit({ commit }, payload) {
|
|
commit("setLoading", false);
|
|
|
|
await axios
|
|
.post(
|
|
ADMIN_GET_ORDER_LABKIT_API,
|
|
{
|
|
cart_id: payload.cart_id,
|
|
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
// commit("setLoading", false);
|
|
console.log("Response:", response.data);
|
|
commit("setOrderLabKit", response.data.data);
|
|
//SET_NOTIFICATION_COUNT
|
|
|
|
})
|
|
.catch((error) => {
|
|
// commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
async addNewSubcription({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_SUBCRIPTIONS_ADD_API, {
|
|
subscription_start_date: payload.subscription_start_date,
|
|
subscription_renewal_date: payload.subscription_renewal_date,
|
|
subscription_status: payload.subscription_status,
|
|
cart_id: payload.cart_id,
|
|
item_id: payload.item_id,
|
|
patient_id: payload.patient_id,
|
|
// status: payload.status,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
if (response.data.user) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data);
|
|
// commit('setShowMsg',response.data.message)
|
|
|
|
}
|
|
console.log('Response:', response.data);
|
|
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
if (error.response.data.message) {
|
|
commit('setErrorMsg', true)
|
|
const isDuplicateEntryError = /1062 Duplicate entry/.test(error.response.data.message);
|
|
if (isDuplicateEntryError) {
|
|
|
|
|
|
// commit('setShowMsg', 'Email already taken!')
|
|
} else {
|
|
// commit('setShowMsg', error.response.data.message)
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
},
|
|
async updateSubcription({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_UPDATE_SUBCRIPTION_API+'/'+payload.id, {
|
|
subscription_start_date: payload.subscription_start_date,
|
|
subscription_renewal_date: payload.subscription_renewal_date,
|
|
subscription_status: payload.subscription_status,
|
|
cart_id: payload.cart_id,
|
|
item_id: payload.item_id,
|
|
patient_id: payload.patient_id,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response Update:', response.data);
|
|
if (response.data.message=='success' && response.status === 200) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:', response.data.message);
|
|
commit('setShowMsg', 'Successfully Updated')
|
|
}
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
// if ( error.response.data.status === 500) {
|
|
commit('setErrorMsg', true)
|
|
|
|
commit('setShowMsg', 'somthing wrong!')
|
|
// }
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async subcriptionGetByID({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_GET_SUBCRIPTION_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response Edit Subcription:', response.data);
|
|
commit('setSingleProduct', response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getSubcriptionsData({ commit }, payload) {
|
|
commit("setLoading", false);
|
|
|
|
await axios
|
|
.post(
|
|
ADMIN_SUBCRIPTIONS_LIST_API,
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
// commit("setLoading", false);
|
|
console.log("Response:", response.data);
|
|
commit("setSubcriptionData", response.data);
|
|
//SET_NOTIFICATION_COUNT
|
|
|
|
})
|
|
.catch((error) => {
|
|
// commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
|
|
async subcriptionDelete({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_DELETE_SUBCRIPTION_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response Delete Subcription:', response.data);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async orderCount({ commit }, payload) {
|
|
commit("setLoading", false);
|
|
|
|
await axios
|
|
.post(
|
|
ADMIN_GET_ORDER_COUNT,
|
|
{
|
|
|
|
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
// commit("setLoading", false);
|
|
console.log("Response:", response.data);
|
|
commit("setOrderCount", response.data);
|
|
//SET_NOTIFICATION_COUNT
|
|
|
|
})
|
|
.catch((error) => {
|
|
// commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
async getAdminAnalyticsOverviewOrder({ commit }, payload) {
|
|
commit("setLoading", true);
|
|
|
|
await axios.post(
|
|
ADMIN_GET_ANALYTICS_OVERVIEW_ORDER_API,
|
|
{
|
|
start_date: payload.start_date,
|
|
end_date: payload.end_date,
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
commit("setLoading", false);
|
|
console.log("Response Overview Order:", response.data);
|
|
commit("setAnalyticsOverviewOrder", response.data);
|
|
commit("setOverviewOrderData", response.data.orders);
|
|
commit("setOverviewOrderChartData", response.data.chart.chart_data);
|
|
commit("setOverviewOrderChartDate", response.data.chart.chart_dates);
|
|
// console.log("Response OverviewOrders:", response.data.orders);
|
|
// console.log("Response setOverviewChartData:", response.data.chart.chart_data);
|
|
// console.log("Response setOverviewChartDate:", response.data.chart.chart_dates);
|
|
//SET_NOTIFICATION_COUNT
|
|
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
async getAdminAnalyticsOverview({ commit }, payload) {
|
|
commit("setLoading", true);
|
|
|
|
await axios.post(
|
|
ADMIN_GET_ANALYTICS_OVERVIEW_API,
|
|
{
|
|
start_date: payload.start_date,
|
|
end_date: payload.end_date,
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
commit("setLoading", false);
|
|
console.log("Response Analytics:", response.data);
|
|
commit("setAnalyticsOverview", response.data);
|
|
commit("setOverviewOrder", response.data.orders);
|
|
commit("setOverviewChartData", response.data.chart.chart_data);
|
|
commit("setOverviewChartDate", response.data.chart.chart_dates);
|
|
console.log("Response OverviewOrders:", response.data.orders);
|
|
console.log("Response setOverviewChartData:", response.data.chart.chart_data);
|
|
console.log("Response setOverviewChartDate:", response.data.chart.chart_dates);
|
|
//SET_NOTIFICATION_COUNT
|
|
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
|
|
async getAdminAnalyticsOrder({ commit }, payload) {
|
|
commit("setLoading", true);
|
|
|
|
await axios.post(
|
|
ADMIN_GET_ANALYTICS_ORDERS_API,
|
|
{
|
|
start_date: payload.start_date,
|
|
end_date: payload.end_date,
|
|
patient:payload.patientId,
|
|
status:payload.order_status,
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
commit("setLoading", false);
|
|
console.log("Response Analytics Order Data:", response.data);
|
|
commit("setAnalyticsOverview", {
|
|
chart:{
|
|
chart_data:response.data.chart.chart_data,
|
|
chart_dates:response.data.chart.chart_dates,
|
|
},
|
|
orders:response.data.orders,
|
|
totals: response.data.totals,
|
|
patient_stats:{
|
|
new_users:[],
|
|
returning_users:[],
|
|
}
|
|
});
|
|
commit("setOverviewOrder", response.data.orders);
|
|
commit("setOverviewChartData", response.data.chart.chart_data);
|
|
commit("setOverviewChartDate", response.data.chart.chart_dates);
|
|
// console.log("Response OverviewOrders:", response.data.orders);
|
|
// console.log("Response setOverviewChartData:", response.data.chart.chart_data);
|
|
// console.log("Response setOverviewChartDate:", response.data.chart.chart_dates);
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
async getAnalyticOrderFilters({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_GET_ORDERS_FILTERS_API, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Filters Response:', response.data);
|
|
commit('setOrderFilters',response.data.patients);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getInitialPatients({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_GET_PATIENTS_INITIAL_API, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Filters Response:', response.data);
|
|
commit('setOrderFilters',response.data.patients);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async searchPatients({ commit }, payload) {
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
if(payload)
|
|
{
|
|
await axios.post(ADMIN_GET_PATIENTS_SEARCH_API + '?term='+payload, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
console.log('Filters Response:', response.data);
|
|
commit('setOrderFilters',response.data.patients);
|
|
|
|
})
|
|
.catch(error => {
|
|
console.error('Error:', error);
|
|
});
|
|
}
|
|
},
|
|
async updateStatusItem({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_ITEM_STATUS_UPDATE_ORDERS_API+'/'+payload.item_id, {status:payload.status,order_id:payload.order_id}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Filters Response:', response.data);
|
|
commit('setOrderFilters',response.data.patients);
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getAdminDashboardData({ commit }, payload) {
|
|
commit("setLoading", true);
|
|
|
|
await axios.post(
|
|
DASHBOARD_API,
|
|
{
|
|
start_date: payload.start_date,
|
|
end_date: payload.end_date,
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
commit("setLoading", false);
|
|
console.log("Response Dashoard:", response.data);
|
|
commit("setDashboardData", response.data);
|
|
//SET_NOTIFICATION_COUNT
|
|
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
async admiUserList({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_USER_LIST_API, {
|
|
start: payload.startL,
|
|
length:payload.endL,
|
|
// search:payload.search,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
|
|
commit('setAdminUserList',response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async adminUserSave({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ADMIN_SAVE_API, {
|
|
name: payload.name,
|
|
last_name: payload.last_name,
|
|
email: payload.email,
|
|
password:payload.password,
|
|
phone_no: payload.phone_no,
|
|
role_id: payload.role_id,
|
|
profile_pic:payload.profile_pic
|
|
}, {
|
|
headers: {
|
|
'Content-Type': 'multipart/form-data',
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.success) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:','successfully saved!');
|
|
commit('setShowMsg', 'successfully saved!')
|
|
|
|
}
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
commit('setErrorMsg', true)
|
|
const isDuplicateEntryError = /1062 Duplicate entry/.test(error.response.data.message);
|
|
if (isDuplicateEntryError) {
|
|
|
|
|
|
commit('setShowMsg', 'Email already taken!')
|
|
} else {
|
|
commit('setShowMsg', error.response.data.message)
|
|
}
|
|
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async adminUpdateUser({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_UPDATE_API+'/'+payload.id, {
|
|
name: payload.name,
|
|
last_name: payload.last_name,
|
|
email: payload.email,
|
|
password:payload.password,
|
|
phone_no: payload.phone_no,
|
|
role_id: payload.role_id,
|
|
profile_pic:payload.profile_pic
|
|
}, {
|
|
headers: {
|
|
'Content-Type': 'multipart/form-data',
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
if (response.data.success) {
|
|
commit('setSuccessMsg', true)
|
|
console.log('Response:','successfully saved!');
|
|
commit('setShowMsg', 'successfully saved!')
|
|
|
|
}
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
commit('setErrorMsg', true)
|
|
const isDuplicateEntryError = /1062 Duplicate entry/.test(error.response.data.message);
|
|
if (isDuplicateEntryError) {
|
|
|
|
|
|
commit('setShowMsg', 'Email already taken!')
|
|
} else {
|
|
commit('setShowMsg', error.response.data.message)
|
|
}
|
|
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async singleUserEdit({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_SINGLE_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSingleUser', response.data.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getAllProductsList ({commit,state},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_GET_PRODUCTS_LIST_API, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response Products:', response.data);
|
|
commit('setProductsList',response.data.data);
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getAdminProductsAnalytics({ commit }, payload) {
|
|
commit("setLoading", true);
|
|
|
|
await axios.post(
|
|
ADMIN_GET_PRODUCTS_ANALYTICS_API,
|
|
{
|
|
start_date: payload.start_date,
|
|
end_date: payload.end_date,
|
|
single_product: payload.single_product,
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
commit("setLoading", false);
|
|
console.log("Response Products Analytics:", response.data);
|
|
commit("setProductsAnalytics", response.data);
|
|
//SET_NOTIFICATION_COUNT
|
|
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
async getAdminRoles({ commit }, payload) {
|
|
commit("setLoading", true);
|
|
|
|
await axios.post(
|
|
ADMIN_GET_ROLES_API,
|
|
{},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
commit("setLoading", false);
|
|
console.log("Response Permissions:", response.data);
|
|
commit("setPermissions", response.data.data);
|
|
//SET_NOTIFICATION_COUNT
|
|
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
console.error("Error:", error);
|
|
});
|
|
},
|
|
async saveRole({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_GET_ROLES_SAVE_API, {
|
|
role_name: payload.name,
|
|
role_guard: payload.guard,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Successfully Added')
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getRoleByID({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_GET_ROLES_BY_ID_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSingleRole', response.data.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async updateRole({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_UPDATE_ROLES_BY_ID_API+'/'+payload.id, {
|
|
role_name: payload.name,
|
|
role_guard: payload.guard,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Successfully Updated')
|
|
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
if ( error.response.data.status === 500) {
|
|
commit('setErrorMsg', true)
|
|
|
|
commit('setShowMsg', 'somthing wrong!')
|
|
}
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async deleteRole({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_DELETE_ROLES_BY_ID_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Successfully Deleted')
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async permissionsRole({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_GET_PERMISSION_ROLE_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data.data);
|
|
|
|
commit('setPermissionsRole', response.data.data)
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async permissionsUpdate({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_UPDATE_PERMISSION_API+'/'+payload.id, {permisssions:payload.permisssions}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data.success);
|
|
if (response.data.success) {
|
|
commit("setIsTonalSnackbarVisible", true);
|
|
commit('setSuccessMsg', true)
|
|
commit("setShowMsg", response.data.success);
|
|
}
|
|
// commit('setPermissionsRole', response.data.data)
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getAllRolesList ({commit,state},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ROLES_LIST_API, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response Roles List:', response.data);
|
|
commit('setRolesList',response.data.data);
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async updateSelectedTimezone({ commit }, payload) {
|
|
commit("setSelectedTimezone", payload);
|
|
},
|
|
async getAvailableSlotsData({ commit, state }, payload) {
|
|
commit("setLoading", true);
|
|
await axios.post(
|
|
ADMIN_GET_AVAILABLE_SLOTS_API + payload.date,
|
|
{},
|
|
{
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
Accept: "application/json",
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
commit("setLoading", false);
|
|
commit("setAvailableSlots", response.data.available_slots);
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
console.log("Error:", error);
|
|
});
|
|
},
|
|
async saveShippingInformation({ commit, state }, payload) {
|
|
|
|
await axios
|
|
.post(
|
|
ADMIN_STORE_ORDER_API + '/1/'+payload.patient_id,
|
|
{
|
|
first_name: payload.first_name,
|
|
last_name: payload.last_name,
|
|
email: payload.email,
|
|
phone: payload.phone,
|
|
patient_id: payload.patient_id,
|
|
shipping_address1: payload.shipping_address1,
|
|
shipping_address2: payload.shipping_address2,
|
|
shipping_city: payload.shipping_city,
|
|
shipping_state: payload.shipping_state,
|
|
shipping_zipcode: payload.shipping_zipcode,
|
|
shipping_country: payload.shipping_country,
|
|
billing_address1: null,
|
|
billing_address2: null,
|
|
billing_city: null,
|
|
billing_state: null,
|
|
billing_zipcode: null,
|
|
billing_country: null,
|
|
shipping_amount: payload.shipping_amount,
|
|
total_amount: payload.total_amount,
|
|
items: payload.items,
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
"Content-Type": "application/json",
|
|
Accept: "application/json",
|
|
},
|
|
}
|
|
)
|
|
.then((r) => {
|
|
console.log("store order", r.data);
|
|
localStorage.setItem('cart_id',r.data.cart.id)
|
|
})
|
|
.catch((e) => {
|
|
commit("setLoading", false);
|
|
console.log("error ", e.response);
|
|
});
|
|
},
|
|
async processPayment({ commit, state }, payload) {
|
|
commit("setLoading", true);
|
|
|
|
await axios
|
|
.post(
|
|
ADMIN_PROCESS_PAYMENT_API,
|
|
{},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
"Content-Type": "application/json",
|
|
Accept: "application/json",
|
|
},
|
|
}
|
|
)
|
|
|
|
.then((response) => {
|
|
console.log(response.data);
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
console.error(error);
|
|
});
|
|
},
|
|
async savePatientAppointment({ commit, state }, payload) {
|
|
// commit('setLoading', true)
|
|
commit("setShowMsg", null);
|
|
commit("setSuccessMsg", false);
|
|
await axios
|
|
.post(
|
|
ADMIN_BOOK_APPOINTMENT_API,
|
|
{
|
|
patient_id: payload.patient_id,
|
|
patient_name: payload.patient_name,
|
|
patient_email: payload.patient_email,
|
|
appointment_date: payload.appointment_date,
|
|
appointment_time: payload.appointment_time,
|
|
timezone: payload.timezone,
|
|
cart_id: localStorage.getItem('cart_id'),
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
console.log("Response:", response.data);
|
|
// commit("setTimeDiff", response.data.time_diff);
|
|
const appointmentDetail = response.data.appointment;
|
|
localStorage.setItem(
|
|
"patient_appointment_id",
|
|
appointmentDetail.id
|
|
);
|
|
localStorage.setItem(
|
|
"selected_time_slot",
|
|
payload.timeSlotString
|
|
);
|
|
commit("updateBookAppointment", {
|
|
appointment_date: appointmentDetail.appointment_date,
|
|
appointment_time: appointmentDetail.appointment_time,
|
|
timezone: appointmentDetail.timezone,
|
|
slot_time: payload.timeSlotString,
|
|
});
|
|
// commit('setLoading', false)
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Order Created Added')
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
if (error.response.data.message) {
|
|
commit("setIsTonalSnackbarVisible", true);
|
|
commit('setSuccessMsg', true)
|
|
commit("setShowMsg", error.response.data.message);
|
|
}
|
|
console.log("Error:", error);
|
|
});
|
|
},
|
|
async orderPrecriptionList ({commit,state},payload){
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ORDER_GET_PERCRPTION_API, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response Roles List:', response.data.data);
|
|
let itemsPrescriptions = [];
|
|
for (let data of response.data.data) {
|
|
let dataObject = {};
|
|
|
|
dataObject.name = data.name;
|
|
dataObject.brand = data.brand;
|
|
dataObject.from = data.from;
|
|
dataObject.direction_quantity =
|
|
data.direction_quantity;
|
|
dataObject.dosage = data.dosage;
|
|
dataObject.quantity = data.quantity;
|
|
dataObject.refill_quantity =
|
|
data.refill_quantity;
|
|
dataObject.actions = "";
|
|
dataObject.id = data.id;
|
|
dataObject.comments = data.comments;
|
|
dataObject.direction_one = data.direction_one;
|
|
dataObject.direction_two = data.direction_two;
|
|
|
|
dataObject.status = data.status;
|
|
dataObject.date = data.created_at;
|
|
|
|
|
|
itemsPrescriptions.push(dataObject);
|
|
}
|
|
console.log("Response setPrescription:", response.data);
|
|
|
|
|
|
commit('setOrderPrecriptionList',itemsPrescriptions);
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async savePercriptionOrder({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ORDER_SAVE_PERCRPTION_API, {
|
|
name: payload.medicines,
|
|
brand: payload.brand,
|
|
from: payload.from,
|
|
dosage: payload.dosage,
|
|
quantity: payload.quantity,
|
|
direction_quantity: payload.direction_quantity,
|
|
direction_one: payload.direction_one,
|
|
direction_two: payload.direction_two,
|
|
refill_quantity: payload.refill_quantity,
|
|
dont_substitute: payload.dont_substitute,
|
|
comments: payload.comments,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Successfully Added')
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async savePercriptionUpdate({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ORDER_UPDATE_PERCRPTION_API+"/"+payload.id, {
|
|
name: payload.medicines,
|
|
brand: payload.brand,
|
|
from: payload.from,
|
|
dosage: payload.dosage,
|
|
quantity: payload.quantity,
|
|
direction_quantity: payload.direction_quantity,
|
|
direction_one: payload.direction_one,
|
|
direction_two: payload.direction_two,
|
|
refill_quantity: payload.refill_quantity,
|
|
dont_substitute: payload.dont_substitute,
|
|
comments: payload.comments,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Successfully Update')
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getPercrptionByID({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ORDER_GET_ID_PERCRPTION_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSinglePrescription', response.data.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async deletePerscription({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_ORDER_DELETE_PERCRPTION_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Successfully Deleted')
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async updateShippingInformation({ commit, state }, payload) {
|
|
|
|
await axios
|
|
.post(
|
|
ADMIN_UPDATE_ORDER_API + '/'+payload.id,
|
|
{
|
|
first_name: payload.first_name,
|
|
last_name: payload.last_name,
|
|
email: payload.email,
|
|
phone: payload.phone,
|
|
patient_id: payload.patient_id,
|
|
shipping_address1: payload.shipping_address1,
|
|
shipping_address2: payload.shipping_address2,
|
|
shipping_city: payload.shipping_city,
|
|
shipping_state: payload.shipping_state,
|
|
shipping_zipcode: payload.shipping_zipcode,
|
|
shipping_country: payload.shipping_country,
|
|
billing_address1: null,
|
|
billing_address2: null,
|
|
billing_city: null,
|
|
billing_state: null,
|
|
billing_zipcode: null,
|
|
billing_country: null,
|
|
shipping_amount: payload.shipping_amount,
|
|
total_amount: payload.total_amount,
|
|
items: payload.items,
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
"Content-Type": "application/json",
|
|
Accept: "application/json",
|
|
},
|
|
}
|
|
)
|
|
.then((r) => {
|
|
console.log("store order", r.data);
|
|
localStorage.setItem('cart_id',r.data.cart.id)
|
|
})
|
|
.catch((e) => {
|
|
commit("setLoading", false);
|
|
console.log("error ", e.response);
|
|
});
|
|
},
|
|
async updatePatientAppointment({ commit, state }, payload) {
|
|
// commit('setLoading', true)
|
|
commit("setShowMsg", null);
|
|
commit("setSuccessMsg", false);
|
|
await axios
|
|
.post(
|
|
ADMIN_UPDATE_APPOINTMENT_API + '/' + payload.id,
|
|
{
|
|
patient_id: payload.patient_id,
|
|
patient_name: payload.patient_name,
|
|
patient_email: payload.patient_email,
|
|
appointment_date: payload.appointment_date,
|
|
appointment_time: payload.appointment_time,
|
|
timezone: payload.timezone,
|
|
cart_id: localStorage.getItem('cart_id'),
|
|
},
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${localStorage.getItem(
|
|
"admin_access_token"
|
|
)}`,
|
|
},
|
|
}
|
|
)
|
|
.then((response) => {
|
|
console.log("Response:", response.data);
|
|
// commit("setTimeDiff", response.data.time_diff);
|
|
const appointmentDetail = response.data.appointment;
|
|
localStorage.setItem(
|
|
"patient_appointment_id",
|
|
appointmentDetail.id
|
|
);
|
|
localStorage.setItem(
|
|
"selected_time_slot",
|
|
payload.timeSlotString
|
|
);
|
|
commit("updateBookAppointment", {
|
|
appointment_date: appointmentDetail.appointment_date,
|
|
appointment_time: appointmentDetail.appointment_time,
|
|
timezone: appointmentDetail.timezone,
|
|
slot_time: payload.timeSlotString,
|
|
});
|
|
// commit('setLoading', false)
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Order Updated Added')
|
|
})
|
|
.catch((error) => {
|
|
commit("setLoading", false);
|
|
if (error.response.data.message) {
|
|
commit("setIsTonalSnackbarVisible", true);
|
|
commit('setSuccessMsg', true)
|
|
commit("setShowMsg", error.response.data.message);
|
|
}
|
|
console.log("Error:", error);
|
|
});
|
|
},
|
|
async savePercriptionOrderDetail({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ORDER_DETAIL_SAVE_PERCRPTION_API, {
|
|
name: payload.medicines,
|
|
order_id: payload.order_id,
|
|
patient_id:payload.patient_id,
|
|
prescription_id:payload.prescription_id,
|
|
brand: payload.brand,
|
|
from: payload.from,
|
|
dosage: payload.dosage,
|
|
quantity: payload.quantity,
|
|
direction_quantity: payload.direction_quantity,
|
|
direction_one: payload.direction_one,
|
|
direction_two: payload.direction_two,
|
|
refill_quantity: payload.refill_quantity,
|
|
dont_substitute: payload.dont_substitute,
|
|
comments: payload.comments,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Successfully Added')
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async getOrderDetailPercrptionByID({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ORDER_DETAIL_SINGLE_PERCRPTION_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setOrderDetailPrecriptionList', response.data)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async updatePercriptionOrderDetail({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ORDER_DETAIL_UPDATE_PERCRPTION_API+'/'+payload.id, {
|
|
name: payload.medicines,
|
|
order_id: payload.order_id,
|
|
patient_id:payload.patient_id,
|
|
prescription_id:payload.prescription_id,
|
|
brand: payload.brand,
|
|
from: payload.from,
|
|
dosage: payload.dosage,
|
|
quantity: payload.quantity,
|
|
direction_quantity: payload.direction_quantity,
|
|
direction_one: payload.direction_one,
|
|
direction_two: payload.direction_two,
|
|
refill_quantity: payload.refill_quantity,
|
|
dont_substitute: payload.dont_substitute,
|
|
comments: payload.comments,
|
|
}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Successfully Update')
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async deleteOrderDetailPerscription({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
console.log(localStorage.getItem('admin_access_token'))
|
|
await axios.post(ADMIN_ORDER_DETAIL_DELETE_PERCRPTION_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setSuccessMsg', true)
|
|
commit('setShowMsg', 'Successfully Deleted')
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
async orderPaymentDetails({ commit }, payload) {
|
|
commit('setLoading', true)
|
|
await axios.post(ADMIN_ORDER_PAYMENT_DETAILS_API+'/'+payload.id, {}, {
|
|
headers: {
|
|
'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
|
|
}
|
|
}) .then(response => {
|
|
commit('setLoading', false)
|
|
console.log('Response:', response.data);
|
|
commit('setOrderPaymentDetails', response.data.payment)
|
|
|
|
})
|
|
.catch(error => {
|
|
commit('setLoading', false)
|
|
console.error('Error:', error);
|
|
});
|
|
},
|
|
},
|
|
getters: {
|
|
getOrderPaymentDetails(state){
|
|
return state.orderPaymentDetails;
|
|
},
|
|
getCurrentFilterDate(state){
|
|
return state.filter_date;
|
|
},
|
|
getIsTonalSnackbarVisible(state) {
|
|
return state.isTonalSnackbarVisible;
|
|
},
|
|
getAvailableSlots(state) {
|
|
return state.available_slots;
|
|
},
|
|
getSelectedTimezone(state) {
|
|
return state.selectedTimezone;
|
|
},
|
|
getRolesList(state){
|
|
return state.rolesList
|
|
},
|
|
getSingleRole(state){
|
|
return state.singleRole
|
|
},
|
|
getSingleOrderNote(state){
|
|
return state.orderNote
|
|
},
|
|
|
|
getPermissions(state){
|
|
return state.permissions
|
|
},
|
|
getProductsAnalytics(state){
|
|
return state.productsAnalytics
|
|
},
|
|
getProductsList(state){
|
|
return state.productsList
|
|
},
|
|
getDashboardData(state){
|
|
return state.dashboardData
|
|
},
|
|
getOrderFilters(state){
|
|
return state.orderFilters
|
|
},
|
|
getAnalyticsOverview(state){
|
|
return state.analyticsOverview
|
|
},
|
|
getAnalyticsOverviewOrder(state){
|
|
return state.analyticsOverviewOrder
|
|
},
|
|
|
|
getIsLoading(state){
|
|
return state.isLoading
|
|
},
|
|
getErrorMsg(state) {
|
|
return state.isErrorMsg
|
|
},
|
|
getSuccessMsg(state) {
|
|
console.log('payload');
|
|
return state.isSuccessMsg
|
|
},
|
|
getShowMsg(state) {
|
|
console.log('payload');
|
|
return state.showMessage
|
|
},
|
|
|
|
getSubcriptions(state){
|
|
return state.subcriptions
|
|
},
|
|
getPatientList(state){
|
|
return state.patientList
|
|
},
|
|
getPatientMeetingList(state){
|
|
return state.patientMeetingList
|
|
},
|
|
getProviderMeetingList(state){
|
|
return state.providerMeetingList
|
|
},
|
|
getPatientLabKitList(state){
|
|
return state.patientLabKitList
|
|
},
|
|
getPatientLabKitStatus(state){
|
|
return state.patientLabKitStatus
|
|
},
|
|
getOverviewOrder(state){
|
|
return state.overviewOrders
|
|
},
|
|
getOverviewOrderData(state){
|
|
return state.overviewOrdersData
|
|
},
|
|
|
|
getAnalyticsOrder(state){
|
|
return state.analyticsOrder
|
|
},
|
|
getOverviewChartData(state){
|
|
return state.overviewChartData
|
|
},
|
|
getOverviewOrderChartData(state){
|
|
return state.overviewOrderChartData
|
|
},
|
|
getOverviewOrderChartDate(state){
|
|
return state.overviewOrderChartDate
|
|
},
|
|
|
|
getOverviewChartDate(state){
|
|
return state.overviewChartDate
|
|
},
|
|
|
|
|
|
getPatientPrescriptionStatus(state){
|
|
return state.patientPrescriptionStatus
|
|
},
|
|
getProvidersList(state){
|
|
return state.providersList
|
|
},
|
|
getLabsList(state){
|
|
return state.labsList
|
|
},
|
|
getSinglePatientAppointment(state){
|
|
return state.singlePatientAppointment
|
|
},
|
|
getPrescriptionList(state){
|
|
return state.patientPrescription
|
|
},
|
|
getPatientNotes(state){
|
|
return state.patientNotes
|
|
},
|
|
getMedcineList(state){
|
|
return state.medicineList
|
|
},
|
|
getQuestioneriesList(state){
|
|
return state.questioneriesList
|
|
},
|
|
getAdminDetail(state){
|
|
return state.adminDetail
|
|
},
|
|
getSiteSetting(state){
|
|
return state.siteSetting
|
|
},
|
|
getCheckLoginExpire(state){
|
|
return state.checkLoginExpire
|
|
},
|
|
getLabKitList(state) {
|
|
return state.labKitList
|
|
},
|
|
getPatientDetail(state) {
|
|
return state.patientDetail
|
|
},
|
|
getProviderDetail(state) {
|
|
return state.providerDetail
|
|
},
|
|
getPatientAnswers(state){
|
|
return state.patientAnswers
|
|
},
|
|
getProvidersReportFilter(state){
|
|
return state.providersReportFilter
|
|
},
|
|
getProvidersReportData(state){
|
|
return state.providersReportData
|
|
},
|
|
getOrderList(state){
|
|
return state.orderList
|
|
},
|
|
getPatientOrderDetail(state) {
|
|
return state.patientOrderDetail;
|
|
},
|
|
getOrderLabKit(state) {
|
|
return state.orderLabKit
|
|
},
|
|
getOrderCount(state) {
|
|
return state.orderCount
|
|
},
|
|
getSinglePatient(state) {
|
|
return state.singlePatient
|
|
},
|
|
getPatientDataTable(state){
|
|
return state.patientDataTable;
|
|
},
|
|
getSingleProvider(state, payload) {
|
|
return state.singleProvider;
|
|
},
|
|
getSingleProduct(state, payload) {
|
|
return state.singleProduct;
|
|
},
|
|
getAdminUserList(state, payload) {
|
|
return state.adminUserList;
|
|
},
|
|
getSingleUser(state, payload) {
|
|
return state.singleUser;
|
|
},
|
|
getPermissionsRole(state, payload) {
|
|
return state.permissionsRole
|
|
},
|
|
getOrderPrecriptionList(state, payload) {
|
|
return state.orderPrecriptionList
|
|
},
|
|
getSinglePrescription(state, payload) {
|
|
return state.singlePrescription
|
|
},
|
|
getPermissionUser(state, payload) {
|
|
return state.permissionUser
|
|
},
|
|
getItemsListByOrder(state){
|
|
return state.itemByOrder
|
|
},
|
|
getOrderDetailPrecriptionList(state){
|
|
return state.orderDetailPrecriptionList
|
|
},
|
|
}
|
|
})
|