From 656d6f8029f8bf9b2daa9dcc89101a879a70b860 Mon Sep 17 00:00:00 2001
From: wlzboy <66905212@qq.com>
Date: 星期三, 03 十二月 2025 23:10:05 +0800
Subject: [PATCH] feat:优先添加执行人

---
 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysTaskServiceImpl.java | 1741 +++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 files changed, 1,675 insertions(+), 66 deletions(-)

diff --git a/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysTaskServiceImpl.java b/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysTaskServiceImpl.java
index 386cf99..466e111 100644
--- a/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysTaskServiceImpl.java
+++ b/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysTaskServiceImpl.java
@@ -1,12 +1,17 @@
 package com.ruoyi.system.service.impl;
 
-import java.util.Date;
-import java.util.List;
-import java.util.ArrayList;
-import java.io.File;
-import java.io.IOException;
+import java.io.*;
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.net.HttpURLConnection;
+import java.net.URL;
 
+import com.ruoyi.common.core.domain.entity.SysUser;
+import com.ruoyi.system.domain.vo.*;
+import com.ruoyi.system.mapper.*;
 import com.ruoyi.system.utils.TaskCodeGenerator;
+import com.ruoyi.common.config.ImageUrlConfig;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -21,18 +26,23 @@
 import com.ruoyi.system.domain.SysTaskVehicle;
 import com.ruoyi.system.domain.SysTaskAttachment;
 import com.ruoyi.system.domain.SysTaskLog;
-import com.ruoyi.system.domain.vo.TaskQueryVO;
-import com.ruoyi.system.domain.vo.TaskCreateVO;
-import com.ruoyi.system.domain.vo.TaskUpdateVO;
-import com.ruoyi.system.domain.vo.TaskStatisticsVO;
+import com.ruoyi.system.domain.SysTaskEmergency;
+import com.ruoyi.system.domain.SysTaskWelfare;
+import com.ruoyi.system.domain.SysTaskAssignee;
 import com.ruoyi.system.domain.enums.TaskStatus;
-import com.ruoyi.system.mapper.SysTaskMapper;
-import com.ruoyi.system.mapper.SysTaskVehicleMapper;
-import com.ruoyi.system.mapper.SysTaskAttachmentMapper;
-import com.ruoyi.system.mapper.SysTaskLogMapper;
-import com.ruoyi.system.mapper.VehicleInfoMapper;
 import com.ruoyi.system.domain.VehicleInfo;
 import com.ruoyi.system.service.ISysTaskService;
