ks-app-employment-service/stores/useSkillDevelopmentStore.js

import { computed, ref, watch } from 'vue';
import { defineStore } from 'pinia';
import { useAuthUserStore, useBasicStore } from './index';
import { getCurrentPosition, getPath, getSkill } from '@/apiRc/service';

export const useSkillDevelopmentStore = defineStore('skill-development', () => {
    const storeBasic = useBasicStore();
    const storeUser = useAuthUserStore();

    const profession = ref('');
    const professions = ref([]);
    const professionsRef = computed(() => {
        const userInfo = storeUser.userInfo;
        if (!userInfo || !userInfo.professions || userInfo.professions.length === 0) {
            return professions.value;
        }
        const userProfessionsLabels = userInfo.professions.map((d) => d.label);
        let professionsA = [];
        let professionsB = [];
        professions.value.filter((d) => userProfessionsLabels.includes(d.label));
        for (const d of professions.value) {
            if (userProfessionsLabels.includes(d.label)) {
                professionsA.push(d);
            } else {
                professionsB.push(d);
            }
        }
        if (professionsA.length === 0) {
            professionsA = userInfo.professions;
            professionsB = professions.value;
        }
        return [...professionsA, ...professionsB];
    });

    const targetCareer = ref('');
    const paths = ref([]);
    const pathsRef = computed(() => {
        return paths.value.filter((d) => {
            return `${d.startJobId}` === profession.value;
        });
    });

    const result = ref([]);

    const fetchData = async () => {
        try {
            const { code, msg, data } = await getCurrentPosition();
            if (code !== 0) {
                $emitter.emit('error-message', msg);
                return;
            }
            if (!data) {
                return;
            }
            professions.value = data.map((d) => {
                return {
                    label: d.name,
                    value: `${d.jobId}`
                };
            });
        } catch (e) {
            console.warn(e);
        }
    };

    const fetchDataPath = async () => {
        try {
            const { code, msg, data } = await getPath();
            if (code !== 0) {
                $emitter.emit('error-message', msg);
                return;
            }
            if (!data) {
                return;
            }
            paths.value = data.map((d) => {
                return {
                    label: d.endJob,
                    value: d.endJob,
                    startJobId: d.startJobId
                };
            });
        } catch (e) {
            console.warn(e);
        }
    };

    const fetchResult = async () => {
        const current = professionsRef.value.find((d) => d.value === profession.value);
        const target = pathsRef.value.find((d) => d.value === targetCareer.value);
        if (!current || !target) {
            return;
        }
        const params = {
            currentJobName: current.label,
            targetJobName: target.label
        };
        try {
            const { code, msg, data } = await getSkill(params);
            if (code !== 0) {
                $emitter.emit('error-message', msg);
                return;
            }
            if (typeof data !== 'undefined' && Array.isArray(data) && data.length > 0 && data[0]) {
                const excludes = data[0].currentSkillDetList.map((d) => d.skillId);
                result.value = data[0].targetSkillDetList
                    .filter((d) => !excludes.includes(d.skillId))
                    .map((d) => {
                        return {
                            type: d.skillType,
                            title: d.skillName,
                            name: d.skillName,
                            weight: d.skillWeight,
                            score: d.skillScore
                        };
                    });
            }
        } catch (e) {
            console.warn(e);
        }
    };

    const eventChange = () => {
        targetCareer.value = '';
    };

    const eventSearch = () => {
        if (pathsRef.value.length === 0) {
            ElMessage.warning({
                message: '当前职业暂无发展路径，敬请期待！',
                duration: 5000
            });
            return;
        }
        if (!profession.value) {
            ElMessage.warning({
                message: '请选择当前职位！',
                duration: 5000
            });
            return;
        }
        if (!targetCareer.value) {
            ElMessage.warning({
                message: '请选择目标职业！',
                duration: 5000
            });
            return;
        }
        void fetchResult();
    };

    watch(
        () => storeBasic.loaded,
        () => {
            if (storeBasic.loaded) {
                void fetchData();
                void fetchDataPath();
            }
        }
    );

    watch(
        () => professionsRef.value,
        () => {
            if (typeof professionsRef.value[0] !== 'undefined') {
                if (professionsRef.value[0].value) {
                    profession.value = professionsRef.value[0].value;
                }
            }
        }
    );

    watch(
        () => profession.value,
        () => {
            const userInfo = storeUser.userInfo;
            if (userInfo.professions[0] && profession.value === userInfo.professions[0].value) {
                targetCareer.value = '';
            }
        }
    );

    return {
        profession,
        professionsRef,
        targetCareer,
        pathsRef,
        result,
        eventChange,
        eventSearch
    };
});