Fixed: [弱掃] p14.1 Bad use of null-like value

Tomas

2023-08-05 977da9f44b1229c975e895f3e10eb9595bd17eb9

 PAMapp/store/index.ts

@@ -1,34 +1,51 @@
import { StrictQueryParams } from '~/shared/models/strict-query.model';
import { Module, VuexModule, Mutation, Action } from 'vuex-module-decorators'

import { getFavoriteFromStorage, setFavoriteToStorage } from '~/shared/storageConsultant';

import myConsultantService from '~/shared/services/my-consultant.service';
import queryConsultantService from '~/shared/services/query-consultant.service';
import appointmentService from '~/shared/services/appointment.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";

import { Consultant } from '~/shared/models/consultant.model';
import { Appointment, AppointmentLog } from '~/shared/models/appointment.model';
import { AgentOfStrictQuery } from '~/shared/models/strict-query.model';
@Module
export default class Store extends VuexModule {
    recommendList: Consultant[] = [];
    strictQueryList: AgentOfStrictQuery[] = [];
    myConsultantList: Consultant[] = [];
    myAppointmentGroupByConsultantList: ConsultantWithAppointmentId[] = [];

    myAppointmentList: Appointment[] = [];
    myNewAppointmentSum: number = 0;
    reviewLogList: AppointmentLog[] = [];
    unReviewLogList: AppointmentLog[] = [];
    notificationList: NotificationList[] = [];

    myAppointmentReviewLogList: AppointmentLog[] = [];
    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;
      this.recommendList = data;
    }

    @Mutation
@@ -38,22 +55,27 @@

    @Mutation
    updateStrictQueryList(data: AgentOfStrictQuery[]) {
        this.strictQueryList = data;
        this.strictQueryList = data.sort((a, b) => b.suitability - a.suitability);
    }

    @Mutation
    updateMyAppointmentList(data: Appointment[]) {
        this.myAppointmentList = data;
    updateReviewLog(data: AppointmentLog[]) {
        this.reviewLogList = data;
    }

    @Mutation
    updateMyNewAppointmentSum(newAppointmentSum: number) {
      this.myNewAppointmentSum = newAppointmentSum;
    updateUnReviewLog(data: AppointmentLog[]) {
        this.unReviewLogList = data;
    }

    @Mutation
    updateMyAppointmentReviewLog(data: AppointmentLog[]) {
        this.myAppointmentReviewLogList = data;
    updateNotification(data: NotificationList[]) {
        this.notificationList = data;
    }

    @Mutation
    updateAppointmentGroupByConsultantList(data: ConsultantWithAppointmentId[]) {
      this.myAppointmentGroupByConsultantList = data;
    }

    @Action
@@ -65,25 +87,43 @@

    @Action
    async storeConsultantList() {
        const localData = getFavoriteFromStorage();
      const localData = getFavoriteFromStorage();

        if (!this.isUserLogin) {
            this.context.commit('updateConsultantList', localData)
            return;
        };
      // 使用 Optional Chaining (安全的選擇性屬性存取) 來處理可能為 null 或 undefined 的情況
      if (!this.isUserLogin) {
        this.context.commit('updateConsultantList', localData);
        return;
      }

      if (localData?.length) {
        const addFavoriteAgentList: AddFavoriteConsultantItem[] = localData.map(i => ({ agentNo: i.agentNo, createdTime: i.updateTime }));

        if (localData?.length) {
            const agentNoList = localData.map(i => i.agentNo)
            await queryConsultantService.addFavoriteConsultant(agentNoList).then(res => {
                localStorage.removeItem('favoriteConsultant')
            })
        // 確保異步操作的回傳結果不為 null 或 undefined
        const response = await queryConsultantService.addFavoriteConsultant(addFavoriteAgentList);
        if (response !== null) {
          localStorage.removeItem('favoriteConsultant');
        } else {
          throw new Error('queryConsultantService.addFavoriteConsultant returned null-like value.');
        }
      }

        myConsultantService.getFavoriteConsultantList().then(data => {
            this.context.commit('updateConsultantList', data);
        })
      // 確保異步操作的回傳結果不為 null 或 undefined
      const favoriteConsultantList = await myConsultantService.getFavoriteConsultantList();
      if (favoriteConsultantList !== null) {
        this.context.commit('updateConsultantList', favoriteConsultantList);
      } else {
        throw new Error('myConsultantService.getFavoriteConsultantList returned null-like value.');
      }

      // 確保異步操作的回傳結果不為 null 或 undefined
      const groupByConsultantData = await myConsultantService.getAllGroupByConsultant();
      if (groupByConsultantData !== null) {
        this.context.commit('updateAppointmentGroupByConsultantList', groupByConsultantData);
      } else {
        throw new Error('myConsultantService.getAllGroupByConsultant returned null-like value.');
      }
    }


    @Action
    async removeFromMyConsultantList(agentNo: string) {
@@ -105,33 +145,35 @@

    @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([consultantToAdd.agentNo])
                } else {
                    setFavoriteToStorage(newData);
                }
    if (consultantToAdd) {
      const found = this.myConsultantList.find(item => item.agentNo === consultantToAdd.agentNo);
      if (!found) {
        const newData = [consultantToAdd].concat(this.myConsultantList);

                this.context.commit('updateConsultantList', newData)

                return true;
        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
    storeMyAppointmentList(): void {
      appointmentService.getMyAppointmentList().then((data) => {
            const newAppointmentSum = data.filter(item => !item.consultantViewTime || item.consultantViewTime === null).length;
            this.context.commit('updateMyAppointmentList', data);
            this.context.commit('updateMyNewAppointmentSum', newAppointmentSum);
        });
    }
    return false;
  }


    @Action
    storeMyAppointmentReviewLog() {
@@ -143,15 +185,11 @@
                }
            });
            const sortedData = dataWithLatestDate.sort((a, b) => +b.compareDate - +a.compareDate);
            this.context.commit('updateMyAppointmentReviewLog', sortedData);
            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
    updateMyAppointment(myAppointment: Appointment) {
        const data = this.myAppointmentList.filter(item => item.id !== myAppointment.id);
        data.unshift(myAppointment);
        this.context.commit('updateMyAppointmentList', data)
    }

    @Action
@@ -163,4 +201,13 @@
        });
    }

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

}