fix:app 用户登录，默认不勾选用户协议

wlzboy

2025-11-02 2cd31915236257e325b49f2e86f6912512e1f7ce

 app/pages/task/create-emergency.vue

@@ -4,27 +4,55 @@
      <view class="back-btn" @click="goBack">
        <uni-icons type="arrowleft" size="20"></uni-icons>
      </view>
      <view class="title">创建非急救转运任务</view>
      <view class="title">创建转运任务</view>
    </view>
    
    <view class="form-section">
      <view class="form-item">
        <view class="form-label">任务车辆</view>
        <picker mode="selector" :range="vehicles" @change="onVehicleChange">
        <view class="form-label required">任务车辆</view>
        <picker mode="selector" :range="vehicles" :value="selectedVehicleIndex" @change="onVehicleChange">
          <view class="form-input picker-input">
            {{ selectedVehicle || '请选择任务车辆' }}
            <uni-icons type="arrowright" size="16" color="#999"></uni-icons>
          </view>
        </picker>
      </view>
        <view class="form-item">
        <view class="form-label">归属机构</view>
        <picker mode="selector" :range="organizations" @change="onOrganizationChange">
          <view class="form-input picker-input">
            {{ selectedOrganization || '请选择归属机构' }}
            <uni-icons type="arrowright" size="16" color="#999"></uni-icons>
          </view>
        </picker>
      </view>
      
      <view class="form-item">
        <view class="form-label required">任务类型</view>
        <picker mode="selector" :range="emergencyTaskTypeOptions" range-key="text" @change="onEmergencyTaskTypeChange">
          <view class="form-input picker-input">
            {{ selectedEmergencyTaskType || '请选择任务类型' }}
            <uni-icons type="arrowright" size="16" color="#999"></uni-icons>
          </view>
        </picker>
      </view>
      
      <view class="form-item">
        <view class="form-label required">单据类型</view>
        <picker mode="selector" :range="documentTypeOptions" range-key="text" @change="onDocumentTypeChange">
          <view class="form-input picker-input">
            {{ selectedDocumentType || '请选择单据类型' }}
            <uni-icons type="arrowright" size="16" color="#999"></uni-icons>
          </view>
        </picker>
      </view>
      <view class="form-item">
        <view class="form-label">执行任务人员</view>
        <view class="staff-list">
          <view class="staff-item" v-for="(staff, index) in selectedStaff" :key="staff.userId">
            <view class="staff-info">
              <text class="staff-name">{{ staff.nickName }}</text>
              <text class="staff-role">({{ staff.postName || staff.roleName || '未知职位' }})</text>
              <text class="staff-role">({{ getUserTypeName(staff.type) || '未知职位' }})</text>
            </view>
            <uni-icons 
              v-if="index > 0" 
@@ -47,28 +75,10 @@
        </view>
      </view>
      
      <view class="form-item">
        <view class="form-label">归属机构</view>
        <picker mode="selector" :range="organizations" @change="onOrganizationChange">
          <view class="form-input picker-input">
            {{ selectedOrganization || '请选择归属机构' }}
            <uni-icons type="arrowright" size="16" color="#999"></uni-icons>
          </view>
        </picker>
      </view>
    
      
      <view class="form-item">
        <view class="form-label">任务类型</view>
        <picker mode="selector" :range="emergencyTaskTypes" @change="onEmergencyTaskTypeChange">
          <view class="form-input picker-input">
            {{ selectedEmergencyTaskType || '请选择任务类型' }}
            <uni-icons type="arrowright" size="16" color="#999"></uni-icons>
          </view>
        </picker>
      </view>
      
      <view class="form-item">
        <view class="form-label">转运时间</view>
        <view class="form-label required">转运时间</view>
        <uni-datetime-picker 
          v-model="taskForm.transferTime" 
          type="datetime" 
@@ -79,7 +89,7 @@
      
      <view class="form-section-title">患者信息</view>
      <view class="form-item">
        <view class="form-label">联系人</view>
        <view class="form-label required">联系人</view>
        <input 
          class="form-input" 
          placeholder="请输入联系人" 
@@ -88,7 +98,7 @@
      </view>
      
      <view class="form-item">
        <view class="form-label">联系电话</view>
        <view class="form-label required">联系电话</view>
        <input 
          class="form-input" 
          type="number" 
@@ -98,7 +108,7 @@
      </view>
      
      <view class="form-item">
        <view class="form-label">患者姓名</view>
        <view class="form-label required">患者姓名</view>
        <input 
          class="form-input" 
          placeholder="请输入患者姓名" 
@@ -163,14 +173,14 @@
      
      <view class="form-section-title">转出医院信息</view>
      <view class="form-item">
        <view class="form-label">医院名称</view>
        <view class="form-label required">医院名称</view>
        <view class="hospital-search-container">
          <input 
            class="form-input" 
            placeholder="请输入医院名称或地址搜索" 
            v-model="hospitalOutSearchKeyword"
            @input="onHospitalOutSearch"
            @focus="showHospitalOutResults = true"
            @focus="onHospitalOutFocus"
          />
          <view class="search-results" v-if="showHospitalOutResults && hospitalOutResults.length > 0">
            <view 
