feat: 任务修改接口，删除一些不要的字段同步

wlzboy

6 小时以前 5f2ee03958a1a16dc27195c76ea7cffb422c95d1

 app/pages/task/index.vue

@@ -108,20 +108,26 @@
      
      <scroll-view class="task-list-scroll" scroll-y="true">
        <view class="task-list">
          <view class="task-item" v-for="task in filteredTaskList" :key="task.id">
          <view class="task-item" v-for="task in filteredTaskList" :key="task.taskId">
            <view class="task-main" @click="viewTaskDetail(task)">
              <view class="task-title">{{ getTaskTypeText(task.type) }} - {{ task.vehicle }}</view>
              <view class="task-info">
                <view class="info-row">
                  <view class="info-item">
                    <view class="label">任务编号:</view>
                    <view class="value">{{ task.taskNo }}</view>
                  </view>
                  <view class="info-item">
                    <view class="label">任务状态:</view>
                    <view class="value">{{ getStatusText(task.status) }}</view>
                  </view>
              <!-- 任务头部：标题和状态标签 -->
              <view class="task-header">
                <view class="task-title">
                  {{ getTaskTypeText(task.taskType) }} - {{ task.vehicle }}
                  <text v-if="task.isHeadPush === '1'" class="head-push-tag">总</text>
                </view>
                <view class="task-status" :class="task.taskStatus === 'PENDING' ? 'status-pending' : task.taskStatus === 'DEPARTING' ? 'status-departing' : task.taskStatus === 'ARRIVED' ? 'status-arrived' : task.taskStatus === 'RETURNING' ? 'status-returning' : task.taskStatus === 'COMPLETED' ? 'status-completed' : task.taskStatus === 'CANCELLED' ? 'status-cancelled' : task.taskStatus === 'IN_PROGRESS' ? 'status-in-progress' : 'status-default'">
                  {{ getStatusText(task.taskStatus) }}
                </view>
              </view>
              
              <!-- 任务编号单独一行 -->
              <view class="task-code-row">
                <text class="task-code">{{ task.showTaskCode }}</text>
              </view>
              
              <!-- 任务详细信息 -->
              <view class="task-info">
                <view class="info-row">
                  <view class="info-item">
                    <view class="label">出发地:</view>
@@ -147,52 +153,73 @@
            
            <!-- 操作按钮 -->
            <view class="task-actions">
              <button 
                class="action-btn" 
                :class="{ disabled: isActionDisabled(task, 'depart') }"
                @click="handleTaskAction(task, 'depart')"
                v-if="task.status !== 'completed'"
              >
                出发
              </button>
              <button 
                class="action-btn" 
                :class="{ disabled: isActionDisabled(task, 'arrive') }"
                @click="handleTaskAction(task, 'arrive')"
                v-if="task.status !== 'completed'"
              >
                已到达
              </button>
              <button 
                class="action-btn" 
                :class="{ disabled: isActionDisabled(task, 'return') }"
                @click="handleTaskAction(task, 'return')"
                v-if="task.status !== 'completed'"
              >
                返程
              </button>
              <button 
                class="action-btn" 
                :class="{ disabled: isActionDisabled(task, 'settle') }"
                @click="handleTaskAction(task, 'settle')"
                v-if="task.status !== 'completed'"
              >
                结算
              </button>
              <button 
                class="action-btn primary" 
                :class="{ disabled: isActionDisabled(task, 'complete') }"
                @click="handleTaskAction(task, 'complete')"
                v-if="task.status !== 'completed'"
              >
                已完成
              </button>
              <!-- 待处理状态: 显示出发、取消 -->
              <template v-if="task.taskStatus === 'PENDING'">
                <button 
                  class="action-btn primary" 
                  @click="handleTaskAction(task, 'depart')"
                >
                  出发
                </button>
                <button 
                  class="action-btn cancel" 
                  @click="handleTaskAction(task, 'cancel')"
                >
                  取消
                </button>
              </template>
              
              <!-- 出发中状态: 显示已到达、强制结束 -->
              <template v-else-if="task.taskStatus === 'DEPARTING'">
                <button 
                  class="action-btn primary" 
                  @click="handleTaskAction(task, 'arrive')"
                >
                  已到达
                </button>
                <button 
                  class="action-btn cancel" 
                  @click="handleTaskAction(task, 'forceCancel')"
                >
                  强制结束
                </button>
              </template>
              
              <!-- 已到达状态: 显示已返程 -->
              <template v-else-if="task.taskStatus === 'ARRIVED'">
                <button 
                  class="action-btn primary" 
                  @click="handleTaskAction(task, 'return')"
                >
                  已返程
                </button>
              </template>
              
              <!-- 返程中状态: 显示已完成 -->
              <template v-else-if="task.taskStatus === 'RETURNING'">
                <button 
                  class="action-btn primary" 
                  @click="handleTaskAction(task, 'complete')"
                >
                  已完成
                </button>
              </template>
              
              <!-- 已完成/已取消: 不显示按钮 -->
            </view>
          </view>
          
          <view class="no-data" v-if="filteredTaskList.length === 0">
            <uni-icons type="info" size="40" color="#ccc"></uni-icons>
            <text>暂无任务数据</text>
          </view>
          <!-- 加载更多提示 -->
          <view class="load-more" v-if="filteredTaskList.length > 0 && hasMore">
            <uni-icons type="spinner-cycle" size="20" color="#999"></uni-icons>
            <text>正在加载更多数据...</text>
          </view>
          <view class="load-more no-more" v-else-if="filteredTaskList.length > 0 && !hasMore">
            <text>没有更多数据了</text>
          </view>
        </view>
      </scroll-view>
