renfan
/
charging_pile
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

【admin&front】新增&优化# 1、优化小程序维修单步骤，新增重领配件 2、优化配件领用

dev1.0
renfan 2024-09-11 21:27:42 +08:00
parent bd92831ec0
commit 2e626f7ae8
28 changed files with 1019 additions and 471 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
admin/src/main/java/com/hcy/admin/controller/sparePartStockAudit/SparePartStockAuditController.java
View File

@ -182,4 +182,18 @@ public class SparePartStockAuditController {
iSparePartStockAuditService.receiving(sparePartStockAuditParam);
return AjaxResult.success();
}
/**
* 备件领用仓管员上传图片
*
* @author hcy
* @param sparePartStockAuditParam 参数
* @return Object
*/
@Log(title = "仓管员上传图片")
@PostMapping("/warehouseKeeperImg")
public Object warehouseKeeperImg(@RequestBody SparePartStockAuditParam sparePartStockAuditParam) {
iSparePartStockAuditService.warehouseKeeperImg(sparePartStockAuditParam);
return AjaxResult.success();
}
}

20
admin/src/main/java/com/hcy/admin/service/largeDataScreen/impl/LargeDataScreenServiceImpl.java
View File

@ -21,6 +21,7 @@ import com.hcy.common.enums.order.MaintenanceOrderStatusEnum;
import com.hcy.common.enums.order.OrderStateEnum;
import com.hcy.common.enums.equipment.EquipmentStateEnum;
import com.hcy.common.enums.order.RepairOrderStatusEnum;
import com.hcy.common.mapper.client.ClientMapper;
import com.hcy.common.mapper.client.EquipmentMapper;
import com.hcy.common.mapper.order.MaintenanceOrderMapper;
@ -396,39 +397,42 @@ public class LargeDataScreenServiceImpl implements ILargeDataScreenService {
endTime = now.withHour(23).withMinute(59).withSecond(59);
}
//获取巡检订单总数
//获取维修订单总数
Integer routingInspectionOrderCount = repairOrderMapper.selectCount(
new QueryWrapper<RepairOrder>()
.eq("is_delete", GlobalConstant.NOT_DELETE)
.ge("create_time", Timestamp.valueOf(startTime)) // 开始时间
.le("create_time", Timestamp.valueOf(endTime))); // 结束时间
//orderStatus; // 订单状态 0-待抢单；1-待接单；2-接单超时；3-检测中；4-待客户确认；5-维修中；6-已完成；7-已退单；8-已关闭
//orderStatus; // 订单状态 0-待接单；1-待维修；2-排查中；3-待确认；4-维修中；5-测试中；6-已完成；
//获取已完成订单总数
Integer doneOrderCount = repairOrderMapper.selectCount(
new QueryWrapper<RepairOrder>()
.eq("is_delete", GlobalConstant.NOT_DELETE)
.eq("order_status", MaintenanceOrderStatusEnum.FINISHED.getStatus())
.eq("order_status", RepairOrderStatusEnum.FINISHED.getStatus())
.ge("create_time", Timestamp.valueOf(startTime)) // 开始时间
.le("create_time", Timestamp.valueOf(endTime))); // 结束时间
//获取检修中订单总数
//获取维修中订单总数
Integer underOverhaulOrderCount = repairOrderMapper.selectCount(
new QueryWrapper<RepairOrder>()
.eq("is_delete", GlobalConstant.NOT_DELETE)
.eq("order_status", MaintenanceOrderStatusEnum.MAINTENANCE_ING.getStatus())
.ne("order_status", RepairOrderStatusEnum.IN_MAINTENANCE.getStatus())
.ne("order_status", RepairOrderStatusEnum.TEST_IN_PROCESS.getStatus())
.ge("create_time", Timestamp.valueOf(startTime)) // 开始时间
.le("create_time", Timestamp.valueOf(endTime))); // 结束时间
//获取报修中订单总数
Integer underWarrantyOrderCount = repairOrderMapper.selectCount(
new QueryWrapper<RepairOrder>()
.eq("is_delete", GlobalConstant.NOT_DELETE)
.ne("order_status", MaintenanceOrderStatusEnum.FINISHED.getStatus())
.ne("order_status", MaintenanceOrderStatusEnum.MAINTENANCE_ING.getStatus())
.ne("order_status", RepairOrderStatusEnum.PENDING_ORDER.getStatus())
.ne("order_status", RepairOrderStatusEnum.AWAITING_REPAIR.getStatus())
.ne("order_status", RepairOrderStatusEnum.UNDER_INVESTIGATION.getStatus())
.ne("order_status", RepairOrderStatusEnum.TO_BE_CONFIRMED.getStatus())
.ge("create_time", Timestamp.valueOf(startTime)) // 开始时间
.le("create_time", Timestamp.valueOf(endTime))); // 结束时间
LargeDataVo vo = new LargeDataVo();
vo.setOrderSum(routingInspectionOrderCount); //工单总数
vo.setDoneOrderSum(doneOrderCount); //已完成订单数
vo.setUnderOverhaulOrderSum(underOverhaulOrderCount); //检修中订单数
vo.setUnderOverhaulOrderSum(underOverhaulOrderCount); //维修中订单数
vo.setUnderWarrantyOrderSum(underWarrantyOrderCount); //报修中订单数
return vo;
}

6
admin/src/main/java/com/hcy/admin/service/sparePartStockAudit/ISparePartStockAuditService.java
View File

@ -96,4 +96,10 @@ public interface ISparePartStockAuditService {
* 备件采购收货
*/
void receiving(SparePartStockAuditParam sparePartStockAuditParam);
/**
* 仓管员上传图片
* @param sparePartStockAuditParam
*/
void warehouseKeeperImg(SparePartStockAuditParam sparePartStockAuditParam);
}

240
admin/src/main/java/com/hcy/admin/service/sparePartStockAudit/impl/SparePartStockAuditServiceImpl.java
View File

