feat: 完善职业图谱功能

apiRc/jobSkill.js

@@ -13,6 +13,16 @@ export function getJobSkillDetail(params) {
   })
 }
 
+// 获取技能权重
+export function getJobSkillWeight(params) {
+  return request({
+    url: '/jobSkillDet/getJobSkillWeight',
+    method: 'get',
+    params,
+    baseUrlType: 'zytp'
+  })
+}
+
 // 暂未使用 - 如果需要在 CareerPath.vue 中点击路径职位查看详细技能信息时使用
 // 使用场景：获取职业路径中某个职位的详细技能信息（包含技能分数、类型等）
 // export function getJobPathSkill(data) {

apiRc/user/user.js

@@ -8,8 +8,7 @@ import request from '@/utilsRc/request'
 // 获取用户信息（职业规划推荐用）
 export function appUserInfo() {
   return request({
-    url: '/app/user/appUserInfo',
-    method: 'get',
-    baseUrlType: 'user' // 使用用户接口专用baseUrl
+    fullUrl: 'http://ks.zhaopinzao8dian.com/api/ks/app/user/appUserInfo',
+    method: 'get'
   })
 }

pages/service/career-planning.vue

@@ -49,10 +49,8 @@
                 />
                 <SkillDevelopment 
                     v-else 
-                    :current-job-skills="recommendSkillsData.currentJobSkills"
-                    :recommended-jobs="recommendSkillsData.recommendedJobs"
-                    :path-data="pathSkillsData.pathData"
-                    :target-career="pathSkillsData.targetCareer"
+                    :current-job-name="currentJobName"
+                    @path-data-updated="handlePathDataUpdated"
                 />
             </scroll-view>
         </view>
@@ -67,7 +65,6 @@
 <script setup>
 import { ref, inject, nextTick, onMounted } from 'vue';
 import { onLoad } from '@dcloudio/uni-app';
-import { getJobSkillDetail } from '@/apiRc/jobSkill.js';
 import { appUserInfo } from '@/apiRc/user/user.js';
 import RemindPopup from './components/RemindPopup.vue';
 import PageHeader from './components/PageHeader.vue';