+import com.ruoyi.system.service.ILegacySystemSyncService;
+import com.ruoyi.system.service.ISysTaskEmergencyService;
+import com.ruoyi.system.service.ITaskAttachmentSyncService;
+import com.ruoyi.system.service.IMapService;
+import com.ruoyi.system.event.TaskCreatedEvent;
+import com.ruoyi.system.event.TaskAssignedEvent;
+import com.ruoyi.system.event.TaskStatusChangedEvent;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationEventPublisher;
 
 /**
  * 浠诲姟绠＄悊Service涓氬姟灞傚鐞�
@@ -42,6 +52,8 @@
  */
 @Service
 public class SysTaskServiceImpl implements ISysTaskService {
+    
+    private static final Logger log = LoggerFactory.getLogger(SysTaskServiceImpl.class);
     
     @Autowired
     private SysTaskMapper sysTaskMapper;
@@ -56,7 +68,37 @@
     private SysTaskLogMapper sysTaskLogMapper;
     
     @Autowired
+    private SysTaskEmergencyMapper sysTaskEmergencyMapper;
+    
+    @Autowired
+    private SysTaskWelfareMapper sysTaskWelfareMapper;
+    
+    @Autowired
+    private SysTaskAssigneeMapper sysTaskAssigneeMapper;
+    
+    @Autowired
     private VehicleInfoMapper vehicleInfoMapper;
+
+    @Autowired(required = false)
+    private ILegacySystemSyncService legacySystemSyncService;
+    
+    @Autowired
+    private ISysTaskEmergencyService sysTaskEmergencyService;
+    
+    @Autowired
+    private ApplicationEventPublisher eventPublisher;
+    
+    @Autowired
+    private ImageUrlConfig imageUrlConfig;
+    
+    @Autowired(required = false)
+    private ITaskAttachmentSyncService taskAttachmentSyncService;
+
+    @Autowired
+    private SysUserMapper sysUserMapper;
+
+    @Autowired(required = false)
+    private IMapService mapService;
 
     /**
      * 鏌ヨ浠诲姟绠＄悊
@@ -66,7 +108,20 @@
      */
     @Override
     public SysTask selectSysTaskByTaskId(Long taskId) {
-        return sysTaskMapper.selectSysTaskByTaskId(taskId);
+        SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
+        if (task != null) {
+            // 鍔犺浇鎬ユ晳杞繍鎵╁睍淇℃伅
+            if ("EMERGENCY_TRANSFER".equals(task.getTaskType())) {
+                SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
+                task.setEmergencyInfo(emergencyInfo);
+            }
+            // 鍔犺浇绂忕杞︽墿灞曚俊鎭�
+            else if ("WELFARE".equals(task.getTaskType())) {
+                SysTaskWelfare welfareInfo = sysTaskWelfareMapper.selectSysTaskWelfareByTaskId(taskId);
+                task.setWelfareInfo(welfareInfo);
+            }
+        }
+        return task;
     }
 
     /**
@@ -89,31 +144,108 @@
     @Override
     @Transactional
     public int insertSysTask(TaskCreateVO createVO) {
+        String username = SecurityUtils.getUsername();
         SysTask task = new SysTask();
         task.setTaskCode(generateTaskCode());
         task.setTaskType(createVO.getTaskType());
         task.setTaskStatus(TaskStatus.PENDING.getCode());
         task.setTaskDescription(createVO.getTaskDescription());
-        task.setDepartureAddress(createVO.getDepartureAddress());
-        task.setDestinationAddress(createVO.getDestinationAddress());
-        task.setDepartureLongitude(createVO.getDepartureLongitude());
-        task.setDepartureLatitude(createVO.getDepartureLatitude());
-        task.setDestinationLongitude(createVO.getDestinationLongitude());
-        task.setDestinationLatitude(createVO.getDestinationLatitude());
         task.setPlannedStartTime(createVO.getPlannedStartTime());
         task.setPlannedEndTime(createVO.getPlannedEndTime());
         task.setAssigneeId(createVO.getAssigneeId());
         task.setCreatorId(SecurityUtils.getUserId());
-        task.setDeptId(SecurityUtils.getDeptId());
-        task.setCreateBy(SecurityUtils.getUsername());
+        // 浼樺厛浣跨敤鍓嶇浼犲叆鐨勯儴闂↖D锛屽鏋滄病鏈夊垯浣跨敤褰撳墠鐢ㄦ埛鐨勯儴闂↖D
+        task.setDeptId(createVO.getDeptId() != null ? createVO.getDeptId() : SecurityUtils.getDeptId());
+        task.setCreateBy(username);
         task.setCreateTime(DateUtils.getNowDate());
-        task.setUpdateBy(SecurityUtils.getUsername());
+        task.setUpdateBy(username);
         task.setUpdateTime(DateUtils.getNowDate());
         task.setRemark(createVO.getRemark());
         task.setDelFlag("0");
         
-        // 璁＄畻棰勮鍏噷鏁�
-        calculateEstimatedDistance(task);
+        // 璁剧疆閫氱敤鍦板潃鍜屽潗鏍囦俊鎭�
+        if (createVO.getDepartureAddress() != null) {
+            task.setDepartureAddress(createVO.getDepartureAddress());
+        }
+        if (createVO.getDestinationAddress() != null) {
+            task.setDestinationAddress(createVO.getDestinationAddress());
+        }
+        if (createVO.getDepartureLongitude() != null) {
+            task.setDepartureLongitude(createVO.getDepartureLongitude());
+        }
+        if (createVO.getDepartureLatitude() != null) {
+            task.setDepartureLatitude(createVO.getDepartureLatitude());
+        }
+        if (createVO.getDestinationLongitude() != null) {
+            task.setDestinationLongitude(createVO.getDestinationLongitude());
+        }
+        if (createVO.getDestinationLatitude() != null) {
+            task.setDestinationLatitude(createVO.getDestinationLatitude());
+        }
+        if (createVO.getEstimatedDistance() != null) {
+            task.setEstimatedDistance(createVO.getEstimatedDistance());
+        }
+        
+        // 璁剧疆鎬ユ晳杞繍鐗瑰畾淇℃伅
+        if (createVO.getTransferTime() != null) {
+            task.setPlannedStartTime(createVO.getTransferTime());
+        }
+        if (createVO.getTransferDistance() != null) {
+            task.setEstimatedDistance(createVO.getTransferDistance());
+        }
+        
+        // 璁剧疆绂忕杞︾壒瀹氫俊鎭�
+        if (createVO.getServiceTime() != null) {
+            task.setPlannedStartTime(createVO.getServiceTime());
+        }
+        if (createVO.getStartAddress() != null) {
+            task.setDepartureAddress(createVO.getStartAddress());
+        }
+        if (createVO.getEndAddress() != null) {
+            task.setDestinationAddress(createVO.getEndAddress());
+        }
+        // 璁剧疆绂忕杞﹀叕閲屾暟
+        if (createVO.getDistance() != null) {
+            task.setEstimatedDistance(createVO.getDistance());
+        }
+        
+        // 鑷姩鑾峰彇鍑哄彂鍦癎PS鍧愭爣锛堝鏋滅己澶憋級
+        if (task.getDepartureAddress() != null && 
+            (task.getDepartureLongitude() == null || task.getDepartureLatitude() == null) && 
+            mapService != null) {
+            try {
+                Map<String, Double> coords = mapService.geocoding(
+                    task.getDepartureAddress(), 
+                    extractCityFromAddress(task.getDepartureAddress())
+                );
+                if (coords != null) {
+                    task.setDepartureLongitude(BigDecimal.valueOf(coords.get("lng")));
+                    task.setDepartureLatitude(BigDecimal.valueOf(coords.get("lat")));
+                    log.info("鍑哄彂鍦癎PS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                }
+            } catch (Exception e) {
+                log.error("鑷姩鑾峰彇鍑哄彂鍦癎PS鍧愭爣澶辫触", e);
+            }
+        }
+        
+        // 鑷姩鑾峰彇鐩殑鍦癎PS鍧愭爣锛堝鏋滅己澶憋級
+        if (task.getDestinationAddress() != null && 
+            (task.getDestinationLongitude() == null || task.getDestinationLatitude() == null) && 
+            mapService != null) {
+            try {
+                Map<String, Double> coords = mapService.geocoding(
+                    task.getDestinationAddress(), 
+                    extractCityFromAddress(task.getDestinationAddress())
+                );
+                if (coords != null) {
+                    task.setDestinationLongitude(BigDecimal.valueOf(coords.get("lng")));
+                    task.setDestinationLatitude(BigDecimal.valueOf(coords.get("lat")));
+                    log.info("鐩殑鍦癎PS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                }
+            } catch (Exception e) {
+                log.error("鑷姩鑾峰彇鐩殑鍦癎PS鍧愭爣澶辫触", e);
+            }
+        }
         
         int result = sysTaskMapper.insertSysTask(task);
         
@@ -124,15 +256,30 @@
                 taskVehicle.setTaskId(task.getTaskId());
                 taskVehicle.setVehicleId(vehicleId);
                 taskVehicle.setAssignTime(DateUtils.getNowDate());
-                taskVehicle.setAssignBy(SecurityUtils.getUsername());
+                taskVehicle.setAssignBy(username);
                 taskVehicle.setStatus("ASSIGNED");
-                taskVehicle.setCreateBy(SecurityUtils.getUsername());
+                taskVehicle.setCreateBy(username);
                 taskVehicle.setCreateTime(DateUtils.getNowDate());
-                taskVehicle.setUpdateBy(SecurityUtils.getUsername());
+                taskVehicle.setUpdateBy(username);
                 taskVehicle.setUpdateTime(DateUtils.getNowDate());
                 
                 sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
             }
+        }
+        
+        // 淇濆瓨鎵ц浜哄憳淇℃伅锛堝寘鍚鑹茬被鍨嬶級
+        if (result > 0 && createVO.getAssignees() != null && !createVO.getAssignees().isEmpty()) {
+            saveTaskAssignees(task.getTaskId(), createVO.getAssignees(),username);
+        }
+        
+        // 淇濆瓨鎬ユ晳杞繍鎵╁睍淇℃伅
+        if (result > 0 && "EMERGENCY_TRANSFER".equals(createVO.getTaskType())) {
+            saveEmergencyInfo(task.getTaskId(),username, createVO,null,null,null);
+        }
+        
+        // 淇濆瓨绂忕杞︽墿灞曚俊鎭�
+        if (result > 0 && "WELFARE".equals(createVO.getTaskType())) {
+            saveWelfareInfo(task.getTaskId(),SecurityUtils.getUsername(), createVO);
         }
         
         // 璁板綍鎿嶄綔鏃ュ織
@@ -140,6 +287,253 @@
             recordTaskLog(task.getTaskId(), "CREATE", "鍒涘缓浠诲姟", null, 
                          "浠诲姟绫诲瀷锛�" + createVO.getTaskType(), SecurityUtils.getUserId(), SecurityUtils.getUsername());
         }
+        
+        // 鍙戝竷浠诲姟鍒涘缓浜嬩欢
+        if (result > 0) {
+            eventPublisher.publishEvent(new TaskCreatedEvent(
+                this,
+                task.getTaskId(),
+                task.getTaskCode(),
+                task.getTaskType(),
+                task.getCreatorId(),
+                SecurityUtils.getUsername()
+            ));
+        }
+        
+        // 鍙戝竷浠诲姟鍒嗛厤浜嬩欢
+        if (result > 0 && createVO.getAssignees() != null && !createVO.getAssignees().isEmpty()) {
+            List<Long> assigneeIds = createVO.getAssignees().stream()
+                .map(assignee -> assignee.getUserId())
+                .collect(Collectors.toList());
+            List<String> assigneeNames = createVO.getAssignees().stream()
+                .map(assignee -> assignee.getUserName())
+                .collect(Collectors.toList());
+            
+            eventPublisher.publishEvent(new TaskAssignedEvent(
+                this,
+                task.getTaskId(),
+                task.getTaskCode(),
+                assigneeIds,
+                assigneeNames,
+                SecurityUtils.getUserId(),
+                SecurityUtils.getUsername()
+            ));
+        }
+        
+        // 寮傛鍚屾鎬ユ晳杞繍浠诲姟鍒版棫绯荤粺
+        if (result > 0 && "EMERGENCY_TRANSFER".equals(createVO.getTaskType()) && legacySystemSyncService != null) {
+            final Long finalTaskId = task.getTaskId();
+            new Thread(() -> {
+                try {
+                    Thread.sleep(2000); // 绛夊緟2绉掞紝纭繚浜嬪姟宸叉彁浜�
+                    legacySystemSyncService.syncEmergencyTaskToLegacy(finalTaskId);
+                } catch (Exception e) {
+                    // 鍚屾澶辫触涓嶅奖鍝嶄富娴佺▼锛屼粎璁板綍鏃ュ織
+                }
+            }).start();
+        }
+        
+        return result;
+    }
+
+    /**
+     * 鏂板浠诲姟绠＄悊锛堝厑璁镐粠澶栭儴浼犲叆鐢ㄦ埛淇℃伅銆侀儴闂ㄤ俊鎭拰鏃堕棿淇℃伅锛�
+     * 
+     * @param createVO 浠诲姟鍒涘缓瀵硅薄
+     * @param userId 鐢ㄦ埛ID
+     * @param deptId 閮ㄩ棬ID
+     * @param createTime 鍒涘缓鏃堕棿
+     * @param updateTime 鏇存柊鏃堕棿
+     * @return 缁撴灉
+     */
+    @Override
+    @Transactional
+    public int insertTask(TaskCreateVO createVO,String serviceOrderId,String dispatchOrderId, String serviceOrdNo, Long userId,String userName, Long deptId, Date createTime, Date updateTime) {
+        SysTask task = new SysTask();
+        if(createVO.getTaskCode()!=null){
+            task.setTaskCode(createVO.getTaskCode());
+        }else{
+            task.setTaskCode(generateTaskCode());
+        }
+        task.setTaskType(createVO.getTaskType());
+        task.setTaskStatus(TaskStatus.PENDING.getCode());
+        task.setTaskDescription(createVO.getTaskDescription());
+        task.setPlannedStartTime(createVO.getPlannedStartTime());
+        task.setPlannedEndTime(createVO.getPlannedEndTime());
+        task.setActualStartTime(createVO.getActualStartTime());
+        task.setActualEndTime(createVO.getActualEndTime());
+        task.setAssigneeId(createVO.getAssigneeId());
+        // 浣跨敤澶栭儴浼犲叆鐨勭敤鎴稩D鍜岄儴闂↖D
+        task.setCreatorId(userId);
+        task.setDeptId(deptId);
+        task.setCreateBy(userName);
+        // 浣跨敤澶栭儴浼犲叆鐨勫垱寤烘椂闂村拰鏇存柊鏃堕棿
+        task.setCreateTime(createTime);
+        task.setUpdateTime(updateTime);
+        task.setUpdateBy(userName);
+        task.setRemark(createVO.getRemark());
+        task.setDelFlag("0");
+
+
+        
+        // 璁剧疆閫氱敤鍦板潃鍜屽潗鏍囦俊鎭�
+        if (createVO.getDepartureAddress() != null) {
+            task.setDepartureAddress(createVO.getDepartureAddress());
+        }
+        if (createVO.getDestinationAddress() != null) {
+            task.setDestinationAddress(createVO.getDestinationAddress());
+        }
+        if (createVO.getDepartureLongitude() != null) {
+            task.setDepartureLongitude(createVO.getDepartureLongitude());
+        }
+        if (createVO.getDepartureLatitude() != null) {
+            task.setDepartureLatitude(createVO.getDepartureLatitude());
+        }
+        if (createVO.getDestinationLongitude() != null) {
+            task.setDestinationLongitude(createVO.getDestinationLongitude());
+        }
+        if (createVO.getDestinationLatitude() != null) {
+            task.setDestinationLatitude(createVO.getDestinationLatitude());
+        }
+        if (createVO.getEstimatedDistance() != null) {
+            task.setEstimatedDistance(createVO.getEstimatedDistance());
+        }
+        
+        // 璁剧疆鎬ユ晳杞繍鐗瑰畾淇℃伅
+        if (createVO.getTransferTime() != null) {
+            task.setPlannedStartTime(createVO.getTransferTime());
+        }
+        if (createVO.getTransferDistance() != null) {
+            task.setEstimatedDistance(createVO.getTransferDistance());
+        }
+        
+        // 璁剧疆绂忕杞︾壒瀹氫俊鎭�
+        if (createVO.getPlannedStartTime() != null) {
+            task.setPlannedStartTime(createVO.getPlannedStartTime());
+        }
+        if (createVO.getStartAddress() != null) {
+            task.setDepartureAddress(createVO.getStartAddress());
+        }
+        if (createVO.getEndAddress() != null) {
+            task.setDestinationAddress(createVO.getEndAddress());
+        }
+        // 璁剧疆绂忕杞﹀叕閲屾暟
+        if (createVO.getDistance() != null) {
+            task.setEstimatedDistance(createVO.getDistance());
+        }
+        
+        // 鑷姩鑾峰彇鍑哄彂鍦癎PS鍧愭爣锛堝鏋滅己澶憋級
+        if (task.getDepartureAddress() != null && 
+            (task.getDepartureLongitude() == null || task.getDepartureLatitude() == null) && 
+            mapService != null) {
+            try {
+                Map<String, Double> coords = mapService.geocoding(
+                    task.getDepartureAddress(), 
+                    extractCityFromAddress(task.getDepartureAddress())
+                );
+                if (coords != null) {
+                    task.setDepartureLongitude(BigDecimal.valueOf(coords.get("lng")));
+                    task.setDepartureLatitude(BigDecimal.valueOf(coords.get("lat")));
+                    log.info("鍑哄彂鍦癎PS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                }
+            } catch (Exception e) {
+                log.error("鑷姩鑾峰彇鍑哄彂鍦癎PS鍧愭爣澶辫触", e);
+            }
+        }
+        
+        // 鑷姩鑾峰彇鐩殑鍦癎PS鍧愭爣锛堝鏋滅己澶憋級
+        if (task.getDestinationAddress() != null && 
+            (task.getDestinationLongitude() == null || task.getDestinationLatitude() == null) && 
+            mapService != null) {
+            try {
+                Map<String, Double> coords = mapService.geocoding(
+                    task.getDestinationAddress(), 
+                    extractCityFromAddress(task.getDestinationAddress())
+                );
+                if (coords != null) {
+                    task.setDestinationLongitude(BigDecimal.valueOf(coords.get("lng")));
+                    task.setDestinationLatitude(BigDecimal.valueOf(coords.get("lat")));
+                    log.info("鐩殑鍦癎PS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                }
+            } catch (Exception e) {
+                log.error("鑷姩鑾峰彇鐩殑鍦癎PS鍧愭爣澶辫触", e);
+            }
+        }
+        
+        int result = sysTaskMapper.insertSysTask(task);
+        
+        // 淇濆瓨杞﹁締鍏宠仈淇℃伅
+        if (result > 0 && createVO.getVehicleIds() != null && !createVO.getVehicleIds().isEmpty()) {
+            for (Long vehicleId : createVO.getVehicleIds()) {
+                SysTaskVehicle taskVehicle = new SysTaskVehicle();
+                taskVehicle.setTaskId(task.getTaskId());
+                taskVehicle.setVehicleId(vehicleId);
+                taskVehicle.setAssignTime(updateTime);
+                taskVehicle.setAssignBy(userName);
+                taskVehicle.setStatus("ASSIGNED");
+                taskVehicle.setCreateBy(userName);
+                taskVehicle.setCreateTime(createTime);
+                taskVehicle.setUpdateBy(userName);
+                taskVehicle.setUpdateTime(updateTime);
+
+                sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
+            }
+        }
+        
+        // 淇濆瓨鎵ц浜哄憳淇℃伅锛堝寘鍚鑹茬被鍨嬶級
+        if (result > 0 && createVO.getAssignees() != null && !createVO.getAssignees().isEmpty()) {
+            saveTaskAssignees(task.getTaskId(), createVO.getAssignees(),userName);
+        }
+        
+        // 淇濆瓨鎬ユ晳杞繍鎵╁睍淇℃伅
+        if (result > 0 && "EMERGENCY_TRANSFER".equals(createVO.getTaskType())) {
+            saveEmergencyInfo(task.getTaskId(),userName, createVO, serviceOrderId, dispatchOrderId, serviceOrdNo);
+        }
+        
+        // 淇濆瓨绂忕杞︽墿灞曚俊鎭�
+        if (result > 0 && "WELFARE".equals(createVO.getTaskType())) {
+            saveWelfareInfo(task.getTaskId(),userName, createVO);
+        }
+        
+        // 璁板綍鎿嶄綔鏃ュ織
+        if (result > 0) {
+            recordTaskLog(task.getTaskId(), "CREATE", "鍒涘缓浠诲姟", null, 
+                         "浠诲姟绫诲瀷锛�" + createVO.getTaskType(), userId, userName);
+        }
+        
+        // 鍙戝竷浠诲姟鍒涘缓浜嬩欢
+        if (result > 0) {
+            eventPublisher.publishEvent(new TaskCreatedEvent(
+                this,
+                task.getTaskId(),
+                task.getTaskCode(),
+                task.getTaskType(),
+                userId,
+                userName
+            ));
+        }
+        
+        // 鍙戝竷浠诲姟鍒嗛厤浜嬩欢
+        if (result > 0 && createVO.getAssignees() != null && !createVO.getAssignees().isEmpty()) {
+            List<Long> assigneeIds = createVO.getAssignees().stream()
+                .map(assignee -> assignee.getUserId())
+                .collect(Collectors.toList());
+            List<String> assigneeNames = createVO.getAssignees().stream()
+                .map(assignee -> assignee.getUserName())
+                .collect(Collectors.toList());
+            
+            eventPublisher.publishEvent(new TaskAssignedEvent(
+                this,
+                task.getTaskId(),
+                task.getTaskCode(),
+                assigneeIds,
+                assigneeNames,
+                userId,
+                userName
+            ));
+        }
+        
+
         
         return result;
     }
@@ -152,38 +546,401 @@
      */
     @Override
     @Transactional
-    public int updateSysTask(TaskUpdateVO updateVO) {
+    public int updateSysTask(TaskUpdateVO updateVO, Boolean updateFromLegacy) {
         SysTask oldTask = sysTaskMapper.selectSysTaskByTaskId(updateVO.getTaskId());
         if (oldTask == null) {
             throw new RuntimeException("浠诲姟涓嶅瓨鍦�");
         }
+        String userName = SecurityUtils.getUsername();
         
         SysTask task = new SysTask();
         task.setTaskId(updateVO.getTaskId());
         task.setTaskDescription(updateVO.getTaskDescription());
+        task.setPlannedStartTime(updateVO.getPlannedStartTime());
+        task.setPlannedEndTime(updateVO.getPlannedEndTime());
+        task.setAssigneeId(updateVO.getAssigneeId());
+        task.setUpdateBy(userName);
+        task.setUpdateTime(updateVO.getUpdateTime() != null ? updateVO.getUpdateTime() : DateUtils.getNowDate());
+        task.setRemark(updateVO.getRemark());
+        
+        // 璁剧疆閫氱敤鍦板潃鍜屽潗鏍囦俊鎭�
         task.setDepartureAddress(updateVO.getDepartureAddress());
         task.setDestinationAddress(updateVO.getDestinationAddress());
         task.setDepartureLongitude(updateVO.getDepartureLongitude());
         task.setDepartureLatitude(updateVO.getDepartureLatitude());
         task.setDestinationLongitude(updateVO.getDestinationLongitude());
         task.setDestinationLatitude(updateVO.getDestinationLatitude());
-        task.setPlannedStartTime(updateVO.getPlannedStartTime());
-        task.setPlannedEndTime(updateVO.getPlannedEndTime());
-        task.setAssigneeId(updateVO.getAssigneeId());
-        task.setUpdateBy(SecurityUtils.getUsername());
-        task.setUpdateTime(DateUtils.getNowDate());
-        task.setRemark(updateVO.getRemark());
         
-        // 閲嶆柊璁＄畻棰勮鍏噷鏁�
-        calculateEstimatedDistance(task);
+        // 璁剧疆棰勮璺濈
+        if (updateVO.getEstimatedDistance() != null) {
+            task.setEstimatedDistance(updateVO.getEstimatedDistance());
+        } else if (updateVO.getTransferDistance() != null) {
+            // 鍏煎鎬ユ晳杞繍瀛楁
+            task.setEstimatedDistance(updateVO.getTransferDistance());
+        } else if (updateVO.getDistance() != null) {
+            // 鍏煎绂忕杞﹀瓧娈�
+            task.setEstimatedDistance(updateVO.getDistance());
+        }
         
+        // 濡傛灉鏇存柊浜嗛儴闂↖D
+        if (updateVO.getDeptId() != null) {
+            task.setDeptId(updateVO.getDeptId());
+        }
+        
+        // 濡傛灉鏇存柊浜嗕换鍔＄紪鍙�
+        if (updateVO.getTaskCode() != null) {
+            task.setTaskCode(updateVO.getTaskCode());
+        }
+        
+        // 鑷姩鑾峰彇鍑哄彂鍦癎PS鍧愭爣锛堝鏋滄洿鏂颁簡鍦板潃浣嗙己澶卞潗鏍囷級
+        if (updateVO.getDepartureAddress() != null && 
+            (updateVO.getDepartureLongitude() == null || updateVO.getDepartureLatitude() == null) && 
+            mapService != null) {
+            if (!updateVO.getDepartureAddress().equals(oldTask.getDepartureAddress())) {
+                try {
+                    Map<String, Double> coords = mapService.geocoding(
+                        updateVO.getDepartureAddress(),
+                        extractCityFromAddress(updateVO.getDepartureAddress())
+                    );
+                    if (coords != null) {
+                        task.setDepartureLongitude(BigDecimal.valueOf(coords.get("lng")));
+                        task.setDepartureLatitude(BigDecimal.valueOf(coords.get("lat")));
+                        log.info("鍑哄彂鍦癎PS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                    }
+                } catch (Exception e) {
+                    log.error("鑷姩鑾峰彇鍑哄彂鍦癎PS鍧愭爣澶辫触", e);
+                }
+            }
+        }
+        
+        // 鑷姩鑾峰彇鐩殑鍦癎PS鍧愭爣锛堝鏋滄洿鏂颁簡鍦板潃浣嗙己澶卞潗鏍囷級
+        if (updateVO.getDestinationAddress() != null && 
+            (updateVO.getDestinationLongitude() == null || updateVO.getDestinationLatitude() == null) && 
+            mapService != null) {
+            if (!updateVO.getDestinationAddress().equals(oldTask.getDestinationAddress())) {
+                try {
+                    Map<String, Double> coords = mapService.geocoding(
+                        updateVO.getDestinationAddress(),
+                        extractCityFromAddress(updateVO.getDestinationAddress())
+                    );
+                    if (coords != null) {
+                        task.setDestinationLongitude(BigDecimal.valueOf(coords.get("lng")));
+                        task.setDestinationLatitude(BigDecimal.valueOf(coords.get("lat")));
+                        log.info("鐩殑鍦癎PS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                    }
+                } catch (Exception e) {
+                    log.error("鑷姩鑾峰彇鐩殑鍦癎PS鍧愭爣澶辫触", e);
+                }
+            }
+        }
+        // 鐢ㄤ簬璺熻釜鏄惁闇�瑕侀噸鏂板悓姝ワ紙杞﹁締銆佷汉鍛樸�佸湴鍧�銆佹垚浜や环鍙樻洿锛�
+        boolean needResync = true;
         int result = sysTaskMapper.updateSysTask(task);
+        
+
+        
+        // 鏇存柊杞﹁締鍏宠仈
+        if (result > 0 && updateVO.getVehicleIds() != null && !updateVO.getVehicleIds().isEmpty()) {
+            // 鏌ヨ鐜版湁鐨勮溅杈嗗叧鑱�
+            List<SysTaskVehicle> existingVehicles = sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(updateVO.getTaskId());
+            List<Long> existingVehicleIds = existingVehicles.stream()
+                .map(SysTaskVehicle::getVehicleId)
+                .collect(Collectors.toList());
+            
+            // 姣旇緝鏂版棫杞﹁締ID鍒楄〃锛屽垽鏂槸鍚︽湁鍙樺寲
+            boolean vehiclesChanged = !new HashSet<>(existingVehicleIds).equals(new HashSet<>(updateVO.getVehicleIds()));
+            
+            // 鍙湁杞﹁締鍙戠敓鍙樺寲鏃舵墠鏇存柊
+            if (vehiclesChanged) {
+                // 鍒犻櫎鏃х殑杞﹁締鍏宠仈
+                sysTaskVehicleMapper.deleteSysTaskVehicleByTaskId(updateVO.getTaskId());
+                
+                // 娣诲姞鏂扮殑杞﹁締鍏宠仈
+                Date now = DateUtils.getNowDate();
+                String currentUser = userName;
+                for (Long vehicleId : updateVO.getVehicleIds()) {
+                    SysTaskVehicle taskVehicle = new SysTaskVehicle();
+                    taskVehicle.setTaskId(updateVO.getTaskId());
+                    taskVehicle.setVehicleId(vehicleId);
+                    taskVehicle.setAssignTime(now);
+                    taskVehicle.setAssignBy(currentUser);
+                    taskVehicle.setCreateTime(now);
+                    sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
+                }
+                
+                // 鏍囪闇�瑕侀噸鏂板悓姝ワ紙杞﹁締鍙樻洿锛�
+                needResync = true;
+            }
+        }
+        
+        // 鏇存柊鎵ц浜哄憳锛堟娴嬩汉鍛樺彉鏇达級
+        if (result > 0 && updateVO.getAssignees() != null) {
+            // 鏌ヨ鐜版湁鐨勬墽琛屼汉鍛�
+            List<SysTaskAssignee> existingAssignees = sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(updateVO.getTaskId());
+            List<Long> existingAssigneeIds = existingAssignees.stream()
+                .map(SysTaskAssignee::getUserId)
+                .collect(Collectors.toList());
+            
+            List<Long> newAssigneeIds = updateVO.getAssignees().stream()
+                .map(TaskCreateVO.AssigneeInfo::getUserId)
+                .collect(Collectors.toList());
+            
+            // 姣旇緝鏂版棫鎵ц浜哄憳ID鍒楄〃锛屽垽鏂槸鍚︽湁鍙樺寲
+            boolean assigneesChanged = !new HashSet<>(existingAssigneeIds).equals(new HashSet<>(newAssigneeIds));
+            
+            // 鍙湁鎵ц浜哄憳鍙戠敓鍙樺寲鏃舵墠鏇存柊
+            if (assigneesChanged) {
+                // 鍒犻櫎鏃х殑鎵ц浜哄憳鍏宠仈
+                sysTaskAssigneeMapper.deleteSysTaskAssigneeByTaskId(updateVO.getTaskId());
+                
+                // 娣诲姞鏂扮殑鎵ц浜哄憳鍏宠仈
+                if (!updateVO.getAssignees().isEmpty()) {
+                    saveTaskAssignees(updateVO.getTaskId(), updateVO.getAssignees(), userName);
+                }
+                
+                // 鏍囪闇�瑕侀噸鏂板悓姝ワ紙浜哄憳鍙樻洿锛�
+                needResync = true;
+            }
+        }
+        
+        // 鏇存柊鎬ユ晳杞繍鎵╁睍淇℃伅锛堟娴嬪湴鍧�鍜屾垚浜や环鍙樻洿锛�
+        if (result > 0 && "EMERGENCY_TRANSFER".equals(oldTask.getTaskType())) {
+            // 鑾峰彇鏃х殑鎬ユ晳杞繍淇℃伅
+            SysTaskEmergency oldEmergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(updateVO.getTaskId());
+            
+            // 妫�娴嬭浆鍑哄尰闄㈠湴鍧�鍙樻洿
+            boolean hospitalOutAddressChanged = false;
+            if (updateVO.getHospitalOut() != null && updateVO.getHospitalOut().getAddress() != null
+                && oldEmergency != null
+                && !updateVO.getHospitalOut().getAddress().equals(oldEmergency.getHospitalOutAddress())) {
+                hospitalOutAddressChanged = true;
+            }
+            
+            // 妫�娴嬭浆鍏ュ尰闄㈠湴鍧�鍙樻洿
+            boolean hospitalInAddressChanged = false;
+            if (updateVO.getHospitalIn() != null && updateVO.getHospitalIn().getAddress() != null
+                && oldEmergency != null
+                && !updateVO.getHospitalIn().getAddress().equals(oldEmergency.getHospitalInAddress())) {
+                hospitalInAddressChanged = true;
+            }
+            
+            // 妫�娴嬫垚浜や环鍙樻洿
+            boolean transferPriceChanged = false;
+            if (updateVO.getPrice() != null
+                && oldEmergency != null
+                && oldEmergency.getTransferPrice() != null
+                && updateVO.getPrice().compareTo(oldEmergency.getTransferPrice()) != 0) {
+                transferPriceChanged = true;
+            }
+
+            ;
+            
+            // 鏇存柊鎬ユ晳杞繍淇℃伅
+            if (updateVO.getHospitalOut() != null || updateVO.getHospitalIn() != null || updateVO.getPatient() != null) {
+                updateEmergencyInfoFromCreateVO(updateVO.getTaskId(), updateVO, userName);
+            }
+            
+            // 濡傛灉鍦板潃鎴栨垚浜や环鍙戠敓鍙樻洿锛屾爣璁伴渶瑕侀噸鏂板悓姝�
+            if (hospitalOutAddressChanged || hospitalInAddressChanged || transferPriceChanged) {
+                needResync = true;
+            }
+        }
+        
+        // 鏇存柊绂忕杞︽墿灞曚俊鎭�
+        if (result > 0 && "WELFARE".equals(oldTask.getTaskType())) {
+            if (updateVO.getPassenger() != null || updateVO.getStartAddress() != null || updateVO.getEndAddress() != null) {
+                updateWelfareInfoFromCreateVO(updateVO.getTaskId(), updateVO, userName);
+            }
+        }
+        
+        // 濡傛灉鏄�ユ晳杞繍浠诲姟涓旀湁鍙樻洿锛屾爣璁伴渶瑕侀噸鏂板悓姝�
+        if (result > 0 && "EMERGENCY_TRANSFER".equals(oldTask.getTaskType()) && needResync && !updateFromLegacy) {
+            try {
+                sysTaskEmergencyService.markNeedResync(updateVO.getTaskId());
+            } catch (Exception e) {
+                // 鏍囪澶辫触涓嶅奖鍝嶄富娴佺▼
+            }
+        }
         
         // 璁板綍鎿嶄綔鏃ュ織
         if (result > 0) {
-            recordTaskLog(updateVO.getTaskId(), "UPDATE", "鏇存柊浠诲姟", 
-                         buildTaskDescription(oldTask), buildTaskDescription(task), 
-                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
+            recordTaskLog(updateVO.getTaskId(), "UPDATE", "鏇存柊浠诲姟",
+                buildTaskDescription(oldTask), buildTaskDescription(task),
+                SecurityUtils.getUserId(), userName);
+        }
+        
+        return result;
+    }
+
+    /**
+     * 鏇存柊浠诲姟锛堢敤浜庢棫绯荤粺鍚屾锛�
+     * 
+     * @param updateVO 浠诲姟鏇存柊瀵硅薄
+     * @param serviceOrderId 鏃х郴缁熸湇鍔″崟ID
+     * @param dispatchOrderId 鏃х郴缁熻皟搴﹀崟ID
+     * @param serviceOrdNo 鏃х郴缁熸湇鍔″崟缂栧彿
+     * @param userId 鐢ㄦ埛ID
+     * @param userName 鐢ㄦ埛鍚�
+     * @param deptId 閮ㄩ棬ID
+     * @param createTime 鍒涘缓鏃堕棿
+     * @param updateTime 鏇存柊鏃堕棿
+     * @return 缁撴灉
+     */
+    @Override
+    public int updateTask(TaskUpdateVO updateVO, String serviceOrderId, String dispatchOrderId, String serviceOrdNo,
+                         Long userId, String userName, Long deptId, Date createTime, Date updateTime) {
+        // 閫氳繃鏃х郴缁熸湇鍔″崟ID鏌ユ壘浠诲姟
+        SysTaskEmergency taskEmergency = sysTaskEmergencyMapper.selectByLegacyServiceOrdId(Long.parseLong(serviceOrderId));
+        Long taskId = taskEmergency.getTaskId();
+        updateVO.setTaskId(taskId);
+        SysTask task = new SysTask();
+        task.setTaskId(taskId);
+        task.setTaskDescription(updateVO.getTaskDescription());
+        task.setPlannedStartTime(updateVO.getPlannedStartTime());
+        task.setPlannedEndTime(updateVO.getPlannedEndTime());
+        task.setAssigneeId(updateVO.getAssigneeId());
+        task.setUpdateBy(userName);
+        task.setUpdateTime(DateUtils.getNowDate());
+        task.setRemark(updateVO.getRemark());
+
+        
+        // 璁剧疆鍦板潃鍜屽潗鏍囦俊鎭�
+        task.setDepartureAddress(updateVO.getDepartureAddress());
+        task.setDestinationAddress(updateVO.getDestinationAddress());
+        task.setDepartureLongitude(updateVO.getDepartureLongitude());
+        task.setDepartureLatitude(updateVO.getDepartureLatitude());
+        task.setDestinationLongitude(updateVO.getDestinationLongitude());
+        task.setDestinationLatitude(updateVO.getDestinationLatitude());
+        
+        // 濡傛灉鏇存柊浜嗛儴闂↖D
+        if (updateVO.getDeptId() != null) {
+            task.setDeptId(updateVO.getDeptId());
+        }
+        
+        // 濡傛灉鏇存柊浜嗕换鍔＄紪鍙�
+        if (updateVO.getTaskCode() != null) {
+            task.setTaskCode(updateVO.getTaskCode());
+        }
+        
+        // 鑾峰彇鏃т换鍔′俊鎭紝鐢ㄤ簬鍒ゆ柇鍦板潃鏄惁鍙樻洿
+        SysTask oldTask = sysTaskMapper.selectSysTaskByTaskId(taskId);
+        
+        // 鑷姩鑾峰彇鍑哄彂鍦癎PS鍧愭爣锛堝鏋滃湴鍧�鍙樻洿涓旂己澶卞潗鏍囷級
+        if (oldTask != null && updateVO.getDepartureAddress() != null
+            && !updateVO.getDepartureAddress().equals(oldTask.getDepartureAddress())
+            && (updateVO.getDepartureLongitude() == null || updateVO.getDepartureLatitude() == null)
+            && mapService != null) {
+            try {
+                Map<String, Double> coords = mapService.geocoding(
+                    updateVO.getDepartureAddress(),
+                    extractCityFromAddress(updateVO.getDepartureAddress())
+                );
+                if (coords != null) {
+                    task.setDepartureLongitude(BigDecimal.valueOf(coords.get("lng")));
+                    task.setDepartureLatitude(BigDecimal.valueOf(coords.get("lat")));
+                    log.info("鍑哄彂鍦癎PS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                }
+            } catch (Exception e) {
+                log.error("鑷姩鑾峰彇鍑哄彂鍦癎PS鍧愭爣澶辫触", e);
+            }
+        }
+        
+        // 鑷姩鑾峰彇鐩殑鍦癎PS鍧愭爣锛堝鏋滃湴鍧�鍙樻洿涓旂己澶卞潗鏍囷級
+        if (oldTask != null && updateVO.getDestinationAddress() != null
+            && !updateVO.getDestinationAddress().equals(oldTask.getDestinationAddress())
+            && (updateVO.getDestinationLongitude() == null || updateVO.getDestinationLatitude() == null)
+            && mapService != null) {
+            try {
+                Map<String, Double> coords = mapService.geocoding(
+                    updateVO.getDestinationAddress(),
+                    extractCityFromAddress(updateVO.getDestinationAddress())
+                );
+                if (coords != null) {
+                    task.setDestinationLongitude(BigDecimal.valueOf(coords.get("lng")));
+                    task.setDestinationLatitude(BigDecimal.valueOf(coords.get("lat")));
+                    log.info("鐩殑鍦癎PS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                }
+            } catch (Exception e) {
+                log.error("鑷姩鑾峰彇鐩殑鍦癎PS鍧愭爣澶辫触", e);
+            }
+        }
+        
+        int result = sysTaskMapper.updateSysTask(task);
+        
+        // 鏇存柊杞﹁締鍏宠仈
+        if (result > 0 && updateVO.getVehicleIds() != null && !updateVO.getVehicleIds().isEmpty()) {
+            // 鏌ヨ鐜版湁鐨勮溅杈嗗叧鑱�
+            List<SysTaskVehicle> existingVehicles = sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId);
+            List<Long> existingVehicleIds = existingVehicles.stream()
+                .map(SysTaskVehicle::getVehicleId)
+                .collect(Collectors.toList());
+            
+            // 姣旇緝鏂版棫杞﹁締ID鍒楄〃锛屽垽鏂槸鍚︽湁鍙樺寲
+            boolean vehiclesChanged = !new HashSet<>(existingVehicleIds).equals(new HashSet<>(updateVO.getVehicleIds()));
+            
+            // 鍙湁杞﹁締鍙戠敓鍙樺寲鏃舵墠鏇存柊
+            if (vehiclesChanged) {
+                // 鍒犻櫎鏃х殑杞﹁締鍏宠仈
+                sysTaskVehicleMapper.deleteSysTaskVehicleByTaskId(taskId);
+                
+                // 娣诲姞鏂扮殑杞﹁締鍏宠仈
+                Date now = DateUtils.getNowDate();
+                for (Long vehicleId : updateVO.getVehicleIds()) {
+                    SysTaskVehicle taskVehicle = new SysTaskVehicle();
+                    taskVehicle.setTaskId(taskId);
+                    taskVehicle.setVehicleId(vehicleId);
+                    taskVehicle.setAssignTime(now);
+                    taskVehicle.setAssignBy(userName);
+                    taskVehicle.setCreateTime(now);
+                    sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
+                }
+            }
+        }
+        
+        // 鏇存柊鎵ц浜哄憳锛堟娴嬩汉鍛樺彉鏇达級
+        if (result > 0 && updateVO.getAssignees() != null) {
+            // 鏌ヨ鐜版湁鐨勬墽琛屼汉鍛�
+            List<SysTaskAssignee> existingAssignees = sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(taskId);
+            List<Long> existingAssigneeIds = existingAssignees.stream()
+                .map(SysTaskAssignee::getUserId)
+                .collect(Collectors.toList());
+            
+            List<Long> newAssigneeIds = updateVO.getAssignees().stream()
+                .map(TaskCreateVO.AssigneeInfo::getUserId)
+                .collect(Collectors.toList());
+            
+            // 姣旇緝鏂版棫鎵ц浜哄憳ID鍒楄〃锛屽垽鏂槸鍚︽湁鍙樺寲
+            boolean assigneesChanged = !new HashSet<>(existingAssigneeIds).equals(new HashSet<>(newAssigneeIds));
+            
+            // 鍙湁鎵ц浜哄憳鍙戠敓鍙樺寲鏃舵墠鏇存柊
+            if (assigneesChanged) {
+                // 鍒犻櫎鏃х殑鎵ц浜哄憳鍏宠仈
+                sysTaskAssigneeMapper.deleteSysTaskAssigneeByTaskId(taskId);
+                
+                // 娣诲姞鏂扮殑鎵ц浜哄憳鍏宠仈
+                if (!updateVO.getAssignees().isEmpty()) {
+                    saveTaskAssignees(taskId, updateVO.getAssignees(), userName);
+                }
+            }
+        }
+        
+        // 鏇存柊鎬ユ晳杞繍鎵╁睍淇℃伅
+        if (result > 0) {
+            // 鏇存柊鏃х郴缁烮D
+            if (serviceOrderId != null) {
+                taskEmergency.setLegacyServiceOrdId(Long.parseLong(serviceOrderId));
+            }
+            if (dispatchOrderId != null) {
+                taskEmergency.setLegacyDispatchOrdId(Long.parseLong(dispatchOrderId));
+            }
+            if (serviceOrdNo != null) {
+                taskEmergency.setLegacyServiceOrdNo(serviceOrdNo);
+            }
+            
+            // 浣跨敤TaskCreateVO鐨勫瓧娈垫潵鏇存柊鎬ユ晳杞繍淇℃伅
+            if (updateVO.getHospitalOut() != null || updateVO.getHospitalIn() != null || updateVO.getPatient() != null) {
+                updateEmergencyInfoFromCreateVO(taskId, updateVO, userName);
+            }
         }
         
         return result;
@@ -219,19 +976,40 @@
     @Override
     @Transactional
     public int assignTask(Long taskId, Long assigneeId, String remark) {
-        SysTask task = new SysTask();
-        task.setTaskId(taskId);
-        task.setAssigneeId(assigneeId);
-        task.setUpdateBy(SecurityUtils.getUsername());
-        task.setUpdateTime(DateUtils.getNowDate());
+        SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
+        if (task == null) {
+            throw new RuntimeException("浠诲姟涓嶅瓨鍦�");
+        }
         
-        int result = sysTaskMapper.assignTask(task);
+        SysTask updateTask = new SysTask();
+        updateTask.setTaskId(taskId);
+        updateTask.setAssigneeId(assigneeId);
+        updateTask.setUpdateBy(SecurityUtils.getUsername());
+        updateTask.setUpdateTime(DateUtils.getNowDate());
+        
+        int result = sysTaskMapper.assignTask(updateTask);
         
         // 璁板綍鎿嶄綔鏃ュ織
         if (result > 0) {
             recordTaskLog(taskId, "ASSIGN", "鍒嗛厤浠诲姟", null, 
                          "鍒嗛厤缁欑敤鎴稩D锛�" + assigneeId + "锛屽娉細" + remark, 
                          SecurityUtils.getUserId(), SecurityUtils.getUsername());
+        }
+        
+        // 鍙戝竷浠诲姟鍒嗛厤浜嬩欢
+        if (result > 0) {
+            List<Long> assigneeIds = new ArrayList<>();
+            assigneeIds.add(assigneeId);
+            
+            eventPublisher.publishEvent(new TaskAssignedEvent(
+                this,
+                task.getTaskId(),
+                task.getTaskCode(),
+                assigneeIds,
+                null, // 濮撳悕鍒楄〃鍦ㄧ洃鍚櫒涓煡璇�
+                SecurityUtils.getUserId(),
+                SecurityUtils.getUsername()
+            ));
         }
         
         return result;
@@ -248,6 +1026,21 @@
     @Override
     @Transactional
     public int changeTaskStatus(Long taskId, TaskStatus newStatus, String remark) {
+        return changeTaskStatusWithLocation(taskId, newStatus, remark, null);
+    }
+
+    /**
+     * 鍙樻洿浠诲姟鐘舵�侊紙鍚獹PS浣嶇疆淇℃伅锛�
+     * 
+     * @param taskId 浠诲姟ID
+     * @param newStatus 鏂扮姸鎬�
+     * @param remark 澶囨敞
+     * @param locationLog GPS浣嶇疆淇℃伅鏃ュ織瀵硅薄
+     * @return 缁撴灉
+     */
+    @Override
+    @Transactional
+    public int changeTaskStatusWithLocation(Long taskId, TaskStatus newStatus, String remark, SysTaskLog locationLog) {
         SysTask oldTask = sysTaskMapper.selectSysTaskByTaskId(taskId);
         if (oldTask == null) {
             throw new RuntimeException("浠诲姟涓嶅瓨鍦�");
@@ -266,20 +1059,50 @@
         task.setUpdateTime(DateUtils.getNowDate());
         
         // 鏍规嵁鐘舵�佽缃浉搴旂殑鏃堕棿
-        if (newStatus == TaskStatus.IN_PROGRESS && oldTask.getActualStartTime() == null) {
+        if (newStatus == TaskStatus.DEPARTING && oldTask.getActualStartTime() == null) {
+            // 鍑哄彂涓細璁剧疆瀹為檯寮�濮嬫椂闂�
+            task.setActualStartTime(DateUtils.getNowDate());
+        } else if (newStatus == TaskStatus.IN_PROGRESS && oldTask.getActualStartTime() == null) {
+            // 鍏煎鏃ф暟鎹細浠诲姟涓姸鎬佷篃璁剧疆瀹為檯寮�濮嬫椂闂�
             task.setActualStartTime(DateUtils.getNowDate());
         } else if (newStatus == TaskStatus.COMPLETED) {
+            // 宸插畬鎴愶細璁剧疆瀹為檯缁撴潫鏃堕棿
             task.setActualEndTime(DateUtils.getNowDate());
         }
         
         int result = sysTaskMapper.updateTaskStatus(task);
         
-        // 璁板綍鎿嶄綔鏃ュ織
+        // 璁板綍鎿嶄綔鏃ュ織锛堝惈GPS浣嶇疆淇℃伅锛�
         if (result > 0) {
             recordTaskLog(taskId, "STATUS_CHANGE", "鐘舵�佸彉鏇�", 
                          "鐘舵�侊細" + oldTaskStatus.getInfo(), 
                          "鐘舵�侊細" + newStatus.getInfo() + "锛屽娉細" + remark, 
-                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
+                         SecurityUtils.getUserId(), SecurityUtils.getUsername(),
+                         locationLog);
+        }
+        
+        // 鍙戝竷浠诲姟鐘舵�佸彉鏇翠簨浠�
+        if (result > 0) {
+            // 鏌ヨ浠诲姟鐨勬墍鏈夋墽琛屼汉
+            List<SysTaskAssignee> assignees = sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(taskId);
+            List<Long> assigneeIds = null;
+            if (assignees != null && !assignees.isEmpty()) {
+                assigneeIds = assignees.stream()
+                    .map(SysTaskAssignee::getUserId)
+                    .collect(Collectors.toList());
+            }
+            
+            eventPublisher.publishEvent(new TaskStatusChangedEvent(
+                this,
+                oldTask.getTaskId(),
+                oldTask.getTaskCode(),
+                oldTaskStatus.getCode(),
+                newStatus.getCode(),
+                oldTaskStatus.getInfo(),
+                newStatus.getInfo(),
+                assigneeIds,
+                oldTask.getCreatorId()
+            ));
         }
         
         return result;
@@ -290,37 +1113,183 @@
      * 
      * @param taskId 浠诲姟ID
      * @param file 鏂囦欢
+     * @param category 闄勪欢鍒嗙被
      * @return 缁撴灉
      */
     @Override
     @Transactional
-    public int uploadAttachment(Long taskId, MultipartFile file) {
+    public Long uploadAttachment(Long taskId, MultipartFile file, String category) {
         try {
-            // 涓婁紶鏂囦欢
-            String fileName = FileUploadUtils.upload("/task", file);
-            String filePath = FileUploadUtils.getDefaultBaseDir() + fileName;
+            // 涓婁紶鏂囦欢锛岃繑鍥炵浉瀵硅矾寰勶紙濡傦細/task/2025/01/15/xxx.jpg锛�
+            String fileName = category+"_"+System.currentTimeMillis()+"_"+file.getOriginalFilename();
+
+            fileName=saveLocalPath(fileName,file.getInputStream());
             
             SysTaskAttachment attachment = new SysTaskAttachment();
             attachment.setTaskId(taskId);
             attachment.setFileName(file.getOriginalFilename());
-            attachment.setFilePath(filePath);
+            // 淇濆瓨鐩稿璺緞锛屼笉鍖呭惈 baseDir
+            attachment.setFilePath(fileName);
             attachment.setFileSize(file.getSize());
             attachment.setFileType(getFileType(file.getOriginalFilename()));
+            attachment.setAttachmentCategory(category);
             attachment.setUploadTime(DateUtils.getNowDate());
             attachment.setUploadBy(SecurityUtils.getUsername());
             
-            int result = sysTaskAttachmentMapper.insertSysTaskAttachment(attachment);
+            Long result = sysTaskAttachmentMapper.insertSysTaskAttachment(attachment);
             
             // 璁板綍鎿嶄綔鏃ュ織
             if (result > 0) {
+                String categoryDesc = getCategoryDesc(category);
                 recordTaskLog(taskId, "UPDATE", "涓婁紶闄勪欢", null, 
-                             "涓婁紶鏂囦欢锛�" + file.getOriginalFilename(), 
+                             "涓婁紶鏂囦欢锛�" + file.getOriginalFilename() + "(鍒嗙被锛�" + categoryDesc + ")", 
                              SecurityUtils.getUserId(), SecurityUtils.getUsername());
+
+
             }
             
-            return result;
+            return attachment.getAttachmentId();
         } catch (IOException e) {
             throw new RuntimeException("鏂囦欢涓婁紶澶辫触锛�" + e.getMessage());
+        }
+    }
+    
+    /**
+     * 浠庡井淇ediaId涓婁紶浠诲姟闄勪欢
+     * 
+     * @param taskId 浠诲姟ID
+     * @param accessToken 寰俊AccessToken
+     * @param mediaId 寰俊mediaId
+     * @param category 闄勪欢鍒嗙被
+     * @return 杩斿洖闄勪欢ID
+     */
+    @Override
+    @Transactional
+    public Long uploadAttachmentFromWechat(Long taskId, String accessToken, String mediaId, String category) {
+        try {
+            // 浠庡井淇℃湇鍔″櫒涓嬭浇鏂囦欢
+            String wechatUrl = String.format(
+                "https://api.weixin.qq.com/cgi-bin/media/get?access_token=%s&media_id=%s",
+                accessToken, mediaId
+            );
+            
+            byte[] fileBytes = downloadFromUrl(wechatUrl);
+            if (fileBytes == null || fileBytes.length == 0) {
+                throw new RuntimeException("浠庡井淇′笅杞芥枃浠跺け璐�");
+            }
+            
+            // 鐢熸垚鏂囦欢鍚嶏紙浣跨敤mediaId浣滀负鏂囦欢鍚嶇殑涓�閮ㄥ垎锛�
+            String fileName = "wx_" + mediaId.substring(0, Math.min(20, mediaId.length())) + "_" + System.currentTimeMillis() + ".jpg";
+            
+            // 淇濆瓨鍒版湰鍦�
+            String relativeFilePath = saveLocalPath(fileName, fileBytes);
+
+            // 淇濆瓨闄勪欢璁板綍
+            SysTaskAttachment attachment = new SysTaskAttachment();
+            attachment.setTaskId(taskId);
+            attachment.setFileName(fileName);
+            // 淇濆瓨鐩稿璺緞
+            attachment.setFilePath(relativeFilePath);
+            attachment.setFileSize((long) fileBytes.length);
+            attachment.setFileType("jpg");
+            attachment.setAttachmentCategory(category);
+            attachment.setUploadTime(DateUtils.getNowDate());
+            attachment.setUploadBy(SecurityUtils.getUsername());
+            
+            Long result = sysTaskAttachmentMapper.insertSysTaskAttachment(attachment);
+            
+            // 璁板綍鎿嶄綔鏃ュ織
+            if (result > 0) {
+                String categoryDesc = getCategoryDesc(category);
+                recordTaskLog(taskId, "UPDATE", "涓婁紶闄勪欢", null, 
+                             "閫氳繃寰俊涓婁紶鏂囦欢锛�" + fileName + "(鍒嗙被锛�" + categoryDesc + ")", 
+                             SecurityUtils.getUserId(), SecurityUtils.getUsername());
+
+
+            }
+            
+            return attachment.getAttachmentId();
+        } catch (Exception e) {
+            throw new RuntimeException("浠庡井淇′笂浼犳枃浠跺け璐ワ細" + e.getMessage());
+        }
+    }
+
+    private static String saveLocalPath(String fileName, byte[] fileBytes) throws IOException {
+        String baseDir = FileUploadUtils.getDefaultBaseDir();
+        String datePath = DateUtils.datePath();
+        String uploadDir = baseDir + "/task/" + datePath;
+
+        // 鍒涘缓鐩綍
+        File uploadPath = new File(uploadDir);
+        if (!uploadPath.exists()) {
+            uploadPath.mkdirs();
+        }
+
+        // 淇濆瓨鏂囦欢
+        String filePath = uploadDir + "/" + fileName;
+        File file = new File(filePath);
+        try (FileOutputStream fos = new FileOutputStream(file)) {
+            fos.write(fileBytes);
+        }
+
+        // 鐢熸垚鐩稿璺緞锛堜笉鍖呭惈baseDir锛�
+        String relativeFilePath = "/task/" + datePath + "/" + fileName;
+        return relativeFilePath;
+    }
+
+    private String saveLocalPath(String fileName,InputStream stream){
+        String baseDir = FileUploadUtils.getDefaultBaseDir();
+        String datePath = DateUtils.datePath();
+        String uploadDir = baseDir + "/task/" + datePath;
+
+        // 鍒涘缓鐩綍
+        File uploadPath = new File(uploadDir);
+        if (!uploadPath.exists()) {
+            uploadPath.mkdirs();
+        }
+
+        // 淇濆瓨鏂囦欢
+        String filePath = uploadDir + "/" + fileName;
+       //灏唅nputstream鍐欏叆鏂囦欢
+        try (OutputStream os = new FileOutputStream(filePath)) {
+            byte[] buffer = new byte[1024]; // 缂撳啿鍖猴紝鍑忓皯 IO 娆℃暟
+            int bytesRead;
+            // 寰幆璇诲彇杈撳叆娴佷腑鐨勬暟鎹紝鍐欏叆杈撳嚭娴�
+            while ((bytesRead = stream.read(buffer)) != -1) {
+                os.write(buffer, 0, bytesRead);
+            }
+            os.flush(); // 寮哄埗鍒锋柊缂撳啿鍖猴紝纭繚鏁版嵁鍐欏叆鏂囦欢
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        // 鐢熸垚鐩稿璺緞锛堜笉鍖呭惈baseDir锛�
+        String relativeFilePath = "/task/" + datePath + "/" + fileName;
+        return relativeFilePath;
+    }
+
+    /**
+     * 浠� URL 涓嬭浇鏂囦欢
+     */
+    private byte[] downloadFromUrl(String fileUrl) throws IOException {
+        URL url = new URL(fileUrl);
+        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+        connection.setRequestMethod("GET");
+        connection.setConnectTimeout(10000);
+        connection.setReadTimeout(30000);
+        
+        try (InputStream inputStream = connection.getInputStream()) {
+            byte[] buffer = new byte[4096];
+            int bytesRead;
+            java.io.ByteArrayOutputStream outputStream = new java.io.ByteArrayOutputStream();
+            
+            while ((bytesRead = inputStream.read(buffer)) != -1) {
+                outputStream.write(buffer, 0, bytesRead);
+            }
+            
+            return outputStream.toByteArray();
+        } finally {
+            connection.disconnect();
         }
     }
 
@@ -356,6 +1325,27 @@
         
         return result;
     }
+    
+    /**
+     * 鏍规嵁ID鑾峰彇闄勪欢璇︽儏
+     * 
+     * @param attachmentId 闄勪欢ID
+     * @return 闄勪欢璇︽儏
+     */
+    @Override
+    public SysTaskAttachment getAttachmentById(Long attachmentId) {
+        SysTaskAttachment attachment = sysTaskAttachmentMapper.selectSysTaskAttachmentByAttachmentId(attachmentId);
+        if (attachment != null) {
+            // 鎷兼帴瀹屾暣URL
+            buildAttachmentUrl(attachment);
+        }
+        return attachment;
+    }
+
+    @Override
+    public List<SysTaskAttachment> getAttachmentsByTaskId(Long taskId) {
+        return sysTaskAttachmentMapper.selectSysTaskAttachmentByTaskId(taskId);
+    }
 
     /**
      * 鍒嗛厤杞﹁締缁欎换鍔�
@@ -367,7 +1357,7 @@
      */
     @Override
     @Transactional
-    public int assignVehicleToTask(Long taskId, Long vehicleId, String remark) {
+    public int assignVehicleToTask(Long taskId, Long vehicleId, String remark,Long userId,String userName) {
         // 妫�鏌ユ槸鍚﹀凡缁忓垎閰�
         int exists = sysTaskVehicleMapper.checkTaskVehicleExists(taskId, vehicleId);
         if (exists > 0) {
@@ -378,7 +1368,7 @@
         taskVehicle.setTaskId(taskId);
         taskVehicle.setVehicleId(vehicleId);
         taskVehicle.setAssignTime(DateUtils.getNowDate());
-        taskVehicle.setAssignBy(SecurityUtils.getUsername());
+        taskVehicle.setAssignBy(userName);
         taskVehicle.setStatus("ASSIGNED");
         taskVehicle.setRemark(remark);
         
@@ -388,7 +1378,7 @@
         if (result > 0) {
             recordTaskLog(taskId, "ASSIGN", "鍒嗛厤杞﹁締", null, 
                          "鍒嗛厤杞﹁締ID锛�" + vehicleId + "锛屽娉細" + remark, 
-                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
+                         userId, userName);
         }
         
         return result;
@@ -426,10 +1416,10 @@
      */
     @Override
     @Transactional
-    public int assignMultipleVehiclesToTask(Long taskId, List<Long> vehicleIds, String remark) {
+    public int assignMultipleVehiclesToTask(Long taskId, List<Long> vehicleIds, String remark,Long userId,String userName) {
         List<SysTaskVehicle> taskVehicles = new ArrayList<>();
         Date now = DateUtils.getNowDate();
-        String assignBy = SecurityUtils.getUsername();
+        String assignBy = userName;
         
         for (Long vehicleId : vehicleIds) {
             // 妫�鏌ユ槸鍚﹀凡缁忓垎閰�
@@ -455,7 +1445,7 @@
         if (result > 0) {
             recordTaskLog(taskId, "ASSIGN", "鎵归噺鍒嗛厤杞﹁締", null, 
                          "鍒嗛厤杞﹁締鏁伴噺锛�" + result + "锛屽娉細" + remark, 
-                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
+                         userId,userName);
         }
         
         return result;
@@ -488,6 +1478,7 @@
             VehicleInfo queryParam = new VehicleInfo();
             queryParam.setStatus("0"); // 0琛ㄧず姝ｅ父鐘舵��
             // 涓嶈缃甦eptId锛屾煡璇㈡墍鏈夐儴闂ㄧ殑杞﹁締
+            queryParam.setDeptId(deptId);
             
             List<VehicleInfo> vehicles = vehicleInfoMapper.selectVehicleInfoList(queryParam);
             
@@ -554,11 +1545,104 @@
             // 鏌ヨ鍏宠仈杞﹁締
             task.setAssignedVehicles(sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId));
             // 鏌ヨ闄勪欢
-            task.setAttachments(sysTaskAttachmentMapper.selectSysTaskAttachmentByTaskId(taskId));
+            List<SysTaskAttachment> attachments = sysTaskAttachmentMapper.selectSysTaskAttachmentByTaskId(taskId);
+            // 涓烘瘡涓檮浠舵嫾鎺ュ畬鏁碪RL
+            if (attachments != null && !attachments.isEmpty()) {
+                attachments.forEach(this::buildAttachmentUrl);
+            }
+            task.setAttachments(attachments);
             // 鏌ヨ鎿嶄綔鏃ュ織
             task.setOperationLogs(sysTaskLogMapper.selectSysTaskLogByTaskId(taskId));
+            // 鏌ヨ鎵ц浜哄憳鍒楄〃
+            task.setAssignees(sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(taskId));
+            // 鍔犺浇鎬ユ晳杞繍鎵╁睍淇℃伅
+            if ("EMERGENCY_TRANSFER".equals(task.getTaskType())) {
+                SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
+                task.setEmergencyInfo(emergencyInfo);
+            }
+            // 鍔犺浇绂忕杞︽墿灞曚俊鎭�
+            else if ("WELFARE".equals(task.getTaskType())) {
+                SysTaskWelfare welfareInfo = sysTaskWelfareMapper.selectSysTaskWelfareByTaskId(taskId);
+                task.setWelfareInfo(welfareInfo);
+            }
         }
         return task;
+    }
+
+    /**
+     * 妫�鏌ヨ溅杈嗘槸鍚︽湁姝ｅ湪杩涜涓殑浠诲姟
+     * 姝ｅ湪杩涜涓殑浠诲姟鏄寚鐘舵�佷笉涓猴細PENDING锛堝緟澶勭悊锛夈�丆OMPLETED锛堝凡瀹屾垚锛夈�丆ANCELLED锛堝凡鍙栨秷锛夌殑浠诲姟
+     * 
+     * @param vehicleId 杞﹁締ID
+     * @return 姝ｅ湪杩涜涓殑浠诲姟鍒楄〃
+     */
+    @Override
+    public List<SysTask> checkVehicleActiveTasks(Long vehicleId) {
+        return sysTaskMapper.selectActiveTasksByVehicleId(vehicleId);
+    }
+
+    /**
+     * 妫�鏌ヤ换鍔℃槸鍚﹀凡鍏宠仈鏃х郴缁熸湇鍔″崟ID
+     * 
+     * @param taskId 浠诲姟ID
+     * @return true-宸插叧鑱旓紝false-鏈叧鑱�
+     */
+    @Override
+    public boolean hasLegacyServiceOrdId(Long taskId) {
+        // 鍙湁鎬ユ晳杞繍浠诲姟鎵嶆湁鏃х郴缁烮D
+        SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
+        if (task != null && "EMERGENCY_TRANSFER".equals(task.getTaskType())) {
+            SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
+            return emergencyInfo != null && emergencyInfo.getLegacyServiceOrdId() != null;
+        }
+        return false;
+    }
+
+    /**
+     * 妫�鏌ヤ换鍔℃槸鍚﹀凡鍏宠仈鏃х郴缁熻皟搴﹀崟ID
+     * 
+     * @param taskId 浠诲姟ID
+     * @return true-宸插叧鑱旓紝false-鏈叧鑱�
+     */
+    @Override
+    public boolean hasLegacyDispatchOrdId(Long taskId) {
+        // 鍙湁鎬ユ晳杞繍浠诲姟鎵嶆湁鏃х郴缁烮D
+        SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
+        if (task != null && "EMERGENCY_TRANSFER".equals(task.getTaskType())) {
+            SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
+            return emergencyInfo != null && emergencyInfo.getLegacyDispatchOrdId() != null;
+        }
+        return false;
+    }
+
+    /**
+     * 鏍规嵁鏃х郴缁熸湇鍔″崟ID妫�鏌ユ槸鍚﹀瓨鍦ㄤ换鍔�
+     * 
+     * @param legacyServiceOrdId 鏃х郴缁熸湇鍔″崟ID
+     * @return true-瀛樺湪锛宖alse-涓嶅瓨鍦�
+     */
+    @Override
+    public boolean existsByLegacyServiceOrdId(Long legacyServiceOrdId) {
+        if (legacyServiceOrdId == null) {
+            return false;
+        }
+        SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectByLegacyServiceOrdId(legacyServiceOrdId);
+        return emergencyInfo != null;
+    }
+
+    /**
+     * 鏍规嵁鏃х郴缁熻皟搴﹀崟ID妫�鏌ユ槸鍚﹀瓨鍦ㄤ换鍔�
+     * 
+     * @param legacyDispatchOrdId 鏃х郴缁熻皟搴﹀崟ID
+     * @return true-瀛樺湪锛宖alse-涓嶅瓨鍦�
+     */
+    @Override
+    public boolean existsByLegacyDispatchOrdId(Long legacyDispatchOrdId) {
+        if (legacyDispatchOrdId == null) {
+            return false;
+        }
+        SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectByLegacyDispatchOrdId(legacyDispatchOrdId);
+        return emergencyInfo != null;
     }
 
     @Autowired
@@ -571,6 +1655,30 @@
      */
     private String generateTaskCode() {
         return taskCodeGenerator.generateTaskCode();
+    }
+    
+    /**
+     * 浠庡湴鍧�涓彁鍙栧煄甯傚悕绉帮紙鐢ㄤ簬鍦板浘鍦扮悊缂栫爜锛�
+     * 
+     * @param address 鍦板潃
+     * @return 鍩庡競鍚嶇О
+     */
+    private String extractCityFromAddress(String address) {
+        if (address == null || address.trim().isEmpty()) {
+            return null;
+        }
+        
+        // 甯歌鍩庡競鍚嶅垪琛�
+        String[] cities = {"骞垮窞", "娣卞湷", "涓滆帪", "浣涘北", "鐝犳捣", "鎯犲窞", "涓北", "姹熼棬", "婀涙睙", "鑲囧簡", "娓呰繙", "闊跺叧", "姊呭窞", "娌虫簮", "娼窞", "鎻槼", "姹曞ご", "姹曞熬", "浜戞诞", "闃虫睙","鍖椾含","涓婃捣","澶╂触"};
+        
+        
+        for (String city : cities) {
+            if (address.contains(city)) {
+                return city;
+            }
+        }
+        
+        return null;
     }
 
     /**
@@ -586,7 +1694,29 @@
      */
     private void recordTaskLog(Long taskId, String operationType, String operationDesc, 
                               String oldValue, String newValue, Long operatorId, String operatorName) {
-        SysTaskLog log = new SysTaskLog();
+        recordTaskLog(taskId, operationType, operationDesc, oldValue, newValue, 
+                     operatorId, operatorName, null);
+    }
+
+    /**
+     * 璁板綍浠诲姟鎿嶄綔鏃ュ織锛堝惈GPS浣嶇疆淇℃伅锛�
+     * 
+     * @param taskId 浠诲姟ID
+     * @param operationType 鎿嶄綔绫诲瀷
+     * @param operationDesc 鎿嶄綔鎻忚堪
+     * @param oldValue 鎿嶄綔鍓嶅��
+     * @param newValue 鎿嶄綔鍚庡��
+     * @param operatorId 鎿嶄綔浜篒D
+     * @param operatorName 鎿嶄綔浜哄鍚�
+     * @param log GPS浣嶇疆淇℃伅鏃ュ織瀵硅薄锛堝彲涓簄ull锛�
+     */
+    private void recordTaskLog(Long taskId, String operationType, String operationDesc, 
+                              String oldValue, String newValue, Long operatorId, String operatorName,
+                              SysTaskLog log) {
+        if (log == null) {
+            log = new SysTaskLog();
+        }
+        
         log.setTaskId(taskId);
         log.setOperationType(operationType);
         log.setOperationDesc(operationDesc);
@@ -664,4 +1794,483 @@
             task.setEstimatedDistance(java.math.BigDecimal.ZERO);
         }
     }
+
+    /**
+     * 淇濆瓨浠诲姟鎵ц浜哄憳淇℃伅锛堝寘鍚鑹茬被鍨嬶級
+     * 
+     * @param taskId 浠诲姟ID
+     * @param assignees 鎵ц浜哄憳淇℃伅鍒楄〃
+     */
+    private void saveTaskAssignees(Long taskId, java.util.List<TaskCreateVO.AssigneeInfo> assignees,String userName) {
+        if (assignees == null || assignees.isEmpty()) {
+            return;
+        }
+        
+        java.util.List<SysTaskAssignee> taskAssignees = new java.util.ArrayList<>();
+        Date now = DateUtils.getNowDate();
+        String currentUser = userName;
+        
+        for (int i = 0; i < assignees.size(); i++) {
+            TaskCreateVO.AssigneeInfo assigneeInfo = assignees.get(i);
+            
+            SysTaskAssignee taskAssignee = new SysTaskAssignee();
+            taskAssignee.setTaskId(taskId);
+            taskAssignee.setUserId(assigneeInfo.getUserId());
+            taskAssignee.setUserName(assigneeInfo.getUserName());
+            taskAssignee.setUserType(assigneeInfo.getUserType());
+            // 绗竴涓墽琛屼汉鍛樹负涓昏鎵ц浜�
+            taskAssignee.setIsPrimary(i == 0 ? "1" : "0");
+            taskAssignee.setSortOrder(i);
+            taskAssignee.setCreateTime(now);
+            taskAssignee.setCreateBy(currentUser);
+            taskAssignee.setUpdateTime(now);
+            taskAssignee.setUpdateBy(currentUser);
+            
+            taskAssignees.add(taskAssignee);
+        }
+        
+        // 鎵归噺淇濆瓨
+        if (!taskAssignees.isEmpty()) {
+            sysTaskAssigneeMapper.batchInsertSysTaskAssignee(taskAssignees);
+        }
+    }
+    
+    /**
+     * 淇濆瓨鎬ユ晳杞繍浠诲姟鎵╁睍淇℃伅
+     * 
+     * @param taskId 浠诲姟ID
+     * @param createVO 浠诲姟鍒涘缓瀵硅薄
+     */
+    private void saveEmergencyInfo(Long taskId,String createUserName, TaskCreateVO createVO,String serviceOrderId,String dispatchOrderId, String serviceOrdNo) {
+        SysTaskEmergency emergencyInfo = new SysTaskEmergency();
+        emergencyInfo.setTaskId(taskId);
+        
+        // 璁剧疆鎮ｈ�呬俊鎭�
+        if (createVO.getPatient() != null) {
+            emergencyInfo.setPatientContact(createVO.getPatient().getContact());
+            emergencyInfo.setPatientPhone(createVO.getPatient().getPhone());
+            emergencyInfo.setPatientName(createVO.getPatient().getName());
+            emergencyInfo.setPatientGender(createVO.getPatient().getGender());
+            emergencyInfo.setPatientIdCard(createVO.getPatient().getIdCard());
+            emergencyInfo.setPatientCondition(createVO.getPatient().getCondition());
+        }
+        
+        // 璁剧疆杞嚭鍖婚櫌淇℃伅
+        if (createVO.getHospitalOut() != null) {
+            emergencyInfo.setHospitalOutId(createVO.getHospitalOut().getId());
+            emergencyInfo.setHospitalOutName(createVO.getHospitalOut().getName());
+            emergencyInfo.setHospitalOutDepartment(createVO.getHospitalOut().getDepartment());
+            emergencyInfo.setHospitalOutDepartmentId(createVO.getHospitalOut().getDepartmentId());
+            emergencyInfo.setHospitalOutBedNumber(createVO.getHospitalOut().getBedNumber());
+            emergencyInfo.setHospitalOutAddress(createVO.getHospitalOut().getAddress());
+            
+            // GPS鍧愭爣锛氫紭鍏堜娇鐢ㄥ墠绔紶鍏ョ殑锛屽惁鍒欏悗绔嚜鍔ㄨ幏鍙�
+            if (createVO.getHospitalOut().getLongitude() != null && createVO.getHospitalOut().getLatitude() != null) {
+                emergencyInfo.setHospitalOutLongitude(createVO.getHospitalOut().getLongitude());
+                emergencyInfo.setHospitalOutLatitude(createVO.getHospitalOut().getLatitude());
+            } else if (mapService != null && createVO.getHospitalOut().getAddress() != null) {
+                // 鍚庣鑷姩鑾峰彇GPS鍧愭爣
+                try {
+                    Map<String, Double> coords = mapService.geocoding(
+                        createVO.getHospitalOut().getAddress(), 
+                        extractCityFromAddress(createVO.getHospitalOut().getAddress())
+                    );
+                    if (coords != null) {
+                        emergencyInfo.setHospitalOutLongitude(BigDecimal.valueOf(coords.get("lng")));
+                        emergencyInfo.setHospitalOutLatitude(BigDecimal.valueOf(coords.get("lat")));
+                        log.info("杞嚭鍖婚櫌GPS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                    }
+                } catch (Exception e) {
+                    log.error("鑷姩鑾峰彇杞嚭鍖婚櫌GPS鍧愭爣澶辫触", e);
+                }
+            }
+        }
+        
+        // 璁剧疆杞叆鍖婚櫌淇℃伅
+        if (createVO.getHospitalIn() != null) {
+            emergencyInfo.setHospitalInId(createVO.getHospitalIn().getId());
+            emergencyInfo.setHospitalInName(createVO.getHospitalIn().getName());
+            emergencyInfo.setHospitalInDepartment(createVO.getHospitalIn().getDepartment());
+            emergencyInfo.setHospitalInDepartmentId(createVO.getHospitalIn().getDepartmentId());
+            emergencyInfo.setHospitalInBedNumber(createVO.getHospitalIn().getBedNumber());
+            emergencyInfo.setHospitalInAddress(createVO.getHospitalIn().getAddress());
+            
+            // GPS鍧愭爣锛氫紭鍏堜娇鐢ㄥ墠绔紶鍏ョ殑锛屽惁鍒欏悗绔嚜鍔ㄨ幏鍙�
+            if (createVO.getHospitalIn().getLongitude() != null && createVO.getHospitalIn().getLatitude() != null) {
+                emergencyInfo.setHospitalInLongitude(createVO.getHospitalIn().getLongitude());
+                emergencyInfo.setHospitalInLatitude(createVO.getHospitalIn().getLatitude());
+            } else if (mapService != null && createVO.getHospitalIn().getAddress() != null) {
+                // 鍚庣鑷姩鑾峰彇GPS鍧愭爣
+                try {
+                    Map<String, Double> coords = mapService.geocoding(
+                        createVO.getHospitalIn().getAddress(), 
+                        extractCityFromAddress(createVO.getHospitalIn().getAddress())
+                    );
+                    if (coords != null) {
+                        emergencyInfo.setHospitalInLongitude(BigDecimal.valueOf(coords.get("lng")));
+                        emergencyInfo.setHospitalInLatitude(BigDecimal.valueOf(coords.get("lat")));
+                        log.info("杞叆鍖婚櫌GPS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                    }
+                } catch (Exception e) {
+                    log.error("鑷姩鑾峰彇杞叆鍖婚櫌GPS鍧愭爣澶辫触", e);
+                    }
+                }
+        }
+        
+        // 璁剧疆璐圭敤淇℃伅
+        emergencyInfo.setTransferDistance(createVO.getTransferDistance());
+        emergencyInfo.setTransferPrice(createVO.getPrice());
+        
+        // 璁剧疆鍗曟嵁绫诲瀷ID
+        emergencyInfo.setDocumentTypeId(createVO.getDocumentTypeId());
+        
+        // 璁剧疆浠诲姟绫诲瀷ID
+        emergencyInfo.setTaskTypeId(createVO.getTaskTypeId());
+        
+        // 璁剧疆鐥呮儏ID鍒楄〃锛堝皢List<Long>杞崲涓洪�楀彿鍒嗛殧鐨勫瓧绗︿覆锛�
+        if (createVO.getDiseaseIds() != null && !createVO.getDiseaseIds().isEmpty()) {
+            String diseaseIdsStr = createVO.getDiseaseIds().stream()
+                .map(String::valueOf)
+                .collect(Collectors.joining(","));
+            emergencyInfo.setDiseaseIds(diseaseIdsStr);
+        }
+
+        if(serviceOrderId!=null){
+            emergencyInfo.setLegacyServiceOrdId(Long.parseLong(serviceOrderId));
+            emergencyInfo.setSyncStatus(2);
+            emergencyInfo.setSyncTime(new Date());
+            emergencyInfo.setSyncErrorMsg("鏃х郴缁熷悓姝ヨ繃鏉�");
+        }
+        if(dispatchOrderId!=null){
+            emergencyInfo.setLegacyDispatchOrdId(Long.parseLong(dispatchOrderId));
+            emergencyInfo.setDispatchSyncStatus(2);
+            emergencyInfo.setDispatchSyncTime(new Date());
+            emergencyInfo.setDispatchSyncErrorMsg("鏃х郴缁熷悓姝ヨ繃鏉�");
+        }
+        if(serviceOrdNo!=null){
+            emergencyInfo.setLegacyServiceOrdNo(serviceOrdNo);
+        }
+        // 绯荤粺瀛楁
+        emergencyInfo.setCreateTime(DateUtils.getNowDate());
+        emergencyInfo.setUpdateTime(DateUtils.getNowDate());
+        emergencyInfo.setCreateBy(createUserName);
+        emergencyInfo.setUpdateBy(createUserName);
+        
+        sysTaskEmergencyMapper.insertSysTaskEmergency(emergencyInfo);
+    }
+
+    /**
+     * 浠� TaskCreateVO 鏇存柊鎬ユ晳杞繍浠诲姟鎵╁睍淇℃伅
+     * 
+     * @param taskId 浠诲姟ID
+     * @param createVO 浠诲姟鍒涘缓/鏇存柊瀵硅薄
+     * @param userName 鎿嶄綔浜哄悕
+     */
+    private void updateEmergencyInfoFromCreateVO(Long taskId, TaskCreateVO createVO, String userName) {
+        // 鏌ヨ鐜版湁鐨勬墿灞曚俊鎭�
+        SysTaskEmergency existingInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
+        if (existingInfo == null) {
+            // 濡傛灉涓嶅瓨鍦紝鍒欏垱寤烘柊鐨�
+            existingInfo = new SysTaskEmergency();
+            existingInfo.setTaskId(taskId);
+            existingInfo.setCreateTime(DateUtils.getNowDate());
+            existingInfo.setCreateBy(userName);
+        }
+        
+        // 鏇存柊鎮ｈ�呬俊鎭�
+        if (createVO.getPatient() != null) {
+            if (createVO.getPatient().getContact() != null) {
+                existingInfo.setPatientContact(createVO.getPatient().getContact());
+            }
+            if (createVO.getPatient().getPhone() != null) {
+                existingInfo.setPatientPhone(createVO.getPatient().getPhone());
+            }
+            if (createVO.getPatient().getName() != null) {
+                existingInfo.setPatientName(createVO.getPatient().getName());
+            }
+            if (createVO.getPatient().getGender() != null) {
+                existingInfo.setPatientGender(createVO.getPatient().getGender());
+            }
+            if (createVO.getPatient().getIdCard() != null) {
+                existingInfo.setPatientIdCard(createVO.getPatient().getIdCard());
+            }
+            if (createVO.getPatient().getCondition() != null) {
+                existingInfo.setPatientCondition(createVO.getPatient().getCondition());
+            }
+        }
+        
+        // 鏇存柊杞嚭鍖婚櫌淇℃伅
+        if (createVO.getHospitalOut() != null) {
+            if (createVO.getHospitalOut().getId() != null) {
+                existingInfo.setHospitalOutId(createVO.getHospitalOut().getId());
+            }
+            if (createVO.getHospitalOut().getName() != null) {
+                existingInfo.setHospitalOutName(createVO.getHospitalOut().getName());
+            }
+            if (createVO.getHospitalOut().getDepartment() != null) {
+                existingInfo.setHospitalOutDepartment(createVO.getHospitalOut().getDepartment());
+            }
+            if (createVO.getHospitalOut().getDepartmentId() != null) {
+                existingInfo.setHospitalOutDepartmentId(createVO.getHospitalOut().getDepartmentId());
+            }
+            if (createVO.getHospitalOut().getBedNumber() != null) {
+                existingInfo.setHospitalOutBedNumber(createVO.getHospitalOut().getBedNumber());
+            }
+            if (createVO.getHospitalOut().getAddress() != null && !createVO.getHospitalOut().getAddress().equals(existingInfo.getHospitalOutAddress())) {
+                existingInfo.setHospitalOutAddress(createVO.getHospitalOut().getAddress());
+                
+                // 濡傛灍鏇存柊浜嗗湴鍧�浣嗘病鏈塆PS鍧愭爣锛屽悗绔嚜鍔ㄨ幏鍙�
+                if (createVO.getHospitalOut().getLongitude() == null && createVO.getHospitalOut().getLatitude() == null && mapService != null) {
+                    try {
+
+                        Map<String, Double> coords = mapService.geocoding(
+                            createVO.getHospitalOut().getAddress(),
+                            extractCityFromAddress(createVO.getHospitalOut().getAddress())
+                        );
+                        if (coords != null) {
+                            existingInfo.setHospitalOutLongitude(BigDecimal.valueOf(coords.get("lng")));
+                            existingInfo.setHospitalOutLatitude(BigDecimal.valueOf(coords.get("lat")));
+                            log.info("杞嚭鍖婚櫌GPS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                        }
+                    } catch (Exception e) {
+                        log.error("鑷姩鑾峰彇杞嚭鍖婚櫌GPS鍧愭爣澶辫触", e);
+                    }
+                }
+            }
+            if (createVO.getHospitalOut().getLongitude() != null) {
+                existingInfo.setHospitalOutLongitude(createVO.getHospitalOut().getLongitude());
+            }
+            if (createVO.getHospitalOut().getLatitude() != null) {
+                existingInfo.setHospitalOutLatitude(createVO.getHospitalOut().getLatitude());
+            }
+        }
+        
+        // 鏇存柊杞叆鍖婚櫌淇℃伅
+        if (createVO.getHospitalIn() != null) {
+            if (createVO.getHospitalIn().getId() != null) {
+                existingInfo.setHospitalInId(createVO.getHospitalIn().getId());
+            }
+            if (createVO.getHospitalIn().getName() != null) {
+                existingInfo.setHospitalInName(createVO.getHospitalIn().getName());
+            }
+            if (createVO.getHospitalIn().getDepartment() != null) {
+                existingInfo.setHospitalInDepartment(createVO.getHospitalIn().getDepartment());
+            }
+            if (createVO.getHospitalIn().getDepartmentId() != null) {
+                existingInfo.setHospitalInDepartmentId(createVO.getHospitalIn().getDepartmentId());
+            }
+            if (createVO.getHospitalIn().getBedNumber() != null) {
+                existingInfo.setHospitalInBedNumber(createVO.getHospitalIn().getBedNumber());
+            }
+            if (createVO.getHospitalIn().getAddress() != null && !createVO.getHospitalIn().getAddress().equals(existingInfo.getHospitalInAddress())) {
+                existingInfo.setHospitalInAddress(createVO.getHospitalIn().getAddress());
+                
+                // 濡傛灉鏇存柊浜嗗湴鍧�浣嗘病鏈塆PS鍧愭爣锛屽悗绔嚜鍔ㄨ幏鍙�
+                if (createVO.getHospitalIn().getLongitude() == null && createVO.getHospitalIn().getLatitude() == null && mapService != null) {
+                    try {
+                        Map<String, Double> coords = mapService.geocoding(
+                            createVO.getHospitalIn().getAddress(),
+                            extractCityFromAddress(createVO.getHospitalIn().getAddress())
+                        );
+                        if (coords != null) {
+                            existingInfo.setHospitalInLongitude(BigDecimal.valueOf(coords.get("lng")));
+                            existingInfo.setHospitalInLatitude(BigDecimal.valueOf(coords.get("lat")));
+                            log.info("杞叆鍖婚櫌GPS鍧愭爣鑷姩鑾峰彇鎴愬姛: {}, {}", coords.get("lng"), coords.get("lat"));
+                        }
+                    } catch (Exception e) {
+                        log.error("鑷姩鑾峰彇杞叆鍖婚櫌GPS鍧愭爣澶辫触", e);
+                    }
+                }
+            }
+            if (createVO.getHospitalIn().getLongitude() != null) {
+                existingInfo.setHospitalInLongitude(createVO.getHospitalIn().getLongitude());
+            }
+            if (createVO.getHospitalIn().getLatitude() != null) {
+                existingInfo.setHospitalInLatitude(createVO.getHospitalIn().getLatitude());
+            }
+        }
+        
+        // 鏇存柊璐圭敤淇℃伅
+        if (createVO.getTransferDistance() != null) {
+            existingInfo.setTransferDistance(createVO.getTransferDistance());
+        }
+        if (createVO.getPrice() != null) {
+            existingInfo.setTransferPrice(createVO.getPrice());
+        }
+        
+        // 鏇存柊鍗曟嵁绫诲瀷ID
+        if (createVO.getDocumentTypeId() != null) {
+            existingInfo.setDocumentTypeId(createVO.getDocumentTypeId());
+        }
+        
+        // 鏇存柊浠诲姟绫诲瀷ID
+        if (createVO.getTaskTypeId() != null) {
+            existingInfo.setTaskTypeId(createVO.getTaskTypeId());
+        }
+        
+        // 鏇存柊鐥呮儏ID鍒楄〃
+        if (createVO.getDiseaseIds() != null && !createVO.getDiseaseIds().isEmpty()) {
+            String diseaseIdsStr = createVO.getDiseaseIds().stream()
+                .map(String::valueOf)
+                .collect(Collectors.joining(","));
+            existingInfo.setDiseaseIds(diseaseIdsStr);
+        }
+        
+        // 绯荤粺瀛楁
+        existingInfo.setUpdateTime(DateUtils.getNowDate());
+        existingInfo.setUpdateBy(userName);
+        
+        // 鎵ц鏇存柊
+        sysTaskEmergencyMapper.updateSysTaskEmergency(existingInfo);
+    }
+    
+    /**
+     * 浠� TaskCreateVO 鏇存柊绂忕杞︿换鍔℃墿灞曚俊鎭�
+     * 
+     * @param taskId 浠诲姟ID
+     * @param createVO 浠诲姟鍒涘缓/鏇存柊瀵硅薄
+     * @param userName 鎿嶄綔浜哄悕
+     */
+    private void updateWelfareInfoFromCreateVO(Long taskId, TaskCreateVO createVO, String userName) {
+        // 鏌ヨ鐜版湁鐨勬墿灞曚俊鎭�
+        SysTaskWelfare existingInfo = sysTaskWelfareMapper.selectSysTaskWelfareByTaskId(taskId);
+        if (existingInfo == null) {
+            // 濡傛灉涓嶅瓨鍦紝鍒欏垱寤烘柊鐨�
+            existingInfo = new SysTaskWelfare();
+            existingInfo.setTaskId(taskId);
+            existingInfo.setCreateTime(DateUtils.getNowDate());
+            existingInfo.setCreateBy(userName);
+        }
+        
+        // 鏇存柊涔樺淇℃伅
+        if (createVO.getPassenger() != null) {
+            if (createVO.getPassenger().getContact() != null) {
+                existingInfo.setPassengerContact(createVO.getPassenger().getContact());
+            }
+            if (createVO.getPassenger().getPhone() != null) {
+                existingInfo.setPassengerPhone(createVO.getPassenger().getPhone());
+            }
+        }
+        
+        // 鏇存柊鍦板潃淇℃伅
+        if (createVO.getStartAddress() != null) {
+            existingInfo.setPickupAddress(createVO.getStartAddress());
+        }
+        if (createVO.getEndAddress() != null) {
+            existingInfo.setDestinationAddress(createVO.getEndAddress());
+        }
+        
+        // 鏇存柊GPS鍧愭爣
+        if (createVO.getDepartureLongitude() != null) {
+            existingInfo.setPickupLongitude(createVO.getDepartureLongitude());
+        }
+        if (createVO.getDepartureLatitude() != null) {
+            existingInfo.setPickupLatitude(createVO.getDepartureLatitude());
+        }
+        if (createVO.getDestinationLongitude() != null) {
+            existingInfo.setDestinationLongitude(createVO.getDestinationLongitude());
+        }
+        if (createVO.getDestinationLatitude() != null) {
+            existingInfo.setDestinationLatitude(createVO.getDestinationLatitude());
+        }
+        
+        // 鏇存柊璺濈鍜岃垂鐢�
+        if (createVO.getDistance() != null) {
+            existingInfo.setServiceDistance(createVO.getDistance());
+        } else if (createVO.getEstimatedDistance() != null) {
+            existingInfo.setServiceDistance(createVO.getEstimatedDistance());
+        }
+        if (createVO.getPrice() != null) {
+            existingInfo.setServicePrice(createVO.getPrice());
+        }
+        
+        // 绯荤粺瀛楁
+        existingInfo.setUpdateTime(DateUtils.getNowDate());
+        existingInfo.setUpdateBy(userName);
+        
+        // 鎵ц鏇存柊
+        sysTaskWelfareMapper.updateSysTaskWelfare(existingInfo);
+    }
+
+    /**
+     * 淇濆瓨绂忕杞︿换鍔℃墿灞曚俊鎭�
+     * 
+     * @param taskId 浠诲姟ID
+     * @param createVO 浠诲姟鍒涘缓瀵硅薄
+     */
+    private void saveWelfareInfo(Long taskId,String userName, TaskCreateVO createVO) {
+        SysTaskWelfare welfareInfo = new SysTaskWelfare();
+        welfareInfo.setTaskId(taskId);
+        
+        // 璁剧疆涔樺淇℃伅
+        if (createVO.getPassenger() != null) {
+            welfareInfo.setPassengerContact(createVO.getPassenger().getContact());
+            welfareInfo.setPassengerPhone(createVO.getPassenger().getPhone());
+        }
+        
+        // 璁剧疆鍦板潃淇℃伅
+        welfareInfo.setPickupAddress(createVO.getStartAddress());
+        welfareInfo.setDestinationAddress(createVO.getEndAddress());
+        
+        // 璁剧疆GPS鍧愭爣
+        welfareInfo.setPickupLongitude(createVO.getDepartureLongitude());
+        welfareInfo.setPickupLatitude(createVO.getDepartureLatitude());
+        welfareInfo.setDestinationLongitude(createVO.getDestinationLongitude());
+        welfareInfo.setDestinationLatitude(createVO.getDestinationLatitude());
+        
+        // 璁剧疆璺濈鍜岃垂鐢�
+        // 浼樺厛浣跨敤绂忕杞︿笓鐢ㄧ殑distance瀛楁锛屽鏋滄病鏈夊垯浣跨敤閫氱敤鐨別stimatedDistance
+        BigDecimal serviceDistance = createVO.getDistance() != null ? createVO.getDistance() : createVO.getEstimatedDistance();
+        welfareInfo.setServiceDistance(serviceDistance);
+        welfareInfo.setServicePrice(createVO.getPrice());
+        
+        // 绯荤粺瀛楁
+        welfareInfo.setCreateTime(DateUtils.getNowDate());
+        welfareInfo.setUpdateTime(DateUtils.getNowDate());
+        welfareInfo.setCreateBy(userName);
+        welfareInfo.setUpdateBy(userName);
+        
+        sysTaskWelfareMapper.insertSysTaskWelfare(welfareInfo);
+    }
+    
+    /**
+     * 鑾峰彇闄勪欢鍒嗙被鎻忚堪
+     * 
+     * @param category 闄勪欢鍒嗙被浠ｇ爜
+     * @return 鍒嗙被鎻忚堪
+     */
+    private String getCategoryDesc(String category) {
+        if (category == null || category.isEmpty()) {
+            return "鏈垎绫�";
+        }
+        switch (category) {
+            case "1": return "鐭ユ儏鍚屾剰涔�";
+            case "2": return "鐥呬汉璧勬枡";
+            case "3": return "鎿嶄綔璁板綍";
+            case "4": return "鍑鸿溅鍓�";
+            case "5": return "鍑鸿溅鍚�";
+            case "6": return "绯诲畨鍏ㄥ甫";
+            default: return "鍏朵粬";
+        }
+    }
+    
+    /**
+     * 鏋勫缓闄勪欢鐨勫畬鏁碪RL
+     * 
+     * @param attachment 闄勪欢瀵硅薄
+     */
+    private void buildAttachmentUrl(SysTaskAttachment attachment) {
+        if (attachment != null && StringUtils.isNotEmpty(attachment.getFilePath())) {
+            String imageUrl = imageUrlConfig.getImageUrl();
+            if (StringUtils.isNotEmpty(imageUrl)) {
+                // 鎷兼帴瀹屾暣URL锛氬煙鍚� + 鐩稿璺緞
+                attachment.setFileUrl(imageUrl + attachment.getFilePath());
+            } else {
+                // 濡傛灉鏈厤缃煙鍚嶏紝鐩存帴浣跨敤鐩稿璺緞
+                attachment.setFileUrl(attachment.getFilePath());
+            }
+        }
+    }
+    
+   
 }

--
Gitblit v1.9.1