@ -31,6 +31,7 @@ import com.hcy.common.enums.SparePartStockAuditEnum;
import com.hcy.common.enums.audit.AuditStateEnum;
import com.hcy.common.enums.order.MaintenanceOrderStatusEnum;
import com.hcy.common.enums.order.OrderOperateRecordEnum;
import com.hcy.common.enums.order.RepairOrderStopEnum;
import com.hcy.common.exception.OperateException;
import com.hcy.common.mapper.SparePartAudit.SparePartAuditMapper;
import com.hcy.common.mapper.client.ClientContactsMapper;
@ -118,6 +119,7 @@ public class SparePartStockAuditServiceImpl implements ISparePartStockAuditServi
.eq(params.getWarehouseId() != null, SparePartStockAudit::getWarehouseId, params.getWarehouseId())
.eq(params.getDeliveryMethod() != null, SparePartStockAudit::getDeliveryMethod, params.getDeliveryMethod())
.eq(params.getPurchaseStatus() != null, SparePartStockAudit::getPurchaseStatus, params.getPurchaseStatus())
.eq(params.getReceiveStatus() != null, SparePartStockAudit::getReceiveStatus, params.getReceiveStatus())
.ge(StringUtils.isNotEmpty(params.getCreateTimeStart()), SparePartStockAudit::getCreateTime, params.getCreateTimeStart())
.le(StringUtils.isNotEmpty(params.getCreateTimeEnd()), SparePartStockAudit::getCreateTime, params.getCreateTimeEnd())
.orderByDesc(SparePartStockAudit::getCreateTime);
@ -190,7 +192,7 @@ public class SparePartStockAuditServiceImpl implements ISparePartStockAuditServi
}
}
int number = 0; //领用数量
Integer number = 0; //领用数量
if (item.getOrderType() != null && item.getOrderType() == SparePartStockAuditEnum.MAINTENANCE_ORDER.getStatus()) {
MaintenanceOrder maintenanceOrder = maintenanceOrderMapper.findMaintenanceOrderById(item.getOrderId());
@ -353,7 +355,7 @@ public class SparePartStockAuditServiceImpl implements ISparePartStockAuditServi
vo.setRecipient(user.getUsername());
vo.setRecipientPhone(user.getMobile());
} else if (model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.REPAIR_ORDER.getStatus()) {
RepairOrder repairOrder = maintenanceOrderMapper.findRepairOrderById(model.getOrderId());
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(model.getOrderId());
User user = userMapper.selectById(repairOrder.getReceiverId());
List<OrderSparePartListVo> orderSparePartListVoList = new ArrayList<>();
@ -556,6 +558,9 @@ public class SparePartStockAuditServiceImpl implements ISparePartStockAuditServi
if (model.getPurchaseStatus() != null && sparePartStockAuditParam.getAuditResult() == AuditStateEnum.NOT_PASS.getStatus()) {
model.setPurchaseStatus(AuditStateEnum.NOT_PASS_STATE.getStatus()); //审核未通过
}
if(model.getReceiveStatus() != null && sparePartStockAuditParam.getAuditResult() == AuditStateEnum.NOT_PASS.getStatus()){
model.setReceiveStatus(AuditStateEnum.NOT_PASS_STATE.getStatus()); //审核未通过
}
model.setAuditState(AuditStateEnum.AUDITED.getStatus()); // 审核状态（0=未审核，1=已审核，2=已取消）
model.setAuditTime(new Date()); // 审核时间
model.setAuditIdea(sparePartStockAuditParam.getAuditIdea()); // 审核意见
@ -603,6 +608,9 @@ public class SparePartStockAuditServiceImpl implements ISparePartStockAuditServi
if (model.getPurchaseStatus() != null && model.getPurchaseStatus() == AuditStateEnum.CHECK_PENDING.getStatus()) {
model.setPurchaseStatus(AuditStateEnum.WAITDELIVER.getStatus()); //审核通过改成待发货
}
if(model.getReceiveStatus() != null && model.getReceiveStatus() == AuditStateEnum.UNREVIEWED.getStatus()){
model.setReceiveStatus(AuditStateEnum.UNCLAIMED.getStatus());//审核通过改成待领取
}
if(model.getOrderId() != null && model.getOrderType() == SparePartStockAuditEnum.MAINTENANCE_ORDER.getStatus()){
//新增检修单操作记录
orderOperateRecordService.addMaintenanceOrder(model.getOrderId()
@ -732,6 +740,10 @@ public class SparePartStockAuditServiceImpl implements ISparePartStockAuditServi
sparePartStockAuditMapper.updateById(model);
}
/**
* 配件采购审核
* @param sparePartStockAuditParam
*/
@Override
@Transactional
public void purchaseAudit(SparePartStockAuditParam sparePartStockAuditParam) {
@ -745,87 +757,164 @@ public class SparePartStockAuditServiceImpl implements ISparePartStockAuditServi
// 配件领用状态 1=未通过，2=待管理员审核
model.setPurchaseStatus(sparePartStockAuditParam.getPurchaseStatus());
model.setReceiveStatus(sparePartStockAuditParam.getReceiveStatus());
model.setPurchaseIdea(sparePartStockAuditParam.getPurchaseIdea()); // 采购意见
//仓管员检修单审核不通过
if(model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.MAINTENANCE_ORDER.getStatus() &&
sparePartStockAuditParam.getPurchaseStatus() == AuditStateEnum.NOT_PASS_STATE.getStatus()){
MaintenanceOrder maintenanceOrder = maintenanceOrderMapper.findMaintenanceOrderById(model.getOrderId());
if(maintenanceOrder != null){
maintenanceOrder.setOrderStatus(MaintenanceOrderStatusEnum.RETURNED.getStatus());
maintenanceOrder.setReturnCause(sparePartStockAuditParam.getPurchaseIdea());
maintenanceOrderMapper.updateById(maintenanceOrder);
//配件采购
if(sparePartStockAuditParam.getPurchaseStatus() != null){
//仓管员检修单审核不通过
if(model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.MAINTENANCE_ORDER.getStatus()
&& sparePartStockAuditParam.getPurchaseStatus() == AuditStateEnum.NOT_PASS_STATE.getStatus()){
MaintenanceOrder maintenanceOrder = maintenanceOrderMapper.findMaintenanceOrderById(model.getOrderId());
if(maintenanceOrder != null){
maintenanceOrder.setOrderStatus(MaintenanceOrderStatusEnum.RETURNED.getStatus());
maintenanceOrder.setReturnCause(sparePartStockAuditParam.getPurchaseIdea());
maintenanceOrderMapper.updateById(maintenanceOrder);
User user = userMapper.selectById(maintenanceOrder.getReceiverId());
if(user != null){
//新增检修单操作记录
orderOperateRecordService.addMaintenanceOrder(model.getOrderId()
, OrderOperateRecordEnum.SPARE_PARTS_AUDIT_ONE.getDesc()
,OrderOperateRecordEnum.AUDIT.getStatus()
,"仓管员【"+AdminThreadLocal.get("username")+"】完成审核，审核结果：不通过，审核意见："+sparePartStockAuditParam.getPurchaseIdea()+"。系统会自动退回到检修员【"+user.getUsername()+"】重新报价。");
User user = userMapper.selectById(maintenanceOrder.getReceiverId());
if(user != null){
//新增检修单操作记录
orderOperateRecordService.addMaintenanceOrder(model.getOrderId()
, OrderOperateRecordEnum.SPARE_PARTS_AUDIT_ONE.getDesc()
,OrderOperateRecordEnum.AUDIT.getStatus()
,"仓管员【"+AdminThreadLocal.get("username")+"】完成审核，审核结果：不通过，审核意见："+sparePartStockAuditParam.getPurchaseIdea()+"。系统会自动退回到检修员【"+user.getUsername()+"】重新报价。");
}
}
}
} else if (model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.REPAIR_ORDER.getStatus() &&
sparePartStockAuditParam.getPurchaseStatus() == AuditStateEnum.NOT_PASS_STATE.getStatus()) {
//仓管员维修单审核不通过
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(model.getOrderId());
if(repairOrder != null){
repairOrder.setOrderStatus(MaintenanceOrderStatusEnum.RETURNED.getStatus());
repairOrder.setReturnCause(sparePartStockAuditParam.getPurchaseIdea());
repairOrderMapper.updateById(repairOrder);
} else if (model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.REPAIR_ORDER.getStatus()
&& sparePartStockAuditParam.getPurchaseStatus() == AuditStateEnum.NOT_PASS_STATE.getStatus()) {
//仓管员维修单审核不通过
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(model.getOrderId());
if(repairOrder != null){
repairOrder.setReturnCause(sparePartStockAuditParam.getPurchaseIdea());
repairOrderMapper.updateById(repairOrder);
User user = userMapper.selectById(repairOrder.getReceiverId());
/*User user = userMapper.selectById(repairOrder.getReceiverId());
if(user != null){
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(model.getOrderId()
, OrderOperateRecordEnum.SPARE_PARTS_AUDIT_ONE.getDesc()
,OrderOperateRecordEnum.AUDIT.getStatus()
,"仓管员【"+AdminThreadLocal.get("username")+"】完成审核，审核结果：不通过，审核意见："+sparePartStockAuditParam.getPurchaseIdea()+"。系统会自动退回到检修员【"+user.getUsername()+"】重新报价。");
}*/
}
}
}
// 出库时需要判断库存数量是否大于出库数量，大于才允许出库；反之，提示备件库存数量不足
//获取待审核备件信息
List<SparePartAudit> stockAuditId = sparePartAuditMapper.selectList(
new QueryWrapper<SparePartAudit>()
.eq("stock_audit_id", model.getId())
.eq("is_delete", 0)
);
if (model.getReceiptType() == AuditStateEnum.OUT_WAREHOUSE.getStatus()
&& model.getPurchaseStatus() == AuditStateEnum.CHECK_PENDING.getStatus()) {
// 通过审核的出库单
//获取备件信息
for (SparePartAudit sparePartAudit : stockAuditId) {
SparePart sparePart = sparePartMapper.selectOne(
new QueryWrapper<SparePart>()
.eq("id", sparePartAudit.getSparePartsId())
.eq("is_delete", 0)
.last("limit 1"));
// 出库时需要判断库存数量是否大于出库数量，大于才允许出库；反之，提示备件库存数量不足
if (sparePart.getQuantity() >= sparePartAudit.getCount()) {
model.setAuditState(AuditStateEnum.UNREVIEWED.getStatus());
} else {
throw new OperateException("备件库存数量不足，请联系客服人员！");
// 出库时需要判断库存数量是否大于出库数量，大于才允许出库；反之，提示备件库存数量不足
//获取待审核备件信息
List<SparePartAudit> stockAuditId = sparePartAuditMapper.selectList(
new QueryWrapper<SparePartAudit>()
.eq("stock_audit_id", model.getId())
.eq("is_delete", 0)
);
if (model.getReceiptType() == AuditStateEnum.OUT_WAREHOUSE.getStatus()
&& model.getPurchaseStatus() == AuditStateEnum.CHECK_PENDING.getStatus()) {
// 通过审核的出库单
//获取备件信息
for (SparePartAudit sparePartAudit : stockAuditId) {
SparePart sparePart = sparePartMapper.selectOne(
new QueryWrapper<SparePart>()
.eq("id", sparePartAudit.getSparePartsId())
.eq("is_delete", 0)
.last("limit 1"));
// 出库时需要判断库存数量是否大于出库数量，大于才允许出库；反之，提示备件库存数量不足
if (sparePart.getQuantity() >= sparePartAudit.getCount()) {
model.setAuditState(AuditStateEnum.UNREVIEWED.getStatus());
sparePart.setQuantity(sparePart.getQuantity() - sparePartAudit.getCount());
} else {
throw new OperateException("备件库存数量不足，请联系客服人员！");
}
sparePartMapper.updateById(sparePart);
}
sparePartMapper.updateById(sparePart);
}
if(model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.MAINTENANCE_ORDER.getStatus()){
//新增检修单操作记录
orderOperateRecordService.addMaintenanceOrder(model.getOrderId()
, OrderOperateRecordEnum.SPARE_PARTS_AUDIT_ONE.getDesc()
,OrderOperateRecordEnum.AUDIT.getStatus()
,"仓管员【"+AdminThreadLocal.get("username")+"】已经完成审核，审核通过；等待管理员审核。");
} else if (model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.REPAIR_ORDER.getStatus()) {
if(model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.MAINTENANCE_ORDER.getStatus()){
//新增检修单操作记录
orderOperateRecordService.addMaintenanceOrder(model.getOrderId()
, OrderOperateRecordEnum.SPARE_PARTS_AUDIT_ONE.getDesc()
,OrderOperateRecordEnum.AUDIT.getStatus()
,"仓管员【"+AdminThreadLocal.get("username")+"】已经完成审核，审核通过；等待管理员审核。");
} /*else if (model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.REPAIR_ORDER.getStatus()) {
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(model.getOrderId()
, OrderOperateRecordEnum.SPARE_PARTS_AUDIT_ONE.getDesc()
,OrderOperateRecordEnum.AUDIT.getStatus()
,"仓管员【"+AdminThreadLocal.get("username")+"】已经完成审核，审核通过；等待管理员审核");
}*/
}
} else if (sparePartStockAuditParam.getReceiveStatus() != null) {
//配件领用
//仓管员检修单审核不通过
if(model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.MAINTENANCE_ORDER.getStatus()
&& sparePartStockAuditParam.getReceiveStatus() == AuditStateEnum.NOT_PASS_STATE.getStatus()){
MaintenanceOrder maintenanceOrder = maintenanceOrderMapper.findMaintenanceOrderById(model.getOrderId());
if(maintenanceOrder != null){
maintenanceOrder.setOrderStatus(MaintenanceOrderStatusEnum.RETURNED.getStatus());
maintenanceOrder.setReturnCause(sparePartStockAuditParam.getPurchaseIdea());
maintenanceOrderMapper.updateById(maintenanceOrder);
User user = userMapper.selectById(maintenanceOrder.getReceiverId());
if(user != null){
//新增检修单操作记录
orderOperateRecordService.addMaintenanceOrder(model.getOrderId()
, OrderOperateRecordEnum.SPARE_PARTS_AUDIT_ONE.getDesc()
,OrderOperateRecordEnum.AUDIT.getStatus()
,"仓管员【"+AdminThreadLocal.get("username")+"】完成审核，审核结果：不通过，审核意见："+sparePartStockAuditParam.getPurchaseIdea()+"。系统会自动退回到检修员【"+user.getUsername()+"】重新报价。");
}
}
} else if (model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.REPAIR_ORDER.getStatus()
&& sparePartStockAuditParam.getReceiveStatus() == AuditStateEnum.NOT_PASS_STATE.getStatus()) {
//仓管员维修单审核不通过
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(model.getOrderId());
if(repairOrder != null){
repairOrder.setReturnCause(sparePartStockAuditParam.getPurchaseIdea());
repairOrder.setRepairNextStep(RepairOrderStopEnum.RECOLLAR_FITTING.getStatus());//维修单审核不通过步骤为重领配件
repairOrderMapper.updateById(repairOrder);
}
}
// 出库时需要判断库存数量是否大于出库数量，大于才允许出库；反之，提示备件库存数量不足
//获取待审核备件信息
List<SparePartAudit> stockAuditId = sparePartAuditMapper.selectList(
new QueryWrapper<SparePartAudit>()
.eq("stock_audit_id", model.getId())
.eq("is_delete", 0)
);
if (model.getReceiptType() == AuditStateEnum.OUT_WAREHOUSE.getStatus()
&& model.getReceiveStatus() == AuditStateEnum.UNREVIEWED.getStatus()) {
// 通过审核的出库单
//获取备件信息
for (SparePartAudit sparePartAudit : stockAuditId) {
SparePart sparePart = sparePartMapper.selectOne(
new QueryWrapper<SparePart>()
.eq("id", sparePartAudit.getSparePartsId())
.eq("is_delete", 0)
.last("limit 1"));
// 出库时需要判断库存数量是否大于出库数量，大于才允许出库；反之，提示备件库存数量不足
if (sparePart.getQuantity() >= sparePartAudit.getCount()) {
model.setAuditState(AuditStateEnum.UNREVIEWED.getStatus());
sparePart.setQuantity(sparePart.getQuantity() - sparePartAudit.getCount());
} else {
throw new OperateException("备件库存数量不足，请联系客服人员！");
}
sparePartMapper.updateById(sparePart);
}
if(model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.MAINTENANCE_ORDER.getStatus()){
//新增检修单操作记录
orderOperateRecordService.addMaintenanceOrder(model.getOrderId()
, OrderOperateRecordEnum.SPARE_PARTS_AUDIT_ONE.getDesc()
,OrderOperateRecordEnum.AUDIT.getStatus()
,"仓管员【"+AdminThreadLocal.get("username")+"】已经完成审核，审核通过；等待管理员审核。");
} /*else if (model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.REPAIR_ORDER.getStatus()) {
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(model.getOrderId()
, OrderOperateRecordEnum.SPARE_PARTS_AUDIT_ONE.getDesc()
,OrderOperateRecordEnum.AUDIT.getStatus()
,"仓管员【"+AdminThreadLocal.get("username")+"】已经完成审核，审核通过；等待管理员审核");
}*/
}
}
sparePartStockAuditMapper.updateById(model);
}
@ -909,6 +998,7 @@ public class SparePartStockAuditServiceImpl implements ISparePartStockAuditServi
Assert.notNull(model, "数据不存在!");
model.setPurchaseStatus(sparePartStockAuditParam.getPurchaseStatus()); // 配件领用状态 1=未通过，2=待管理员审核
model.setReceiveStatus(sparePartStockAuditParam.getReceiveStatus()); // 配件领用状态（0=未审核，1=审核未通过，2=待领取，3=待确认，4=已完成）
model.setPurchaseIdea(sparePartStockAuditParam.getPurchaseIdea()); // 采购意见
// 出库时需要判断库存数量是否大于出库数量，大于才允许出库；反之，提示备件库存数量不足
@ -919,9 +1009,11 @@ public class SparePartStockAuditServiceImpl implements ISparePartStockAuditServi
.eq("is_delete", 0)
);
/*if (model.getReceiptType() == AuditStateEnum.OUT_WAREHOUSE.getStatus()
&& model.getPurchaseStatus() == AuditStateEnum.CHECK_PENDING.getStatus()) {*/
if (model.getReceiptType() == AuditStateEnum.OUT_WAREHOUSE.getStatus()
&& model.getPurchaseStatus() == AuditStateEnum.CHECK_PENDING.getStatus()) {
&& model.getReceiveStatus() == AuditStateEnum.UNREVIEWED.getStatus()) {
// 通过审核的出库单
//获取备件信息
for (SparePartAudit sparePartAudit : stockAuditId) {
@ -1003,4 +1095,32 @@ public class SparePartStockAuditServiceImpl implements ISparePartStockAuditServi
sparePartStockAuditMapper.updateById(model);
}
/**
* 仓管员上传图片
*
* @param sparePartStockAuditParam
*/
@Override
public void warehouseKeeperImg(SparePartStockAuditParam sparePartStockAuditParam) {
SparePartStockAudit model = sparePartStockAuditMapper.selectOne(
new LambdaQueryWrapper<SparePartStockAudit>()
.eq(SparePartStockAudit::getIsDelete, GlobalConstant.NOT_DELETE)
.eq(SparePartStockAudit::getId, sparePartStockAuditParam.getId()));
Assert.notNull(model, "数据不存在!");
model.setWarehouseKeeperImg(sparePartStockAuditParam.getWarehouseKeeperImg()); // 仓管员上传图片
model.setReceiveStatus(AuditStateEnum.TO_BE_CONFIRMED.getStatus()); // 配件领用状态 3=待确认
sparePartStockAuditMapper.updateById(model);
if(model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.MAINTENANCE_ORDER.getStatus()){
} else if (model.getOrderType() != null && model.getOrderType() == SparePartStockAuditEnum.REPAIR_ORDER.getStatus()) {
RepairOrder repairOrder = repairOrderMapper.selectOne(new LambdaQueryWrapper<RepairOrder>()
.eq(RepairOrder::getId, model.getOrderId()));
repairOrder.setOrderStatus(AuditStateEnum.TO_BE_CONFIRMED.getStatus());// 维修工单状态 3=待确认
repairOrderMapper.updateById(repairOrder);
}
}
}

4
admin/src/main/java/com/hcy/admin/service/system/impl/SystemAuthAdminServiceImpl.java
View File

@ -380,9 +380,9 @@ public class SystemAuthAdminServiceImpl implements ISystemAuthAdminService {
addWarehouse(systemAuthAdminParam,province + city + district,adminId,WarehouseEnum.MAINTANCE_WAREHOUSE.getStatus());
}
if(roleList.contains(String.valueOf(RoleEnum.MAINTENANCE_MAN.getStatus()))){
/*if(roleList.contains(String.valueOf(RoleEnum.MAINTENANCE_MAN.getStatus()))){
addWarehouse(systemAuthAdminParam,province + city + district,adminId,WarehouseEnum.REPAIR_WAREHOUSE.getStatus());
}
}*/
}
private void addWarehouse(SystemAuthAdminParam systemAuthAdminParam,String addressDetail,Long adminId,Integer roleType) {

4
admin/src/main/java/com/hcy/admin/validate/sparePartStockAudit/SparePartStockAuditParam.java
View File

@ -93,7 +93,8 @@ public class SparePartStockAuditParam implements Serializable {
private String recipient; //领用员工
private String recipientPhone; //领用员工联系电话
private Integer recipientNumber; //领用数量
private Integer purchaseStatus; //配件领用状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer purchaseStatus; //配件采购状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer receiveStatus; // 配件领用状态（0=未审核，1=审核未通过，2=待领取，3=待确认，4=已完成）
private String purchaseIdea; //采购意见
private String orderType; // 0-检修工单 1-维修工单
private String workOrderNo; //工单号
@ -102,4 +103,5 @@ public class SparePartStockAuditParam implements Serializable {
private String createTimeStart; //创建时间
private String createTimeEnd; //创建时间
private String responsiblePerson; // 经办人
private String warehouseKeeperImg; // 仓管员上传图片
}

6
admin/src/main/java/com/hcy/admin/vo/sparePartStockAudit/SparePartStockAuditDetailVo.java
View File

@ -53,7 +53,8 @@ public class SparePartStockAuditDetailVo implements Serializable {
private String recipient; //领用员工
private String recipientPhone; //领用员工联系电话
private Integer recipientNumber; //领用数量
private Integer purchaseStatus; //配件领用状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer purchaseStatus; //配件采购状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer receiveStatus; // 配件领用状态（0=未审核，1=审核未通过，2=待领取，3=待确认，4=已完成）
private Date createTime; // 创建时间
private Integer orderType; // 0-检修工单 1-维修工单
@ -64,5 +65,6 @@ public class SparePartStockAuditDetailVo implements Serializable {
private String creator; // 创建人
private Long auditorId; // 审核人id
private String responsiblePerson; // 经办人
private String responsiblePerson; // 经办人、
private String warehouseKeeperImg; // 仓管员上传图片
}

5
admin/src/main/java/com/hcy/admin/vo/sparePartStockAudit/SparePartStockAuditListVo.java
View File

@ -53,8 +53,8 @@ public class SparePartStockAuditListVo implements Serializable {
private String recipient; //领用员工
private String recipientPhone; //领用员工联系电话
private Integer recipientNumber; //领用数量
private Integer purchaseStatus; //配件领用状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer purchaseStatus; //配件采购状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer receiveStatus; // 配件领用状态（0=未审核，1=审核未通过，2=待领取，3=待确认，4=已完成）
private String workOrderNo; //工单号
private List<SparePartAuditListVo> sparePartAuditList; //待入库的备件
private List<OrderSparePartListVo> orderSparePartListVoList; //订单配件
@ -64,4 +64,5 @@ public class SparePartStockAuditListVo implements Serializable {
private Long auditorId; // 审核人id
private String responsiblePerson; // 经办人
private String clientName; // 客户名称
private String warehouseKeeperImg; // 仓管员上传图片
}

3
admin/src/main/resources/application-dev.yml
View File

@ -1,6 +1,7 @@
# 项目配置
like:
upload-directory: /www/wwwroot/housekeeping/server/public/uploads/ # 上传目录
#upload-directory: /www/wwwroot/housekeeping/server/public/uploads/ # 上传目录
upload-directory: E:\upload\ # 上传目录
# 框架配置
spring:

3
admin/src/main/resources/application.yml
View File

@ -1,6 +1,7 @@
# 项目配置
like:
upload-directory: ./www/wwwroot/java-smyy/public/uploads/
#upload-directory: ./www/wwwroot/java-smyy/public/uploads/
upload-directory: E:\upload\
# 服务配置
server:

4
common/src/main/java/com/hcy/common/dto/SparePartStockAuditDto.java
View File

@ -96,7 +96,8 @@ public class SparePartStockAuditDto implements Serializable {
private String recipient; //领用员工
private String recipientPhone; //领用员工联系电话
private Integer recipientNumber; //领用数量
private Integer purchaseStatus; //配件领用状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer purchaseStatus; //配件采购状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer receiveStatus; // 配件领用状态（0=未审核，1=审核未通过，2=待领取，3=待确认，4=已完成）
private String purchaseIdea; //采购意见
private String orderType; // 0-检修工单 1-维修工单
private String workOrderNo; //工单号
@ -104,4 +105,5 @@ public class SparePartStockAuditDto implements Serializable {
private String createTimeStart; //创建时间
private String createTimeEnd; //创建时间
private String warehouseKeeperImg; // 仓管员上传图片
}

2
common/src/main/java/com/hcy/common/dto/order/RepairOrderDto.java
View File

@ -72,7 +72,7 @@ public class RepairOrderDto implements Serializable {
private BigDecimal actualAmount; // 实际金额
private Long clientScrapAddressId; // 客户报废收货地址
private Long scrapConfirmation; // 报废确认（0=是，1=否）
private Integer scrapConfirmation; // 报废确认（0=是，1=否）
private Integer priority; // 优先级（0=加急，1=普通）
private Integer isReassignment; // 是否在改派中（0=是，1=否）

2
common/src/main/java/com/hcy/common/entity/order/RepairOrder.java
View File

@ -72,7 +72,7 @@ public class RepairOrder implements Serializable {
private Integer isConfirmReceipt; //是否确认收货 0-未收货 1-已收货
private String completeImg; // 完工照片
private Long clientScrapAddressId; // 客户报废收货地址
private Long scrapConfirmation; // 报废确认（0=是，1=否）
private Integer scrapConfirmation; // 报废确认（0=是，1=否）
private Integer priority; // 优先级（0=普通，1=加急）
@TableField(value = "is_reassignment",updateStrategy = FieldStrategy.IGNORED)

48
common/src/main/java/com/hcy/common/entity/order/RepairOrderStepData.java
View File

@ -23,7 +23,7 @@ public class RepairOrderStepData implements Serializable {
private String img; // 照片
private String title; // 标题
private Integer dscType; // 描述类型：0=配件领用
private Integer auditStatus; // 审核状态（0=不通过，1=通过）
private Integer auditStatus; // 审核状态（0=通过，1=不通过）
private Long creatorId; // 创建人id
private Date createTime; // 创建时间
@ -49,4 +49,50 @@ public class RepairOrderStepData implements Serializable {
this.auditStatus = auditStatus;
this.creatorId = creatorId;
}
public RepairOrderStepData(Long repairOrderId, Integer repairStep, String remark, String img, String title, Integer auditStatus, Long creatorId) {
this.repairOrderId = repairOrderId;
this.repairStep = repairStep;
this.remark = remark;
this.img = img;
this.title = title;
this.auditStatus = auditStatus;
this.creatorId = creatorId;
}
public RepairOrderStepData(Long id , Long repairOrderId, Integer repairStep, String remark, String img, String title, Long creatorId, Date createTime) {
this.id = id;
this.repairOrderId = repairOrderId;
this.repairStep = repairStep;
this.remark = remark;
this.img = img;
this.title = title;
this.creatorId = creatorId;
this.createTime = createTime;
}
public RepairOrderStepData(Long id ,Long repairOrderId, Integer repairStep, String remark, String img, String title, Integer dscType, Integer auditStatus, Long creatorId, Date createTime) {
this.id = id;
this.repairOrderId = repairOrderId;
this.repairStep = repairStep;
this.remark = remark;
this.img = img;
this.title = title;
this.dscType = dscType;
this.auditStatus = auditStatus;
this.creatorId = creatorId;
this.createTime = createTime;
}
public RepairOrderStepData(Long id ,Long repairOrderId, Integer repairStep, String remark, String img, String title, Integer auditStatus, Long creatorId, Date createTime) {
this.id = id;
this.repairOrderId = repairOrderId;
this.repairStep = repairStep;
this.remark = remark;
this.img = img;
this.title = title;
this.auditStatus = auditStatus;
this.creatorId = creatorId;
this.createTime = createTime;
}
}

5
common/src/main/java/com/hcy/common/entity/sparePartStockAudit/SparePartStockAudit.java
View File

@ -52,10 +52,11 @@ public class SparePartStockAudit implements Serializable {
private String recipient; //领用员工
private String recipientPhone; //领用员工联系电话
private Integer recipientNumber; //领用数量
private Integer purchaseStatus; //配件领用状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成，6=填写中，7=收货超期）
private Integer purchaseStatus; //配件采购状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成，6=填写中，7=收货超期）
private Integer receiveStatus; // 配件领用状态（0=未审核，1=审核未通过，2=待领取，3=待确认，4=已完成）
private String purchaseIdea; //采购意见
private Date consignerTime; //发货时间
private Integer creatorId; // 创建人id
private Long auditorId; // 审核人id 经办人
private String warehouseKeeperImg; // 仓管员上传图片
}

11
common/src/main/java/com/hcy/common/enums/audit/AuditStateEnum.java
View File

@ -10,12 +10,15 @@ import java.util.Map;
*/
public enum AuditStateEnum {
//配件领用状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成，6=填写中，7=收货超期）
// 配件领用状态（0=未审核，1=审核未通过，2=待领取，3=待确认，4=已完成）
UNCLAIMED(2, "待领取"),
TO_BE_CONFIRMED(3, "待确认"),
FINISHED(4, "已完成"),
//配件采购状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成，6=填写中，7=收货超期）
UNREVIEWED(0, "待审核"),
AUDITED(1, "已审核"),
CANCELED(2,"已取消"),
NOT_PASS_STATE(1, "未通过"),
CHECK_PENDING(2, "待管理员审核"),
WAITDELIVER(3, "待发货"),
@ -25,7 +28,7 @@ public enum AuditStateEnum {
OVERDUE(7, "收货超期"),
CANCELED_AUDIT(8, "已取消"),
//审核结果（0=已通过，1=未通过）
//审核结果（0=已通过，1=未通过）
NOT_PASS(1,"未通过"),
ALREADY_PASSED(0, "已通过"),

5
common/src/main/java/com/hcy/common/enums/order/RepairOrderStopEnum.java
View File

@ -29,8 +29,11 @@ public enum RepairOrderStopEnum {
FUNCTIONAL_TEST(13,"功能测试"),
AGING_TEST(14,"老化测试"),
PACKAGE_AND_SHIP(15,"包装出货"),
FILL_IN_THE_RECEIPT(16,"填写回单");
FILL_IN_THE_RECEIPT(16,"填写回单"),
FINISH(17, "结束"),
//描述类型：0-配件领用
ACCESSORY_REQUISITION(0,"配件领用");
private final int status;
private final String desc;

194
front/src/main/java/com/hcy/front/controller/order/RepairOrderController.java
View File

@ -101,6 +101,92 @@ public class RepairOrderController {
return AjaxResult.success();
}
/**
* 故障检测
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/faultDetect")
public Object faultDetect(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.faultDetect(repairOrderParam);
return AjaxResult.success();
}
/**
* 小程序工单状态数量
* @return Object
*/
@GetMapping("/orderStatusCount")
public Object orderStatusCount(RepairOrderParam repairOrderParam) {
return AjaxResult.success(iRepairOrderService.orderStatusCount(repairOrderParam));
}
/**
* 确认服务报价
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/confirmServiceOfferPrice")
public Object confirmServiceOfferPrice(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.confirmServiceOfferPrice(repairOrderParam);
return AjaxResult.success();
}
/**
* 确认报废
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/confirmedScrap")
public Object confirmedScrap(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.confirmedScrap(repairOrderParam);
return AjaxResult.success();
}
/**
* 填写报废单
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/scrapForm")
public Object scrapForm(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.scrapForm(repairOrderParam);
return AjaxResult.success();
}
/**
* 填写回单
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/fillInReceipt")
public Object fillInReceipt(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.fillInReceipt(repairOrderParam);
return AjaxResult.success();
}
/**
* 备件领用申请
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/sparePartsRequisition")
public Object sparePartsRequisition(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.sparePartsRequisition(repairOrderParam);
return AjaxResult.success();
}
/**
* 确认收货
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/confirmReceipt")
public Object confirmReceipt(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.confirmReceipt(repairOrderParam);
return AjaxResult.success();
}
/**
* 扫一扫
* @param repairOrderParam 参数
@ -155,112 +241,4 @@ public class RepairOrderController {
iRepairOrderService.maintenanceProcedure(repairOrderParam);
return AjaxResult.success();
}
/**
* 退单
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/refundOrder")
public Object refundOrder(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.refundOrder(repairOrderParam);
return AjaxResult.success();
}
/**
* 故障检测
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/faultDetect")
public Object faultDetect(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.faultDetect(repairOrderParam);
return AjaxResult.success();
}
/**
* 小程序工单状态数量
* @return Object
*/
@GetMapping("/orderStatusCount")
public Object orderStatusCount(RepairOrderParam repairOrderParam) {
return AjaxResult.success(iRepairOrderService.orderStatusCount(repairOrderParam));
}
/**
* 确认服务报价
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/confirmServiceOfferPrice")
public Object confirmServiceOfferPrice(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.confirmServiceOfferPrice(repairOrderParam);
return AjaxResult.success();
}
/**
* 确认报废
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/confirmedScrap")
public Object confirmedScrap(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.confirmedScrap(repairOrderParam);
return AjaxResult.success();
}
/**
* 上传维修中、维修后照片
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/uploadPictures")
public Object uploadPictures(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.uploadPictures(repairOrderParam);
return AjaxResult.success();
}
/**
* 填写报废单
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/scrapForm")
public Object scrapForm(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.scrapForm(repairOrderParam);
return AjaxResult.success();
}
/**
* 填写回单
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/fillInReceipt")
public Object fillInReceipt(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.fillInReceipt(repairOrderParam);
return AjaxResult.success();
}
/**
* 备件领用申请
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/sparePartsRequisition")
public Object sparePartsRequisition(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.sparePartsRequisition(repairOrderParam);
return AjaxResult.success();
}
/**
* 确认收货
* @param repairOrderParam 参数
* @return Object
*/
@PostMapping("/confirmReceipt")
public Object confirmReceipt(@RequestBody RepairOrderParam repairOrderParam) {
iRepairOrderService.confirmReceipt(repairOrderParam);
return AjaxResult.success();
}
}

12
front/src/main/java/com/hcy/front/service/order/IRepairOrderService.java
View File

@ -61,12 +61,6 @@ public interface IRepairOrderService {
*/
void sweep(RepairOrderParam repairOrderParam);
/**
* 退单
* @param repairOrderParam
*/
void refundOrder(RepairOrderParam repairOrderParam);
/**
* 故障检测
* @param repairOrderParam
@ -98,12 +92,6 @@ public interface IRepairOrderService {
*/
void confirmedScrap(RepairOrderParam repairOrderParam);
/**
* 上传维修中、维修后照片
* @param repairOrderParam
*/
void uploadPictures(RepairOrderParam repairOrderParam);
/**
* 填写报废单
* @param repairOrderParam

840
front/src/main/java/com/hcy/front/service/order/impl/RepairOrderServiceImpl.java
View File

@ -209,59 +209,59 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
if(repairOrderParam.getIsClient() == MaintenanceOrderStatusEnum.REPAIRER.getStatus()){
repairOrderDto.setReceiverId(FrontThreadLocal.getUserId().longValue()); //接单人
if(StringUtils.isEmpty(repairOrderParam.getOrderStatusIds())){
repairOrderDto.setOrderStatusIds("1,2,7,8");
}
}else{
if(StringUtils.isEmpty(repairOrderParam.getOrderStatusIds())){
repairOrderDto.setOrderStatusIds("0,1,2,7,8");
}
repairOrderDto.setClientId(repairOrderDto.getClientId()); // 客户id
}
// 待接单数量
Integer pendingOrderCount = repairOrderMapper.selectPendingOrderCount(repairOrderDto);
// 检测中数量
Integer checkingCount = repairOrderMapper.selectCount(
new LambdaQueryWrapper<RepairOrder>()
.eq(RepairOrder::getIsDelete, GlobalConstant.NOT_DELETE)
.and(query -> query
.eq(RepairOrder:: getOrderStatus, MaintenanceOrderStatusEnum.CHECKING.getStatus())
.or()
.eq(RepairOrder:: getOrderStatus, MaintenanceOrderStatusEnum.RETURNED.getStatus()))
.eq(repairOrderDto.getClientId() != null, RepairOrder::getClientId, repairOrderDto.getClientId())
.eq(repairOrderDto.getReceiverId() != null, RepairOrder::getReceiverId, repairOrderDto.getReceiverId()));
Integer pendingOrderCount = orderStatusCount(RepairOrderStatusEnum.PENDING_ORDER.getStatus(),repairOrderDto.getClientId(),repairOrderDto.getReceiverId());
// 待维修数量
Integer waitingRepairCount = orderStatusCount(RepairOrderStatusEnum.AWAITING_REPAIR.getStatus(),repairOrderDto.getClientId(),repairOrderDto.getReceiverId());
// 排查中数量
Integer underInvestigationCount = orderStatusCount(RepairOrderStatusEnum.UNDER_INVESTIGATION.getStatus(),repairOrderDto.getClientId(),repairOrderDto.getReceiverId());
// 待确认数量
Integer toBeConfirmedCount = repairOrderMapper.selectCount(
new LambdaQueryWrapper<RepairOrder>()
.eq(RepairOrder::getIsDelete, GlobalConstant.NOT_DELETE)
.eq(RepairOrder:: getOrderStatus, MaintenanceOrderStatusEnum.WAIT_CONFIRMATION.getStatus())
.eq(repairOrderDto.getClientId() != null, RepairOrder::getClientId, repairOrderDto.getClientId())
.eq(repairOrderDto.getReceiverId() != null, RepairOrder::getReceiverId, repairOrderDto.getReceiverId()));
Integer toBeConfirmedCount = orderStatusCount(RepairOrderStatusEnum.TO_BE_CONFIRMED.getStatus(),repairOrderDto.getClientId(),repairOrderDto.getReceiverId());
// 维修中数量
Integer inMaintenanceCount = repairOrderMapper.selectCount(
new LambdaQueryWrapper<RepairOrder>()
.eq(RepairOrder::getIsDelete, GlobalConstant.NOT_DELETE)
.eq(RepairOrder:: getOrderStatus, MaintenanceOrderStatusEnum.MAINTENANCE_ING.getStatus())
.eq(repairOrderDto.getClientId() != null, RepairOrder::getClientId, repairOrderDto.getClientId())
.eq(repairOrderDto.getReceiverId() != null, RepairOrder::getReceiverId, repairOrderDto.getReceiverId()));
Integer inMaintenanceCount = orderStatusCount(RepairOrderStatusEnum.IN_MAINTENANCE.getStatus(),repairOrderDto.getClientId(),repairOrderDto.getReceiverId());
// 测试中数量
Integer testInProcessCount = orderStatusCount(RepairOrderStatusEnum.TEST_IN_PROCESS.getStatus(),repairOrderDto.getClientId(),repairOrderDto.getReceiverId());
// 已完成数量
Integer completedCount = repairOrderMapper.selectCount(
new LambdaQueryWrapper<RepairOrder>()
.eq(RepairOrder::getIsDelete, GlobalConstant.NOT_DELETE)
.eq(RepairOrder:: getOrderStatus, MaintenanceOrderStatusEnum.FINISHED.getStatus())
.eq(repairOrderDto.getClientId() != null, RepairOrder::getClientId, repairOrderDto.getClientId())
.eq(repairOrderDto.getReceiverId() != null, RepairOrder::getReceiverId, repairOrderDto.getReceiverId()));
Integer completedCount = orderStatusCount(RepairOrderStatusEnum.FINISHED.getStatus(),repairOrderDto.getClientId(),repairOrderDto.getReceiverId());
OrderStatusCountVo orderStatusCountVo = new OrderStatusCountVo();
orderStatusCountVo.setPendingOrderCount(pendingOrderCount);
orderStatusCountVo.setCheckingCount(checkingCount);
orderStatusCountVo.setWaitingRepairCount(waitingRepairCount);
orderStatusCountVo.setUnderInvestigationCount(underInvestigationCount);
orderStatusCountVo.setToBeConfirmedCount(toBeConfirmedCount);
orderStatusCountVo.setInMaintenanceCount(inMaintenanceCount);
orderStatusCountVo.setTestInProcessCount(testInProcessCount);
orderStatusCountVo.setCompletedCount(completedCount);
return orderStatusCountVo;
}
/**
* 查询维修单各个状态订单数量
* @param orderStatus
* @param clientId
* @param receiverId
* @return
*/
public Integer orderStatusCount(Integer orderStatus,Long clientId,Long receiverId){
Integer count = repairOrderMapper.selectCount(
new LambdaQueryWrapper<RepairOrder>()
.eq(RepairOrder::getIsDelete, GlobalConstant.NOT_DELETE)
.eq(RepairOrder:: getOrderStatus, orderStatus)
.eq(clientId != null, RepairOrder::getClientId, clientId)
.eq(receiverId != null, RepairOrder::getReceiverId, receiverId));
return count;
}
/**
* 确认服务报价
*/
@ -320,53 +320,16 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(repairOrderParam.getId());
Assert.notNull(repairOrder, "数据不存在");
repairOrder.setScrapOrNot(repairOrderParam.getScrapOrNot()); // 是否报废（0=是，1=否）
repairOrder.setScrapConfirmation(repairOrderParam.getScrapConfirmation()); // 报废确认（0=是，1=否）
repairOrder.setReturnOrNot(repairOrderParam.getReturnOrNot()); // 是否回寄（0=是 1=否）
repairOrder.setDeliveryMethod(repairOrderParam.getDeliveryMethod()); // 收件方式（0=物流快递 1-上门取件 2-送货上门）
repairOrder.setClientScrapAddressId(repairOrderParam.getClientScrapAddressId()); // 客户报废收件地址
repairOrder.setClientScrapRemark(repairOrderParam.getClientScrapRemark()); // 客户报废备注
repairOrder.setOrderStatus(MaintenanceOrderStatusEnum.FINISHED.getStatus());
repairOrder.setOrderAccomplishTime(new Date()); //订单完成时间
repairOrderMapper.updateById(repairOrder);
// 用户确认报废就新增操作记录
if(repairOrderParam.getScrapConfirmation() == RepairOrderStatusEnum.YES.getStatus()){
User user = userMapper.selectById(repairOrder.getReceiverId());
if(user != null){
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(repairOrder.getId()
,OrderOperateRecordEnum.FINISH.getDesc()
,"【"+user.getUsername()+"】确认报废，已经完成任务");
}
}
}
/**
* 上传维修中、维修后照片
*/
@Override
@Transactional
public void uploadPictures(RepairOrderParam repairOrderParam) {
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(repairOrderParam.getId());
Assert.notNull(repairOrder, "数据不存在");
/*if(repairOrderParam.getInMaintenanceImg() != null){
repairOrder.setInMaintenanceImg(repairOrderParam.getInMaintenanceImg()); // 维修中照片
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(repairOrder.getId()
,OrderOperateRecordEnum.UPLOADING_IN_MAINTENANCE.getDesc()
,"【"+FrontThreadLocal.get("username")+"】已上传维修中照片。");
}else{
repairOrder.setAfterRepairImg(repairOrderParam.getAfterRepairImg()); // 维修后照片
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(repairOrder.getId()
,OrderOperateRecordEnum.UPLOADING_AFTER_REPAIR.getDesc()
,"【"+FrontThreadLocal.get("username")+"】已上传维修后照片。");
}*/
repairOrder.setScrapConfirmation(RepairOrderStatusEnum.YES.getStatus()); // 报废确认（0=是，1=否）
repairOrderMapper.updateById(repairOrder);
//维修单步骤数据
RepairOrderStepData repairOrderStepData = new RepairOrderStepData();
repairOrderStepData.setRepairOrderId(repairOrder.getId());
repairOrderStepData.setTitle("客户确认报废");
repairOrderStepData.setAuditStatus(repairOrder.getScrapConfirmation());
repairOrderStepData.setCreatorId(FrontThreadLocal.getUserId().longValue());
repairOrderStepDataMapper.insert(repairOrderStepData);
}
/**
@ -423,66 +386,6 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
}
}
/**
* 备件领用申请
*/
@Override
@Transactional
public void sparePartsRequisition(RepairOrderParam repairOrderParam) {
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(repairOrderParam.getId());
Assert.notNull(repairOrder, "数据不存在");
//我的仓库领用
if(repairOrder.getWarehouseType() == MaintenanceOrderStatusEnum.MY_WAREHOUSE.getStatus()){
//获取领用备件列表
List<OrderSparePart> orderSpareParts = orderSparePartMapper.findOrderSparePartByRepairOrderId(repairOrder.getId());
for (OrderSparePart item : orderSpareParts) {
//获取备件信息
SparePart sparePart = sparePartMapper.findSparePartById(item.getSparePartsId());
if(sparePart.getQuantity() >= item.getQuantity()){
//扣除对应的数量
sparePart.setQuantity(sparePart.getQuantity() - item.getQuantity());
sparePartMapper.updateById(sparePart);
}else{
throw new OperateException("仓库中【" + sparePart.getSparePartsName() + "】备件数量不足" + item.getQuantity() + sparePart.getUnit() + "，配件领用失败");
}
}
repairOrder.setIsConfirmReceipt(MaintenanceOrderStatusEnum.CONFIRM_RECEIPT.getStatus());
repairOrder.setIsMaintain(MaintenanceOrderStatusEnum.MAINTAIN.getStatus());
repairOrderMapper.updateById(repairOrder);
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(repairOrder.getId()
,OrderOperateRecordEnum.SPARE_PARTS_RECEIVE.getDesc()
,OrderOperateRecordEnum.SPARE_PARTS_RECEIVE_TYPE.getStatus()
,"【"+FrontThreadLocal.get("username")+"】创建了【配件领用】单。选择仓库：自身仓库。");
//我的仓库也要新增配件领用记录 并且状态是已完成
/*SparePartStockAudit sparePartStockAudit = getSparePartStockAudit(maintenanceOrderParam);
sparePartStockAudit.setPurchaseStatus(AuditStateEnum.DONE.getStatus());
sparePartStockAuditMapper.insert(sparePartStockAudit);*/
}else{
SparePartStockAudit resultSps = sparePartStockAuditMapper.findSparePartStockAuditByOrderId(repairOrder.getId()
, SparePartStockAuditEnum.REPAIR_ORDER.getStatus());
if(resultSps != null){
//已有领取记录但被拒绝则重新审核
resultSps.setPurchaseStatus(AuditStateEnum.UNREVIEWED.getStatus());
resultSps.setCreateTime(new Date());
sparePartStockAuditMapper.updateById(resultSps);
}else{
//没领过配件则创建新的领用单
SparePartStockAudit sparePartStockAudit = getSparePartStockAudit(repairOrderParam);
sparePartStockAudit.setPurchaseStatus(AuditStateEnum.UNREVIEWED.getStatus());
sparePartStockAuditMapper.insert(sparePartStockAudit);
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(repairOrder.getId()
,OrderOperateRecordEnum.SPARE_PARTS_RECEIVE.getDesc()
,OrderOperateRecordEnum.SPARE_PARTS_RECEIVE_TYPE.getStatus()
,"【"+FrontThreadLocal.get("username")+"】创建了配件领用申请单。");
}
}
}
/**
* 确认收货
*/
@ -531,12 +434,12 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
SparePartStockAudit sparePartStockAudit = new SparePartStockAudit();
sparePartStockAudit.setReceiptNumber(OrderUtil.getOrderNo(lastSparePartStockAudit == null ? "" :lastSparePartStockAudit.getReceiptNumber()));
sparePartStockAudit.setOrderId(repairOrderParam.getId());
sparePartStockAudit.setOrderType(SparePartStockAuditEnum.REPAIR_ORDER.getStatus());
sparePartStockAudit.setReceiptType(AuditStateEnum.OUT_WAREHOUSE.getStatus());
sparePartStockAudit.setOutInWarehouseType(AuditStateEnum.STAFF_MATERIALS.getStatus());
sparePartStockAudit.setConsignee(user.getUsername());
sparePartStockAudit.setPhone(user.getMobile());
sparePartStockAudit.setCreatorId(FrontThreadLocal.getUserId());
sparePartStockAudit.setOrderType(SparePartStockAuditEnum.REPAIR_ORDER.getStatus());// 0-检修工单 1-维修工单
sparePartStockAudit.setReceiptType(AuditStateEnum.OUT_WAREHOUSE.getStatus());// 单据类型（0=入库单，1=出库单，2=仓库调拨单）
sparePartStockAudit.setOutInWarehouseType(AuditStateEnum.STAFF_MATERIALS.getStatus());// 出入库类别（0=采购入库，1=库存调拨，2=员工领料，3=销售出库）
sparePartStockAudit.setConsignee(user.getUsername());// 收货单位（人员）
sparePartStockAudit.setPhone(user.getMobile());// 联系电话
sparePartStockAudit.setCreatorId(FrontThreadLocal.getUserId());// 创建人id
//获取维修员选择地址
if(repairOrderParam.getAddressId() != null){
@ -548,7 +451,7 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
userAddress.getAddress());
}
sparePartStockAudit.setDeliveryMethod(repairOrderParam.getDeliveryMethod());
sparePartStockAudit.setRemark(repairOrderParam.getRemark());
sparePartStockAudit.setRemark(repairOrderParam.getRepairOrderStepRemark());
return sparePartStockAudit;
}
@ -584,19 +487,6 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
for(RepairOrderDto item : iPage.getRecords()) {
RepairOrderListVo vo = new RepairOrderListVo();
BeanUtils.copyProperties(item, vo);
/*//管辖工厂
SystemAuthAdmin authAdmin = systemAuthAdminMapper.selectOne(
new QueryWrapper<SystemAuthAdmin>()
.eq("user_id", vo.getCreatorId()));
if(authAdmin != null){
Plant plant = plantMapper.selectOne(
new QueryWrapper<Plant>()
.eq("id", authAdmin.getPlantId()));
if(plant != null){
vo.setPlantId(plant.getId());
vo.setPlantName(plant.getName());
}
}*/
//故障类型名称
Fault faultName = faultMapper.selectOne(
new LambdaQueryWrapper<Fault>()
@ -615,6 +505,12 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
}
vo.setCreateTime(item.getCreateTime());
vo.setUpdateTime(item.getUpdateTime());
//配件编码
List<OrderPartCode> orderPartCodes = orderPartCodeMapper.selectList(new LambdaQueryWrapper<OrderPartCode>()
.eq(OrderPartCode::getRepairOrderId, vo.getId()));
vo.setOrderPartCodeList(orderPartCodes);
list.add(vo);
}
@ -696,32 +592,6 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
vo.setAddress(userAddressListVo);
}
//报废地址
/*UserAddress scrapAddress = userAddressMapper.selectOne(
new QueryWrapper<UserAddress>()
.eq("id", model.getScrapAddressId()));
if(scrapAddress != null){
UserAddressListVo scrapAddressListVo = new UserAddressListVo();
BeanUtils.copyProperties(scrapAddress, scrapAddressListVo);
scrapAddressListVo.setProvince(regionMap.get(scrapAddressListVo.getProvinceId()));
scrapAddressListVo.setCity(regionMap.get(scrapAddressListVo.getCityId()));
scrapAddressListVo.setDistrict(regionMap.get(scrapAddressListVo.getDistrictId()));
vo.setScrapAddress(scrapAddressListVo);
}*/
//设备信息
/*Equipment equipment = equipmentMapper.selectOne(
new QueryWrapper<Equipment>()
.eq("id", model.getEquipmentId()));
if(equipment != null){
EquipmentListVo equipmentListVo = new EquipmentListVo();
equipmentListVo.setProvince(regionMap.get(equipment.getProvinceId()));
equipmentListVo.setCity(regionMap.get(equipment.getCityId()));
equipmentListVo.setDistrict(regionMap.get(equipment.getDistrictId()));
BeanUtils.copyProperties(equipment, equipmentListVo);
vo.setEquipment(equipmentListVo);
}*/
//故障类型名称
Fault faultName = faultMapper.selectOne(
new LambdaQueryWrapper<Fault>()
@ -745,19 +615,6 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
}
vo.setSparePartList(orderSparePartListVos);
//确认报废 收件地址
/*UserAddress clientScrapAddress = userAddressMapper.selectOne(
new QueryWrapper<UserAddress>()
.eq("id", model.getClientScrapAddressId()));
if(clientScrapAddress != null){
UserAddressListVo clientScrapAddressVo = new UserAddressListVo();
BeanUtils.copyProperties(clientScrapAddress, clientScrapAddressVo);
clientScrapAddressVo.setProvince(regionMap.get(clientScrapAddressVo.getProvinceId()));
clientScrapAddressVo.setCity(regionMap.get(clientScrapAddressVo.getCityId()));
clientScrapAddressVo.setDistrict(regionMap.get(clientScrapAddressVo.getDistrictId()));
vo.setClientScrapAddress(clientScrapAddressVo);
}*/
//设置备件领用信息
SparePartStockAudit sparePartStockAudit = sparePartStockAuditMapper.findSparePartStockAuditByOrderId(model.getId()
,SparePartStockAuditEnum.REPAIR_ORDER.getStatus());
@ -766,6 +623,34 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
BeanUtils.copyProperties(sparePartStockAudit,sparePartStockAuditDetailVo);
vo.setSparePartStockAudit(sparePartStockAuditDetailVo);
}
//配件编码
List<OrderPartCode> orderPartCodes = orderPartCodeMapper.selectList(new LambdaQueryWrapper<OrderPartCode>()
.eq(OrderPartCode::getRepairOrderId, vo.getId()));
if(orderPartCodes != null){
vo.setOrderPartCodeList(orderPartCodes);
}
//维修单步骤
List<RepairOrderStepData> repairOrderStepData = repairOrderStepDataMapper.selectList(new LambdaQueryWrapper<RepairOrderStepData>()
.eq(RepairOrderStepData::getRepairOrderId, vo.getId())
.orderByDesc(RepairOrderStepData::getId));
if(repairOrderStepData != null){
List<RepairOrderStepDataVo> stepDataVoList = new ArrayList<>();
for (RepairOrderStepData repairOrderStepDatum : repairOrderStepData) {
RepairOrderStepDataVo repairOrderStepDataVo = new RepairOrderStepDataVo();
BeanUtils.copyProperties(repairOrderStepDatum,repairOrderStepDataVo);
//创建人名称
User user1 = userMapper.selectOne(new LambdaQueryWrapper<User>()
.eq(User::getId, repairOrderStepDataVo.getCreatorId()));
if(user1 != null){
repairOrderStepDataVo.setCreatorName(user1.getUsername());
}
stepDataVoList.add(repairOrderStepDataVo);
}
vo.setRepairOrderStepDataList(stepDataVoList);
}
return vo;
}
@ -796,9 +681,11 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
repairOrderMapper.insert(model);
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(model.getId()
, OrderOperateRecordEnum.NEW_CREATE.getDesc()
,"维修主管【"+FrontThreadLocal.get("username")+"】创建了维修工单。");
RepairOrderStepData repairOrderStepData = new RepairOrderStepData();
repairOrderStepData.setRepairOrderId(model.getId());
repairOrderStepData.setTitle("创建维修工单");
repairOrderStepData.setCreatorId(FrontThreadLocal.getUserId().longValue());
repairOrderStepDataMapper.insert(repairOrderStepData);
Client client = clientMapper.findClientById(repairOrderParam.getClientId());
Equipment equipment = equipmentMapper.findEquipmentById(repairOrderParam.getEquipmentId());
@ -880,6 +767,13 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
repairOrder.setRepairNextStep(RepairOrderStopEnum.DISMANTLE.getStatus()); // 下个步骤
}
repairOrderMapper.updateById(repairOrder);
//新增维修单操作记录
RepairOrderStepData repairOrderStepData = new RepairOrderStepData();
repairOrderStepData.setRepairOrderId(repairOrder.getId());
repairOrderStepData.setTitle("扫描绑定模块条码");
repairOrderStepData.setCreatorId(FrontThreadLocal.getUserId().longValue());
repairOrderStepDataMapper.insert(repairOrderStepData);
}else {
throw new OperateException("当前角色不可接单！");
}
@ -893,6 +787,7 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
* @param repairOrderParam
*/
@Override
@Transactional
public void applyForReassignment(RepairOrderParam repairOrderParam) {
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(repairOrderParam.getId());
Assert.notNull(repairOrder, "数据不存在");
@ -907,6 +802,13 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
repairOrder.setIsReassignment(RepairOrderStatusEnum.YES.getStatus());// 是否在改派中（0=是，1=否）
repairOrder.setReassignmentAgreeOrNot(null); // 再次申请改派时，reassignmentAgreeOrNot字段设为null
repairOrderMapper.updateById(repairOrder);
//新增维修单操作记录
RepairOrderStepData repairOrderStepData = new RepairOrderStepData();
repairOrderStepData.setRepairOrderId(repairOrder.getId());
repairOrderStepData.setTitle("维修员申请改派");
repairOrderStepData.setCreatorId(FrontThreadLocal.getUserId().longValue());
repairOrderStepDataMapper.insert(repairOrderStepData);
}else {
throw new OperateException("当前角色不可改派！");
}
@ -940,6 +842,14 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
//审核改派时，不管同不同意，都把isReassignment字段设置回null
repairOrder.setIsReassignment(null);
repairOrderMapper.updateById(repairOrder);
//新增维修单操作记录
RepairOrderStepData repairOrderStepData = new RepairOrderStepData();
repairOrderStepData.setRepairOrderId(repairOrder.getId());
repairOrderStepData.setTitle("维修主管审核改派");
repairOrderStepData.setAuditStatus(repairOrder.getReassignmentAgreeOrNot()); // 审核结果
repairOrderStepData.setCreatorId(FrontThreadLocal.getUserId().longValue());
repairOrderStepDataMapper.insert(repairOrderStepData);
}else {
throw new OperateException("当前角色不可改派！");
}
@ -956,8 +866,8 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(repairOrderParam.getId());
Assert.notNull(repairOrder, "数据不存在");
if(repairOrder.getRepairNextStep() == RepairOrderStopEnum.DISMANTLE.getStatus()){
repairOrder.setRepairStep(RepairOrderStopEnum.RINSE.getStatus());// 当前步骤
if(repairOrderParam.getRepairStep() == RepairOrderStopEnum.DISMANTLE.getStatus()){
repairOrder.setRepairStep(repairOrderParam.getRepairStep());// 当前步骤
repairOrder.setRepairNextStep(RepairOrderStopEnum.RINSE.getStatus()); // 下个步骤
//批量添加配件编码
@ -972,6 +882,7 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
repairOrderStepData.setRepairStep(RepairOrderStopEnum.DISMANTLE.getStatus());// 当前步骤
repairOrderStepData.setRemark(repairOrderParam.getRepairOrderStepRemark());// 备注
repairOrderStepData.setImg(repairOrderParam.getRepairOrderStepImg());// 照片
repairOrderStepData.setTitle(RepairOrderStopEnum.DISMANTLE.getDesc()); // 标题
repairOrderStepData.setCreatorId(FrontThreadLocal.getUserId().longValue()); //创建人
repairOrderStepData.setCreateTime(new Date()); // 创建时间
repairOrderStepDataMapper.insert(repairOrderStepData);
@ -994,76 +905,503 @@ public class RepairOrderServiceImpl implements IRepairOrderService {
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(repairOrderParam.getId());
Assert.notNull(repairOrder, "数据不存在");
if(repairOrderParam.getRepairStep() == null){
throw new OperateException("当前步骤不可为空！");
}
repairOrder.setRepairStep(repairOrderParam.getRepairStep());// 当前步骤
//查看当前步骤是否有记录
RepairOrderStepData repairOrderStepData1 = repairOrderStepDataMapper.selectOne(
new LambdaQueryWrapper<RepairOrderStepData>()
.eq(RepairOrderStepData::getRepairOrderId, repairOrder.getId())
.eq(RepairOrderStepData::getRepairStep, repairOrderParam.getRepairStep()));
if(repairOrderParam.getRepairStep() == RepairOrderStopEnum.RINSE.getStatus()){
//开始清洗
repairOrder.setRepairNextStep(RepairOrderStopEnum.TROUBLESHOOTING.getStatus()); // 下个步骤
repairOrder.setOrderStatus(RepairOrderStatusEnum.UNDER_INVESTIGATION.getStatus()); //清洗完工单状态变为排查中
}else if(repairOrderParam.getRepairStep() == RepairOrderStopEnum.TROUBLESHOOTING.getStatus()){
repairOrder.setRepairNextStep(RepairOrderStopEnum.TROUBLESHOOTING.getStatus()); // 下个步骤
repairOrder.setRepairStep(repairOrder.getRepairNextStep());// 当前步骤
//故障排查
repairOrder.setRepairStep(repairOrderParam.getRepairStep());// 当前步骤
repairOrder.setScrapOrNot(repairOrderParam.getScrapOrNot());// 是否报废（0=是，1=否）
//判断是否报废
if(repairOrderParam.getScrapOrNot() == RepairOrderStatusEnum.YES.getStatus()){
//排查时候选了报废，工单状态改为待确认
repairOrder.setOrderStatus(RepairOrderStatusEnum.TO_BE_CONFIRMED.getStatus());
//维修单步骤数据
repairOrderStepDataMapper.insert(new RepairOrderStepData(
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
repairOrderParam.getScrapOrNot(),
FrontThreadLocal.getUserId().longValue()));
Client client = clientMapper.findClientById(repairOrder.getClientId());
//判断当前客户是全包还是半包
if(client.getMaintainType() == ClientStatusEnum.MODULE_MAINTENANCE_ALL_WRAPPED.getStatus()){
repairOrder.setScrapConfirmation(RepairOrderStatusEnum.YES.getStatus()); // 报废确认（0=是，1=否）
//维修单步骤数据
RepairOrderStepData repairOrderStepData = new RepairOrderStepData();
repairOrderStepData.setRepairOrderId(repairOrder.getId());
repairOrderStepData.setRemark("全包客户自动确认报废");
repairOrderStepData.setTitle("全包客户自动确认报废");
repairOrderStepData.setAuditStatus(Math.toIntExact(repairOrder.getScrapConfirmation()));
repairOrderStepData.setCreatorId(FrontThreadLocal.getUserId().longValue());
repairOrderStepDataMapper.insert(repairOrderStepData);
}
repairOrderMapper.updateById(repairOrder); // 更新维修单
return;
}else{
repairOrder.setRepairNextStep(RepairOrderStopEnum.CONFIRMATION_SIGNATURE.getStatus()); // 下个步骤
}
//确认报废不用填配件数据
if(repairOrderParam.getScrapOrNot() == RepairOrderStatusEnum.NO.getStatus()){
//配件领用申请
if(repairOrderParam.getSparePartParams() != null){
//判断是否已经配件领用过了
List<OrderSparePart> orderSpareParts = orderSparePartMapper.findOrderSparePartByRepairOrderId(repairOrder.getId());
for (OrderSparePart orderSparePart : orderSpareParts) {
//已经领用过的就将之前的配件领用信息删除
orderSparePartMapper.deleteById(orderSparePart);
}
//故障排查完，如果有申请配件，变成待确认
repairOrder.setOrderStatus(RepairOrderStatusEnum.TO_BE_CONFIRMED.getStatus());
for (SparePartParam item : repairOrderParam.getSparePartParams()) {
SparePart sparePart = sparePartMapper.findSparePartById(item.getId());
Assert.notNull(sparePart, "配件数据不存在");
OrderSparePart orderSparePart = new OrderSparePart();
BeanUtils.copyProperties(sparePart, orderSparePart);
orderSparePart.setId(null);
orderSparePart.setRepairOrderId(repairOrder.getId()); //维修单id
orderSparePart.setSparePartsId(item.getId()); // 备件id
orderSparePart.setWarehouseId(sparePart.getWarehouseId()); // 所属仓库id
orderSparePart.setQuantity(item.getQuantity()); // 数量
orderSparePartMapper.insert(orderSparePart);
}
//配件领用申请
SparePartStockAudit resultSps = sparePartStockAuditMapper.findSparePartStockAuditByOrderId(repairOrder.getId()
, SparePartStockAuditEnum.REPAIR_ORDER.getStatus());
if(resultSps != null){
//已有领取记录但被拒绝则重新审核
resultSps.setReceiveStatus(AuditStateEnum.UNREVIEWED.getStatus());
resultSps.setCreateTime(new Date());
sparePartStockAuditMapper.updateById(resultSps);
}else{
//没领过配件则创建新的领用单
SparePartStockAudit sparePartStockAudit = getSparePartStockAudit(repairOrderParam);
sparePartStockAudit.setReceiveStatus(AuditStateEnum.UNREVIEWED.getStatus());
sparePartStockAuditMapper.insert(sparePartStockAudit);
}
if(repairOrderStepData1 != null){
//维修单步骤数据
repairOrderStepDataMapper.updateById(new RepairOrderStepData(
repairOrderStepData1.getId(),
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
RepairOrderStopEnum.ACCESSORY_REQUISITION.getStatus(),
repairOrderParam.getScrapOrNot(),
FrontThreadLocal.getUserId().longValue(),
new Date()));
}else{
//维修单步骤数据
repairOrderStepDataMapper.insert(new RepairOrderStepData(
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
RepairOrderStopEnum.ACCESSORY_REQUISITION.getStatus(),
repairOrderParam.getScrapOrNot(),
FrontThreadLocal.getUserId().longValue()));
}
repairOrderMapper.updateById(repairOrder); // 更新维修单
}else{
//如果没有领配件，就变成维修中
repairOrder.setOrderStatus(RepairOrderStatusEnum.IN_MAINTENANCE.getStatus());
repairOrder.setRepairNextStep(RepairOrderStopEnum.PRE_MAINTENANCE_IMG.getStatus()); // 下个步骤
if(repairOrderStepData1 != null){
//维修单步骤数据
repairOrderStepDataMapper.updateById(new RepairOrderStepData(
repairOrderStepData1.getId(),
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
repairOrderParam.getScrapOrNot(),
FrontThreadLocal.getUserId().longValue(),
new Date()));
}else{
//维修单步骤数据
repairOrderStepDataMapper.insert(new RepairOrderStepData(
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
repairOrderParam.getScrapOrNot(),
FrontThreadLocal.getUserId().longValue()));
}
}
}
repairOrderMapper.updateById(repairOrder); // 更新维修单
return;
}else {
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.RECOLLAR_FITTING.getStatus()) {
// 重领配件
//判断是否已经配件领用过了
List<OrderSparePart> orderSpareParts = orderSparePartMapper.findOrderSparePartByRepairOrderId(repairOrder.getId());
for (OrderSparePart orderSparePart : orderSpareParts) {
//已经领用过的就将之前的配件领用信息删除
orderSparePartMapper.deleteById(orderSparePart);
}
//故障排查完，如果有申请配件，变成待确认
repairOrder.setOrderStatus(RepairOrderStatusEnum.TO_BE_CONFIRMED.getStatus());
for (SparePartParam item : repairOrderParam.getSparePartParams()) {
SparePart sparePart = sparePartMapper.findSparePartById(item.getId());
Assert.notNull(sparePart, "配件数据不存在");
OrderSparePart orderSparePart = new OrderSparePart();
BeanUtils.copyProperties(sparePart, orderSparePart);
orderSparePart.setId(null);
orderSparePart.setRepairOrderId(repairOrder.getId()); //维修单id
orderSparePart.setSparePartsId(item.getId()); // 备件id
orderSparePart.setWarehouseId(sparePart.getWarehouseId()); // 所属仓库id
orderSparePart.setQuantity(item.getQuantity()); // 数量
orderSparePartMapper.insert(orderSparePart);
}
//配件领用申请
SparePartStockAudit resultSps = sparePartStockAuditMapper.findSparePartStockAuditByOrderId(repairOrder.getId()
, SparePartStockAuditEnum.REPAIR_ORDER.getStatus());
if(resultSps != null){
//已有领取记录但被拒绝则重新审核
resultSps.setReceiveStatus(AuditStateEnum.UNREVIEWED.getStatus());
resultSps.setCreateTime(new Date());
sparePartStockAuditMapper.updateById(resultSps);
}else{
//没领过配件则创建新的领用单
SparePartStockAudit sparePartStockAudit = getSparePartStockAudit(repairOrderParam);
sparePartStockAudit.setReceiveStatus(AuditStateEnum.UNREVIEWED.getStatus());
sparePartStockAuditMapper.insert(sparePartStockAudit);
}
if(repairOrderStepData1 != null){
//维修单步骤数据
repairOrderStepDataMapper.updateById(new RepairOrderStepData(
repairOrderStepData1.getId(),
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
RepairOrderStopEnum.RECOLLAR_FITTING.getStatus(),
repairOrderParam.getScrapOrNot(),
FrontThreadLocal.getUserId().longValue(),
new Date()));
}else{
//维修单步骤数据
repairOrderStepDataMapper.insert(new RepairOrderStepData(
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
RepairOrderStopEnum.RECOLLAR_FITTING.getStatus(),
repairOrderParam.getScrapOrNot(),
FrontThreadLocal.getUserId().longValue()));
}
// 确认签名
repairOrder.setRepairNextStep(RepairOrderStopEnum.CONFIRMATION_SIGNATURE.getStatus()); // 下个步骤
repairOrderMapper.updateById(repairOrder); // 更新维修单
return;
} else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.CONFIRMATION_SIGNATURE.getStatus()) {
//判断当前订单是否仓管员已拍照上传
SparePartStockAudit resultSps = sparePartStockAuditMapper.findSparePartStockAuditByOrderId(repairOrder.getId()
, SparePartStockAuditEnum.REPAIR_ORDER.getStatus());
if(resultSps.getReceiveStatus() != AuditStateEnum.TO_BE_CONFIRMED.getStatus()){
throw new OperateException("当前状态不可操作！");
}
// 确认签名
repairOrder.setRepairNextStep(RepairOrderStopEnum.PRE_MAINTENANCE_IMG.getStatus()); // 下个步骤
//确认签名完变成维修中
repairOrder.setOrderStatus(RepairOrderStatusEnum.IN_MAINTENANCE.getStatus());
//配件领用单变成已完成
resultSps.setReceiveStatus(AuditStateEnum.FINISHED.getStatus()); // 已完成
sparePartStockAuditMapper.updateById(resultSps);
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.PRE_MAINTENANCE_IMG.getStatus()) {
// 上传维修前图片
repairOrder.setRepairNextStep(RepairOrderStopEnum.IN_MAINTENANCE_IMG.getStatus()); // 下个步骤
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.IN_MAINTENANCE_IMG.getStatus()) {
// 上传维修中图片
// 更新不更新步骤
if(repairOrderStepData1 == null){
repairOrder.setRepairNextStep(RepairOrderStopEnum.AFTER_REPAIR_IMG.getStatus()); // 下个步骤
}
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.AFTER_REPAIR_IMG.getStatus()) {
// 上传维修后图片
// 更新不更新步骤
if(repairOrderStepData1 == null){
repairOrder.setRepairNextStep(RepairOrderStopEnum.REINFORCING_THREE_ANTI_PAINT.getStatus()); // 下个步骤
}
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.REINFORCING_THREE_ANTI_PAINT.getStatus()) {
// 补强三防漆
// 更新不更新步骤
if(repairOrderStepData1 == null){
repairOrder.setRepairNextStep(RepairOrderStopEnum.REINFORCING_DISPENSING.getStatus()); // 下个步骤
}
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.REINFORCING_DISPENSING.getStatus()) {
// 补强点胶
// 更新不更新步骤
if(repairOrderStepData1 == null){
repairOrder.setRepairNextStep(RepairOrderStopEnum.DC_AND_PFC_ASSEMBLE.getStatus()); // 下个步骤
}
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.DC_AND_PFC_ASSEMBLE.getStatus()) {
// DC&PFC组装
// 更新不更新步骤
if(repairOrderStepData1 == null){
repairOrder.setRepairNextStep(RepairOrderStopEnum.REINFORCING_THREE_ANTI_PAINT_AND_DISPENSING.getStatus()); // 下个步骤
}
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.REINFORCING_THREE_ANTI_PAINT_AND_DISPENSING.getStatus()) {
// 补强三防漆和点胶
// 更新不更新步骤
if(repairOrderStepData1 == null){
repairOrder.setRepairNextStep(RepairOrderStopEnum.MODULE_ASSEMBLY.getStatus()); // 下个步骤
}
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.MODULE_ASSEMBLY.getStatus()) {
// 模块装配
//模块装配完变成测试中
// 更新不更新步骤
if(repairOrderStepData1 == null){
repairOrder.setOrderStatus(RepairOrderStatusEnum.TEST_IN_PROCESS.getStatus());
repairOrder.setRepairNextStep(RepairOrderStopEnum.FUNCTIONAL_TEST.getStatus()); // 下个步骤
}
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.FUNCTIONAL_TEST.getStatus()) {
// 功能测试
// 更新不更新步骤
if(repairOrderStepData1 != null){
//维修单步骤数据
repairOrderStepDataMapper.updateById(new RepairOrderStepData(
repairOrderStepData1.getId(),
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
repairOrderParam.getFunctionalTestPassed(),
FrontThreadLocal.getUserId().longValue(),
new Date()));
}else{
repairOrder.setRepairStep(repairOrderParam.getRepairStep());// 当前步骤
repairOrder.setFunctionalTestPassed(repairOrderParam.getFunctionalTestPassed()); // 功能测试是否通过（0=是，1=否）
if(repairOrderParam.getFunctionalTestPassed() == RepairOrderStatusEnum.YES.getStatus()){
repairOrder.setRepairNextStep(RepairOrderStopEnum.AGING_TEST.getStatus()); // 下个步骤
}else{
repairOrder.setRepairNextStep(RepairOrderStopEnum.FUNCTIONAL_TEST.getStatus()); // 下个步骤
}
repairOrderMapper.updateById(repairOrder); // 更新维修单
//维修单步骤数据
repairOrderStepDataMapper.insert(new RepairOrderStepData(repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
repairOrderParam.getFunctionalTestPassed(),
FrontThreadLocal.getUserId().longValue()));
}
return;
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.AGING_TEST.getStatus()) {
// 老化测试
// 更新不更新步骤
if(repairOrderStepData1 != null){
//维修单步骤数据
repairOrderStepDataMapper.updateById(new RepairOrderStepData(
repairOrderStepData1.getId(),
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
repairOrderParam.getAgingTestPassed(),
FrontThreadLocal.getUserId().longValue(),
new Date()));
}else{
repairOrder.setRepairStep(repairOrderParam.getRepairStep());// 当前步骤
repairOrder.setAgingTestPassed(repairOrderParam.getAgingTestPassed()); // 老化测试是否通过（0=是，1=否）
if(repairOrderParam.getAgingTestPassed() == RepairOrderStatusEnum.YES.getStatus()){
repairOrder.setRepairNextStep(RepairOrderStopEnum.PACKAGE_AND_SHIP.getStatus()); // 下个步骤
}else{
repairOrder.setRepairNextStep(RepairOrderStopEnum.AGING_TEST.getStatus()); // 下个步骤
}
repairOrderMapper.updateById(repairOrder); // 更新维修单
//维修单步骤数据
repairOrderStepDataMapper.insert(new RepairOrderStepData(repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
repairOrderParam.getAgingTestPassed(),
FrontThreadLocal.getUserId().longValue()));
}
return;
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.PACKAGE_AND_SHIP.getStatus()) {
// 包装出货
repairOrder.setExpressName(repairOrderParam.getExpressName());// 快递名称
repairOrder.setExpressNo(repairOrderParam.getExpressNo());// 快递单号
//客户确认报废，完成包装出货就已完成
if(repairOrder.getScrapConfirmation() != null){
if(repairOrder.getScrapConfirmation() == RepairOrderStatusEnum.YES.getStatus()){
repairOrder.setOrderStatus(RepairOrderStatusEnum.FINISHED.getStatus()); // 已完成
repairOrder.setOrderAccomplishTime(new Date()); // 订单完成时间
repairOrderMapper.updateById(repairOrder); // 更新维修单
//维修单步骤数据
repairOrderStepDataMapper.insert(new RepairOrderStepData(
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
FrontThreadLocal.getUserId().longValue()));
//新增维修单操作记录
RepairOrderStepData repairOrderStepData = new RepairOrderStepData();
repairOrderStepData.setRepairOrderId(repairOrder.getId());
repairOrderStepData.setTitle("结束");
repairOrderStepData.setCreatorId(FrontThreadLocal.getUserId().longValue());
repairOrderStepDataMapper.insert(repairOrderStepData);
return;
}
} else {
repairOrder.setRepairNextStep(RepairOrderStopEnum.FILL_IN_THE_RECEIPT.getStatus()); // 下个步骤
}
}else if (repairOrderParam.getRepairStep() == RepairOrderStopEnum.FILL_IN_THE_RECEIPT.getStatus()) {
// 填写回单
//填写回单完变成已完成
repairOrder.setOrderStatus(RepairOrderStatusEnum.FINISHED.getStatus());
repairOrder.setOrderAccomplishTime(new Date()); // 完成时间
repairOrder.setRepairNextStep(RepairOrderStopEnum.FINISH.getStatus()); // 下个步骤
repairOrder.setFaultId(repairOrderParam.getFaultId()); // 维修结论类型id
repairOrder.setFaultDescription(repairOrderParam.getFaultDescription()); // 维修结论描述
repairOrder.setRepairStep(repairOrderParam.getRepairStep());// 当前步骤
repairOrderMapper.updateById(repairOrder); // 更新维修单
//维修单步骤数据
repairOrderStepDataMapper.insert(new RepairOrderStepData(
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
FrontThreadLocal.getUserId().longValue()));
//新增维修单操作记录
RepairOrderStepData repairOrderStepData = new RepairOrderStepData();
repairOrderStepData.setRepairOrderId(repairOrder.getId());
repairOrderStepData.setTitle("结束");
repairOrderStepData.setCreatorId(FrontThreadLocal.getUserId().longValue());
repairOrderStepDataMapper.insert(repairOrderStepData);
return;
} else {
throw new OperateException("当前步骤不正确！");
}
repairOrder.setRepairStep(repairOrder.getRepairNextStep());// 当前步骤
//维修单步骤数据
repairOrderStepDataMapper.insert(new RepairOrderStepData(repairOrderParam.getId(),
RepairOrderStopEnum.RINSE.getStatus(),repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairNextStep()),
FrontThreadLocal.getUserId().longValue()));
if(repairOrderStepData1 != null){
//维修单步骤数据
repairOrderStepDataMapper.updateById(new RepairOrderStepData(
repairOrderStepData1.getId(),
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
FrontThreadLocal.getUserId().longValue(),
new Date()));
}else{
//维修单步骤数据
repairOrderStepDataMapper.insert(new RepairOrderStepData(
repairOrderParam.getId(),
repairOrder.getRepairStep(),
repairOrderParam.getRepairOrderStepRemark(),
repairOrderParam.getRepairOrderStepImg(),
RepairOrderStopEnum.getMsgByCode(repairOrder.getRepairStep()),
FrontThreadLocal.getUserId().longValue()));
}
repairOrderMapper.updateById(repairOrder); // 更新维修单
}
/**
* 退单
* 备件领用申请
*/
@Override
@Transactional
public void refundOrder(RepairOrderParam repairOrderParam) {
public void sparePartsRequisition(RepairOrderParam repairOrderParam) {
RepairOrder repairOrder = repairOrderMapper.findRepairOrderById(repairOrderParam.getId());
Assert.notNull(repairOrder, "数据不存在");
Assert.notNull(repairOrderParam.getCancelCause(), "退单原因不可为空");
repairOrder.setCancelOrderTime(new Date()); //取消时间
repairOrder.setCancelCause(repairOrderParam.getCancelCause()); //取消原因
if(repairOrderParam.getIsClient() == MaintenanceOrderStatusEnum.CLIENT.getStatus()){
if(repairOrder.getOrderStatus() == MaintenanceOrderStatusEnum.WAITING_LIST.getStatus() ||
repairOrder.getOrderStatus() == MaintenanceOrderStatusEnum.PENDING_ORDER.getStatus()){
repairOrder.setOrderStatus(MaintenanceOrderStatusEnum.CLOSED.getStatus());
repairOrderMapper.updateById(repairOrder);
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(repairOrder.getId()
,OrderOperateRecordEnum.REFUND.getDesc()
,"【"+FrontThreadLocal.get("username")+"】已退单。退单原因："+repairOrder.getCancelCause());
}else{
throw new OperateException("当前订单状态不可退单");
}
}else {
if(repairOrder.getOrderStatus() == MaintenanceOrderStatusEnum.CHECKING.getStatus() ||
repairOrder.getOrderStatus() == MaintenanceOrderStatusEnum.PENDING_ORDER.getStatus()){
/*if(repairOrder.getRepairWorkOrderFlow() == OrderStateEnum.WORK_ORDER_TANK.getStatus()){
repairOrder.setOrderStatus(MaintenanceOrderStatusEnum.WAITING_LIST.getStatus());
repairOrder.setReceiverId(null);
repairOrder.setReceiverTime(null);
//我的仓库领用
if(repairOrder.getWarehouseType() == MaintenanceOrderStatusEnum.MY_WAREHOUSE.getStatus()){
//获取领用备件列表
List<OrderSparePart> orderSpareParts = orderSparePartMapper.findOrderSparePartByRepairOrderId(repairOrder.getId());
for (OrderSparePart item : orderSpareParts) {
//获取备件信息
SparePart sparePart = sparePartMapper.findSparePartById(item.getSparePartsId());
if(sparePart.getQuantity() >= item.getQuantity()){
//扣除对应的数量
sparePart.setQuantity(sparePart.getQuantity() - item.getQuantity());
sparePartMapper.updateById(sparePart);
}else{
repairOrder.setOrderStatus(MaintenanceOrderStatusEnum.CHARGEBACK.getStatus());
}*/
throw new OperateException("仓库中【" + sparePart.getSparePartsName() + "】备件数量不足" + item.getQuantity() + sparePart.getUnit() + "，配件领用失败");
}
}
repairOrder.setIsConfirmReceipt(MaintenanceOrderStatusEnum.CONFIRM_RECEIPT.getStatus());
repairOrder.setIsMaintain(MaintenanceOrderStatusEnum.MAINTAIN.getStatus());
repairOrderMapper.updateById(repairOrder);
repairOrderMapper.updateById(repairOrder);
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(repairOrder.getId()
,OrderOperateRecordEnum.SPARE_PARTS_RECEIVE.getDesc()
,OrderOperateRecordEnum.SPARE_PARTS_RECEIVE_TYPE.getStatus()
,"【"+FrontThreadLocal.get("username")+"】创建了【配件领用】单。选择仓库：自身仓库。");
//我的仓库也要新增配件领用记录 并且状态是已完成
/*SparePartStockAudit sparePartStockAudit = getSparePartStockAudit(maintenanceOrderParam);
sparePartStockAudit.setPurchaseStatus(AuditStateEnum.DONE.getStatus());
sparePartStockAuditMapper.insert(sparePartStockAudit);*/
}else{
SparePartStockAudit resultSps = sparePartStockAuditMapper.findSparePartStockAuditByOrderId(repairOrder.getId()
, SparePartStockAuditEnum.REPAIR_ORDER.getStatus());
if(resultSps != null){
//已有领取记录但被拒绝则重新审核
resultSps.setPurchaseStatus(AuditStateEnum.UNREVIEWED.getStatus());
resultSps.setCreateTime(new Date());
sparePartStockAuditMapper.updateById(resultSps);
}else{
//没领过配件则创建新的领用单
SparePartStockAudit sparePartStockAudit = getSparePartStockAudit(repairOrderParam);
sparePartStockAudit.setPurchaseStatus(AuditStateEnum.UNREVIEWED.getStatus());
sparePartStockAuditMapper.insert(sparePartStockAudit);
//新增维修单操作记录
orderOperateRecordService.addRepairOrder(repairOrder.getId()
,OrderOperateRecordEnum.REFUND.getDesc()
,"【"+FrontThreadLocal.get("username")+"】已退单。退单原因："+repairOrder.getCancelCause());
}else{
throw new OperateException("当前订单状态不可退单");
,OrderOperateRecordEnum.SPARE_PARTS_RECEIVE.getDesc()
,OrderOperateRecordEnum.SPARE_PARTS_RECEIVE_TYPE.getStatus()
,"【"+FrontThreadLocal.get("username")+"】创建了配件领用申请单。");
}
}
}

4
front/src/main/java/com/hcy/front/validate/order/RepairOrderParam.java
View File

@ -95,7 +95,7 @@ public class RepairOrderParam implements Serializable {
private Date cancelOrderTime; // 改派订单时间
private String cancelCause; // 改派原因
//服务报价列表
//配件领用列表
private List<SparePartParam> sparePartParams;
private Integer isClient; //是否客户 0-客户端 1-检修员端
@ -118,7 +118,7 @@ public class RepairOrderParam implements Serializable {
private Integer isConfirmReceipt; //是否确认收货 0-未收货 1-已收货
private String completeImg; // 完工照片
private Long clientScrapAddressId; // 客户报废收货地址
private Long scrapConfirmation; // 报废确认（0=是，1=否）
private Integer scrapConfirmation; // 报废确认（0=是，1=否）
private Integer priority; // 优先级（0=加急，1=普通）
private Integer isReassignment; // 是否在改派中（0=是，1=否）

7
front/src/main/java/com/hcy/front/vo/order/OrderStatusCountVo.java
View File

@ -11,13 +11,16 @@ import java.io.Serializable;
public class OrderStatusCountVo implements Serializable {
private static final long serialVersionUID = 1L;
//维修工单状态 0-待接单；1-待维修；2-排查中；3-待确认；4-维修中；5-测试中；6-已完成；
private Integer pendingOrderCount; // 待接单数量
private Integer checkingCount; // 检测中数量
private Integer waitingRepairCount; // 待维修数量
private Integer underInvestigationCount; // 排查中数量
private Integer toBeConfirmedCount; // 待确认数量
private Integer inMaintenanceCount; // 维修中数量
private Integer testInProcessCount; // 测试中数量
private Integer completedCount; // 已完成数量
private Integer checkingCount; // 检测中数量
private Integer toBeInspectedCount; // 待巡检数量
private Integer duringInspectionCount; // 巡检中

7
front/src/main/java/com/hcy/front/vo/order/RepairOrderDetailVo.java
View File

@ -2,6 +2,8 @@ package com.hcy.front.vo.order;
import com.hcy.common.entity.address.UserAddress;
import com.hcy.common.entity.client.Equipment;
import com.hcy.common.entity.order.OrderPartCode;
import com.hcy.common.entity.order.RepairOrderStepData;
import com.hcy.front.vo.address.UserAddressListVo;
import com.hcy.front.vo.client.EquipmentListVo;
import com.hcy.front.vo.client.EquipmentModelDetailVo;
@ -89,7 +91,7 @@ public class RepairOrderDetailVo implements Serializable {
private Long clientScrapAddressId; // 客户报废收货地址id
private UserAddressListVo clientScrapAddress; //客户报废收货地址
private Long scrapConfirmation; // 报废确认（0=是，1=否）
private Integer scrapConfirmation; // 报废确认（0=是，1=否）
private Integer warehouseType; // 仓库类型 0-我的仓库 1-公共仓库
private Integer priority; // 优先级（0=加急，1=普通）
@ -105,5 +107,6 @@ public class RepairOrderDetailVo implements Serializable {
private Integer repairStep; // 当前步骤（0=拆机，1=清洗，2=故障排查，3=确认签名，4=重领配件，5=上传维修前图片，6=上传维修中图片，7=上传维修后图片，8=补强三防漆，9=补强点胶，10=DC&PFC组装，11=补强三防漆和点胶，12=模块装配，13=功能测试，14=老化测试，15=包装出货，16=填写回单）
private Integer repairNextStep; // 下个步骤（0=拆机，1=清洗，2=故障排查，3=确认签名，4=重领配件，5=上传维修前图片，6=上传维修中图片，7=上传维修后图片，8=补强三防漆，9=补强点胶，10=DC&PFC组装，11=补强三防漆和点胶，12=模块装配，13=功能测试，14=老化测试，15=包装出货，16=填写回单）
private List<OrderPartCode> orderPartCodeList; // 配件编码列表
private List<RepairOrderStepDataVo> repairOrderStepDataList; // 维修单步骤数据列表
}

5
front/src/main/java/com/hcy/front/vo/order/RepairOrderListVo.java
View File

@ -1,11 +1,13 @@
package com.hcy.front.vo.order;
import com.hcy.common.entity.order.OrderPartCode;
import com.hcy.front.vo.sparePartStockAudit.SparePartStockAuditDetailVo;
import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
/**
* RepairOrderVo
@ -69,7 +71,7 @@ public class RepairOrderListVo implements Serializable {
private BigDecimal actualAmount; // 实际金额
private Long clientScrapAddressId; // 客户报废收货地址
private Long scrapConfirmation; // 报废确认（0=是，1=否）
private Integer scrapConfirmation; // 报废确认（0=是，1=否）
private SparePartStockAuditDetailVo sparePartStockAudit; //备件领用信息
@ -85,5 +87,6 @@ public class RepairOrderListVo implements Serializable {
private String moduleCode; // 模块代码
private Integer repairStep; // 当前步骤（0=拆机，1=清洗，2=故障排查，3=确认签名，4=重领配件，5=上传维修前图片，6=上传维修中图片，7=上传维修后图片，8=补强三防漆，9=补强点胶，10=DC&PFC组装，11=补强三防漆和点胶，12=模块装配，13=功能测试，14=老化测试，15=包装出货，16=填写回单）
private Integer repairNextStep; // 下个步骤（0=拆机，1=清洗，2=故障排查，3=确认签名，4=重领配件，5=上传维修前图片，6=上传维修中图片，7=上传维修后图片，8=补强三防漆，9=补强点胶，10=DC&PFC组装，11=补强三防漆和点胶，12=模块装配，13=功能测试，14=老化测试，15=包装出货，16=填写回单）
private List<OrderPartCode> orderPartCodeList; // 配件编码列表
}

21
front/src/main/java/com/hcy/front/vo/order/RepairOrderStepDataVo.java 100644
View File

@ -0,0 +1,21 @@
package com.hcy.front.vo.order;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
@Data
public class RepairOrderStepDataVo implements Serializable {
private Long id; // 主键id
private Long repairOrderId; // 维修单id
private Integer repairStep; // 当前步骤（0=拆机，1=清洗，2=故障排查，3=确认签名，4=重领配件，5=上传维修前图片，6=上传维修中图片，7=上传维修后图片，8=补强三防漆，9=补强点胶，10=DC&PFC组装，11=补强三防漆和点胶，12=模块装配，13=功能测试，14=老化测试，15=包装出货，16=填写回单）
private String remark; // 备注
private String img; // 照片
private String title; // 标题
private Integer dscType; // 描述类型：0=配件领用
private Integer auditStatus; // 审核状态（0=通过，1=不通过）
private Long creatorId; // 创建人id
private Date createTime; // 创建时间
private String creatorName; // 创建人名称
}

3
front/src/main/java/com/hcy/front/vo/sparePartStockAudit/SparePartStockAuditDetailVo.java
View File

@ -49,7 +49,8 @@ public class SparePartStockAuditDetailVo implements Serializable {
private String recipient; //领用员工
private String recipientPhone; //领用员工联系电话
private Integer recipientNumber; //领用数量
private Integer purchaseStatus; //配件领用状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer purchaseStatus; //配件采购状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer receiveStatus; // 配件领用状态（0=未审核，1=审核未通过，2=待领取，3=待确认，4=已完成）
private Date createTime; // 创建时间
private Integer orderType; // 0-检修工单 1-维修工单

5
front/src/main/java/com/hcy/front/vo/sparePartStockAudit/SparePartStockAuditListVo.java
View File

@ -48,10 +48,11 @@ public class SparePartStockAuditListVo implements Serializable {
private String recipient; //领用员工
private String recipientPhone; //领用员工联系电话
private Integer recipientNumber; //领用数量
private Integer purchaseStatus; //配件领用状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer purchaseStatus; //配件采购状态（0=待审核，1=未通过，2=待管理员审核，3=待发货，4=待收货，5=已完成）
private Integer receiveStatus; // 配件领用状态（0=未审核，1=审核未通过，2=待领取，3=待确认，4=已完成）
private String workOrderNo; //工单号
private String recipientAndPhone; //领用员工/联系电话
private String supplierPhone; // 供应商/电话
private String creator; // 创建人
private String warehouseKeeperImg; // 仓管员上传图片
}

10
front/target/classes/application.yml
View File

@ -59,6 +59,8 @@ spring:
mybatis-plus:
mapper-locations: classpath*:/mapper/**Mapper.xml # 映射文件路径
typeAliasesPackage: com.hcy.**.mapper
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
global-config:
banner: false
db-config:
@ -87,5 +89,9 @@ byte:
query-order-url: https://developer.toutiao.com/api/apps/ecpay/v1/query_order
query-refund-url: https://developer.toutiao.com/api/apps/ecpay/v1/query_refund
netty:
port: 8081
path: /staff
port: 8083
path: /staff
#adnin服务地址
adminService:
sendLargeScreenUrl : http://localhost:8082/api/system/notification/sendLargeScreen