p95fco63j
/
Water_Machine_Management_System
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

修改工单相关代码 #65

Merged
hnu202326010106 merged 1 commits from wanglei_branch into develop 1 month ago
Conversation 0 Commits 1 Files Changed 5
5 changed files with 374 additions and 104 deletions
Show Stats Download Patch File Download Diff File

161
src/main/java/com/campus/water/controller/WorkOrderController.java
Unescape View File

@ -1,124 +1,109 @@
package com.campus.water.controller;
import com.campus.water.entity.WorkOrder;
import com.campus.water.mapper.WorkOrderRepository;
import com.campus.water.mapper.RepairmanRepository;
import com.campus.water.mapper.AlertRepository;
import com.campus.water.service.WorkOrderService;
import com.campus.water.util.ResultVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
@Controller
@RestController
@RequestMapping("/api/work-orders")
public class WorkOrderController {
@Autowired
private WorkOrderRepository workOrderRepository;
@Autowired
private RepairmanRepository repairmanRepository;
private final WorkOrderService workOrderService;
@Autowired
private AlertRepository alertRepository;
public WorkOrderController(WorkOrderService workOrderService) {
this.workOrderService = workOrderService;
}
// 抢单功能 - 维修人员和管理员可访问
@PostMapping("/grab")
@PreAuthorize("hasAnyRole('REPAIRMAN', 'ADMIN')")
@Transactional
public boolean grabOrder(String orderId, String repairmanId) {
Optional<WorkOrder> orderOpt = workOrderRepository.findById(orderId);
if (orderOpt.isPresent()) {
WorkOrder order = orderOpt.get();
if (order.getStatus() == WorkOrder.OrderStatus.pending) {
var repairman = repairmanRepository.findById(repairmanId);
if (repairman.isPresent() && repairman.get().getStatus() == repairman.get().getStatus().idle) {
order.setStatus(WorkOrder.OrderStatus.grabbed);
order.setAssignedRepairmanId(repairmanId);
order.setGrabbedTime(LocalDateTime.now());
workOrderRepository.save(order);
var repairmanEntity = repairman.get();
repairmanEntity.setStatus(repairmanEntity.getStatus().busy);
repairmanRepository.save(repairmanEntity);
return true;
}
}
public ResultVO<Boolean> grabOrder(
@RequestParam String orderId,
@RequestParam String repairmanId) {
try {
boolean result = workOrderService.grabOrder(orderId, repairmanId);
return result ? ResultVO.success(true, "抢单成功")
: ResultVO.error(400, "抢单失败，工单可能已被抢走或状态异常");
} catch (Exception e) {
return ResultVO.error(500, "抢单失败：" + e.getMessage());
}
return false;
}
// 拒单功能 - 维修人员和管理员可访问
@PostMapping("/reject")
@PreAuthorize("hasAnyRole('REPAIRMAN', 'ADMIN')")
@Transactional
public boolean rejectOrder(String orderId, String repairmanId, String reason) {
Optional<WorkOrder> orderOpt = workOrderRepository.findById(orderId);
if (orderOpt.isPresent()) {
WorkOrder order = orderOpt.get();
if (order.getAssignedRepairmanId() != null &&
order.getAssignedRepairmanId().equals(repairmanId) &&
order.getStatus() == WorkOrder.OrderStatus.grabbed) {
order.setStatus(WorkOrder.OrderStatus.pending);
order.setAssignedRepairmanId(null);
order.setGrabbedTime(null);
workOrderRepository.save(order);
var repairman = repairmanRepository.findById(repairmanId);
if (repairman.isPresent()) {
var repairmanEntity = repairman.get();
repairmanEntity.setStatus(repairmanEntity.getStatus().idle);
repairmanRepository.save(repairmanEntity);
}
return true;
}
public ResultVO<Boolean> rejectOrder(
@RequestParam String orderId,
@RequestParam String repairmanId,
@RequestParam String reason) {
try {
boolean result = workOrderService.rejectOrder(orderId, repairmanId, reason);
return result ? ResultVO.success(true, "拒单成功")
: ResultVO.error(400, "拒单失败，工单状态异常");
} catch (Exception e) {
return ResultVO.error(500, "拒单失败：" + e.getMessage());
}
return false;
}
// 提交维修结果 - 维修人员和管理员可访问
@PostMapping("/submit")
@PreAuthorize("hasAnyRole('REPAIRMAN', 'ADMIN')")
@Transactional
public boolean submitRepairResult(String orderId, String repairmanId,
String dealNote, String imgUrl) {
Optional<WorkOrder> orderOpt = workOrderRepository.findById(orderId);
if (orderOpt.isPresent()) {
WorkOrder order = orderOpt.get();
if (order.getAssignedRepairmanId() != null &&
order.getAssignedRepairmanId().equals(repairmanId) &&
(order.getStatus() == WorkOrder.OrderStatus.grabbed ||
order.getStatus() == WorkOrder.OrderStatus.processing)) {
order.setStatus(WorkOrder.OrderStatus.completed);
order.setCompletedTime(LocalDateTime.now());
order.setDealNote(dealNote);
order.setImgUrl(imgUrl);
workOrderRepository.save(order);
var repairman = repairmanRepository.findById(repairmanId);
if (repairman.isPresent()) {
var repairmanEntity = repairman.get();
repairmanEntity.setStatus(repairmanEntity.getStatus().idle);
repairmanEntity.setWorkCount(repairmanEntity.getWorkCount() + 1);
repairmanRepository.save(repairmanEntity);
}
return true;
}
public ResultVO<Boolean> submitRepairResult(
@RequestParam String orderId,
@RequestParam String repairmanId,
@RequestParam String dealNote,
@RequestParam(required = false) String imgUrl) {
try {
boolean result = workOrderService.submitRepairResult(orderId, repairmanId, dealNote, imgUrl);
return result ? ResultVO.success(true, "维修结果提交成功")
: ResultVO.error(400, "提交失败，工单状态异常");
} catch (Exception e) {
return ResultVO.error(500, "提交失败：" + e.getMessage());
}
return false;
}
// 获取可抢工单列表 - 维修人员和管理员可访问
@GetMapping("/available")
@PreAuthorize("hasAnyRole('REPAIRMAN', 'ADMIN')")
public List<WorkOrder> getAvailableOrders(String areaId) {
return workOrderRepository.findByAreaIdAndStatus(areaId, WorkOrder.OrderStatus.pending);
public ResultVO<List<WorkOrder>> getAvailableOrders(@RequestParam String areaId) {
try {
List<WorkOrder> orders = workOrderService.getAvailableOrders(areaId);
return ResultVO.success(orders);
} catch (Exception e) {
return ResultVO.error(500, "获取工单列表失败：" + e.getMessage());
}
}
// 获取维修工自己的工单 - 维修人员和管理员可访问
@GetMapping("/my")
@PreAuthorize("hasAnyRole('REPAIRMAN', 'ADMIN')")
public List<WorkOrder> getMyOrders(String repairmanId) {
return workOrderRepository.findByAssignedRepairmanId(repairmanId);
public ResultVO<List<WorkOrder>> getMyOrders(@RequestParam String repairmanId) {
try {
List<WorkOrder> orders = workOrderService.getMyOrders(repairmanId);
return ResultVO.success(orders);
} catch (Exception e) {
return ResultVO.error(500, "获取我的工单失败：" + e.getMessage());
}
}
// 管理员手动派单接口
@PostMapping("/assign")
@PreAuthorize("hasRole('ADMIN')")
public ResultVO<Boolean> assignOrderByAdmin(
@RequestParam String orderId,
@RequestParam String repairmanId) {
try {
boolean result = workOrderService.assignOrderByAdmin(orderId, repairmanId);
return result ? ResultVO.success(true, "派单成功")
: ResultVO.error(400, "派单失败，工单或维修人员状态异常");
} catch (Exception e) {
return ResultVO.error(500, "派单失败：" + e.getMessage());
}
}
}

48
src/main/java/com/campus/water/controller/app/RepairmanAppController.java
Unescape View File

@ -0,0 +1,48 @@
package com.campus.water.controller.app;
import com.campus.water.entity.WorkOrder;
import com.campus.water.service.app.RepairmanAppService;
import com.campus.water.util.ResultVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("/api/app/repairman") // 维修人员APP端接口前缀
public class RepairmanAppController {
@Autowired
private RepairmanAppService repairmanAppService;
// 获取可抢工单列表
@GetMapping("/available-orders")
public ResultVO<List<WorkOrder>> getAvailableOrders(@RequestParam String areaId) {
return repairmanAppService.getAvailableOrders(areaId);
}
// 抢单
@PostMapping("/grab-order")
public ResultVO<Boolean> grabOrder(@RequestBody Map<String, String> request) {
return repairmanAppService.grabOrder(request);
}
// 拒单
@PostMapping("/reject-order")
public ResultVO<Boolean> rejectOrder(@RequestBody Map<String, String> request) {
return repairmanAppService.rejectOrder(request);
}
// 提交维修结果
@PostMapping("/submit-result")
public ResultVO<Boolean> submitRepairResult(@RequestBody Map<String, String> request) {
return repairmanAppService.submitRepairResult(request);
}
// 获取我的工单
@GetMapping("/my-orders")
public ResultVO<List<WorkOrder>> getMyOrders(@RequestParam String repairmanId) {
return repairmanAppService.getMyOrders(repairmanId);
}
}

24
src/main/java/com/campus/water/service/WorkOrderService.java
Unescape View File

@ -0,0 +1,24 @@
package com.campus.water.service;
import com.campus.water.entity.WorkOrder;
import java.util.List;
public interface WorkOrderService {
// 抢单
boolean grabOrder(String orderId, String repairmanId);
// 拒单
boolean rejectOrder(String orderId, String repairmanId, String reason);
// 提交维修结果
boolean submitRepairResult(String orderId, String repairmanId, String dealNote, String imgUrl);
// 获取可抢工单
List<WorkOrder> getAvailableOrders(String areaId);
// 获取我的工单
List<WorkOrder> getMyOrders(String repairmanId);
// 管理员手动派单（新增方法）
boolean assignOrderByAdmin(String orderId, String repairmanId);
}

142
src/main/java/com/campus/water/service/WorkOrderServiceImpl.java
Unescape View File

@ -0,0 +1,142 @@
package com.campus.water.service;
import com.campus.water.entity.WorkOrder;
import com.campus.water.entity.Repairman;
import com.campus.water.mapper.WorkOrderRepository;
import com.campus.water.mapper.RepairmanRepository;
import com.campus.water.service.WorkOrderService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
@Service
@RequiredArgsConstructor
public class WorkOrderServiceImpl implements WorkOrderService {
private final WorkOrderRepository workOrderRepository;
private final RepairmanRepository repairmanRepository;
@Override
@Transactional
public boolean grabOrder(String orderId, String repairmanId) {
// 原抢单逻辑（从Controller迁移）
Optional<WorkOrder> orderOpt = workOrderRepository.findById(orderId);
if (orderOpt.isPresent()) {
WorkOrder order = orderOpt.get();
if (order.getStatus() == WorkOrder.OrderStatus.pending) {
var repairman = repairmanRepository.findById(repairmanId);
if (repairman.isPresent() && repairman.get().getStatus() == Repairman.RepairmanStatus.idle) {
order.setStatus(WorkOrder.OrderStatus.grabbed);
order.setAssignedRepairmanId(repairmanId);
order.setGrabbedTime(LocalDateTime.now());
workOrderRepository.save(order);
var repairmanEntity = repairman.get();
repairmanEntity.setStatus(Repairman.RepairmanStatus.busy);
repairmanRepository.save(repairmanEntity);
return true;
}
}
}
return false;
}
@Override
@Transactional
public boolean rejectOrder(String orderId, String repairmanId, String reason) {
// 原拒单逻辑（从Controller迁移）
Optional<WorkOrder> orderOpt = workOrderRepository.findById(orderId);
if (orderOpt.isPresent()) {
WorkOrder order = orderOpt.get();
if (order.getAssignedRepairmanId() != null &&
order.getAssignedRepairmanId().equals(repairmanId) &&
order.getStatus() == WorkOrder.OrderStatus.grabbed) {
order.setStatus(WorkOrder.OrderStatus.pending);
order.setAssignedRepairmanId(null);
order.setGrabbedTime(null);
workOrderRepository.save(order);
var repairman = repairmanRepository.findById(repairmanId);
repairman.ifPresent(rm -> {
rm.setStatus(Repairman.RepairmanStatus.idle);
repairmanRepository.save(rm);
});
return true;
}
}
return false;
}
@Override
@Transactional
public boolean submitRepairResult(String orderId, String repairmanId, String dealNote, String imgUrl) {
// 原提交维修结果逻辑（从Controller迁移）
Optional<WorkOrder> orderOpt = workOrderRepository.findById(orderId);
if (orderOpt.isPresent()) {
WorkOrder order = orderOpt.get();
if (order.getAssignedRepairmanId() != null &&
order.getAssignedRepairmanId().equals(repairmanId) &&
(order.getStatus() == WorkOrder.OrderStatus.grabbed ||
order.getStatus() == WorkOrder.OrderStatus.processing)) {
order.setStatus(WorkOrder.OrderStatus.completed);
order.setCompletedTime(LocalDateTime.now());
order.setDealNote(dealNote);
order.setImgUrl(imgUrl);
workOrderRepository.save(order);
repairmanRepository.findById(repairmanId).ifPresent(rm -> {
rm.setStatus(Repairman.RepairmanStatus.idle);
rm.setWorkCount(rm.getWorkCount() + 1);
repairmanRepository.save(rm);
});
return true;
}
}
return false;
}
@Override
public List<WorkOrder> getAvailableOrders(String areaId) {
return workOrderRepository.findByAreaIdAndStatus(areaId, WorkOrder.OrderStatus.pending);
}
@Override
public List<WorkOrder> getMyOrders(String repairmanId) {
return workOrderRepository.findByAssignedRepairmanId(repairmanId);
}
@Override
@Transactional
public boolean assignOrderByAdmin(String orderId, String repairmanId) {
// 管理员手动派单逻辑（新增实现）
Optional<WorkOrder> orderOpt = workOrderRepository.findById(orderId);
if (orderOpt.isPresent()) {
WorkOrder order = orderOpt.get();
// 校验工单状态（只能分配待处理或超时工单）
if (order.getStatus() == WorkOrder.OrderStatus.pending ||
order.getStatus() == WorkOrder.OrderStatus.timeout) {
Optional<Repairman> repairmanOpt = repairmanRepository.findById(repairmanId);
if (repairmanOpt.isPresent() && repairmanOpt.get().getStatus() == Repairman.RepairmanStatus.idle) {
// 更新工单状态
order.setStatus(WorkOrder.OrderStatus.grabbed);
order.setAssignedRepairmanId(repairmanId);
order.setGrabbedTime(LocalDateTime.now());
workOrderRepository.save(order);
// 更新维修人员状态
Repairman repairman = repairmanOpt.get();
repairman.setStatus(Repairman.RepairmanStatus.busy);
repairmanRepository.save(repairman);
return true;
}
}
}
return false;
}
}

103
src/main/java/com/campus/water/service/app/RepairmanAppService.java
Unescape View File

@ -1,86 +1,157 @@
package com.campus.water.service.app;
import com.campus.water.entity.WorkOrder;
import com.campus.water.controller.WorkOrderController;
import com.campus.water.service.WorkOrderService;
import com.campus.water.util.ResultVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
/**
* 维修人员APP端服务层
* 处理维修人员APP端的工单相关业务逻辑
*/
@Service
public class RepairmanAppService {
// 核心修改：注入WorkOrderService而非WorkOrderController
@Autowired
private WorkOrderController workOrderController;
private WorkOrderService workOrderService;
// 获取可抢工单列表
/**
* 获取可抢工单列表
* @param areaId 区域ID
* @return 可抢工单列表
*/
@PreAuthorize("hasAnyRole('REPAIRMAN', 'ADMIN')")
public ResultVO<List<WorkOrder>> getAvailableOrders(String areaId) {
try {
List<WorkOrder> orders = workOrderController.getAvailableOrders(areaId);
// 参数校验
if (areaId == null || areaId.trim().isEmpty()) {
return ResultVO.error(400, "区域ID不能为空");
}
List<WorkOrder> orders = workOrderService.getAvailableOrders(areaId);
return ResultVO.success(orders);
} catch (Exception e) {
return ResultVO.error(500, "获取工单列表失败: " + e.getMessage());
}
}
// 抢单
/**
* 抢单功能
* @param request 包含orderId和repairmanId的请求参数
* @return 抢单结果
*/
@PreAuthorize("hasAnyRole('REPAIRMAN', 'ADMIN')")
public ResultVO<Boolean> grabOrder(Map<String, String> request) {
try {
// 参数校验
String orderId = request.get("orderId");
String repairmanId = request.get("repairmanId");
boolean result = workOrderController.grabOrder(orderId, repairmanId);
if (orderId == null || orderId.trim().isEmpty()) {
return ResultVO.error(400, "工单ID不能为空");
}
if (repairmanId == null || repairmanId.trim().isEmpty()) {
return ResultVO.error(400, "维修人员ID不能为空");
}
boolean result = workOrderService.grabOrder(orderId, repairmanId);
if (result) {
return ResultVO.success(true, "抢单成功");
} else {
return ResultVO.error(400, "抢单失败，工单可能已被其他人抢走");
return ResultVO.error(400, "抢单失败，工单可能已被其他人抢走或状态异常");
}
} catch (Exception e) {
return ResultVO.error(500, "抢单失败: " + e.getMessage());
}
}
// 拒单
/**
* 拒单功能
* @param request 包含orderId、repairmanId、reason的请求参数
* @return 拒单结果
*/
@PreAuthorize("hasAnyRole('REPAIRMAN', 'ADMIN')")
public ResultVO<Boolean> rejectOrder(Map<String, String> request) {
try {
// 参数校验
String orderId = request.get("orderId");
String repairmanId = request.get("repairmanId");
String reason = request.get("reason");
boolean result = workOrderController.rejectOrder(orderId, repairmanId, reason);
if (orderId == null || orderId.trim().isEmpty()) {
return ResultVO.error(400, "工单ID不能为空");
}
if (repairmanId == null || repairmanId.trim().isEmpty()) {
return ResultVO.error(400, "维修人员ID不能为空");
}
if (reason == null || reason.trim().isEmpty()) {
return ResultVO.error(400, "拒单原因不能为空");
}
boolean result = workOrderService.rejectOrder(orderId, repairmanId, reason);
if (result) {
return ResultVO.success(true, "拒单成功");
} else {
return ResultVO.error(400, "拒单失败");
return ResultVO.error(400, "拒单失败，工单状态异常或无操作权限");
}
} catch (Exception e) {
return ResultVO.error(500, "拒单失败: " + e.getMessage());
}
}
// 提交维修结果
/**
* 提交维修结果
* @param request 包含orderId、repairmanId、dealNote、imgUrl的请求参数
* @return 提交结果
*/
@PreAuthorize("hasAnyRole('REPAIRMAN', 'ADMIN')")
public ResultVO<Boolean> submitRepairResult(Map<String, String> request) {
try {
// 参数校验
String orderId = request.get("orderId");
String repairmanId = request.get("repairmanId");
String dealNote = request.get("dealNote");
String imgUrl = request.get("imgUrl");
String imgUrl = request.get("imgUrl"); // 图片URL可选
boolean result = workOrderController.submitRepairResult(orderId, repairmanId, dealNote, imgUrl);
if (orderId == null || orderId.trim().isEmpty()) {
return ResultVO.error(400, "工单ID不能为空");
}
if (repairmanId == null || repairmanId.trim().isEmpty()) {
return ResultVO.error(400, "维修人员ID不能为空");
}
if (dealNote == null || dealNote.trim().isEmpty()) {
return ResultVO.error(400, "维修处理备注不能为空");
}
boolean result = workOrderService.submitRepairResult(orderId, repairmanId, dealNote, imgUrl);
if (result) {
return ResultVO.success(true, "维修结果提交成功");
} else {
return ResultVO.error(400, "维修结果提交失败");
return ResultVO.error(400, "维修结果提交失败，工单状态异常或无操作权限");
}
} catch (Exception e) {
return ResultVO.error(500, "提交失败: " + e.getMessage());
}
}
// 获取我的工单
/**
* 获取我的工单
* @param repairmanId 维修人员ID
* @return 维修人员名下的工单列表
*/
@PreAuthorize("hasAnyRole('REPAIRMAN', 'ADMIN')")
public ResultVO<List<WorkOrder>> getMyOrders(String repairmanId) {
try {
List<WorkOrder> orders = workOrderController.getMyOrders(repairmanId);
// 参数校验
if (repairmanId == null || repairmanId.trim().isEmpty()) {
return ResultVO.error(400, "维修人员ID不能为空");
}
List<WorkOrder> orders = workOrderService.getMyOrders(repairmanId);
return ResultVO.success(orders);
} catch (Exception e) {
return ResultVO.error(500, "获取工单失败: " + e.getMessage());

Write Preview
Loading…
Cancel
Save