@@ -202,6 +229,10 @@

<script>
  import uniDatetimePicker from '@/uni_modules/uni-datetime-picker/components/uni-datetime-picker/uni-datetime-picker.vue'
  import { listTask, changeTaskStatus } from '@/api/task'
  import { mapState } from 'vuex'
  import { formatDateTime } from '@/utils/common'
  import { checkTaskCanDepart } from '@/utils/taskValidator'
  
  export default {
    components: {
@@ -226,119 +257,71 @@
        currentFilter: 'all',
        
        // 任务列表
        taskList: [
          {
            id: 1,
            title: '紧急维修任务',
            type: 'maintenance', // 维修保养
            startLocation: '广州市天河区XX路123号',
            endLocation: '广州市白云区YY路456号',
            startTime: '2023-05-15 15:00',
            assignee: '张三',
            status: 'pending',
            vehicle: '粤A12345',
            taskNo: 'RW20230515001'
          },
          {
            id: 2,
            title: '定期保养任务',
            type: 'maintenance', // 维修保养
            startLocation: '深圳市南山区XX路789号',
            endLocation: '深圳市福田区YY路999号',
            startTime: '2023-05-14 10:00',
            assignee: '李四',
            status: 'processing',
            vehicle: '粤B67890',
            taskNo: 'RW20230514002'
          },
          {
            id: 3,
            title: '设备巡检任务',
            type: 'inspection', // 巡检任务
            startLocation: '珠海市香洲区XX路321号',
            endLocation: '珠海市金湾区YY路654号',
            startTime: '2023-05-13 17:00',
            assignee: '王五',
            status: 'completed',
            vehicle: '粤C11111',
            taskNo: 'RW20230513003'
          },
          {
            id: 4,
            title: '加油任务',
            type: 'refuel', // 加油
            startLocation: '佛山市禅城区AA路555号',
            endLocation: '佛山市南海区BB路888号',
            startTime: '2023-05-12 09:00',
            assignee: '赵六',
            status: 'completed',
            vehicle: '粤D22222',
            taskNo: 'RW20230512004'
          },
          {
            id: 5,
            title: '急救转运任务',
            type: 'emergency', // 急救转运
            startLocation: '广州市越秀区医院路1号',
            endLocation: '广州市海珠区医院路2号',
            startTime: '2023-05-16 14:00',
            assignee: '张医生,李护士',
            status: 'pending',
            vehicle: '粤E33333',
            taskNo: 'RW20230516005'
          },
          {
            id: 6,
            title: '福祉车任务',
            type: 'welfare', // 福祉车
            startLocation: '广州市荔湾区社区路10号',
            endLocation: '广州市天河区养老院路20号',
            startTime: '2023-05-17 08:00',
            assignee: '王司机',
            status: 'processing',
            vehicle: '粤F44444',
            taskNo: 'RW20230517006'
          }
        ]
        taskList: [],
        loading: false,
        refreshing: false,
        
        // 分页相关
        currentPage: 1,
        pageSize: 10,
        total: 0,
        hasMore: true
      }
    },
    computed: {
      ...mapState({
        currentUser: state => state.user
      }),
      filteredTaskList() {
        let filtered = this.taskList;
        
        // 应用筛选器
        if (this.currentFilter !== 'all') {
          filtered = filtered.filter(task => {
            if (this.currentFilter === 'pending') return task.status === 'pending';
            if (this.currentFilter === 'processing') return task.status === 'processing';
            if (this.currentFilter === 'completed') return task.status === 'completed';
            if (this.currentFilter === 'pending') return task.taskStatus === 'PENDING';
            if (this.currentFilter === 'processing') return ['DEPARTING', 'ARRIVED', 'RETURNING', 'IN_PROGRESS'].includes(task.taskStatus);
            if (this.currentFilter === 'completed') return task.taskStatus === 'COMPLETED';
            return true;
          });
        }
        
        // 应用状态筛选
        if (this.selectedStatus) {
          filtered = filtered.filter(task => task.status === this.selectedStatus);
          const statusMap = {
            'pending': ['PENDING'],
            'processing': ['DEPARTING', 'ARRIVED', 'RETURNING', 'IN_PROGRESS'],
            'completed': ['COMPLETED']
          }
          const validStatuses = statusMap[this.selectedStatus];
          if (validStatuses) {
            filtered = filtered.filter(task => validStatuses.includes(task.taskStatus));
          }
        }
        
        // 应用车牌号筛选
        // 应用车牌号筛选 - 搜索assignedVehicles数组中的车辆
        if (this.searchForm.vehicle) {
          filtered = filtered.filter(task => 
            task.vehicle.includes(this.searchForm.vehicle)
          );
          filtered = filtered.filter(task => {
            // 在车辆列表中查找匹配的车牌号
            if (task.vehicleList && task.vehicleList.length > 0) {
              return task.vehicleList.some(vehicle => 
                vehicle.vehicleNo && vehicle.vehicleNo.includes(this.searchForm.vehicle)
              )
            }
            return false
          });
        }
        
        // 应用任务编号筛选
        // 应用任务编号筛选 - 使用taskCode而不是taskNo
        if (this.searchForm.taskNo) {
          filtered = filtered.filter(task => 
            task.taskNo.includes(this.searchForm.taskNo)
            task.showTaskCode && task.showTaskCode.includes(this.searchForm.taskNo)
          );
        }
        
        // 应用时间范围筛选
        if (this.startDate) {
          filtered = filtered.filter(task => 
            task.startTime >= this.startDate
            task.plannedStartTime && task.plannedStartTime >= this.startDate
          );
        }
        
@@ -349,14 +332,162 @@
          const endDateStr = end.toISOString().split('T')[0];
          
          filtered = filtered.filter(task => 
            task.startTime < endDateStr
            task.plannedStartTime && task.plannedStartTime < endDateStr
          );
        }
        
        return filtered;
      }
    },
    onLoad() {
      this.loadTaskList()
      
      // 监听任务列表刷新事件
      uni.$on('refreshTaskList', this.handleRefreshEvent)
    },
    onShow() {
      // 页面显示时刷新列表（从其他页面返回时）
      this.loadTaskList()
    },
    onUnload() {
      // 页面销毁时移除事件监听
      uni.$off('refreshTaskList', this.handleRefreshEvent)
    },
    onPullDownRefresh() {
      this.refreshList()
    },
    // 监听滚动到底部事件
    onReachBottom() {
      if (this.hasMore && !this.loading) {
        this.loadMore()
      }
    },
    methods: {
      // 处理刷新事件
      handleRefreshEvent() {
        console.log('收到刷新任务列表事件')
        this.refreshList()
      },
      
      // 加载任务列表
      loadTaskList() {
        this.loading = true
        // 重置分页参数
        this.currentPage = 1
        this.hasMore = true
        this.taskList = []
        
        // 后端会自动获取当前用户信息，实现综合查询
        // 综合查询：当前用户所在机构任务 + 当前用户创建的任务 + 分配给当前用户的任务
        const queryParams = {
          pageNum: this.currentPage,
          pageSize: this.pageSize,
          orderByColumn: 'create_time',
          isAsc: 'desc'
        }
        
        listTask(queryParams).then(response => {
          this.loading = false
          const data = response.data || response.rows || []
          // 设置总数和是否有更多数据
          this.total = response.total || data.length || 0
          this.hasMore = data.length === this.pageSize
          
          this.taskList = data.map(task => {
            // 从assignedVehicles数组中获取车辆信息
            let vehicleInfo = '未分配车辆'
            if (task.assignedVehicles && task.assignedVehicles.length > 0) {
              // 如果有多个车辆,显示第一个,并标注数量
              const firstVehicle = task.assignedVehicles[0]
              vehicleInfo = firstVehicle.vehicleNo || '未知车牌'
              if (task.assignedVehicles.length > 1) {
                vehicleInfo += ` 等${task.assignedVehicles.length}辆`
              }
            }
            
            return {
              ...task,
              // 格式化显示字段 - 使用后端返回的assignedVehicles数据
              vehicle: vehicleInfo,
              vehicleList: task.assignedVehicles || [],
              startLocation: this.formatAddress(task.departureAddress || task.startLocation || '未设置'),
              endLocation: this.formatAddress(task.destinationAddress || task.endLocation || '未设置'),
              startTime: task.plannedStartTime ? formatDateTime(task.plannedStartTime, 'YYYY-MM-DD HH:mm') : '未设置',
              assignee: task.assigneeName || '未分配'
            }
          })
        }).catch(error => {
          this.loading = false
          console.error('加载任务列表失败:', error)
          this.$modal.showToast('加载任务列表失败')
        })
      },
      
      // 加载更多数据
      loadMore() {
        if (!this.hasMore || this.loading) return
        
        this.loading = true
        this.currentPage++
        
        const queryParams = {
          pageNum: this.currentPage,
          pageSize: this.pageSize,
          orderByColumn: 'create_time',
          isAsc: 'desc'
        }
        
        listTask(queryParams).then(response => {
          this.loading = false
          const data = response.data || response.rows || []
          // 更新是否有更多数据
          this.hasMore = data.length === this.pageSize
          
          const newTasks = data.map(task => {
            // 从assignedVehicles数组中获取车辆信息
            let vehicleInfo = '未分配车辆'
            if (task.assignedVehicles && task.assignedVehicles.length > 0) {
              // 如果有多个车辆,显示第一个,并标注数量
              const firstVehicle = task.assignedVehicles[0]
              vehicleInfo = firstVehicle.vehicleNo || '未知车牌'
              if (task.assignedVehicles.length > 1) {
                vehicleInfo += ` 等${task.assignedVehicles.length}辆`
              }
            }
            
            return {
              ...task,
              // 格式化显示字段 - 使用后端返回的assignedVehicles数据
              vehicle: vehicleInfo,
              vehicleList: task.assignedVehicles || [],
              startLocation: this.formatAddress(task.departureAddress || task.startLocation || '未设置'),
              endLocation: this.formatAddress(task.destinationAddress || task.endLocation || '未设置'),
              startTime: task.plannedStartTime ? formatDateTime(task.plannedStartTime, 'YYYY-MM-DD HH:mm') : '未设置',
              assignee: task.assigneeName || '未分配'
            }
          })
          
          // 将新数据追加到现有列表中
          this.taskList = [...this.taskList, ...newTasks]
        }).catch(error => {
          this.loading = false
          this.currentPage-- // 出错时回退页码
          console.error('加载更多任务失败:', error)
          this.$modal.showToast('加载更多任务失败')
        })
      },
      
      // 格式化地址 - 只显示-前面的部分
      formatAddress(address) {
        if (!address) return '未设置'
        // 如果地址包含-，只返回-前面的部分
        const dashIndex = address.indexOf('-')
        if (dashIndex > 0) {
          return address.substring(0, dashIndex)
        }
        return address
      },
      
      // 切换查询界面显示/隐藏
      toggleSearch() {
        this.showSearch = !this.showSearch;
@@ -370,17 +501,10 @@
      
      // 查询
      handleSearch() {
        this.loadTaskList()
        this.$modal.showToast('查询成功');
        console.log('查询条件:', {
          status: this.selectedStatus,
          startDate: this.startDate,
          endDate: this.endDate,
          vehicle: this.searchForm.vehicle,
          taskNo: this.searchForm.taskNo
        });
        // 查询完成后隐藏查询界面
        this.showSearch = false;
        // 这里可以调用API进行查询
      },
      
      // 重置查询条件
@@ -395,8 +519,14 @@
      
      // 刷新列表
      refreshList() {
        this.$modal.showToast('列表已刷新');
        // 这里可以重新加载数据
        this.refreshing = true
        this.loadTaskList()
        setTimeout(() => {
          this.refreshing = false
          // this.$modal.showToast('列表已刷新');
          // 停止下拉刷新
          uni.stopPullDownRefresh()
        }, 1000)
      },
      
      // 筛选
@@ -406,93 +536,238 @@
      
      // 查看任务详情
      viewTaskDetail(task) {
        // 跳转到任务详情页面
        this.$tab.navigateTo(`/pages/task/detail?id=${task.id}`);
      },
      
      // 判断操作按钮是否禁用
      isActionDisabled(task, action) {
        // 根据任务状态和操作类型判断是否禁用
        switch (action) {
          case 'depart':
            return task.status !== 'pending';
          case 'arrive':
            return task.status !== 'processing';
          case 'return':
            return task.status !== 'processing';
          case 'settle':
            return task.status !== 'processing';
          case 'complete':
            return task.status !== 'processing';
          default:
            return false;
        // 防御性检查
        if (!task || !task.taskId) {
          console.error('任务数据无效:', task)
          this.$modal.showToast('任务数据异常')
          return
        }
        
        // 跳转到任务详情页面 - 使用uni.navigateTo
        uni.navigateTo({
          url: `/pagesTask/detail?id=${task.taskId}`
        });
      },
      
      // 处理任务操作
      handleTaskAction(task, action) {
        if (this.isActionDisabled(task, action)) {
          return;
        }
        
      async handleTaskAction(task, action) {
        switch (action) {
          case 'depart':
            // 出发操作，根据任务类型显示不同的确认信息
            let departMessage = '确定要标记为已出发吗？';
            if (task.type !== 'maintenance' && task.type !== 'refuel' && task.type !== 'inspection') {
              departMessage = '发出去目的地,确认？';
            // 出发 -> 状态变为出发中
            // 显示加载提示
            uni.showLoading({
              title: '检查任务状态...'
            });
            
            try {
              // 调用工具类检查任务是否可以出发（包含基本校验和冲突检查）
              const checkResult = await checkTaskCanDepart(task)
              
              uni.hideLoading();
              
              console.log('出发检查结果:', checkResult);
              console.log('valid:', checkResult.valid);
              console.log('conflicts:', checkResult.conflicts);
              
              if (!checkResult.valid) {
                // 校验失败，显示提示信息并提供跳转选项
                const conflicts = checkResult.conflicts || [];
                const conflictInfo = conflicts.length > 0 ? conflicts[0] : null;
                
                console.log('冲突信息:', conflictInfo);
                
                // 如果有冲突任务信息，提供跳转按钮
                if (conflictInfo && conflictInfo.taskId) {
                  console.log('显示带跳转按钮的弹窗，任务ID:', conflictInfo.taskId);
                  
                  const conflictTaskId = conflictInfo.taskId;
                  const message = checkResult.message || conflictInfo.message || '存在冲突任务';
                  
                  uni.showModal({
                    title: '提示',
                    content: message,
                    confirmText: '去处理',
                    cancelText: '知道了',
                    success: function(res) {
                      console.log('弹窗点击结果:', res);
                      if (res.confirm) {
                        // 用户点击"现在去处理"，跳转到冲突任务详情页
                        console.log('准备跳转到任务详情页:', conflictTaskId);
                        uni.navigateTo({
                          url: `/pagesTask/detail?id=${conflictTaskId}`
                        });
                      }
                    },
                    fail: function(err) {
                      console.error('显示弹窗失败:', err);
                    }
                  });
                } else {
                  // 没有冲突任务ID，只显示提示
                  console.log('显示普通提示弹窗');
                  uni.showModal({
                    title: '提示',
                    content: checkResult.message || '任务校验失败',
                    showCancel: false,
                    confirmText: '知道了',
                    fail: function(err) {
                      console.error('显示弹窗失败:', err);
                    }
                  });
                }
                return;
              }
              
              // 所有检查通过，可以出发
              this.$modal.confirm('确定要出发吗？').then(() => {
                this.updateTaskStatus(task.taskId, 'DEPARTING', '任务已出发')
              }).catch(() => {});
              
            } catch (error) {
              uni.hideLoading();
              console.error('检查任务状态失败:', error);
              // 检查失败时，仍然允许出发
              this.$modal.confirm('检查任务状态失败，是否继续出发？').then(() => {
                this.updateTaskStatus(task.taskId, 'DEPARTING', '任务已出发')
              }).catch(() => {});
            }
            this.$modal.confirm(departMessage).then(() => {
              task.status = 'processing';
              this.$modal.showToast('已出发');
              // 这里可以调用API更新任务状态
            break;
            
          case 'cancel':
            // 取消 -> 二次确认后状态变为已取消
            this.$modal.confirm('确定要取消此任务吗？').then(() => {
              this.updateTaskStatus(task.taskId, 'CANCELLED', '任务已取消')
            }).catch(() => {});
            break;
            
          case 'arrive':
            // 已到达操作
            this.$modal.confirm('已经到达目的地，确认？').then(() => {
              this.$modal.showToast('已到达');
              // 这里可以调用API更新任务状态
            // 已到达 -> 状态变为已到达
            this.$modal.confirm('确认已到达目的地？').then(() => {
              this.updateTaskStatus(task.taskId, 'ARRIVED', '已到达目的地')
            }).catch(() => {});
            break;
            
          case 'forceCancel':
            // 强制结束 -> 状态变为已取消
            this.$modal.confirm('确定要强制结束此任务吗？').then(() => {
              this.updateTaskStatus(task.taskId, 'CANCELLED', '任务已强制结束')
            }).catch(() => {});
            break;
            
          case 'return':
            // 返程操作
            this.$modal.confirm('现在已经返程中，确认？').then(() => {
              this.$modal.showToast('返程中');
              // 这里可以调用API更新任务状态
            // 已返程 -> 状态变为返程中
            this.$modal.confirm('确认开始返程？').then(() => {
              this.updateTaskStatus(task.taskId, 'RETURNING', '已开始返程')
            }).catch(() => {});
            break;
          case 'settle':
            // 结算操作，跳转到结算页面
            this.$tab.navigateTo(`/pages/task/settlement?id=${task.id}`);
            break;
            
          case 'complete':
            // 已完成操作
            this.$modal.confirm('任务是否已经全部完成，确认？').then(() => {
              task.status = 'completed';
              this.$modal.showToast('任务已完成');
              // 这里可以调用API更新任务状态
            // 已完成 -> 状态变为已完成
            this.$modal.confirm('确认任务已完成？').then(() => {
              this.updateTaskStatus(task.taskId, 'COMPLETED', '任务已完成')
            }).catch(() => {});
            break;
        }
      },
      
      // 更新任务状态
      updateTaskStatus(taskId, status, remark) {
        // 获取GPS位置信息
        this.getLocationAndUpdateStatus(taskId, status, remark)
      },
      
      // 获取位置信息并更新状态
      getLocationAndUpdateStatus(taskId, status, remark) {
        const that = this
        
        // 使用uni.getLocation获取GPS位置
        uni.getLocation({
          type: 'gcj02',
          geocode: true,
          altitude: true,
          success: function(res) {
            console.log('GPS定位成功:', res)
            
            const statusData = {
              taskStatus: status,
              remark: remark,
              latitude: res.latitude,
              longitude: res.longitude,
              locationAddress: res.address ? res.address.street || res.address.poiName || '' : '',
              locationProvince: res.address ? res.address.province || '' : '',
              locationCity: res.address ? res.address.city || '' : '',
              locationDistrict: res.address ? res.address.district || '' : '',
              gpsAccuracy: res.accuracy,
              altitude: res.altitude,
              speed: res.speed,
              heading: res.direction || res.heading
            }
            
            changeTaskStatus(taskId, statusData).then(response => {
              that.$modal.showToast('状态更新成功')
              // 刷新任务列表
              that.loadTaskList()
            }).catch(error => {
              console.error('更新任务状态失败:', error)
              that.$modal.showToast('状态更新失败，请重试')
            })
          },
          fail: function(err) {
            console.error('GPS定位失败:', err)
            
            that.$modal.confirm('GPS定位失败，是否继续更新状态？').then(() => {
              const statusData = {
                taskStatus: status,
                remark: remark
              }
              
              changeTaskStatus(taskId, statusData).then(response => {
                that.$modal.showToast('状态更新成功')
                // 刷新任务列表
                that.loadTaskList()
              }).catch(error => {
                console.error('更新任务状态失败:', error)
                that.$modal.showToast('状态更新失败，请重试')
              })
            }).catch(() => {})
          }
        })
      },
      
      getStatusText(status) {
        const statusMap = {
          'pending': '待处理',
          'processing': '处理中',
          'completed': '已完成'
          'PENDING': '待处理',
          'DEPARTING': '出发中',
          'ARRIVED': '已到达',
          'RETURNING': '返程中',
          'COMPLETED': '已完成',
          'CANCELLED': '已取消',
          'IN_PROGRESS': '处理中' // 兼容旧数据
        }
        return statusMap[status] || '未知'
      },
      
      // 获取状态样式类
      getStatusClass(status) {
        const statusClassMap = {
          'PENDING': 'status-pending',
          'DEPARTING': 'status-departing',
          'ARRIVED': 'status-arrived',
          'RETURNING': 'status-returning',
          'COMPLETED': 'status-completed',
          'CANCELLED': 'status-cancelled',
          'IN_PROGRESS': 'status-in-progress'
        }
        return statusClassMap[status] || 'status-default'
      },
      
      getTaskTypeText(type) {
        const typeMap = {
          'maintenance': '维修保养',
          'refuel': '加油',
          'inspection': '巡检',
          'emergency': '急救转运',
          'welfare': '福祉车'
          'MAINTENANCE': '维修保养',
          'FUEL': '加油',
          'OTHER': '其他',
          'EMERGENCY_TRANSFER': '转运任务',
          'WELFARE': '福祉车'
        }
        return typeMap[type] || '未知类型'
      }
@@ -524,6 +799,17 @@
    * {
      -ms-overflow-style: none; /* IE 10+ */
    }
  }
  
  // 总部推送标记样式
  .head-push-tag {
    color: #ff0000;
    font-size: 24rpx;
    font-weight: bold;
    margin-left: 10rpx;
    padding: 2rpx 8rpx;
    border: 1rpx solid #ff0000;
    border-radius: 4rpx;
  }
  
  // 任务列表区域
@@ -715,10 +1001,90 @@
        padding: 30rpx;
        border-bottom: 1rpx solid #f0f0f0;
        
        .task-title {
          font-size: 32rpx;
          font-weight: bold;
          margin-bottom: 20rpx;
        // 任务头部：标题和状态
        .task-header {
          display: flex;
          justify-content: space-between;
          align-items: flex-start;
          margin-bottom: 15rpx;
          
          .task-title {
            flex: 1;
            font-size: 32rpx;
            font-weight: bold;
            padding-right: 20rpx;
            line-height: 1.4;
          }
          
          .task-status {
            padding: 8rpx 20rpx;
            border-radius: 30rpx;
            font-size: 24rpx;
            white-space: nowrap;
            flex-shrink: 0;
            
            // 待处理 - 橙色
            &.status-pending {
              background-color: #fff3e0;
              color: #ff9500;
            }
            
            // 出发中 - 蓝色
            &.status-departing {
              background-color: #e3f2fd;
              color: #007AFF;
            }
            
            // 已到达 - 紫色
            &.status-arrived {
              background-color: #f3e5f5;
              color: #9c27b0;
            }
            
            // 返程中 - 青色
            &.status-returning {
              background-color: #e0f2f1;
              color: #009688;
            }
            
            // 已完成 - 绿色
            &.status-completed {
              background-color: #e8f5e9;
              color: #34C759;
            }
            
            // 已取消 - 灰色
            &.status-cancelled {
              background-color: #f5f5f5;
              color: #999;
            }
            
            // 处理中 (兼容旧数据) - 蓝色
            &.status-in-progress {
              background-color: #e3f2fd;
              color: #007AFF;
            }
            
            // 默认样式
            &.status-default {
              background-color: #f5f5f5;
              color: #666;
            }
          }
        }
        
        // 任务编号单独一行
        .task-code-row {
          margin-bottom: 15rpx;
          padding: 10rpx 0;
          border-bottom: 1rpx dashed #e0e0e0;
          
          .task-code {
            font-size: 28rpx;
            color: #333;
            font-weight: 500;
            font-family: monospace;
          }
        }
        
        .task-info {
@@ -769,6 +1135,11 @@
            color: white;
          }
          
          &.cancel {
            background-color: #ff3b30;
            color: white;
          }
          
          &.disabled {
            opacity: 0.5;
          }
@@ -794,5 +1165,18 @@
        margin-top: 20rpx;
      }
    }
    
    .load-more {
      display: flex;
      justify-content: center;
      align-items: center;
      padding: 20rpx 0;
      color: #999;
      font-size: 28rpx;
      
      &.no-more {
        color: #666;
      }
    }
  }
</style>