<template>
|
<scroll-view class="create-emergency-task-container" scroll-y="true">
|
<view class="form-header">
|
<view class="back-btn" @click="goBack">
|
<uni-icons type="arrowleft" size="20"></uni-icons>
|
</view>
|
<view class="title">创建转运任务</view>
|
<view class="smart-parse-btn" @click="showSmartParsePopup">
|
<uni-icons type="compose" size="20" color="#007AFF"></uni-icons>
|
<text>智能识别</text>
|
</view>
|
</view>
|
|
<view class="form-section">
|
<view class="form-item">
|
<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">
|
<OrganizationSelector
|
v-model="selectedOrganizationId"
|
:required="true"
|
:auto-select-user-dept="true"
|
@change="onOrganizationChange"
|
/>
|
</view>
|
|
<DepartureSelector
|
:address.sync="departureAddress"
|
:longitude.sync="departureLongitude"
|
:latitude.sync="departureLatitude"
|
:region="selectedRegion"
|
:required="false"
|
@address-selected="onDepartureAddressSelected"
|
@location-success="onDepartureLocationSuccess"
|
/>
|
|
<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>
|
<StaffSelector
|
v-model="selectedStaff"
|
label="执行任务人员"
|
:required="false"
|
:auto-add-current-user="true"
|
:current-user-removable="false"
|
@change="onStaffChange"
|
/>
|
|
|
|
<view class="form-item">
|
<view class="form-label required">转运时间</view>
|
<uni-datetime-picker
|
v-model="taskForm.transferTime"
|
type="datetime"
|
:placeholder="'请选择转运时间'"
|
/>
|
</view>
|
|
<view class="form-section-title">患者信息</view>
|
<view class="form-item">
|
<view class="form-label required">联系人</view>
|
<input
|
class="form-input"
|
placeholder="请输入联系人"
|
v-model="taskForm.patient.contact"
|
/>
|
</view>
|
|
<view class="form-item">
|
<view class="form-label required">联系电话</view>
|
<input
|
class="form-input"
|
type="number"
|
placeholder="请输入联系电话"
|
v-model="taskForm.patient.phone"
|
/>
|
</view>
|
|
<view class="form-item">
|
<view class="form-label required">患者姓名</view>
|
<input
|
class="form-input"
|
placeholder="请输入患者姓名"
|
v-model="taskForm.patient.name"
|
/>
|
</view>
|
|
<view class="form-item">
|
<view class="form-label">性别</view>
|
<view class="radio-group">
|
<label class="radio-item">
|
<radio value="male" :checked="taskForm.patient.gender === 'male'" @click="taskForm.patient.gender = 'male'" />
|
<text>男</text>
|
</label>
|
<label class="radio-item">
|
<radio value="female" :checked="taskForm.patient.gender === 'female'" @click="taskForm.patient.gender = 'female'" />
|
<text>女</text>
|
</label>
|
</view>
|
</view>
|
|
<view class="form-item">
|
<view class="form-label">患者身份证</view>
|
<input
|
class="form-input"
|
type="idcard"
|
placeholder="请输入患者身份证号"
|
v-model="taskForm.patient.idCard"
|
/>
|
</view>
|
|
<DiseaseSelector
|
v-model="selectedDiseases"
|
:other-description.sync="taskForm.patient.condition"
|
/>
|
|
<view class="form-section-title">转出医院信息</view>
|
<HospitalSelector
|
label="医院名称"
|
address-label="转出地址"
|
:required="true"
|
:department-required="true"
|
v-model="taskForm.hospitalOut"
|
:dept-id="selectedOrganizationId"
|
:region="selectedRegion"
|
:department-options="departmentOptions"
|
@change="onHospitalOutChange"
|
@address-selected="onHospitalOutAddressSelected"
|
/>
|
|
<view class="form-section-title">转入医院信息</view>
|
<HospitalSelector
|
label="医院名称"
|
address-label="转入地址"
|
:required="true"
|
:department-required="true"
|
v-model="taskForm.hospitalIn"
|
:dept-id="selectedOrganizationId"
|
:region="selectedRegion"
|
:department-options="departmentOptions"
|
@change="onHospitalInChange"
|
@address-selected="onHospitalInAddressSelected"
|
/>
|
|
<view class="form-item">
|
<view class="form-label required">转运公里数</view>
|
<input
|
class="form-input"
|
type="digit"
|
placeholder="请输入转运公里数"
|
v-model="taskForm.transferDistance"
|
@blur="onDistanceChange"
|
/>
|
</view>
|
|
<view class="form-item">
|
<view class="form-label required">成交价</view>
|
<input
|
class="form-input"
|
type="digit"
|
placeholder="请输入成交价"
|
v-model="taskForm.price"
|
/>
|
</view>
|
|
<view class="form-actions">
|
<button class="submit-btn" @click="submitTask" :disabled="loading">
|
{{ loading ? '保存中...' : '保存' }}
|
</button>
|
</view>
|
</view>
|
|
|
<!-- 智能识别弹窗 -->
|
<uni-popup ref="smartParsePopup" type="bottom" :safe-area="true">
|
<view class="smart-parse-popup">
|
<view class="popup-header">
|
<view class="popup-title">智能识别</view>
|
<view class="popup-close" @click="closeSmartParsePopup">
|
<uni-icons type="closeempty" size="24" color="#333"></uni-icons>
|
</view>
|
</view>
|
|
<view class="parse-content">
|
<view class="parse-tip">
|
<uni-icons type="info" size="18" color="#007AFF"></uni-icons>
|
<text>粘贴或输入文本，如："患者张三，电话13800138000，从广州某某医院转入深圳某某中心，费用￥680"</text>
|
</view>
|
<textarea
|
class="parse-textarea"
|
placeholder="请在此粘贴或输入转运信息..."
|
v-model="rawText"
|
:maxlength="-1"
|
/>
|
</view>
|
|
<view class="popup-footer">
|
<button class="cancel-btn" @click="closeSmartParsePopup">取消</button>
|
<button class="confirm-btn" @click="parseFreeText" :disabled="parseLoading">
|
{{ parseLoading ? '识别中...' : '开始识别' }}
|
</button>
|
</view>
|
</view>
|
</uni-popup>
|
</scroll-view>
|
</template>
|
|
<script>
|
import { mapState } from 'vuex'
|
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, getUserBoundVehicle } from "@/api/vehicle"
|
import { searchHospitals, searchHospitalsByDeptRegion } from "@/api/hospital"
|
import DepartureSelector from './components/DepartureSelector.vue'
|
import { calculateTianDiTuDistance } from "@/api/map"
|
import { listBranchUsers } from "@/api/system/user"
|
import { searchIcd10 } from "@/api/icd10"
|
import { calculateTransferPrice } from "@/api/price"
|
import { checkVehicleActiveTasks } from "@/api/task"
|
|
import { getDicts } from "@/api/dict"
|
import { getServiceOrdAreaTypes, getServiceOrderTypes, getHospitalDepartments } from "@/api/dictionary"
|
import { listBranchCompany, getDept } from "@/api/system/dept"
|
import MapSelector from './components/map-selector.vue'
|
import OrganizationSelector from './components/OrganizationSelector.vue'
|
import HospitalSelector from './components/HospitalSelector.vue'
|
import DiseaseSelector from './components/DiseaseSelector.vue'
|
import StaffSelector from './components/StaffSelector.vue'
|
|
export default {
|
components: {
|
uniDatetimePicker,
|
uniPopup,
|
MapSelector,
|
OrganizationSelector,
|
HospitalSelector,
|
DiseaseSelector,
|
DepartureSelector,
|
StaffSelector
|
},
|
data() {
|
return {
|
selectedVehicle: '',
|
selectedVehicleId: null,
|
selectedOrganizationId: null, // 归属机构ID（部门ID）
|
selectedOrganizationServiceOrderClass: '', // 归属机构的服务单编码
|
selectedRegion: '', // 从归属机构中提取的地域信息（如：广州、深圳等）
|
departureAddress: '', // 出发地地址
|
departureLongitude: null, // 出发地经度
|
departureLatitude: null, // 出发地纬度
|
selectedEmergencyTaskType: '', // 选中的任务类型文本
|
selectedEmergencyTaskTypeId: null, // 选中的任务类型ID
|
selectedDocumentType: '', // 选中的单据类型文本
|
selectedDocumentTypeId: null, // 选中的单据类型ID
|
mapSelectorType: '',
|
// 人员选择相关
|
selectedStaff: [], // 已选择的人员列表
|
// 病情选择相关
|
selectedDiseases: [], // 已选择的病情列表
|
taskForm: {
|
transferTime: '',
|
patient: {
|
contact: '',
|
phone: '',
|
name: '',
|
gender: 'male',
|
idCard: '',
|
condition: ''
|
},
|
hospitalOut: {
|
id: null, // 医院ID
|
name: '',
|
department: '',
|
departmentId: null, // 科室ID
|
bedNumber: '',
|
address: ''
|
},
|
hospitalIn: {
|
id: null, // 医院ID
|
name: '',
|
department: '',
|
departmentId: null, // 科室ID
|
bedNumber: '',
|
address: ''
|
},
|
transferDistance: '',
|
price: ''
|
},
|
vehicles: [],
|
vehicleOptions: [],
|
|
emergencyTaskTypes: [], // 任务类型列表（从 SQL Server 动态加载）
|
emergencyTaskTypeOptions: [], // 任务类型选项（用于picker显示）
|
documentTypes: [], // 单据类型列表
|
documentTypeOptions: [], // 单据类型选项（用于picker显示）
|
departmentOptions: [], // 科室字典数据
|
loading: false,
|
// 智能识别相关
|
rawText: '',
|
parseLoading: false
|
}
|
},
|
computed: {
|
...mapState({
|
currentUser: state => ({
|
userId: state.user.userId,
|
name: state.user.nickName || '张三',
|
nickName: state.user.nickName || '张三',
|
position: '司机',
|
deptId: state.user.deptId || 100,
|
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.setDefaultTransferTime()
|
|
// 先加载车辆列表，然后加载绑定车辆信息
|
this.getAvailableVehicles().then(() => {
|
this.getUserBoundVehicleInfo()
|
})
|
// 加载科室字典数据
|
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() {
|
// 根据用户有权限管理的分公司，查询所有可用车辆
|
return listAvailableVehicles(null, 'EMERGENCY').then(response => {
|
const vehicleList = response.data || []
|
this.vehicleOptions = vehicleList.map(vehicle => ({
|
id: vehicle.vehicleId,
|
name: vehicle.vehicleNo,
|
type: vehicle.vehicleType,
|
status: vehicle.status,
|
deptNames: vehicle.deptNames || [] // 车辆归属的多个分公司
|
}))
|
// 只显示车牌号，不显示分公司
|
this.vehicles = this.vehicleOptions.map(v => v.name)
|
console.log('加载可用车辆数量:', this.vehicles.length)
|
}).catch(error => {
|
console.error('加载车辆列表失败:', error)
|
this.vehicles = []
|
})
|
},
|
|
onVehicleChange(e) {
|
const index = e.detail.value
|
this.selectedVehicle = this.vehicles[index]
|
this.selectedVehicleId = this.vehicleOptions[index]?.id
|
},
|
|
onOrganizationChange(orgData) {
|
// orgData 包含：deptId, deptName, serviceOrderClass, region, departureAddress, departureLongitude, departureLatitude
|
this.selectedOrganizationId = orgData.deptId
|
this.selectedOrganizationServiceOrderClass = orgData.serviceOrderClass
|
this.selectedRegion = orgData.region
|
|
// 自动填充出发地信息（机构的地址和坐标）
|
if (orgData.departureAddress) {
|
this.departureAddress = orgData.departureAddress
|
this.departureLongitude = orgData.departureLongitude || null
|
this.departureLatitude = orgData.departureLatitude || null
|
console.log('自动填充机构出发地:', this.departureAddress, '坐标:', this.departureLongitude, this.departureLatitude)
|
}
|
|
console.log('选中归属机构:', orgData.deptName, '部门ID:', orgData.deptId, '服务单编码:', orgData.serviceOrderClass, '地域:', orgData.region)
|
},
|
replaceRegion(region){
|
return region.replace(/(分公司|总公司|总部)$/g, '').trim();
|
},
|
|
// 加载科室数据（从 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) {
|
const index = e.detail.value
|
const selected = this.emergencyTaskTypeOptions[index]
|
this.selectedEmergencyTaskType = selected.text
|
this.selectedEmergencyTaskTypeId = selected.id
|
},
|
|
|
// 加载单据类型数据
|
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
|
},
|
|
// 转出医院变化
|
onHospitalOutChange(hospitalData) {
|
console.log('转出医院变化:', hospitalData)
|
// 组件已经通过 v-model 更新了 taskForm.hospitalOut
|
|
// 如果转入地址已填写,自动计算距离
|
if (this.taskForm.hospitalIn.address) {
|
// 如果两个都不是"家中",使用医院距离计算
|
if (hospitalData.name !== '家中' && this.taskForm.hospitalIn.name !== '家中') {
|
this.calculateHospitalDistance()
|
} else {
|
// 有一个是"家中",使用地址计算
|
this.calculateDistanceByManualAddress()
|
}
|
}
|
},
|
|
// 转出医院地址选择事件（简化，移除GPS处理）
|
onHospitalOutAddressSelected(data) {
|
if (this.taskForm.hospitalIn.address) {
|
this.calculateDistanceByManualAddress()
|
}
|
},
|
|
// 转入医院变化
|
onHospitalInChange(hospitalData) {
|
console.log('转入医院变化:', hospitalData)
|
// 组件已经通过 v-model 更新了 taskForm.hospitalIn
|
|
// 如果转出地址已填写,自动计算距离
|
if (this.taskForm.hospitalOut.address) {
|
// 如果两个都不是"家中",使用医院距离计算
|
if (hospitalData.name !== '家中' && this.taskForm.hospitalOut.name !== '家中') {
|
this.calculateHospitalDistance()
|
} else {
|
// 有一个是"家中",使用地址计算
|
this.calculateDistanceByManualAddress()
|
}
|
}
|
},
|
|
// 转入医院地址选择事件（简化，移除GPS处理）
|
onHospitalInAddressSelected(data) {
|
if (this.taskForm.hospitalOut.address) {
|
this.calculateDistanceByManualAddress()
|
}
|
},
|
|
// 人员变化事件
|
onStaffChange(staff) {
|
console.log('选中人员变化:', staff)
|
// 组件已经通过 v-model 更新了 selectedStaff
|
},
|
calculateDistanceByManualAddress() {
|
const fromAddress = this.taskForm.hospitalOut.address
|
const toAddress = this.taskForm.hospitalIn.address
|
|
if (!fromAddress || !toAddress) {
|
return
|
}
|
|
console.log('计算手动输入地址距离:', fromAddress, '->', toAddress)
|
|
// 显示加载提示
|
uni.showLoading({
|
title: '计算距离中...'
|
})
|
|
// 调用百度地图API计算距离
|
const region = this.selectedRegion || '广州'
|
calculateTianDiTuDistance(fromAddress, toAddress)
|
.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}公里`)
|
|
// 距离计算成功后，自动计算成交价
|
this.calculatePrice()
|
} else {
|
console.error('距离计算失败:', response.msg)
|
this.$modal.showToast('距离计算失败,请手动输入')
|
}
|
})
|
.catch(error => {
|
uni.hideLoading()
|
console.error('距离计算失败:', error)
|
this.$modal.showToast('距离计算失败,请手动输入')
|
})
|
},
|
|
// 距离输入框失焦时触发成交价计算
|
onDistanceChange() {
|
this.calculatePrice()
|
},
|
|
// 计算成交价
|
calculatePrice() {
|
const fromAddress = this.taskForm.hospitalOut.address
|
const toAddress = this.taskForm.hospitalIn.address
|
const distance = this.taskForm.transferDistance
|
|
// 如果地址或距离不完整，不进行计算
|
if (!fromAddress || !toAddress || !distance || parseFloat(distance) <= 0) {
|
console.log('地址或距离信息不完整，跳过成交价计算')
|
return
|
}
|
|
console.log('开始计算成交价:', fromAddress, '->', toAddress, '距离:', distance)
|
|
// 调用成交价计算接口
|
calculateTransferPrice({
|
fromAddress: fromAddress,
|
toAddress: toAddress,
|
distance: parseFloat(distance),
|
region: this.selectedRegion || ''
|
}).then(response => {
|
if (response.code === 200 && response.data) {
|
const price = response.data.price
|
|
// 只有当返回的价格大于0时，才自动填充成交价
|
if (price && price > 0) {
|
this.taskForm.price = price.toFixed(2)
|
console.log('成交价计算成功:', price)
|
this.$modal.showToast(`成交价: ¥${price.toFixed(2)}`)
|
} else {
|
console.log('成交价为0，不自动填充')
|
}
|
} else {
|
console.log('成交价计算失败，保持手动输入')
|
}
|
}).catch(error => {
|
console.error('成交价计算失败:', error)
|
// 计算失败时不提示用户，允许用户手动输入
|
})
|
},
|
// 手动输入地址时计算距离
|
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.selectedOrganizationId) {
|
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
|
}
|
|
if (!this.taskForm.patient.name) {
|
this.$modal.showToast('请输入患者姓名')
|
return false
|
}
|
|
if (!this.taskForm.patient.phone) {
|
this.$modal.showToast('请输入患者联系电话')
|
return false
|
}
|
|
if (!this.taskForm.hospitalOut.name) {
|
this.$modal.showToast('请输入转出医院名称')
|
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
|
}
|
|
if (!this.taskForm.transferDistance) {
|
this.$modal.showToast('请输入转运公里数')
|
return false
|
}
|
|
if (!this.taskForm.price) {
|
this.$modal.showToast('请输入成交价')
|
return false
|
}
|
|
return true
|
},
|
|
buildSubmitData() {
|
// 合并病情信息：选中的ICD-10疾病 + 其他描述
|
let conditionText = ''
|
if (this.selectedDiseases.length > 0) {
|
// 过滤掉病情名称为空的项，并构建病情字符串
|
const diseaseNames = this.selectedDiseases
|
.filter(d => d.icdName && d.icdName.trim())
|
.map(d => `${d.icdName}(${d.icdCode})`)
|
.join('、')
|
if (diseaseNames) {
|
conditionText = diseaseNames
|
}
|
}
|
if (this.taskForm.patient.condition && this.taskForm.patient.condition.trim()) {
|
if (conditionText) {
|
conditionText += '\n其他：' + this.taskForm.patient.condition
|
} else {
|
conditionText = this.taskForm.patient.condition
|
}
|
}
|
|
const submitData = {
|
taskType: 'EMERGENCY_TRANSFER',
|
deptId: this.selectedOrganizationId, // 归属机构ID（部门ID）
|
vehicleIds: this.selectedVehicleId ? [this.selectedVehicleId] : [],
|
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.filter(d => d.id !== null).map(d => d.id),
|
// 将转出医院地址作为出发地，转入医院地址作为目的地
|
departureAddress: this.departureAddress || this.taskForm.hospitalOut.address || '',
|
destinationAddress: this.taskForm.hospitalIn.address || '',
|
patient: {
|
...this.taskForm.patient,
|
condition: conditionText, // 使用合并后的病情信息
|
diseases: this.selectedDiseases
|
.filter(d => d.icdName && d.icdName.trim())
|
.map(d => ({
|
icdId: d.id,
|
icdCode: d.icdCode,
|
icdName: d.icdName
|
}))
|
},
|
// 医院信息（包含医院ID、科室名称、科室ID、GPS坐标等完整信息）
|
hospitalOut: {
|
...this.taskForm.hospitalOut
|
// GPS坐标由后端自动获取
|
},
|
hospitalIn: {
|
...this.taskForm.hospitalIn
|
// GPS坐标由后端自动获取
|
},
|
|
transferDistance: this.taskForm.transferDistance ? parseFloat(this.taskForm.transferDistance) : null,
|
price: this.taskForm.price ? parseFloat(this.taskForm.price) : null
|
}
|
|
// 出发地GPS坐标（优先使用自定义的出发地坐标）
|
if (this.departureLongitude && this.departureLatitude) {
|
submitData.departureLongitude = this.departureLongitude
|
submitData.departureLatitude = this.departureLatitude
|
}
|
|
// 目标地GPS坐标由后端根据转入医院地址自动获取
|
|
return submitData
|
},
|
|
submitTask() {
|
if (!this.validateForm()) {
|
return
|
}
|
|
this.$modal.confirm('确定要保存任务吗？').then(() => {
|
this.loading = true
|
const submitData = this.buildSubmitData()
|
|
addTask(submitData).then(response => {
|
this.loading = false
|
this.$modal.showToast('任务创建成功')
|
|
// 延迟跳转，让用户看到成功提示
|
setTimeout(() => {
|
// 跳转到任务列表并触发刷新
|
uni.switchTab({
|
url: '/pages/task/index',
|
success: () => {
|
// 使用事件总线通知任务列表页面刷新
|
uni.$emit('refreshTaskList')
|
}
|
})
|
}, 1000)
|
}).catch(error => {
|
this.loading = false
|
console.error('任务创建失败:', error)
|
this.$modal.showToast('任务创建失败，请重试')
|
})
|
}).catch(() => {})
|
},
|
|
goBack() {
|
uni.navigateBack()
|
},
|
|
// 获取当前位置
|
getCurrentLocation() {
|
uni.showLoading({
|
title: '获取位置中...'
|
})
|
|
// 使用uni-app的GPS定位功能
|
uni.getLocation({
|
type: 'gcj02', // 返回国测局坐标，适用于国内地图 火星坐标
|
success: (res) => {
|
console.log('获取到GPS坐标:', res)
|
const latitude = res.latitude
|
const longitude = res.longitude
|
|
// 保存GPS坐标
|
this.departureLatitude = latitude
|
this.departureLongitude = longitude
|
|
// 调用逆地理编码接口，将坐标转换为地址
|
reverseGeocoder(latitude, longitude)
|
.then(response => {
|
uni.hideLoading()
|
|
if (response.code === 200 && response.data) {
|
// 获取详细地址
|
const address = response.data.address || response.data.formattedAddress || ''
|
this.departureAddress = address
|
|
console.log('逆地理编码成功:', address)
|
this.$modal.showToast('已获取当前位置')
|
} else {
|
console.error('逆地理编码失败:', response.msg)
|
this.$modal.showToast('位置解析失败，请手动输入地址')
|
}
|
})
|
.catch(error => {
|
uni.hideLoading()
|
console.error('逆地理编码失败:', error)
|
// 即使地址解析失败，也保留GPS坐标
|
this.$modal.showToast('位置解析失败，但GPS坐标已保存')
|
})
|
},
|
fail: (err) => {
|
uni.hideLoading()
|
console.error('获取位置失败:', err)
|
|
// 提示用户可能的原因
|
let errorMsg = '获取位置失败'
|
if (err.errMsg && err.errMsg.includes('auth deny')) {
|
errorMsg = '请在设置中开启位置权限'
|
} else if (err.errMsg && err.errMsg.includes('timeout')) {
|
errorMsg = '定位超时，请稍后重试'
|
}
|
|
this.$modal.showToast(errorMsg)
|
}
|
})
|
},
|
|
// 出发地地址选择（从地图建议中选择）
|
onDepartureAddressSelected(data) {
|
// data 包含: address, longitude, latitude, location
|
console.log('出发地地址选择:', data)
|
// 组件已经通过 .sync 更新了 departureAddress, departureLongitude, departureLatitude
|
},
|
|
// 出发地GPS定位成功
|
onDepartureLocationSuccess(data) {
|
// data 包含: address, longitude, latitude
|
console.log('出发地GPS定位成功:', data)
|
// 组件已经通过 .sync 更新了 departureAddress, departureLongitude, departureLatitude
|
},
|
|
// ==================== 智能识别相关方法 ====================
|
|
// 显示智能识别弹窗
|
showSmartParsePopup() {
|
this.rawText = ''
|
this.$refs.smartParsePopup.open()
|
},
|
|
// 关闭智能识别弹窗
|
closeSmartParsePopup() {
|
this.$refs.smartParsePopup.close()
|
this.rawText = ''
|
},
|
|
// 解析自由文本并填充表单
|
parseFreeText() {
|
const text = (this.rawText || '').trim()
|
if (!text) {
|
this.$modal.showToast('请先粘贴或输入文本')
|
return
|
}
|
this.parseLoading = true
|
|
const result = {
|
patientName: this.extractPatientName(text),
|
phone: this.extractPhone(text),
|
hospitalOutName: this.extractHospital(text, 'out'),
|
hospitalInName: this.extractHospital(text, 'in'),
|
departmentOut: this.extractDepartment(text, 'out'),
|
departmentIn: this.extractDepartment(text, 'in'),
|
price: this.extractPrice(text)
|
}
|
|
// 应用基础字段
|
if (result.patientName) this.taskForm.patient.name = result.patientName
|
if (result.phone) this.taskForm.patient.phone = result.phone
|
if (result.price) this.taskForm.price = result.price
|
|
// 应用科室信息（匹配 departmentOptions 中的数据）
|
if (result.departmentOut) {
|
const deptOut = this.matchDepartment(result.departmentOut)
|
if (deptOut) {
|
this.taskForm.hospitalOut.department = deptOut.text
|
this.taskForm.hospitalOut.departmentId = deptOut.id
|
}
|
}
|
if (result.departmentIn) {
|
const deptIn = this.matchDepartment(result.departmentIn)
|
if (deptIn) {
|
this.taskForm.hospitalIn.department = deptIn.text
|
this.taskForm.hospitalIn.departmentId = deptIn.id
|
}
|
}
|
|
// 处理医院名称 → 精确匹配医院并补全地址与ID（不限制分公司区域）
|
Promise.all([
|
this.findHospitalByName(result.hospitalOutName, 'out', false),
|
this.findHospitalByName(result.hospitalInName, 'in', false)
|
])
|
.then(([outHosp, inHosp]) => {
|
if (outHosp) {
|
this.taskForm.hospitalOut.id = outHosp.hospId
|
this.taskForm.hospitalOut.name = outHosp.hospName
|
if (outHosp.hospName !== '家中') {
|
this.taskForm.hospitalOut.address = this.buildFullAddress(outHosp)
|
this.taskForm.hospitalOut.city = outHosp.hopsCity || ''
|
this.hospitalOutSearchKeyword = outHosp.hospName
|
} else {
|
this.taskForm.hospitalOut.address = ''
|
this.taskForm.hospitalOut.department = '其它'
|
this.hospitalOutSearchKeyword = '家中'
|
}
|
} else if (result.hospitalOutName) {
|
this.taskForm.hospitalOut.name = result.hospitalOutName
|
this.hospitalOutSearchKeyword = result.hospitalOutName
|
}
|
|
if (inHosp) {
|
this.taskForm.hospitalIn.id = inHosp.hospId
|
this.taskForm.hospitalIn.name = inHosp.hospName
|
if (inHosp.hospName !== '家中') {
|
this.taskForm.hospitalIn.address = this.buildFullAddress(inHosp)
|
this.taskForm.hospitalIn.city = inHosp.hopsCity || ''
|
this.hospitalInSearchKeyword = inHosp.hospName
|
} else {
|
this.taskForm.hospitalIn.address = ''
|
this.taskForm.hospitalIn.department = '其它'
|
this.hospitalInSearchKeyword = '家中'
|
}
|
} else if (result.hospitalInName) {
|
this.taskForm.hospitalIn.name = result.hospitalInName
|
this.hospitalInSearchKeyword = result.hospitalInName
|
}
|
|
// 若两端地址完整，自动计算距离与成交价
|
if (this.taskForm.hospitalOut.address && this.taskForm.hospitalIn.address &&
|
this.taskForm.hospitalOut.name !== '家中' && this.taskForm.hospitalIn.name !== '家中') {
|
this.calculateHospitalDistance()
|
}
|
})
|
.catch(err => {
|
console.error('医院匹配失败:', err)
|
})
|
.finally(() => {
|
this.parseLoading = false
|
this.closeSmartParsePopup()
|
this.$modal.showToast('识别完成，请核对自动填充结果')
|
})
|
},
|
|
// 提取手机号（优先匹配移动号，次匹配座机）
|
extractPhone(text) {
|
// 先去除文本中的空格，再进行匹配
|
const cleanText = text.replace(/\s+/g, '')
|
|
// 匹配11位手机号（支持原文本中有空格的情况）
|
const mobile = cleanText.match(/(?<!\d)(1[3-9]\d{9})(?!\d)/)
|
if (mobile) return mobile[1]
|
|
// 匹配座机号（支持带区号和连字符）
|
const landline = cleanText.match(/0\d{2,3}-?\d{7,8}/)
|
if (landline) return landline[0]
|
|
// 兜底：在原文本中查找带空格的手机号格式（如：182 8569 1756）
|
const mobileWithSpace = text.match(/(?:电话|手机|联系|tel|phone)[：:\s]*([1][3-9][\d\s]{9,15})/i)
|
if (mobileWithSpace) {
|
const cleanMobile = mobileWithSpace[1].replace(/\s+/g, '')
|
if (/^1[3-9]\d{9}$/.test(cleanMobile)) {
|
return cleanMobile
|
}
|
}
|
|
// 最后尝试：直接查找任意带空格的11位数字组合
|
const anyMobile = text.match(/([1][3-9][\d\s]{9,15})/)
|
if (anyMobile) {
|
const cleanAny = anyMobile[1].replace(/\s+/g, '')
|
if (/^1[3-9]\d{9}$/.test(cleanAny)) {
|
return cleanAny
|
}
|
}
|
|
return ''
|
},
|
|
// 提取患者姓名（常见关键词前缀）
|
extractPatientName(text) {
|
const m = text.match(/(?:患者|病人|姓名|联系人)[：: ]?\s*([\u4e00-\u9fa5]{2,4})/)
|
return m ? m[1] : ''
|
},
|
|
// 提取成交价（支持￥/元/RMB等）
|
extractPrice(text) {
|
const m1 = text.match(/(?:成交价|价格|费用|收费|总价|共)[：: ]?\s*(?:￥|¥|RMB|人民币)?\s*([0-9]+(?:\.[0-9]{1,2})?)/i)
|
if (m1) return parseFloat(m1[1]).toFixed(2)
|
const m2 = text.match(/(?:￥|¥)\s*([0-9]+(?:\.[0-9]{1,2})?)/)
|
if (m2) return parseFloat(m2[1]).toFixed(2)
|
const m3 = text.match(/([0-9]+(?:\.[0-9]{1,2})?)\s*(?:元|人民币|RMB)/i)
|
if (m3) return parseFloat(m3[1]).toFixed(2)
|
return ''
|
},
|
|
// 提取医院名称（基于语义标记，支持简称如"省医"）
|
extractHospital(text, type) {
|
// 先尝试语义标记提取
|
const outReg = /(?:转出|来自|从)[：: ]?\s*([^\s，,。；;转]+?(?:医院|中心|卫生院|急救中心|家中|省医|市医|区医|县医|人民医院|中医院|妇幼|儿童医院))/
|
const inReg = /(?:转入|至|前往|到|去往|转回)[：: ]?\s*([^\s，,。；;转]+?(?:医院|中心|卫生院|急救中心|家中|省医|市医|区医|县医|人民医院|中医院|妇幼|儿童医院))/
|
const reg = type === 'out' ? outReg : inReg
|
const m = text.match(reg)
|
if (m) {
|
// 去除可能包含的楼栋、楼层、科室等信息
|
let hospitalName = m[1]
|
// 去除楼栋信息（如：东一号楼、A栋等）
|
hospitalName = hospitalName.replace(/[东西南北中]?[一二三四五六七八九十0-9]+号?楼.*/g, '')
|
// 去除楼层信息（如：四楼、3F等）
|
hospitalName = hospitalName.replace(/[一二三四五六七八九十0-9]+[楼层F].*/g, '')
|
return hospitalName.trim()
|
}
|
|
// 无语义标记时，兜底提取首个"含医院/中心/家中/简称"的片段
|
const any = text.match(/([^\s，,。；;转]+?(?:医院|中心|卫生院|急救中心|家中|省医|市医|区医|县医|人民医院|中医院|妇幼|儿童医院))/g)
|
if (any && any.length > 0) {
|
if (type === 'out') {
|
let name = any[0]
|
name = name.replace(/[东西南北中]?[一二三四五六七八九十0-9]+号?楼.*/g, '')
|
name = name.replace(/[一二三四五六七八九十0-9]+[楼层F].*/g, '')
|
return name.trim()
|
}
|
if (type === 'in') {
|
let name = any[1] || any[0]
|
name = name.replace(/[东西南北中]?[一二三四五六七八九十0-9]+号?楼.*/g, '')
|
name = name.replace(/[一二三四五六七八九十0-9]+[楼层F].*/g, '')
|
return name.trim()
|
}
|
}
|
return ''
|
},
|
|
// 匹配科室（优先使用 departmentOptions 中的数据）
|
matchDepartment(deptName) {
|
if (!deptName || !this.departmentOptions || this.departmentOptions.length === 0) {
|
return null
|
}
|
|
const normalized = deptName.trim().toUpperCase()
|
|
// 1. 精确匹配（不区分大小写）
|
let matched = this.departmentOptions.find(d =>
|
d.text.toUpperCase() === normalized
|
)
|
if (matched) return matched
|
|
// 2. 包含匹配（科室名包含识别到的关键词）
|
matched = this.departmentOptions.find(d =>
|
d.text.toUpperCase().includes(normalized) ||
|
normalized.includes(d.text.toUpperCase())
|
)
|
if (matched) return matched
|
|
// 3. 模糊匹配（去除"科"、"室"等后缀再匹配）
|
const cleanedInput = normalized.replace(/[科室部]/g, '')
|
matched = this.departmentOptions.find(d => {
|
const cleanedDept = d.text.toUpperCase().replace(/[科室部]/g, '')
|
return cleanedDept === cleanedInput ||
|
cleanedDept.includes(cleanedInput) ||
|
cleanedInput.includes(cleanedDept)
|
})
|
if (matched) return matched
|
|
return null
|
},
|
|
// 提取科室信息
|
extractDepartment(text, type) {
|
// 常见科室关键词（作为兜底方案）
|
const departments = [
|
'ICU', 'NICU', 'PICU', 'CCU', 'EICU',
|
'重症监护室', '急诊科', '门诊', '住院部',
|
'内科', '外科', '妇产科', '儿科', '骨科', '神经科',
|
'心内科', '心外科', '呼吸科', '消化科', '肾内科',
|
'血液科', '肿瘤科', '感染科', '皮肤科', '眼科',
|
'耳鼻喉科', '口腔科', '中医科', '康复科', '精神科',
|
'泌尿科', '内分泌科', '风湿科', '普外科', '胸外科',
|
'神经外科', '整形科', '烧伤科', '麻醉科', '放射科',
|
'检验科', '病理科', '药剂科', '营养科'
|
]
|
|
// 优先尝试从 departmentOptions 中匹配
|
if (this.departmentOptions && this.departmentOptions.length > 0) {
|
// 构建 departmentOptions 的匹配模式（按长度倒序）
|
const optionTexts = this.departmentOptions.map(d => d.text).sort((a, b) => b.length - a.length)
|
const optionPattern = optionTexts.map(t => t.replace(/[()（）]/g, '\\$&')).join('|')
|
|
if (optionPattern) {
|
const regex = new RegExp(`(${optionPattern})`, 'gi')
|
const matches = text.match(regex)
|
|
if (matches && matches.length > 0) {
|
// 如果是转出，取第一个科室；如果是转入，取最后一个科室
|
return type === 'out' ? matches[0] : matches[matches.length - 1]
|
}
|
}
|
}
|
|
// 兜底：使用默认科室列表匹配
|
const sortedDepts = departments.sort((a, b) => b.length - a.length)
|
const deptPattern = sortedDepts.join('|')
|
|
const regex = new RegExp(`(${deptPattern})`, 'g')
|
const matches = text.match(regex)
|
|
if (matches && matches.length > 0) {
|
// 如果是转出，取第一个科室；如果是转入，取最后一个科室
|
return type === 'out' ? matches[0] : matches[matches.length - 1]
|
}
|
|
return ''
|
},
|
|
// 通过名称匹配医院（restrictRegion=false 时全局查询）
|
findHospitalByName(name, type, restrictRegion = true) {
|
if (!name) return Promise.resolve(null)
|
const normalized = name.trim()
|
|
// 特殊处理"家中"
|
if (normalized === '家中') {
|
// 查询医院库中的"家中"记录
|
const deptId = this.selectedOrganizationId || null
|
const queryPromise = restrictRegion && deptId
|
? searchHospitalsByDeptRegion('家中', deptId, 50)
|
: searchHospitals('家中', null, 50)
|
|
return queryPromise.then(res => {
|
const list = res.data || []
|
// 查找名称为"家中"的医院记录
|
const homeHospital = list.find(h => h.hospName === '家中')
|
if (homeHospital) {
|
return homeHospital
|
}
|
// 如果没有找到，返回默认结构
|
return {
|
hospId: null,
|
hospName: '家中',
|
hopsCity: '',
|
hospAddress: ''
|
}
|
}).catch(() => {
|
// 查询失败，返回默认结构
|
return {
|
hospId: null,
|
hospName: '家中',
|
hopsCity: '',
|
hospAddress: ''
|
}
|
})
|
}
|
|
// restrictRegion=false 时走全量查询；true 且有 deptId 时走区域接口
|
const deptId = this.selectedOrganizationId || null
|
const queryPromise = (restrictRegion && deptId)
|
? searchHospitalsByDeptRegion(normalized, deptId, 50)
|
: searchHospitals(normalized, null, 50)
|
|
return queryPromise.then(res => {
|
const list = res.data || []
|
if (!list.length) return null
|
|
// 自动选择第一个非"家中"的区院，如果全是"家中"则选第一个
|
const best = this.pickBestHospitalMatch(list, normalized)
|
return best || null
|
})
|
},
|
|
// 在候选中选择最优匹配（支持简称匹配、包含与长度接近）
|
pickBestHospitalMatch(list, name) {
|
const n = name.trim()
|
|
// 过滤掉"家中"，优先选择真实医院
|
const realHospitals = list.filter(h => h.hospName !== '家中')
|
const searchList = realHospitals.length > 0 ? realHospitals : list
|
|
// 1. 完全相等（正式名）
|
let best = searchList.find(h => (h.hospName || '').trim() === n)
|
if (best) return best
|
// 2. 完全相等（简称）
|
best = searchList.find(h => (h.hospShort || '').trim() === n)
|
if (best) return best
|
// 3. 包含（正式名）
|
best = searchList.find(h => (h.hospName || '').includes(n) || n.includes((h.hospName || '')))
|
if (best) return best
|
// 4. 包含（简称）
|
best = searchList.find(h => (h.hospShort || '').includes(n) || n.includes((h.hospShort || '')))
|
if (best) return best
|
// 5. 长度最接近
|
best = [...searchList].sort((a, b) => {
|
const da = Math.abs((a.hospName || '').length - n.length)
|
const db = Math.abs((b.hospName || '').length - n.length)
|
return da - db
|
})[0]
|
|
// 如果没有找到任何匹配，返回第一个
|
return best || searchList[0] || null
|
},
|
|
// 合并医院地址（省 + 市 + 区 + 详细地址）
|
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计算距离
|
calculateTianDiTuDistance(fromAddress, toAddress)
|
.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}公里`)
|
|
// 距离计算成功后，自动计算成交价
|
this.calculatePrice()
|
} else {
|
console.error('距离计算失败:', response.msg)
|
this.$modal.showToast('距离计算失败，请手动输入')
|
}
|
})
|
.catch(error => {
|
uni.hideLoading()
|
console.error('距离计算失败:', error)
|
this.$modal.showToast('距离计算失败，请手动输入')
|
})
|
}
|
}
|
}
|
</script>
|
|
<style lang="scss" scoped>
|
.create-emergency-task-container {
|
padding: 20rpx;
|
background-color: #f5f5f5;
|
min-height: 100vh;
|
|
.form-header {
|
display: flex;
|
align-items: center;
|
padding: 20rpx 0;
|
margin-bottom: 30rpx;
|
|
.back-btn {
|
width: 60rpx;
|
height: 60rpx;
|
border-radius: 50%;
|
background-color: #f0f0f0;
|
display: flex;
|
align-items: center;
|
justify-content: center;
|
margin-right: 20rpx;
|
}
|
|
.title {
|
flex: 1;
|
font-size: 36rpx;
|
font-weight: bold;
|
color: #333;
|
}
|
|
.smart-parse-btn {
|
display: flex;
|
flex-direction: column;
|
align-items: center;
|
justify-content: center;
|
padding: 10rpx 20rpx;
|
|
text {
|
font-size: 22rpx;
|
color: #007AFF;
|
margin-top: 4rpx;
|
}
|
}
|
}
|
|
.form-section {
|
background-color: white;
|
border-radius: 15rpx;
|
padding: 30rpx;
|
box-shadow: 0 2rpx 10rpx rgba(0, 0, 0, 0.05);
|
|
.form-section-title {
|
font-size: 32rpx;
|
font-weight: bold;
|
margin: 40rpx 0 20rpx 0;
|
padding-bottom: 10rpx;
|
border-bottom: 1rpx solid #f0f0f0;
|
}
|
|
.form-item {
|
margin-bottom: 40rpx;
|
|
.form-label {
|
font-size: 28rpx;
|
margin-bottom: 15rpx;
|
color: #333;
|
|
&.required::before {
|
content: '*';
|
color: #ff4d4f;
|
margin-right: 4rpx;
|
font-weight: bold;
|
}
|
}
|
|
.hospital-search-container {
|
position: relative;
|
|
.search-results {
|
position: absolute;
|
top: 75rpx;
|
left: 0;
|
right: 0;
|
max-height: 400rpx;
|
background-color: white;
|
border: 1rpx solid #eee;
|
border-radius: 10rpx;
|
box-shadow: 0 4rpx 12rpx rgba(0, 0, 0, 0.1);
|
z-index: 100;
|
overflow-y: auto;
|
|
.search-result-item {
|
padding: 20rpx 30rpx;
|
border-bottom: 1rpx solid #f0f0f0;
|
|
&:last-child {
|
border-bottom: none;
|
}
|
|
&:active {
|
background-color: #f5f5f5;
|
}
|
|
.hospital-name {
|
font-size: 28rpx;
|
color: #333;
|
font-weight: bold;
|
margin-bottom: 8rpx;
|
|
.hospital-short {
|
display: block;
|
font-size: 22rpx;
|
color: #999;
|
font-weight: normal;
|
margin-top: 6rpx;
|
}
|
}
|
|
.hospital-address {
|
font-size: 24rpx;
|
color: #999;
|
}
|
}
|
}
|
}
|
|
.address-input-container {
|
position: relative;
|
|
.address-suggestions {
|
position: absolute;
|
top: 75rpx;
|
left: 0;
|
right: 0;
|
max-height: 400rpx;
|
background-color: white;
|
border: 1rpx solid #eee;
|
border-radius: 10rpx;
|
box-shadow: 0 4rpx 12rpx rgba(0, 0, 0, 0.1);
|
z-index: 100;
|
overflow-y: auto;
|
|
.address-suggestion-item {
|
padding: 20rpx 30rpx;
|
border-bottom: 1rpx solid #f0f0f0;
|
|
&:last-child {
|
border-bottom: none;
|
}
|
|
&:active {
|
background-color: #f5f5f5;
|
}
|
|
.suggestion-name {
|
font-size: 28rpx;
|
color: #333;
|
font-weight: bold;
|
margin-bottom: 8rpx;
|
}
|
|
.suggestion-address {
|
font-size: 24rpx;
|
color: #999;
|
}
|
}
|
}
|
}
|
|
.form-input {
|
height: 70rpx;
|
padding: 0 20rpx;
|
border: 1rpx solid #eee;
|
border-radius: 10rpx;
|
font-size: 28rpx;
|
|
&.picker-input {
|
display: flex;
|
align-items: center;
|
justify-content: space-between;
|
|
&.disabled {
|
background-color: #f5f5f5;
|
color: #999;
|
}
|
}
|
}
|
|
.form-textarea {
|
width: 100%;
|
min-height: 150rpx;
|
padding: 20rpx;
|
border: 1rpx solid #eee;
|
border-radius: 10rpx;
|
font-size: 28rpx;
|
}
|
|
.form-tip {
|
margin-top: 10rpx;
|
font-size: 24rpx;
|
color: #999;
|
line-height: 1.5;
|
}
|
|
.disease-container {
|
.disease-tags {
|
display: flex;
|
flex-wrap: wrap;
|
gap: 15rpx;
|
margin-bottom: 20rpx;
|
|
.disease-tag {
|
display: flex;
|
align-items: center;
|
padding: 10rpx 20rpx;
|
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
|
border-radius: 30rpx;
|
|
.disease-name {
|
font-size: 26rpx;
|
color: white;
|
margin-right: 10rpx;
|
}
|
}
|
}
|
|
.add-disease-btn {
|
display: flex;
|
align-items: center;
|
justify-content: center;
|
padding: 20rpx;
|
border: 1rpx dashed #007AFF;
|
border-radius: 10rpx;
|
color: #007AFF;
|
font-size: 28rpx;
|
|
text {
|
margin-left: 10rpx;
|
}
|
}
|
}
|
|
.radio-group {
|
display: flex;
|
|
.radio-item {
|
display: flex;
|
align-items: center;
|
margin-right: 30rpx;
|
|
radio {
|
margin-right: 10rpx;
|
}
|
}
|
}
|
|
.staff-list {
|
.staff-item {
|
display: flex;
|
justify-content: space-between;
|
align-items: center;
|
padding: 20rpx;
|
background-color: #f9f9f9;
|
border-radius: 10rpx;
|
margin-bottom: 20rpx;
|
|
.staff-info {
|
flex: 1;
|
display: flex;
|
align-items: center;
|
|
.staff-name {
|
font-size: 28rpx;
|
color: #333;
|
margin-right: 10rpx;
|
}
|
|
.staff-role {
|
font-size: 24rpx;
|
color: #999;
|
}
|
}
|
}
|
|
.add-staff {
|
display: flex;
|
align-items: center;
|
justify-content: center;
|
padding: 20rpx;
|
border: 1rpx dashed #007AFF;
|
border-radius: 10rpx;
|
color: #007AFF;
|
}
|
}
|
}
|
|
.form-actions {
|
margin-top: 50rpx;
|
text-align: center;
|
|
.submit-btn {
|
width: 80%;
|
height: 80rpx;
|
background-color: #007AFF;
|
color: white;
|
border-radius: 10rpx;
|
font-size: 32rpx;
|
|
&[disabled] {
|
background-color: #ccc;
|
color: #999;
|
}
|
}
|
}
|
}
|
}
|
|
// 智能识别弹窗样式
|
.smart-parse-popup {
|
background-color: white;
|
border-radius: 20rpx 20rpx 0 0;
|
max-height: 80vh;
|
display: flex;
|
flex-direction: column;
|
|
.popup-header {
|
display: flex;
|
justify-content: space-between;
|
align-items: center;
|
padding: 30rpx;
|
border-bottom: 1rpx solid #f0f0f0;
|
flex-shrink: 0;
|
|
.popup-title {
|
font-size: 32rpx;
|
font-weight: bold;
|
color: #333;
|
}
|
|
.popup-close {
|
padding: 10rpx;
|
}
|
}
|
|
.parse-content {
|
flex: 1;
|
padding: 30rpx;
|
overflow-y: auto;
|
|
.parse-tip {
|
display: flex;
|
align-items: flex-start;
|
padding: 20rpx;
|
background-color: #f0f7ff;
|
border-radius: 10rpx;
|
margin-bottom: 20rpx;
|
|
text {
|
flex: 1;
|
margin-left: 10rpx;
|
font-size: 24rpx;
|
color: #666;
|
line-height: 1.6;
|
}
|
}
|
|
.parse-textarea {
|
width: 100%;
|
min-height: 300rpx;
|
padding: 20rpx;
|
border: 1rpx solid #eee;
|
border-radius: 10rpx;
|
font-size: 28rpx;
|
line-height: 1.6;
|
}
|
}
|
|
.popup-footer {
|
display: flex;
|
padding: 20rpx 30rpx;
|
border-top: 1rpx solid #f0f0f0;
|
gap: 20rpx;
|
flex-shrink: 0;
|
|
button {
|
flex: 1;
|
height: 80rpx;
|
border-radius: 10rpx;
|
font-size: 30rpx;
|
}
|
|
.cancel-btn {
|
background-color: #f5f5f5;
|
color: #666;
|
}
|
|
.confirm-btn {
|
background-color: #007AFF;
|
color: white;
|
|
&[disabled] {
|
background-color: #ccc;
|
color: #999;
|
}
|
}
|
}
|
}
|
</style>
|