@@ -180,19 +190,20 @@
              @click="selectHospitalOut(hospital)"
            >
              <view class="hospital-name">{{ hospital.hospName }}</view>
              <view class="hospital-address">{{ hospital.hospAddress }}</view>
              <view class="hospital-address">{{ buildFullAddress(hospital) }}</view>
            </view>
          </view>
        </view>
      </view>
      
      <view class="form-item">
        <view class="form-label">科室</view>
        <input 
          class="form-input" 
          placeholder="请输入科室" 
          v-model="taskForm.hospitalOut.department"
        />
        <view class="form-label required">科室</view>
        <picker mode="selector" :range="departmentOptions" range-key="text" @change="onHospitalOutDepartmentChange">
          <view class="form-input picker-input">
            {{ taskForm.hospitalOut.department || '请选择科室' }}
            <uni-icons type="arrowright" size="16" color="#999"></uni-icons>
          </view>
        </picker>
      </view>
      
      <view class="form-item">
@@ -213,14 +224,14 @@
      
      <view class="form-section-title">转入医院信息</view>
      <view class="form-item">
        <view class="form-label">医院名称</view>
        <view class="form-label required">医院名称</view>
        <view class="hospital-search-container">
          <input 
            class="form-input" 
            placeholder="请输入医院名称或地址搜索" 
            v-model="hospitalInSearchKeyword"
            @input="onHospitalInSearch"
            @focus="showHospitalInResults = true"
            @focus="onHospitalInFocus"
          />
          <view class="search-results" v-if="showHospitalInResults && hospitalInResults.length > 0">
            <view 
@@ -230,19 +241,20 @@
              @click="selectHospitalIn(hospital)"
            >
              <view class="hospital-name">{{ hospital.hospName }}</view>
              <view class="hospital-address">{{ hospital.hospAddress }}</view>
              <view class="hospital-address">{{ buildFullAddress(hospital) }}</view>
            </view>
          </view>
        </view>
      </view>
      
      <view class="form-item">
        <view class="form-label">科室</view>
        <input 
          class="form-input" 
          placeholder="请输入科室" 
          v-model="taskForm.hospitalIn.department"
        />
        <view class="form-label required">科室</view>
        <picker mode="selector" :range="departmentOptions" range-key="text" @change="onHospitalInDepartmentChange">
          <view class="form-input picker-input">
            {{ taskForm.hospitalIn.department || '请选择科室' }}
            <uni-icons type="arrowright" size="16" color="#999"></uni-icons>
          </view>
        </picker>
      </view>
      
      <view class="form-item">
@@ -311,14 +323,14 @@
        <view class="staff-filter">
          <view 
            class="filter-item" 
            :class="{ active: staffFilterType === 'all' }"
            @click="filterStaff('all')"
          >全部</view>
          <view 
            class="filter-item" 
            :class="{ active: staffFilterType === 'driver' }"
            @click="filterStaff('driver')"
          >司机</view>
          <view 
            class="filter-item" 
            :class="{ active: staffFilterType === 'doctor' }"
            @click="filterStaff('doctor')"
          >医生</view>
          <view 
            class="filter-item" 
            :class="{ active: staffFilterType === 'nurse' }"
@@ -340,7 +352,7 @@
              </view>
              <view class="staff-detail-row">
                <text class="staff-dept">{{ staff.deptName }}</text>
                <text class="staff-post">{{ staff.postName || staff.roleName || '未知职位' }}</text>
                <text class="staff-post">{{ staff.postName || staff.roleName  || '未知职位' }}</text>
              </view>
            </view>
            <uni-icons 
@@ -410,14 +422,9 @@
            <view v-else class="checkbox-empty"></view>
          </view>
          
          <view class="no-data" v-if="diseaseSearchResults.length === 0 && diseaseSearchKeyword">
          <view class="no-data" v-if="diseaseSearchResults.length === 0">
            <uni-icons type="info" size="40" color="#ccc"></uni-icons>
            <text>未找到相关疾病</text>
          </view>
          
          <view class="no-data" v-if="diseaseSearchResults.length === 0 && !diseaseSearchKeyword">
            <uni-icons type="search" size="40" color="#ccc"></uni-icons>
            <text>请输入关键词搜索疾病</text>
            <text>{{ diseaseSearchKeyword ? '未找到相关疾病' : '暂无病情数据' }}</text>
          </view>
        </scroll-view>
        
@@ -435,11 +442,15 @@
import uniDatetimePicker from '@/uni_modules/uni-datetime-picker/components/uni-datetime-picker/uni-datetime-picker.vue'
import uniPopup from '@/uni_modules/uni-popup/components/uni-popup/uni-popup.vue'
import { addTask } from "@/api/task"
import { listAvailableVehicles } from "@/api/vehicle"
import { calculateDistance } from "@/api/map"
import { listAvailableVehicles, getUserBoundVehicle } from "@/api/vehicle"
import { calculateDistance, baiduDistanceByAddress } from "@/api/map"
import { searchHospitals } from "@/api/hospital"
import { listUser } from "@/api/system/user"
import { searchIcd10 } from "@/api/icd10"

import { getDicts } from "@/api/dict"
import { getServiceOrdAreaTypes, getServiceOrderTypes, getHospitalDepartments } from "@/api/dictionary"
import { listBranchCompany } from "@/api/system/dept"
import MapSelector from '@/components/map-selector.vue'

