update#135494: [ 客戶端 ] 加入顧問到我的顧問清單後，未顯示加入日期

Tomas

2022-02-23 e912d42c4a9d806c2a498fef458ef8cb4e9ba405

 PAMapp/store/index.ts

@@ -1,6 +1,166 @@
import { Module, VuexModule } from 'vuex-module-decorators'
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 } 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';

@Module
export default class Store extends VuexModule {
    recommendList: Consultant[] = [];
    strictQueryList: AgentOfStrictQuery[] = [];
    myConsultantList: Consultant[] = [];

}
    reviewLogList: AppointmentLog[] = [];
    unReviewLogList: AppointmentLog[] = [];
    notificationList: NotificationList[] = [];

    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;
    }

    @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;
    }

    @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);
        })
    }

    @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) {
                    await queryConsultantService.addFavoriteConsultant([{ agentNo: consultantToAdd.agentNo, createdTime: consultantToAdd.updateTime  }])
                } 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);
        })
    }

}