import { Module, VuexModule, Mutation, Action } from 'vuex-module-decorators'
|
|
import myConsultantService from '~/shared/services/my-consultant.service';
|
import queryConsultantService, { AddFavoriteConsultantItem } from '~/shared/services/query-consultant.service';
|
import reviewsService from '~/shared/services/reviews.service';
|
import { Consultant, ConsultantWithAppointmentId } from '~/shared/models/consultant.model';
|
import { getFavoriteFromStorage, setFavoriteToStorage } from '~/shared/storageConsultant';
|
import { AppointmentLog } from '~/shared/models/appointment.model';
|
import { AgentOfStrictQuery, StrictQueryParams } from '~/shared/models/strict-query.model';
|
import { NotificationList } from '~/shared/models/reviews.model';
|
import {AccessFroms} from "~/shared/services/utils.service";
|
|
@Module
|
export default class Store extends VuexModule {
|
recommendList: Consultant[] = [];
|
strictQueryList: AgentOfStrictQuery[] = [];
|
myConsultantList: Consultant[] = [];
|
myAppointmentGroupByConsultantList: ConsultantWithAppointmentId[] = [];
|
|
reviewLogList: AppointmentLog[] = [];
|
unReviewLogList: AppointmentLog[] = [];
|
notificationList: NotificationList[] = [];
|
|
accessFrom: AccessFroms | null = null;
|
|
get isUserLogin() {
|
return this.context.getters['localStorage/isUserLogin'];
|
}
|
|
get strictResultList(): AgentOfStrictQuery[] {
|
const perfectMatchList = this.strictQueryList.filter((i) => i.suitability === 100);
|
return perfectMatchList.length > 5
|
? perfectMatchList
|
: this.strictQueryList;
|
}
|
|
get fromAccess(): AccessFroms | null {
|
return this.accessFrom;
|
}
|
|
@Mutation
|
setAccessSource(from: AccessFroms) {
|
this.accessFrom = from;
|
}
|
|
@Mutation
|
updateRecommend(data: Consultant[]) {
|
this.recommendList = data;
|
}
|
|
@Mutation
|
updateConsultantList(data: Consultant[]) {
|
this.myConsultantList = data;
|
}
|
|
@Mutation
|
updateStrictQueryList(data: AgentOfStrictQuery[]) {
|
this.strictQueryList = data.sort((a, b) => b.suitability - a.suitability);
|
}
|
|
@Mutation
|
updateReviewLog(data: AppointmentLog[]) {
|
this.reviewLogList = data;
|
}
|
|
@Mutation
|
updateUnReviewLog(data: AppointmentLog[]) {
|
this.unReviewLogList = data;
|
}
|
|
@Mutation
|
updateNotification(data: NotificationList[]) {
|
this.notificationList = data;
|
}
|
|
@Mutation
|
updateAppointmentGroupByConsultantList(data: ConsultantWithAppointmentId[]) {
|
this.myAppointmentGroupByConsultantList = data;
|
}
|
|
@Action
|
storeRecommendList() {
|
queryConsultantService.getRecommendConsultantList().then(data => {
|
this.context.commit('updateRecommend', data)
|
})
|
}
|
|
@Action
|
async storeConsultantList() {
|
const localData = getFavoriteFromStorage();
|
|
if (!this.isUserLogin) {
|
this.context.commit('updateConsultantList', localData)
|
return;
|
};
|
|
|
if (localData?.length) {
|
const addFavoriteAgentList: AddFavoriteConsultantItem[] = localData.map(i => ({ agentNo: i.agentNo, createdTime: i.updateTime}));
|
await queryConsultantService.addFavoriteConsultant(addFavoriteAgentList).then(res => {
|
localStorage.removeItem('favoriteConsultant')
|
})
|
}
|
|
myConsultantService.getFavoriteConsultantList().then(data => {
|
this.context.commit('updateConsultantList', data);
|
})
|
|
myConsultantService.getAllGroupByConsultant().then((data) => {
|
this.context.commit('updateAppointmentGroupByConsultantList', data);
|
})
|
}
|
|
@Action
|
async removeFromMyConsultantList(agentNo: string) {
|
const left = this.myConsultantList.filter(item => item.agentNo !== agentNo);
|
|
// no agent was removed
|
if (left.length === this.myConsultantList.length) return false;
|
|
if (!this.isUserLogin) {
|
setFavoriteToStorage(left);
|
} else {
|
await myConsultantService.deleteConsultant(agentNo)
|
}
|
|
this.context.commit('updateConsultantList', left)
|
|
return true
|
}
|
|
@Action
|
async addToMyConsultantList(consultantToAdd: Consultant) {
|
if (consultantToAdd) {
|
const found = this.myConsultantList.find(item => item.agentNo === consultantToAdd.agentNo);
|
if (!found) {
|
const newData = [consultantToAdd].concat(this.myConsultantList);
|
|
if (this.isUserLogin) {
|
try {
|
const response = await queryConsultantService.addFavoriteConsultant([{ agentNo: consultantToAdd.agentNo, createdTime: consultantToAdd.updateTime }]);
|
if (response !== null) {
|
this.context.commit('updateConsultantList', newData);
|
return true;
|
} else {
|
throw new Error('queryConsultantService.addFavoriteConsultant returned null-like value.');
|
}
|
} catch (error) {
|
console.error('An error occurred while adding favorite consultant:', error);
|
throw error;
|
}
|
} else {
|
setFavoriteToStorage(newData);
|
this.context.commit('updateConsultantList', newData);
|
return true;
|
}
|
}
|
}
|
|
return false;
|
}
|
|
|
@Action
|
storeMyAppointmentReviewLog() {
|
reviewsService.getMyReviewLog().then((data) => {
|
const dataWithLatestDate = data.map((item) => {
|
return {
|
...item,
|
compareDate: new Date(item.lastModifiedDate)
|
}
|
});
|
const sortedData = dataWithLatestDate.sort((a, b) => +b.compareDate - +a.compareDate);
|
const reviewLog = sortedData.filter(item => item.score);
|
const unReviewLog = sortedData.filter(item => !item.score);
|
this.context.commit('updateReviewLog', reviewLog);
|
this.context.commit('updateUnReviewLog', unReviewLog);
|
});
|
}
|
|
@Action
|
async storeStrictQueryList(strictQueryDto: StrictQueryParams) {
|
return await queryConsultantService.strictQuery(strictQueryDto).then(res=>{
|
this.context.commit('localStorage/storageRecommendConsultant', JSON.stringify(strictQueryDto));
|
this.context.commit('updateStrictQueryList', res)
|
return res.length;
|
});
|
}
|
|
@Action
|
storeMyPersonalNotification() {
|
reviewsService.getMyPersonalNotification().then(data => {
|
const sortData = data
|
.sort((preItem, nextItem) => +new Date(nextItem.createdDate) - +new Date(preItem.createdDate))
|
this.context.commit('updateNotification', sortData);
|
})
|
}
|
|
}
|