export default {
@@ -453,7 +464,12 @@
      selectedVehicle: '',
      selectedVehicleId: null,
      selectedOrganization: '',
      selectedEmergencyTaskType: '',
      selectedOrganizationId: null, // 归属机构ID（部门ID）
      selectedRegion: '', // 从归属机构中提取的地域信息（如：广州、深圳等）
      selectedEmergencyTaskType: '', // 选中的任务类型文本
      selectedEmergencyTaskTypeId: null, // 选中的任务类型ID
      selectedDocumentType: '', // 选中的单据类型文本
      selectedDocumentTypeId: null, // 选中的单据类型ID
      mapSelectorType: '',
      // 医院搜索相关
      hospitalOutSearchKeyword: '',
@@ -463,12 +479,13 @@
      hospitalInResults: [],
      showHospitalInResults: false,
      searchTimer: null,
      defaultHospitals: [], // 默认的100条医院数据
      // 人员选择相关
      selectedStaff: [], // 已选择的人员列表
      allStaffList: [], // 所有人员列表
      filteredStaffList: [], // 过滤后的人员列表
      staffSearchKeyword: '', // 人员搜索关键词
      staffFilterType: 'all', // 人员筛选类型：all/driver/nurse
      staffFilterType: 'driver', // 人员筛选类型：driver/doctor/nurse，默认选中司机
      // 病情选择相关
      selectedDiseases: [], // 已选择的病情列表
      tempSelectedDiseases: [], // 临时选择的病情列表（用于弹窗）
@@ -486,14 +503,18 @@
          condition: ''
        },
        hospitalOut: {
          id: null,  // 医院ID
          name: '',
          department: '',
          departmentId: null,  // 科室ID
          bedNumber: '',
          address: ''
        },
        hospitalIn: {
          id: null,  // 医院ID
          name: '',
          department: '',
          departmentId: null,  // 科室ID
          bedNumber: '',
          address: ''
        },
