= 职业规划推荐

pages/service/store/skill-development.js

@@ -0,0 +1,192 @@
+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
+    };
+});