@@ -158,53 +155,68 @@ async function getRemindInfo() {
         const response = await appUserInfo();
         const userInfo = response?.data || {};
         
-        // 优先从接口数据中获取 idCard
+        // 检查 idCard（身份证）- 必须项
         let idCard = userInfo?.resume?.idCard ?? userInfo?.idCard ?? null;
-        
-        // 如果接口返回的数据中没有 idCard，则从缓存中读取
         const cachedUserInfo = uni.getStorageSync('userInfo') || {};
         if (!idCard || idCard === null || idCard === '') {
             idCard = cachedUserInfo?.resume?.idCard ?? cachedUserInfo?.idCard ?? null;
         }
-        
-        // 优先从接口数据中获取职位信息
-        currentJobId.value = userInfo?.jobId ?? 
-                             userInfo?.currentJobId ?? 
-                             userInfo?.resume?.jobId ?? 
-                             userInfo?.resume?.currentJobId ?? 
-                             null;
-        currentJobName.value = userInfo?.jobName ?? 
-                               userInfo?.currentJobName ?? 
-                               userInfo?.resume?.jobName ?? 
-                               userInfo?.resume?.currentJobName ?? 
-                               '';
-        
-        // 如果接口数据中没有职位信息，从缓存中读取
-        if (!currentJobId.value && !currentJobName.value) {
-            currentJobId.value = cachedUserInfo?.jobId ?? 
-                                 cachedUserInfo?.currentJobId ?? 
-                                 cachedUserInfo?.resume?.jobId ?? 
-                                 cachedUserInfo?.resume?.currentJobId ?? 
-                                 null;
-            currentJobName.value = cachedUserInfo?.jobName ?? 
-                                   cachedUserInfo?.currentJobName ?? 
-                                   cachedUserInfo?.resume?.jobName ?? 
-                                   cachedUserInfo?.resume?.currentJobName ?? 
-                                   '';
-        }
-        
-        // 如果还是没有职位信息，使用默认值
-        if (!currentJobName.value) {
-            currentJobName.value = '市场专员';
-        }
-        
-        // 判断 idCard 是否存在（包括空字符串、undefined、null 的情况）
         const hasIdCard = idCard !== null && idCard !== undefined && idCard !== '';
         
-        if (!hasIdCard) {
-            remindList.value = ['请完善个人信息'];
+        // 检查职位信息：优先从 jobTitles 数组获取
+        const jobTitles = Array.isArray(userInfo?.jobTitles) ? userInfo.jobTitles : [];
+        const hasJobTitle = jobTitles.length > 0;
+        
+        // 如果 jobTitles 为空，尝试从其他字段获取
+        let jobName = '';
+        if (!hasJobTitle) {
+            jobName = userInfo?.jobName ?? 
+                     userInfo?.currentJobName ?? 
+                     userInfo?.resume?.jobName ?? 
+                     userInfo?.resume?.currentJobName ?? 
+                     '';
+        }
+        const hasJobInfo = hasJobTitle || (jobName && jobName.trim() !== '');
+        
+        // 检查技能标签：从 appSkillsList 获取
+        const appSkillsList = Array.isArray(userInfo?.appSkillsList) ? userInfo.appSkillsList : [];
+        // 检查是否有有效的技能（name 或 nameStr 不为空）
+        const hasSkills = appSkillsList.some(skill => {
+            const skillName = skill?.name || skill?.nameStr;
+            return skillName && skillName.trim() !== '';
+        });
+        
+        // 判断信息是否完整（idCard、职位信息、技能标签都必须有）
+        const isComplete = hasIdCard && hasJobInfo && hasSkills;
+        
+        if (!isComplete) {
+            // 收集缺失的信息提示
+            const missingItems = [];
+            if (!hasIdCard) {
+                missingItems.push('身份证信息');
+            }
+            if (!hasJobInfo) {
+                missingItems.push('职位信息');
+            }
+            if (!hasSkills) {
+                missingItems.push('技能标签');
+            }
+            remindList.value = [`请完善${missingItems.join('、')}`];
         } else {
-            remindList.value = ['暂无待完善信息'];
+            // 信息完整，设置职位信息
+            if (hasJobTitle) {
+                currentJobName.value = jobTitles[0];
+            } else {
+                currentJobName.value = jobName;
+                currentJobId.value = userInfo?.jobId ?? 
+                                   userInfo?.currentJobId ?? 
+                                   userInfo?.resume?.jobId ?? 
+                                   userInfo?.resume?.currentJobId ?? 
+                                   null;
+            }
+            // 信息完整，直接显示页面内容
+            showContent.value = true;
+            return;
         }
         
         setTimeout(() => {
@@ -213,28 +225,62 @@ async function getRemindInfo() {
     } catch (error) {
         // 接口调用失败时，使用缓存作为降级方案
         const cachedUserInfo = uni.getStorageSync('userInfo') || {};
+        
+        // 检查 idCard
         const idCard = cachedUserInfo?.resume?.idCard ?? cachedUserInfo?.idCard ?? null;
+        const hasIdCard = idCard !== null && idCard !== undefined && idCard !== '';
         
-        // 从缓存中获取职位信息
-        currentJobId.value = cachedUserInfo?.jobId ?? 
-                             cachedUserInfo?.currentJobId ?? 
-                             cachedUserInfo?.resume?.jobId ?? 
-                             cachedUserInfo?.resume?.currentJobId ?? 
-                             null;
-        currentJobName.value = cachedUserInfo?.jobName ?? 
-                               cachedUserInfo?.currentJobName ?? 
-                               cachedUserInfo?.resume?.jobName ?? 
-                               cachedUserInfo?.resume?.currentJobName ?? 
-                               '';
-        // 如果缓存中没有职位信息，使用默认值
-        if (!currentJobName.value) {
-            currentJobName.value = '市场专员';
+        // 检查职位信息
+        const cachedJobTitles = Array.isArray(cachedUserInfo?.jobTitles) ? cachedUserInfo.jobTitles : [];
+        const hasJobTitle = cachedJobTitles.length > 0;
+        let jobName = '';
+        if (!hasJobTitle) {
+            jobName = cachedUserInfo?.jobName ?? 
+                     cachedUserInfo?.currentJobName ?? 
+                     cachedUserInfo?.resume?.jobName ?? 
+                     cachedUserInfo?.resume?.currentJobName ?? 
+                     '';
         }
+        const hasJobInfo = hasJobTitle || (jobName && jobName.trim() !== '');
         
-        if (!idCard || idCard === null || idCard === '') {
-            remindList.value = ['请完善个人信息'];
+        // 检查技能标签
+        const cachedAppSkillsList = Array.isArray(cachedUserInfo?.appSkillsList) ? cachedUserInfo.appSkillsList : [];
+        const hasSkills = cachedAppSkillsList.some(skill => {
+            const skillName = skill?.name || skill?.nameStr;
+            return skillName && skillName.trim() !== '';
+        });
+        
+        // 判断信息是否完整（idCard、职位信息、技能标签都必须有）
+        const isComplete = hasIdCard && hasJobInfo && hasSkills;
+        
+        if (!isComplete) {
+            // 收集缺失的信息提示
+            const missingItems = [];
+            if (!hasIdCard) {
+                missingItems.push('身份证信息');
+            }
+            if (!hasJobInfo) {
+                missingItems.push('职位信息');
+            }
+            if (!hasSkills) {
+                missingItems.push('技能标签');
+            }
+            remindList.value = [`请完善${missingItems.join('、')}`];
         } else {
-            remindList.value = ['暂无待完善信息'];
+            // 信息完整，设置职位信息
+            if (hasJobTitle) {
+                currentJobName.value = cachedJobTitles[0];
+            } else {
+                currentJobName.value = jobName;
+                currentJobId.value = cachedUserInfo?.jobId ?? 
+                                   cachedUserInfo?.currentJobId ?? 
+                                   cachedUserInfo?.resume?.jobId ?? 
+                                   cachedUserInfo?.resume?.currentJobId ?? 
+                                   null;
+            }
+            // 信息完整，直接显示页面内容
+            showContent.value = true;
+            return;
         }
         
         setTimeout(() => {
@@ -253,44 +299,8 @@ function handleCancel() {
 async function handleConfirm() {
     remindPopup.value?.close();
     
-    // 直接从缓存中读取 idCard（因为接口返回的数据中没有 idCard）
-    const cachedUserInfo = uni.getStorageSync('userInfo') || {};
-    let idCard = cachedUserInfo?.resume?.idCard ?? cachedUserInfo?.idCard ?? null;
-    
-    // 如果缓存中也没有，尝试从接口获取（虽然接口通常也没有）
-    if (!idCard || idCard === null || idCard === '') {
-        try {
-            const response = await appUserInfo();
-            const userInfo = response?.data || {};
-            idCard = userInfo?.resume?.idCard ?? userInfo?.idCard ?? null;
-        } catch (error) {
-            // 接口调用失败，继续使用缓存数据
-        }
-    }
-    
-    // 如果 idCard 为空，才跳转到完善信息页面
-    if (!idCard || idCard === null || idCard === '') {
-        navTo('/pages/complete-info/complete-info');
-        return;
-    }
-    
-    // 如果 idCard 存在，说明已经完善了信息，直接显示页面内容
-    // 从缓存中更新职位信息
-    currentJobId.value = cachedUserInfo?.jobId ?? 
-                         cachedUserInfo?.currentJobId ?? 
-                         cachedUserInfo?.resume?.jobId ?? 
-                         cachedUserInfo?.resume?.currentJobId ?? 
-                         null;
-    currentJobName.value = cachedUserInfo?.jobName ?? 
-                           cachedUserInfo?.currentJobName ?? 
-                           cachedUserInfo?.resume?.jobName ?? 
-                           cachedUserInfo?.resume?.currentJobName ?? 
-                           '';
-    if (!currentJobName.value) {
-        currentJobName.value = '市场专员';
-    }
-    
-    showContent.value = true;
+    // 跳转到完善信息页面
+    navTo('/pages/complete-info/complete-info');
 }
 
 // 切换tab
@@ -300,19 +310,28 @@ function switchTab(index) {
     if (index === 0 && !currentJobId.value) {
         const cachedUserInfo = uni.getStorageSync('userInfo') || {};
         
+        // 优先从缓存中的 jobTitles 数组获取职位信息（取第一个）
+        const cachedJobTitles = Array.isArray(cachedUserInfo?.jobTitles) ? cachedUserInfo.jobTitles : [];
+        let newJobName = '';
+        
+        if (cachedJobTitles.length > 0) {
+            newJobName = cachedJobTitles[0];
+        } else {
+            // 如果缓存中没有 jobTitles，从其他字段获取
+            newJobName = currentJobName.value || 
+                        (cachedUserInfo?.jobName ?? 
+                        cachedUserInfo?.currentJobName ?? 
+                        cachedUserInfo?.resume?.jobName ?? 
+                        cachedUserInfo?.resume?.currentJobName ?? 
+                        '市场专员');
+        }
+        
         const newJobId = cachedUserInfo?.jobId ?? 
                          cachedUserInfo?.currentJobId ?? 
                          cachedUserInfo?.resume?.jobId ?? 
                          cachedUserInfo?.resume?.currentJobId ?? 
                          null;
         
-        const newJobName = currentJobName.value || 
-                          (cachedUserInfo?.jobName ?? 
-                          cachedUserInfo?.currentJobName ?? 
-                          cachedUserInfo?.resume?.jobName ?? 
-                          cachedUserInfo?.resume?.currentJobName ?? 
-                          '市场专员');
-        
         currentJobId.value = newJobId;
         currentJobName.value = newJobName;
     }
@@ -383,23 +402,23 @@ async function handleJobCardClick(job) {
         mask: true
     });
 
-    const fallbackSkills = Array.isArray(job?.rawSkills) ? job.rawSkills : [];
-    const params = {};
-    if (job?.jobId) {
-        params.jobId = job.jobId;
-    }
-    if (job?.title) {
-        params.jobName = job.title;
-    } else if (job?.jobName) {
-        params.jobName = job.jobName;
-    }
-
     try {
-        const response = await getJobSkillDetail(params);
-        const skillList = Array.isArray(response?.data) ? response.data : [];
+        // 从 appUserInfo 接口获取技能数据
+        const response = await appUserInfo();
+        const userInfo = response?.data || {};
+        const appSkillsList = Array.isArray(userInfo?.appSkillsList) ? userInfo.appSkillsList : [];
+        
+        // 将 appSkillsList 转换为 splitSkillListByScore 需要的格式
+        const skillList = appSkillsList.map(item => ({
+            skillName: item?.name || item?.nameStr || '',
+            skillScore: item?.levels || item?.levelStr || 0
+        })).filter(item => item.skillName);
+        
         const { possessed, improvement } = splitSkillListByScore(skillList);
 
         if (possessed.length === 0 && improvement.length === 0) {
+            // 如果 appUserInfo 中没有技能数据，尝试使用推荐职位数据中的技能信息
+            const fallbackSkills = Array.isArray(job?.rawSkills) ? job.rawSkills : [];
             if (fallbackSkills.length === 0) {
                 uni.showToast({
                     title: '暂无技能数据',
@@ -416,6 +435,8 @@ async function handleJobCardClick(job) {
         }
         skillDetailPopup.value?.open();
     } catch (error) {
+        // 接口调用失败，尝试使用推荐职位数据中的技能信息
+        const fallbackSkills = Array.isArray(job?.rawSkills) ? job.rawSkills : [];
         if (fallbackSkills.length > 0) {
             const fallbackSplit = splitSkillListByScore(fallbackSkills);
             selectedJobPossessedSkills.value = fallbackSplit.possessed;

pages/service/components/CareerRecommend.vue

@@ -21,6 +21,7 @@
                     {{ skill }}
                 </view>
                 <text v-if="!skillTags.length && !isLoadingSkillTags" class="empty-text">暂无技能数据</text>
+                <text v-if="isLoadingSkillTags" class="empty-text">加载中...</text>
             </view>
         </view>
 
@@ -35,7 +36,6 @@
             :key="index"
             @click="handleJobCardClick(job)"
         >
-            <button class="search-btn" @click.stop="handleJobSearch(job)">职位搜索</button>
             <view class="job-header">
                 <text class="job-title">{{ job.title }}</text>
             </view>
@@ -55,7 +55,7 @@
 <script setup>
 import { ref, computed, watch, onMounted } from 'vue';
 import { recommendJob } from '@/apiRc/jobRecommend.js';
-import { getJobSkillDetail } from '@/apiRc/jobSkill.js';
+import { appUserInfo } from '@/apiRc/user/user.js';
 
 const props = defineProps({
     currentJobId: {
@@ -79,7 +79,14 @@ const isLoadingRecommend = ref(false);
 // 计算属性
 const currentJobDisplay = computed(() => props.currentJobName || '市场专员');
 
-// 从技能列表中提取技能名称用于显示
+// 从 appSkillsList 中提取技能名称
+function extractSkillsFromAppSkillsList(appSkillsList = []) {
+    return (Array.isArray(appSkillsList) ? appSkillsList : [])
+        .map(item => item?.name || item?.nameStr || '')
+        .filter(name => !!name && name.trim().length > 0);
+}
+
+// 从技能列表中提取技能名称用于显示（用于推荐职位数据）
 function extractSkillNames(skillList = []) {
     return (Array.isArray(skillList) ? skillList : [])
         .map(item => item?.skillName || '')
@@ -88,38 +95,15 @@ function extractSkillNames(skillList = []) {
 
 // 获取当前职位的技能标签
 async function fetchCurrentJobSkills() {
-    // 如果没有职位名称，从缓存中获取技能标签
-    if (!props.currentJobName || props.currentJobName === '市场专员') {
-        const cachedUserInfo = uni.getStorageSync('userInfo') || {};
-        const cachedSkills = cachedUserInfo?.resume?.skillList ?? 
-                            cachedUserInfo?.skillList ?? 
-                            cachedUserInfo?.appSkillsList ?? 
-                            [];
-        
-        // 如果缓存中有技能数据，使用缓存的数据
-        if (Array.isArray(cachedSkills) && cachedSkills.length > 0) {
-            skillTags.value = extractSkillNames(cachedSkills);
-        } else {
-            skillTags.value = [];
-        }
-        
-        // 通知父组件技能数据已更新
-        emit('skills-updated', {
-            currentJobSkills: skillTags.value,
-            recommendedJobs: recommendedJobs.value
-        });
-        return;
-    }
-
-    // 优先调用接口获取技能数据
     isLoadingSkillTags.value = true;
     try {
-        const response = await getJobSkillDetail({
-            jobName: props.currentJobName
-        });
+        // 优先从 appUserInfo 接口获取技能标签
+        const response = await appUserInfo();
+        const userInfo = response?.data || {};
         
-        const skillList = Array.isArray(response?.data) ? response.data : [];
-        const apiSkills = extractSkillNames(skillList);
+        // 从 appSkillsList 中提取技能名称
+        const appSkillsList = Array.isArray(userInfo?.appSkillsList) ? userInfo.appSkillsList : [];
+        const apiSkills = extractSkillsFromAppSkillsList(appSkillsList);
         
         // 如果接口返回了技能数据，使用接口数据
         if (apiSkills.length > 0) {
@@ -127,13 +111,11 @@ async function fetchCurrentJobSkills() {
         } else {
             // 如果接口没有返回技能数据，从缓存中读取
             const cachedUserInfo = uni.getStorageSync('userInfo') || {};
-            const cachedSkills = cachedUserInfo?.resume?.skillList ?? 
-                                cachedUserInfo?.skillList ?? 
-                                cachedUserInfo?.appSkillsList ?? 
-                                [];
+            const cachedAppSkills = Array.isArray(cachedUserInfo?.appSkillsList) ? cachedUserInfo.appSkillsList : [];
+            const cachedSkills = extractSkillsFromAppSkillsList(cachedAppSkills);
             
-            if (Array.isArray(cachedSkills) && cachedSkills.length > 0) {
-                skillTags.value = extractSkillNames(cachedSkills);
+            if (cachedSkills.length > 0) {
+                skillTags.value = cachedSkills;
             } else {
                 skillTags.value = [];
             }
@@ -145,15 +127,13 @@ async function fetchCurrentJobSkills() {
             recommendedJobs: recommendedJobs.value
         });
     } catch (error) {
-        // 接口调用失败时，从缓存中读取
+        // appUserInfo 接口调用失败时，从缓存中读取
         const cachedUserInfo = uni.getStorageSync('userInfo') || {};
-        const cachedSkills = cachedUserInfo?.resume?.skillList ?? 
-                            cachedUserInfo?.skillList ?? 
-                            cachedUserInfo?.appSkillsList ?? 
-                            [];
+        const cachedAppSkills = Array.isArray(cachedUserInfo?.appSkillsList) ? cachedUserInfo.appSkillsList : [];
+        const cachedSkills = extractSkillsFromAppSkillsList(cachedAppSkills);
         
-        if (Array.isArray(cachedSkills) && cachedSkills.length > 0) {
-            skillTags.value = extractSkillNames(cachedSkills);
+        if (cachedSkills.length > 0) {
+            skillTags.value = cachedSkills;
         } else {
             skillTags.value = [];
         }
@@ -221,17 +201,15 @@ onMounted(() => {
 watch(
     () => [props.currentJobId, props.currentJobName],
     () => {
-        fetchCurrentJobSkills();
-        fetchRecommendedJobs();
+        if (props.currentJobName) {
+            fetchCurrentJobSkills();
+            fetchRecommendedJobs();
+        }
     },
     { immediate: true }
 );
 
 // 事件处理
-function handleJobSearch(job) {
-    // TODO: 实现职位搜索跳转
-}
-
 function handleJobCardClick(job) {
     emit('job-card-click', job);
 }
@@ -315,24 +293,8 @@ function handleJobCardClick(job) {
     cursor: pointer;
 }
 
-.search-btn {
-    position: absolute;
-    top: 16rpx;
-    right: 16rpx;
-    background-color: #FFDAB9;
-    color: #FF6347;
-    font-size: 20rpx;
-    padding: 6rpx 14rpx;
-    border-radius: 6rpx;
-    border: 1rpx solid #FFA07A;
-    white-space: nowrap;
-    z-index: 10;
-    line-height: 1.2;
-}
-
 .job-header {
     margin-bottom: 16rpx;
-    padding-right: 100rpx;
 }
 
 .job-title {

pages/service/components/PageHeader.vue

@@ -1,5 +1,5 @@
 <template>
-    <view class="page-header">
+    <view class="page-header" :style="{ paddingTop: statusBarHeight > 0 ? `calc(40rpx + ${statusBarHeight * 2}rpx)` : '40rpx' }">
         <view class="header-top">
             <view class="title-section">
                 <text class="main-title">职业规划推荐指导平台</text>
@@ -54,7 +54,7 @@
 </template>
 
 <script setup>
-import { defineProps, defineEmits } from 'vue';
+import { defineProps, defineEmits, ref, onMounted } from 'vue';
 
 const props = defineProps({
     activeTab: {
@@ -65,6 +65,18 @@ const props = defineProps({
 
 const emit = defineEmits(['tab-change', 'search-click', 'menu-click', 'more-click']);
 
+// 状态栏高度
+const statusBarHeight = ref(0);
+
+onMounted(() => {
+    try {
+        const systemInfo = uni.getSystemInfoSync();
+        statusBarHeight.value = systemInfo.statusBarHeight || 0;
+    } catch (error) {
+        statusBarHeight.value = 0;
+    }
+});
+
 function handleTabClick(index) {
     emit('tab-change', index);
 }
@@ -86,6 +98,12 @@ function handleMoreClick() {
 .page-header {
     padding: 40rpx 28rpx 0;
     flex-shrink: 0;
+    /* #ifdef MP-WEIXIN */
+    padding-top: calc(40rpx + env(safe-area-inset-top));
+    /* #endif */
+    /* #ifdef H5 */
+    padding-top: calc(40rpx + var(--status-bar-height, 0px));
+    /* #endif */
 }
 
 .header-top {

pages/service/components/SkillDevelopment.vue

@@ -1,5 +1,52 @@
 <template>
     <view class="skill-development">
+        <!-- 职业技能查询区域 -->
+        <view class="query-section">
+            <view class="section-title">
+                <uni-icons type="search" size="18" color="#286BFA"></uni-icons>
+                <text class="title-text">职业技能查询</text>
+            </view>
+            
+            <view class="input-group">
+                <view class="input-item">
+                    <text class="input-label">当前职位</text>
+                    <input 
+                        class="input-field" 
+                        :value="currentPosition"
+                        placeholder="市场专员"
+                        placeholder-style="color: #999999"
+                        disabled
+                    />
+                </view>
+                
+                <view class="input-item">
+                    <text class="input-label">目标职业</text>
+                    <picker 
+                        mode="selector"
+                        :range="targetCareerOptions"
+                        range-key="label"
+                        :value="selectedTargetIndex"
+                        @change="handleTargetChange"
+                    >
+                        <view class="picker-field">
+                            <text :class="selectedTargetIndex >= 0 ? 'picker-text' : 'picker-placeholder'">
+                                {{ selectedTargetIndex >= 0 ? targetCareerOptions[selectedTargetIndex].label : '请选择目标职业' }}
+                            </text>
+                            <uni-icons type="arrowdown" size="16" color="#999999"></uni-icons>
+                        </view>
+                    </picker>
+                </view>
+            </view>
+            
+            <button class="query-btn" @click="handleQuery">
+                <text>查询技能发展路径</text>
+                <uni-icons type="search" size="18" color="#FFFFFF"></uni-icons>
+            </button>
+            <view v-if="totalPathCount > 0" class="path-summary">
+                系统已收录 {{ totalPathCount }} 条职业路径
+            </view>
+        </view>
+
         <view class="content-section">
             <view class="section-title">
                 <uni-icons type="person-filled" size="18" color="#000000"></uni-icons>
@@ -11,17 +58,23 @@
             </view>
             
             <view class="skill-list">
+                <view v-if="isLoadingSkills" class="empty-text">加载中...</view>
+                <view v-else-if="!hasQueried" class="empty-text">请先查询职业路径以获取技能发展数据</view>
+                <view v-else-if="skillList.length === 0" class="empty-text">暂无数据</view>
                 <view 
+                    v-else
                     class="skill-item" 
                     v-for="(skill, index) in skillList" 
                     :key="index"
-                    @click="handleSkillItemClick(skill)"
                 >
                     <view class="skill-header">
                         <text class="skill-name">{{ skill.name }}</text>
-                        <text class="skill-weight">权重: {{ skill.weight }}</text>
+                        <view class="skill-info">
+                            <text class="skill-score">技能分数: {{ skill.score }}</text>
+                            <text class="skill-weight">权重: {{ skill.weight }}</text>
+                        </view>
                     </view>
-                    <view class="skill-tags">
+                    <view class="skill-tags" v-if="skill.tags && skill.tags.length > 0">
                         <view 
                             class="skill-tag" 
                             v-for="(tag, tagIndex) in skill.tags" 
@@ -33,151 +86,395 @@
                 </view>
             </view>
         </view>
-        
-        <!-- 技能权重弹出层 -->
-        <SkillWeightPopup
-            ref="skillWeightPopup"
-            :skill-name="selectedSkillName"
-            :weight="selectedSkillWeight"
-            :current-level="selectedSkillLevel"
-            @close="handlePopupClose"
-        />
     </view>
 </template>
 
 <script setup>
-import { ref, computed, watch } from 'vue';
-import SkillWeightPopup from './SkillWeightPopup.vue';
+import { ref, computed, watch, onMounted } from 'vue';
+import { getJobPathPage, getJobPathDetail, getJobPathNum } from '@/apiRc/jobPath.js';
+import { getJobSkillWeight } from '@/apiRc/jobSkill.js';
 
 const props = defineProps({
-    // 来自职业推荐 tab 的数据
-    currentJobSkills: {
-        type: Array,
-        default: () => []
-    },
-    recommendedJobs: {
-        type: Array,
-        default: () => []
-    },
-    // 来自职业路径 tab 的数据
-    pathData: {
-        type: Object,
-        default: () => ({
-            start: { title: '', skills: [] },
-            steps: [],
-            end: { title: '', skills: [] }
-        })
-    },
-    targetCareer: {
+    // 当前职位名称
+    currentJobName: {
         type: String,
         default: ''
     }
 });
 
-// 综合技能列表（基于前两个 tab 的数据）
-const skillList = computed(() => {
-    const skillMap = new Map();
+const emit = defineEmits(['path-data-updated']);
 
-    // 1. 收集当前职位技能（已有技能，权重较低）
-    props.currentJobSkills.forEach(skill => {
-        if (skill && skill.trim()) {
-            const existing = skillMap.get(skill) || { name: skill, weight: 0, tags: [], currentLevel: 0 };
-            existing.weight = Math.max(existing.weight, 0.3); // 已有技能权重较低
-            existing.tags.push('当前技能');
-            skillMap.set(skill, existing);
-        }
-    });
+// 当前职位（从父组件获取）
+const currentPosition = computed(() => props.currentJobName || '市场专员');
 
-    // 2. 收集推荐职位的技能（需要发展的技能，权重较高）
-    props.recommendedJobs.forEach(job => {
-        if (Array.isArray(job.skills)) {
-            job.skills.forEach(skill => {
-                if (skill && skill.trim()) {
-                    const existing = skillMap.get(skill) || { name: skill, weight: 0, tags: [], currentLevel: 0 };
-                    existing.weight = Math.max(existing.weight, 0.7); // 推荐职位技能权重较高
-                    if (!existing.tags.includes('推荐技能')) {
-                        existing.tags.push('推荐技能');
-                    }
-                    skillMap.set(skill, existing);
-                }
-            });
-        }
-    });
+// 目标职业选项列表
+const targetCareerOptions = ref([]);
+const selectedTargetIndex = ref(-1);
+const selectedJobPathId = ref(null);
 
-    // 3. 收集职业路径中的技能（发展路径技能，权重最高）
-    const pathSkills = [];
-    if (props.pathData.start && Array.isArray(props.pathData.start.skills)) {
-        pathSkills.push(...props.pathData.start.skills);
+// 职业路径数量
+const totalPathCount = ref(0);
+
+// 技能列表数据（从接口获取）
+const skillList = ref([]);
+const isLoadingSkills = ref(false);
+// 是否已经查询过（用于区分未查询和已查询但无数据）
+const hasQueried = ref(false);
+
+function parseSkillList(skillString) {
+    if (!skillString) {
+        return [];
     }
-    if (Array.isArray(props.pathData.steps)) {
-        props.pathData.steps.forEach(step => {
-            if (Array.isArray(step.skills)) {
-                pathSkills.push(...step.skills);
-            }
+    return skillString
+        .split(/[,，]/)
+        .map(item => item.trim())
+        .filter(item => item.length > 0);
+}
+
+async function fetchTargetCareerOptions(keyword = '') {
+    try {
+        const response = await getJobPathPage({
+            jobName: keyword,
+            pageNo: 1,
+            pageSize: 100
+        });
+        
+        const list = response?.data?.list || response?.list || [];
+        
+        targetCareerOptions.value = list.map(item => ({
+            label: item.endJob || item.startJob || '未知职位',
+            value: item.id,
+            startJob: item.startJob,
+            endJob: item.endJob,
+            jobOrder: item.jobOrder
+        }));
+
+        if (targetCareerOptions.value.length === 0) {
+            selectedTargetIndex.value = -1;
+            selectedJobPathId.value = null;
+        }
+    } catch (error) {
+        targetCareerOptions.value = [];
+        selectedTargetIndex.value = -1;
+        selectedJobPathId.value = null;
+        uni.showToast({
+            title: '职业路径列表获取失败',
+            icon: 'none'
         });
     }
-    if (props.pathData.end && Array.isArray(props.pathData.end.skills)) {
-        pathSkills.push(...props.pathData.end.skills);
+}
+
+async function fetchPathCount() {
+    try {
+        const response = await getJobPathNum();
+        totalPathCount.value = response?.data ?? 0;
+    } catch (error) {
+        totalPathCount.value = 0;
+    }
+}
+
+async function loadPathDetail(jobPathId) {
+    if (!jobPathId || jobPathId === null || jobPathId === undefined || jobPathId === '') {
+        uni.showToast({
+            title: '职业路径ID无效',
+            icon: 'none'
+        });
+        localPathData.value = {
+            start: { title: '暂无数据', skills: [] },
+            steps: [],
+            end: { title: '暂无数据', skills: [] }
+        };
+        return;
     }
     
-    pathSkills.forEach(skill => {
-        if (skill && skill.trim()) {
-            const existing = skillMap.get(skill) || { name: skill, weight: 0, tags: [], currentLevel: 0 };
-            existing.weight = Math.max(existing.weight, 0.9); // 路径技能权重最高
-            if (!existing.tags.includes('路径技能')) {
-                existing.tags.push('路径技能');
-            }
-            skillMap.set(skill, existing);
+    try {
+        const requestParams = {
+            jobPathId: jobPathId
+        };
+        
+        const response = await getJobPathDetail(requestParams);
+        
+        const details = Array.isArray(response?.data) ? response.data : [];
+        
+        if (details.length === 0) {
+            localPathData.value = {
+                start: { title: '暂无数据', skills: [] },
+                steps: [],
+                end: { title: '暂无数据', skills: [] }
+            };
+            uni.showToast({
+                title: '暂无职业路径数据',
+                icon: 'none'
+            });
+            return;
         }
+
+        const normalized = details.map(item => ({
+            title: item?.name || '未命名职位',
+            skills: parseSkillList(item?.skillNameList)
+        }));
+
+        const start = normalized[0] || { title: '暂无数据', skills: [] };
+        const end = normalized[normalized.length - 1] || { title: '暂无数据', skills: [] };
+        const steps = normalized.slice(1, normalized.length - 1);
+
+        localPathData.value = {
+            start,
+            steps,
+            end
+        };
+        
+        // 通知父组件路径数据已更新
+        emit('path-data-updated', {
+            pathData: localPathData.value,
+            targetCareer: targetCareerOptions.value[selectedTargetIndex.value]?.label || ''
+        });
+    } catch (error) {
+        uni.showToast({
+            title: '获取路径详情失败',
+            icon: 'none'
+        });
+        localPathData.value = {
+            start: { title: '暂无数据', skills: [] },
+            steps: [],
+            end: { title: '暂无数据', skills: [] }
+        };
+        emit('path-data-updated', {
+            pathData: localPathData.value,
+            targetCareer: ''
+        });
+    }
+}
+
+function handleTargetChange(e) {
+    const index = Number(e.detail.value);
+    selectedTargetIndex.value = index;
+    const option = targetCareerOptions.value[index];
+    selectedJobPathId.value = option ? option.value : null;
+    // 重新选择目标职业时，重置查询状态和技能列表
+    hasQueried.value = false;
+    skillList.value = [];
+}
+
+async function handleQuery() {
+    if (selectedTargetIndex.value < 0) {
+        uni.showToast({
+            title: '请选择目标职业',
+            icon: 'none'
+        });
+        return;
+    }
+
+    const option = targetCareerOptions.value[selectedTargetIndex.value];
+    if (!option) {
+        uni.showToast({
+            title: '目标职业数据异常',
+            icon: 'none'
+        });
+        return;
+    }
+
+    // 获取技能权重数据
+    await fetchSkillWeight();
+}
+
+// 获取技能权重数据
+async function fetchSkillWeight() {
+    // 获取当前职位（使用界面上显示的值）
+    const currentJob = currentPosition.value || props.currentJobName || '';
+    
+    if (!currentJob) {
+        skillList.value = [];
+        uni.showToast({
+            title: '当前职位信息缺失',
+            icon: 'none'
+        });
+        return;
+    }
+    
+    // 获取目标职业（使用界面上选择的值）
+    const targetCareer = selectedTargetIndex.value >= 0 
+        ? targetCareerOptions.value[selectedTargetIndex.value]?.label 
+        : '';
+    
+    if (!targetCareer) {
+        skillList.value = [];
+        uni.showToast({
+            title: '请选择目标职业',
+            icon: 'none'
+        });
+        return;
+    }
+    
+    isLoadingSkills.value = true;
+    uni.showLoading({
+        title: '加载中...',
+        mask: true
     });
     
-    // 转换为数组并按权重排序
-    const result = Array.from(skillMap.values())
-        .map(item => ({
-            name: item.name,
-            weight: item.weight.toFixed(2),
-            tags: [...new Set(item.tags)], // 去重
-            currentLevel: item.currentLevel || Math.floor(item.weight * 5) + 1 // 根据权重计算等级
-        }))
-        .sort((a, b) => parseFloat(b.weight) - parseFloat(a.weight)); // 按权重降序
+    try {
+        const response = await getJobSkillWeight({
+            currentJobName: currentJob,
+            targetJobName: targetCareer
+        });
         
-    return result;
+        // 标记已经查询过
+        hasQueried.value = true;
+        
+        // 处理接口返回的数据
+        const responseData = response?.data || response || [];
+        const dataItem = Array.isArray(responseData) ? responseData[0] : responseData;
+        
+        // 合并当前职位和目标职位的技能列表
+        const currentSkills = Array.isArray(dataItem?.currentSkillDetList) ? dataItem.currentSkillDetList : [];
+        const targetSkills = Array.isArray(dataItem?.targetSkillDetList) ? dataItem.targetSkillDetList : [];
+        const allSkills = [...currentSkills, ...targetSkills];
+        
+        // 转换为组件需要的格式
+        skillList.value = allSkills.map(item => ({
+            name: item?.skillName || item?.name || '',
+            weight: item?.skillWeight || item?.weight || '0',
+            score: item?.skillScore !== undefined && item?.skillScore !== null ? item.skillScore : 0,
+            tags: item?.tags || [],
+            currentLevel: item?.currentLevel || item?.level || 0
+        })).filter(item => item.name).sort((a, b) => {
+            // 按技能分数降序排序（skillScore）
+            const scoreA = parseFloat(a.score) || 0;
+            const scoreB = parseFloat(b.score) || 0;
+            return scoreB - scoreA;
+        });
+        
+        if (skillList.value.length === 0) {
+            uni.showToast({
+                title: '暂无技能数据',
+                icon: 'none'
+            });
+        }
+    } catch (error) {
+        // 查询失败也标记为已查询
+        hasQueried.value = true;
+        uni.showToast({
+            title: '获取技能权重失败',
+            icon: 'none'
+        });
+        skillList.value = [];
+    } finally {
+        isLoadingSkills.value = false;
+        uni.hideLoading();
+    }
+}
+
+onMounted(async () => {
+    await Promise.all([
+        fetchTargetCareerOptions(),
+        fetchPathCount()
+    ]);
 });
-
-// 弹出层引用
-const skillWeightPopup = ref(null);
-
-// 选中的技能信息
-const selectedSkillName = ref('');
-const selectedSkillWeight = ref('');
-const selectedSkillLevel = ref(0);
-
-// 处理技能项点击
-function handleSkillItemClick(skill) {
-    selectedSkillName.value = skill.name || '';
-    selectedSkillWeight.value = skill.weight || '0';
-    selectedSkillLevel.value = skill.currentLevel || 0;
-    skillWeightPopup.value?.open();
-}
-
-// 处理弹出层关闭
-function handlePopupClose() {
-    // 可以在这里处理关闭后的逻辑
-}
 </script>
 
 <style lang="scss" scoped>
 .skill-development {
-    padding: 10rpx 0 20rpx;
+    padding: 10rpx 28rpx 20rpx;
     background-color: #EBF4FF;
     min-height:95%;
 }
 
+.query-section {
+    background-color: #FFFFFF;
+    border-radius: 16rpx;
+    padding: 28rpx;
+    margin-bottom: 20rpx;
+    box-shadow: 0 4rpx 12rpx rgba(0, 0, 0, 0.08);
+    
+    .section-title {
+        margin-top: 0;
+    }
+}
+
 .content-section {
-    background-color: #EBF4FF;
+    background-color: #FFFFFF;
+    border-radius: 16rpx;
     padding: 28rpx;
     box-sizing: border-box;
     overflow: visible;
+    box-shadow: 0 4rpx 12rpx rgba(0, 0, 0, 0.08);
+}
+
+.input-group {
+    display: flex;
+    flex-direction: column;
+    gap: 20rpx;
+    margin-bottom: 24rpx;
+}
+
+.input-item {
+    display: flex;
+    flex-direction: column;
+    gap: 12rpx;
+}
+
+.input-label {
+    font-size: 28rpx;
+    color: #000000;
+    font-weight: 500;
+}
+
+.input-field {
+    background-color: #F5F5F5;
+    border: 1rpx solid #E0E0E0;
+    border-radius: 12rpx;
+    padding: 20rpx 24rpx;
+    font-size: 28rpx;
+    color: #666666;
+}
+
+.picker-field {
+    background-color: #F5F5F5;
+    border: 1rpx solid #E0E0E0;
+    border-radius: 12rpx;
+    padding: 20rpx 24rpx;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+}
+
+.picker-text {
+    font-size: 28rpx;
+    color: #000000;
+}
+
+.picker-placeholder {
+    font-size: 28rpx;
+    color: #999999;
+}
+
+.query-btn {
+    width: 100%;
+    height: 80rpx;
+    line-height: 40rpx;
+    border-radius: 20rpx;
+    background: linear-gradient(180deg, rgba(18, 125, 240, 1) 0%, rgba(59, 14, 123, 0.71) 100%);
+    color: rgba(255, 255, 255, 1);
+    font-size: 28rpx;
+    text-align: center;
+    font-family: '阿里巴巴普惠体3.0-regular', 'PingFang SC', 'Helvetica Neue', Helvetica, Arial, 'Microsoft YaHei', sans-serif;
+    border: 2rpx solid rgba(187, 187, 187, 1);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 12rpx;
+    padding: 0;
+}
+
+.path-summary {
+    margin-top: 16rpx;
+    font-size: 24rpx;
+    color: #666666;
+    text-align: center;
+}
+
+button::after {
+    border: none;
 }
 
 .section-title {
@@ -185,7 +482,10 @@ function handlePopupClose() {
     align-items: center;
     gap: 12rpx;
     margin-bottom: 24rpx;
-    margin-top: -20rpx;
+    
+    .content-section & {
+        margin-top: 0;
+    }
 }
 
 .title-text {
@@ -253,6 +553,25 @@ function handlePopupClose() {
     white-space: nowrap;
 }
 
+.skill-info {
+    display: flex;
+    align-items: center;
+    gap: 12rpx;
+    flex-shrink: 0;
+    margin-left: 16rpx;
+}
+
+.skill-score {
+    font-size: 24rpx;
+    line-height: 34rpx;
+    border-radius: 10rpx;
+    background-color: rgba(49, 100, 239, 0.1);
+    color: rgba(44, 101, 247, 1);
+    text-align: center;
+    padding: 6rpx 12rpx;
+    white-space: nowrap;
+}
+
 .skill-weight {
     font-size: 24rpx;
     line-height: 34rpx;
@@ -262,8 +581,6 @@ function handlePopupClose() {
     text-align: center;
     padding: 6rpx 12rpx;
     white-space: nowrap;
-    flex-shrink: 0;
-    margin-left: 16rpx;
 }
 
 .skill-tags {

utilsRc/config.js

@@ -26,11 +26,14 @@ let exports = {
 	// baseUrl: 'http://ks.zhaopinzao8dian.com/api/ks', // 已从根目录config.js引用，不再重复配置
 	
 	// ========== 职业图谱专用baseUrl ==========
-	zytpBaseUrl: 'http://ks.zhaopinzao8dian.com/api/ks_zytp/admin-api/zytp',
+	zytpBaseUrl: 'http://222.80.110.161:11111/career-map/api/ks_zytp/admin-api/zytp',
 	
-	// ========== 用户接口专用baseUrl（appUserInfo等接口使用） ==========
+	// ========== 用户接口专用baseUrl（其他用户接口使用） ==========
 	userBaseUrl: 'http://ks.zhaopinzao8dian.com/api/ks', // 用户相关接口使用根目录config.js的baseUrl
 	
+	// ========== appUserInfo接口专用baseUrl ==========
+	appUserInfoBaseUrl: 'http://222.80.110.161:11111/api/ks', // appUserInfo接口专用，与其他接口路径不一致
+
 
 
 	// 应用信息

utilsRc/request.js

@@ -14,23 +14,28 @@ let timeout = 10000
 const baseUrl = configRc.baseUrl
 const zytpBaseUrl = configRc.zytpBaseUrl || ''
 const userBaseUrl = configRc.userBaseUrl || ''
+const appUserInfoBaseUrl = configRc.appUserInfoBaseUrl || ''
 
 const request = config => {
   // 是否需要设置 token
   const isToken = (config.headers || {}).isToken === false
   config.header = config.header || {}
-  // 从存储中获取微信登录的 token
-  const token = getToken()
-  if (token && !isToken) {
-    config.header['Authorization'] = 'Bearer ' + token
-  }
   // get请求映射params参数
   const baseType = config.baseUrlType
+  // 职业图谱相关接口不需要Authorization
+  const isZytpApi = baseType === 'zytp'
+  // 从存储中获取微信登录的 token
+  const token = getToken()
+  if (token && !isToken && !isZytpApi) {
+    config.header['Authorization'] = 'Bearer ' + token
+  }
   let requestBaseUrl = baseUrl
   if (baseType === 'zytp' && zytpBaseUrl) {
     requestBaseUrl = zytpBaseUrl
   } else if (baseType === 'user' && userBaseUrl) {
     requestBaseUrl = userBaseUrl
+  } else if (baseType === 'appUserInfo' && appUserInfoBaseUrl) {
+    requestBaseUrl = appUserInfoBaseUrl
   }
   let requestUrl = config.fullUrl ? config.fullUrl : (requestBaseUrl + (config.url || ''))