@@ -502,8 +523,13 @@
      },
      vehicles: [],
      vehicleOptions: [],
      organizations: ['广州分公司', '深圳分公司', '珠海分公司', '佛山分公司'],
      emergencyTaskTypes: ['急救转运', '航空转运'],
      organizations: [], // 归属机构列表（从后台加载分公司数据）
      organizationOptions: [], // 归属机构选项（用于picker显示）
      emergencyTaskTypes: [], // 任务类型列表（从 SQL Server 动态加载）
      emergencyTaskTypeOptions: [], // 任务类型选项（用于picker显示）
      documentTypes: [], // 单据类型列表
      documentTypeOptions: [], // 单据类型选项（用于picker显示）
      departmentOptions: [], // 科室字典数据
      loading: false,
      addressCoordinates: {
        hospitalOutAddress: null,
@@ -515,20 +541,82 @@
    ...mapState({
      currentUser: state => ({
        userId: state.user.userId,
        name: state.user.name || '张三',
        nickName: state.user.nickName || state.user.name || '张三',
        name: state.user.nickName || '张三',
        nickName: state.user.nickName || '张三',
        position: '司机',
        deptId: state.user.deptId || 100,
        phonenumber: state.user.phonenumber || ''
        phonenumber: state.user.phonenumber || '',
        branchCompanyId: state.user.branchCompanyId,
        branchCompanyName: state.user.branchCompanyName
      })
    })
    }),
    // 计算车辆在picker中的索引，用于默认选中
    selectedVehicleIndex() {
      if (!this.selectedVehicle || this.vehicles.length === 0) {
        return 0
      }
      const index = this.vehicles.findIndex(v => v === this.selectedVehicle)
      return index !== -1 ? index : 0
    }
  },
  onLoad(options) {
    this.getAvailableVehicles()
    // 设置默认转运时间为当前时间
    this.setDefaultTransferTime()
    
    // 先加载车辆列表，然后加载绑定车辆信息
    this.getAvailableVehicles().then(() => {
      this.getUserBoundVehicleInfo()
    })
    this.initSelectedStaff()
    this.loadDeptStaff()
    // 加载分公司数据（会自动设置默认分公司并加载医院列表）
    this.loadBranchCompanies()
    // 加载科室字典数据
    this.loadDepartments()
    // 加载任务类型数据
    this.loadEmergencyTaskTypes()
    // 加载单据类型数据
    this.loadDocumentTypes()
  },
  methods: {
    // 获取用户绑定的车辆信息
    getUserBoundVehicleInfo() {
      const userId = this.currentUser.userId
      if (!userId) {
        console.warn('用户ID不存在，无法获取绑定车辆')
        return
      }
      
      getUserBoundVehicle(userId).then(response => {
        const boundVehicle = response.data
        
        if (boundVehicle && boundVehicle.vehicleId) {
          const boundVehicleNo = boundVehicle.vehicleNo
          const boundVehicleId = boundVehicle.vehicleId
          
          console.log('用户绑定的车辆:', boundVehicleNo, 'ID:', boundVehicleId)
          
          // 在车辆列表中查找绑定的车辆
          const vehicleIndex = this.vehicleOptions.findIndex(v => 
            v.id === boundVehicleId || v.name === boundVehicleNo
          )
          
          if (vehicleIndex !== -1) {
            // 设置默认选中的车辆
            this.selectedVehicle = this.vehicleOptions[vehicleIndex].name
            this.selectedVehicleId = this.vehicleOptions[vehicleIndex].id
            console.log('默认选中车辆:', this.selectedVehicle)
          } else {
            console.warn('绑定的车辆不在可用车辆列表中')
          }
        } else {
          console.log('用户未绑定车辆')
        }
      }).catch(error => {
        console.error('获取用户绑定车辆信息失败:', error)
      })
    },
    
    getAvailableVehicles() {
      const deptId = this.currentUser.deptId
      return listAvailableVehicles(deptId, 'EMERGENCY').then(response => {
@@ -552,11 +640,217 @@
    },
    
    onOrganizationChange(e) {
      this.selectedOrganization = this.organizations[e.detail.value]
      const index = e.detail.value
      const selected = this.organizationOptions[index]
      this.selectedOrganization = selected.deptName
      this.selectedOrganizationId = selected.deptId // 保存部门ID
      // 从归属机构中提取地域关键词（去除"分公司"后缀）
      // 例如："广州分公司" -> "广州"
      this.selectedRegion = selected.deptName.replace(/分公司$/g, '').trim()
      // 重新加载医院列表（带地域过滤）
      this.loadDefaultHospitals()
    },
    
    // 加载分公司数据（parent_id=100的部门）
    loadBranchCompanies() {
      listBranchCompany().then(response => {
        const list = response.data || []
        // 过滤出 parent_id = 100 的部门（分公司）
        this.organizationOptions = list.filter(dept => dept.parentId === 100)
        // 生成picker的数据源（只显示名称）
        this.organizations = this.organizationOptions.map(dept => dept.deptName)
        
        // 默认设置为当前用户的分公司
        if (this.currentUser.branchCompanyName) {
          const index = this.organizationOptions.findIndex(
            dept => dept.deptName === this.currentUser.branchCompanyName
          )
          if (index !== -1) {
            this.selectedOrganization = this.currentUser.branchCompanyName
            this.selectedOrganizationId = this.organizationOptions[index].deptId // 保存部门ID
            // 提取地域关键词
            this.selectedRegion = this.selectedOrganization.replace(/分公司$/g, '').trim()
            console.log('默认选中归属机构:', this.selectedOrganization, '部门ID:', this.selectedOrganizationId, '地域:', this.selectedRegion)
            // 加载医院列表（带地域过滤）
            this.loadDefaultHospitals()
          }
        }
      }).catch(error => {
        console.error('加载分公司数据失败:', error)
        this.organizationOptions = []
        this.organizations = []
      })
    },
    
    // 加载科室数据（从 SQL Server 动态加载）
    loadDepartments() {
      getHospitalDepartments().then(response => {
        const list = response.data || [];
        this.departmentOptions = list.map(item => ({
          id: item.vID,
          text: item.vtext,
          dictValue: item.vtext  // 为了保持兼容性，保留dictValue字段
        }));
        // console.log('科室数据加载成功:', this.departmentOptions);
      }).catch(error => {
        console.error('加载科室数据失败:', error)
        this.departmentOptions = []
      })
    },
    
    // 加载任务类型数据（从 SQL Server）
    loadEmergencyTaskTypes() {
      getServiceOrderTypes().then(response => {
        const list = response.data || []
        this.emergencyTaskTypes = list
        this.emergencyTaskTypeOptions = list.map(item => ({
          id: item.vID,
          text: item.vtext
        }))
        
        // 默认选中第一个任务类型
        if (this.emergencyTaskTypeOptions.length > 0) {
          this.selectedEmergencyTaskType = this.emergencyTaskTypeOptions[0].text
          this.selectedEmergencyTaskTypeId = this.emergencyTaskTypeOptions[0].id
          console.log('默认选中任务类型:', this.selectedEmergencyTaskType)
        }
      }).catch(error => {
        console.error('加载任务类型失败:', error)
        this.emergencyTaskTypes = []
        this.emergencyTaskTypeOptions = []
      })
    },
    
    // 任务类型选择
    onEmergencyTaskTypeChange(e) {
      this.selectedEmergencyTaskType = this.emergencyTaskTypes[e.detail.value]
      const index = e.detail.value
      const selected = this.emergencyTaskTypeOptions[index]
      this.selectedEmergencyTaskType = selected.text
      this.selectedEmergencyTaskTypeId = selected.id
    },
    getUserTypeName(staffType){
      switch(staffType){
        case "nurse":
          return "护士";
        case "doctor":
          return "医生";
        case "driver":
          return "司机";
        default:
          return "司机";
      }
    },
    
    // 加载单据类型数据
    loadDocumentTypes() {
      getServiceOrdAreaTypes().then(response => {
        const list = response.data || []
        this.documentTypes = list
        this.documentTypeOptions = list.map(item => ({
          id: item.vID,
          text: item.vtext
        }))
        
        // 默认选中第一个单据类型
        if (this.documentTypeOptions.length > 0) {
          this.selectedDocumentType = this.documentTypeOptions[0].text
          this.selectedDocumentTypeId = this.documentTypeOptions[0].id
          console.log('默认选中单据类型:', this.selectedDocumentType)
        }
      }).catch(error => {
        console.error('加载单据类型失败:', error)
        this.documentTypes = []
        this.documentTypeOptions = []
      })
    },
    
    // 单据类型选择
    onDocumentTypeChange(e) {
      const index = e.detail.value
      const selected = this.documentTypeOptions[index]
      this.selectedDocumentType = selected.text
      this.selectedDocumentTypeId = selected.id
    },
    
    // 转出医院科室选择
    onHospitalOutDepartmentChange(e) {
      const index = e.detail.value
      const selected = this.departmentOptions[index]
      this.taskForm.hospitalOut.department = selected.text  // 保存科室名称
      this.taskForm.hospitalOut.departmentId = selected.id  // 保存科室ID
    },
    
    // 转入医院科室选择
    onHospitalInDepartmentChange(e) {
      const index = e.detail.value
      const selected = this.departmentOptions[index]
      this.taskForm.hospitalIn.department = selected.text  // 保存科室名称
      this.taskForm.hospitalIn.departmentId = selected.id  // 保存科室ID
    },
    
    // 加载默认医院列表（前100条）
    loadDefaultHospitals() {
      // 转出医院：只加载当前区域的医院（带地域过滤）
      searchHospitals('', this.selectedRegion).then(response => {
        this.hospitalOutResults = response.data || []
        console.log('加载转出医院（当前区域）:', this.selectedRegion, '数量:', this.hospitalOutResults.length)
      }).catch(error => {
        console.error('加载转出医院列表失败:', error)
        this.hospitalOutResults = []
      })
      
      // 转入医院：加载所有医院（不带地域过滤，后续会按地域排序）
      searchHospitals('', this.selectedRegion).then(response => {
        const allHospitals = response.data || []
        // 将医院按地域排序：本地区域优先
        this.hospitalInResults = this.sortHospitalsByRegion(allHospitals)
        console.log('加载转入医院（全部区域）:', '数量:', this.hospitalInResults.length)
      }).catch(error => {
        console.error('加载转入医院列表失败:', error)
        this.hospitalInResults = []
      })
    },
    
    // 按地域排序医院：本地区域优先
    sortHospitalsByRegion(hospitals) {
      if (!this.selectedRegion || !hospitals || hospitals.length === 0) {
        return hospitals
      }
      
      const region = this.selectedRegion
      const localHospitals = []
      const otherHospitals = []
      
      hospitals.forEach(hospital => {
        // 判断医院是否在本地区域（省、市、区任一包含地域关键词）
        const isLocal = 
          (hospital.hopsProvince && hospital.hopsProvince.includes(region)) ||
          (hospital.hopsCity && hospital.hopsCity.includes(region)) ||
          (hospital.hopsArea && hospital.hopsArea.includes(region))
        
        if (isLocal) {
          localHospitals.push(hospital)
        } else {
          otherHospitals.push(hospital)
        }
      })
      
      // 本地医院在前，其他医院在后
      return [...localHospitals, ...otherHospitals]
    },
    
    // 转出医院输入框获得焦点
    onHospitalOutFocus() {
      // 如果没有搜索关键词，只显示当前区域的医院
      if (!this.hospitalOutSearchKeyword || this.hospitalOutSearchKeyword.trim() === '') {
        searchHospitals('', this.selectedRegion).then(response => {
          this.hospitalOutResults = response.data || []
        }).catch(error => {
          console.error('加载转出医院失败:', error)
          this.hospitalOutResults = []
        })
      }
      this.showHospitalOutResults = true
    },
    
    // 转出医院搜索
@@ -569,45 +863,71 @@
        clearTimeout(this.searchTimer)
      }
      
      // 如果关键词为空，只显示当前区域的医院
      if (!keyword || keyword.trim() === '') {
        this.hospitalOutResults = []
        searchHospitals('', this.selectedRegion).then(response => {
          this.hospitalOutResults = response.data || []
        }).catch(error => {
          console.error('加载转出医院失败:', error)
          this.hospitalOutResults = []
        })
        this.showHospitalOutResults = true
        return
      }
      
      // 有关键词时，去服务端搜索（仅限当前区域）
      this.searchTimer = setTimeout(() => {
        this.searchHospitalOut(keyword)
      }, 300)
    },
    
    // 搜索转出医院
    // 搜索转出医院（仅限当前区域）
    searchHospitalOut(keyword) {
      searchHospitals(keyword).then(response => {
      // 传入关键词和地域过滤，只搜索当前区域的医院
      searchHospitals(keyword, this.selectedRegion).then(response => {
        this.hospitalOutResults = response.data || []
        this.showHospitalOutResults = true
        console.log('搜索转出医院:', keyword, '区域:', this.selectedRegion, '结果数:', this.hospitalOutResults.length)
      }).catch(error => {
        console.error('搜索医院失败:', error)
        console.error('搜索转出医院失败:', error)
        this.hospitalOutResults = []
      })
    },
    
    // 选择转出医院
    selectHospitalOut(hospital) {
      this.taskForm.hospitalOut.id = hospital.hospId  // 保存医院ID
      this.taskForm.hospitalOut.name = hospital.hospName
      this.taskForm.hospitalOut.address = hospital.hospAddress
      // 合并省市区 + 详细地址
      const fullAddress = this.buildFullAddress(hospital)
      this.taskForm.hospitalOut.address = fullAddress
      this.hospitalOutSearchKeyword = hospital.hospName
      this.showHospitalOutResults = false
      this.hospitalOutResults = []
      
      // 如果有GPS坐标，保存下来
      // 注意：HospData表中可能没有GPS坐标，需要根据地址进行地理编码
      // 这里先置为null，后续可以通过地址解析获取
      this.addressCoordinates.hospitalOutAddress = null
      // 保存转出医院的城市信息
      this.taskForm.hospitalOut.city = hospital.hopsCity || ''
      
      // 如果两个医院都已选择，自动计算距离
      if (this.taskForm.hospitalIn.address) {
        // 这里可以调用地址解析和距离计算
        // 暂时留空，由用户手动输入距离
        this.calculateHospitalDistance()
      }
    },
    
    // 转入医院输入框获得焦点
    onHospitalInFocus() {
      // 如果没有搜索关键词，显示所有医院（本地区域优先）
      if (!this.hospitalInSearchKeyword || this.hospitalInSearchKeyword.trim() === '') {
        searchHospitals('', '').then(response => {
          const allHospitals = response.data || []
          // 按地域排序：本地区域优先
          this.hospitalInResults = this.sortHospitalsByRegion(allHospitals)
        }).catch(error => {
          console.error('加载转入医院失败:', error)
          this.hospitalInResults = []
        })
      }
      this.showHospitalInResults = true
    },
    
    // 转入医院搜索
@@ -620,54 +940,79 @@
        clearTimeout(this.searchTimer)
      }
      
      // 如果关键词为空，显示所有医院（本地区域优先）
      if (!keyword || keyword.trim() === '') {
        this.hospitalInResults = []
        searchHospitals('', '').then(response => {
          const allHospitals = response.data || []
          // 按地域排序：本地区域优先
          this.hospitalInResults = this.sortHospitalsByRegion(allHospitals)
        }).catch(error => {
          console.error('加载转入医院失败:', error)
          this.hospitalInResults = []
        })
        this.showHospitalInResults = true
        return
      }
      
      // 有关键词时，去服务端搜索（不限区域，但结果按地域排序）
      this.searchTimer = setTimeout(() => {
        this.searchHospitalIn(keyword)
      }, 300)
    },
    
    // 搜索转入医院
    // 搜索转入医院（不限区域，但本地区域优先）
    searchHospitalIn(keyword) {
      searchHospitals(keyword).then(response => {
        this.hospitalInResults = response.data || []
      // 传入关键词，不传地域过滤（搜索所有区域）
      searchHospitals(keyword, '').then(response => {
        const allHospitals = response.data || []
        // 按地域排序：本地区域优先
        this.hospitalInResults = this.sortHospitalsByRegion(allHospitals)
        this.showHospitalInResults = true
        console.log('搜索转入医院:', keyword, '结果数:', this.hospitalInResults.length)
      }).catch(error => {
        console.error('搜索医院失败:', error)
        console.error('搜索转入医院失败:', error)
        this.hospitalInResults = []
      })
    },
    
    // 选择转入医院
    selectHospitalIn(hospital) {
      this.taskForm.hospitalIn.id = hospital.hospId  // 保存医院ID
      this.taskForm.hospitalIn.name = hospital.hospName
      this.taskForm.hospitalIn.address = hospital.hospAddress
      // 合并省市区 + 详细地址
      const fullAddress = this.buildFullAddress(hospital)
      this.taskForm.hospitalIn.address = fullAddress
      this.hospitalInSearchKeyword = hospital.hospName
      this.showHospitalInResults = false
      this.hospitalInResults = []
      
      // 如果有GPS坐标，保存下来
      this.addressCoordinates.hospitalInAddress = null
      // 保存转入医院的城市信息
      this.taskForm.hospitalIn.city = hospital.hopsCity || ''
      
      // 如果两个医院都已选择，自动计算距离
      if (this.taskForm.hospitalOut.address) {
        // 这里可以调用地址解析和距离计算
        // 暂时留空，由用户手动输入距离
        this.calculateHospitalDistance()
      }
    },
    
    // 初始化选中的人员（默认包含当前用户）
    initSelectedStaff() {
      this.selectedStaff = [{
      // 构建当前用户对象，包含完整的角色信息
      const currentUserStaff = {
        userId: this.currentUser.userId,
        nickName: this.currentUser.nickName,
        phonenumber: this.currentUser.phonenumber,
        postName: this.currentUser.position,
        deptId: this.currentUser.deptId
      }]
        deptId: this.currentUser.deptId,
        posts: this.currentUser.posts || [],
        roles: this.currentUser.roles || [],
        dept: this.currentUser.dept || null
      }
      
      // 为当前用户设置角色类型
      currentUserStaff.type = this.getUserType(currentUserStaff)
      
      this.selectedStaff = [currentUserStaff]
    },
    
    // 加载当前用户所在分公司的所有人员
@@ -675,13 +1020,17 @@
      const deptId = this.currentUser.deptId
      if (!deptId) {
        console.error('无法获取当前用户所在部门')
        this.$modal.showToast('无法获取所在部门信息')
        return
      }
      
      // 查询当前部门下的所有用户（司机、护士）
      // 直接查询当前用户部门下的所有用户
      // 后端SQL会自动处理：如果传入的是子部门，会查找其所属的分公司及其所有子部门的用户
      const queryParams = {
        deptId: deptId,
        status: '0' // 只查询正常状态的用户
        status: '0', // 只查询正常状态的用户
        pageNum: 1,
        pageSize: 10000 // 设置足够大的页面大小，获取所有用户
      }
      
      listUser(queryParams).then(response => {
@@ -709,17 +1058,22 @@
    getUserType(user) {
      const postName = user.posts && user.posts.length > 0 ? user.posts[0].postName : ''
      const roleName = user.roles && user.roles.length > 0 ? user.roles[0].roleName : ''
      
      const deptName = user.dept?.deptName || ''
      // console.log("获取用户类型:", postName, roleName,user)
      // 判断是否为司机
      if (postName.includes('司机') || roleName.includes('司机')) {
      if (postName.includes('司机') || roleName.includes('司机') || deptName.includes('车队') || deptName.includes('司机')) {
        return 'driver'
      }
      // 判断是否为医生
      if (postName.includes('医生') || roleName.includes('医生') || deptName.includes('医生')) {
        return 'doctor'
      }
      // 判断是否为护士
      if (postName.includes('护士') || roleName.includes('护士')) {
      if (postName.includes('护士') || roleName.includes('护士') || deptName.includes('护士')) {
        return 'nurse'
      }
      // 其他类型
      return 'other'
      // 其他类型，默认为司机
      return 'driver'
    },
    
    // 显示人员选择弹窗
@@ -732,7 +1086,7 @@
    closeStaffSelector() {
      this.$refs.staffPopup.close()
      this.staffSearchKeyword = ''
      this.staffFilterType = 'all'
      this.staffFilterType = 'driver' // 重置为默认的司机类型
    },
    
    // 人员搜索
@@ -754,6 +1108,8 @@
      // 按类型过滤
      if (this.staffFilterType === 'driver') {
        list = list.filter(staff => staff.type === 'driver')
      } else if (this.staffFilterType === 'doctor') {
        list = list.filter(staff => staff.type === 'doctor')
      } else if (this.staffFilterType === 'nurse') {
        list = list.filter(staff => staff.type === 'nurse')
      }
@@ -822,7 +1178,8 @@
      // 初始化临时选择列表（复制当前已选择的病情）
      this.tempSelectedDiseases = [...this.selectedDiseases]
      this.diseaseSearchKeyword = ''
      this.diseaseSearchResults = []
      // 默认加载所有病情
      this.loadAllDiseases()
      this.$refs.diseasePopup.open()
    },
    
@@ -844,14 +1201,28 @@
        clearTimeout(this.diseaseSearchTimer)
      }
      
      // 如果关键词为空，加载所有病情
      if (!keyword || keyword.trim() === '') {
        this.diseaseSearchResults = []
        this.loadAllDiseases()
        return
      }
      
      // 有关键词时进行搜索
      this.diseaseSearchTimer = setTimeout(() => {
        this.searchDiseaseByKeyword(keyword)
      }, 300)
    },
    
    // 加载所有病情（默认显示）
    loadAllDiseases() {
      // 使用空字符串或特殊标识符来获取所有病情
      // 如果后端不支持空查询，可以传入一个通配符如'%'或者修改后端接口
      searchIcd10('').then(response => {
        this.diseaseSearchResults = response.data || []
      }).catch(error => {
        console.error('加载病情列表失败:', error)
        this.diseaseSearchResults = []
      })
    },
    
    // 根据关键词搜索病情
@@ -899,9 +1270,43 @@
      this.selectedDiseases.splice(index, 1)
    },
    
    // 设置默认转运时间为当前时间
    setDefaultTransferTime() {
      const now = new Date()
      const year = now.getFullYear()
      const month = String(now.getMonth() + 1).padStart(2, '0')
      const day = String(now.getDate()).padStart(2, '0')
      const hours = String(now.getHours()).padStart(2, '0')
      const minutes = String(now.getMinutes()).padStart(2, '0')
      const seconds = String(now.getSeconds()).padStart(2, '0')
      
      // 格式化为 YYYY-MM-DD HH:mm:ss
      this.taskForm.transferTime = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`
    },
    
    validateForm() {
      if (!this.selectedVehicleId) {
        this.$modal.showToast('请选择任务车辆')
        return false
      }
      
      if (!this.selectedEmergencyTaskType) {
        this.$modal.showToast('请选择任务类型')
        return false
      }
      
      if (!this.selectedDocumentType) {
        this.$modal.showToast('请选择单据类型')
        return false
      }
      
      if (!this.taskForm.transferTime) {
        this.$modal.showToast('请选择转运时间')
        return false
      }
      
      if (!this.taskForm.patient.contact) {
        this.$modal.showToast('请输入联系人')
        return false
      }
      
@@ -920,8 +1325,18 @@
        return false
      }
      
      if (!this.taskForm.hospitalOut.department) {
        this.$modal.showToast('请选择转出医院科室')
        return false
      }
      
      if (!this.taskForm.hospitalIn.name) {
        this.$modal.showToast('请输入转入医院名称')
        return false
      }
      
      if (!this.taskForm.hospitalIn.department) {
        this.$modal.showToast('请选择转入医院科室')
        return false
      }
      
@@ -945,9 +1360,25 @@
      
      const submitData = {
        taskType: 'EMERGENCY_TRANSFER',
        deptId: this.selectedOrganizationId, // 归属机构ID（部门ID）
        vehicleIds: this.selectedVehicleId ? [this.selectedVehicleId] : [],
        assigneeIds: this.selectedStaff.map(staff => staff.userId), // 添加执行人员ID列表
        transferTime: this.taskForm.transferTime,
        assigneeIds: this.selectedStaff.map(staff => staff.userId), // 执行人员ID列表
        assigneeId: this.selectedStaff.length > 0 ? this.selectedStaff[0].userId : null, // 主要执行人
        // 执行人员详细信息（包含角色类型）
        assignees: this.selectedStaff.map(staff => ({
          userId: staff.userId,
          userName: staff.nickName,
          userType: staff.type // driver/doctor/nurse
        })),
        transferTime: this.taskForm.transferTime, // 转运时间
        plannedStartTime: this.taskForm.transferTime, // 计划开始时间
        documentTypeId: this.selectedDocumentTypeId, // 单据类型ID
        taskTypeId: this.selectedEmergencyTaskTypeId, // 任务类型ID
        // 病情ID列表（用于同步调度单的OrdICD_ID参数）
        diseaseIds: this.selectedDiseases.map(d => d.id),
        // 将转出医院地址作为出发地，转入医院地址作为目的地
        departureAddress: this.taskForm.hospitalOut.address || '',
        destinationAddress: this.taskForm.hospitalIn.address || '',
        patient: {
          ...this.taskForm.patient,
          condition: conditionText, // 使用合并后的病情信息
@@ -957,22 +1388,33 @@
            icdName: d.icdName
          }))
        },
        hospitalOut: this.taskForm.hospitalOut,
        hospitalIn: this.taskForm.hospitalIn,
        // 医院信息（包含医院ID、科室名称、科室ID等完整信息）
        hospitalOut: this.taskForm.hospitalOut,  // 包含: id, name, department, departmentId, bedNumber, address
        hospitalIn: this.taskForm.hospitalIn,    // 包含: id, name, department, departmentId, bedNumber, address
        transferDistance: this.taskForm.transferDistance ? parseFloat(this.taskForm.transferDistance) : null,
        price: this.taskForm.price ? parseFloat(this.taskForm.price) : null
      }
      
      if (this.addressCoordinates.hospitalOutAddress) {
        // 转出医院GPS坐标写入扩展表
        if (!submitData.hospitalOut) submitData.hospitalOut = {}
        submitData.hospitalOut.longitude = this.addressCoordinates.hospitalOutAddress.lng
        submitData.hospitalOut.latitude = this.addressCoordinates.hospitalOutAddress.lat
        
        // 同时写入主任务表的出发地经纬度
        submitData.departureLongitude = this.addressCoordinates.hospitalOutAddress.lng
        submitData.departureLatitude = this.addressCoordinates.hospitalOutAddress.lat
      }
      
      if (this.addressCoordinates.hospitalInAddress) {
        // 转入医院GPS坐标写入扩展表
        if (!submitData.hospitalIn) submitData.hospitalIn = {}
        submitData.hospitalIn.longitude = this.addressCoordinates.hospitalInAddress.lng
        submitData.hospitalIn.latitude = this.addressCoordinates.hospitalInAddress.lat
        
        // 同时写入主任务表的目的地经纬度
        submitData.destinationLongitude = this.addressCoordinates.hospitalInAddress.lng
        submitData.destinationLatitude = this.addressCoordinates.hospitalInAddress.lat
      }
      
      return submitData
@@ -991,7 +1433,9 @@
          this.loading = false
          this.$modal.showToast('任务创建成功')
          setTimeout(() => {
            this.$tab.navigateTo('/pages/task/index')
            uni.switchTab({
              url: '/pages/task/index'
            })
          }, 1500)
        }).catch(error => {
          this.loading = false
@@ -1003,6 +1447,68 @@
    
    goBack() {
      uni.navigateBack()
    },
    
    // 合并医院地址（省 + 市 + 区 + 详细地址）
    buildFullAddress(hospital) {
      const parts = []
      if (hospital.hopsProvince) {
        parts.push(hospital.hopsProvince)
      }
      if (hospital.hopsCity) {
        parts.push(hospital.hopsCity)
      }
      if (hospital.hopsArea) {
        parts.push(hospital.hopsArea)
      }
      if (hospital.hospAddress) {
        parts.push(hospital.hospAddress)
      }
      return parts.join('')
    },
    
    // 自动计算两个医院之间的距离
    calculateHospitalDistance() {
      const fromAddress = this.taskForm.hospitalOut.address
      const fromCity = this.taskForm.hospitalOut.city
      const toAddress = this.taskForm.hospitalIn.address
      const toCity = this.taskForm.hospitalIn.city
      
      if (!fromAddress || !toAddress) {
        console.log('地址信息不完整，无法计算距离')
        return
      }
      
      console.log('开始计算距离:', fromAddress, '->', toAddress)
      
      // 显示加载提示
      uni.showLoading({
        title: '计算距离中...'
      })
      
      // 调用百度地图API计算距离
      baiduDistanceByAddress(fromAddress, fromCity, toAddress, toCity)
        .then(response => {
          uni.hideLoading()
          
          if (response.code === 200 && response.data) {
            const distanceInMeters = response.data.distance
            // 转换为公里，保留1位小数
            const distanceInKm = (distanceInMeters / 1000).toFixed(1)
            this.taskForm.transferDistance = distanceInKm
            
            console.log('距离计算成功:', distanceInKm, 'km')
            // this.$modal.showToast(`距离计算成功: ${distanceInKm}公里`)
          } else {
            console.error('距离计算失败:', response.msg)
            this.$modal.showToast('距离计算失败，请手动输入')
          }
        })
        .catch(error => {
          uni.hideLoading()
          console.error('距离计算失败:', error)
          this.$modal.showToast('距离计算失败，请手动输入')
        })
    }
  }
}
@@ -1059,6 +1565,13 @@
        font-size: 28rpx;
        margin-bottom: 15rpx;
        color: #333;
        
        &.required::before {
          content: '*';
          color: #ff4d4f;
          margin-right: 4rpx;
          font-weight: bold;
        }
      }
      
      .hospital-search-container {