licq/heli-mes
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

装配派工人员改为多选

Browse Source 
不管控装配派工数量及顺序
装配派工中有一个人报工了，不允许修改数据
小程序提交配套逻辑修改
This commit is contained in:
Ledo 2025-05-16 00:28:24 +08:00
parent 6f82360744
commit 1d24328e6e
19 changed files with 1001 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mes-module-heli/mes-module-heli-api/src/main/java/com/chanko/yunxi/mes/module/heli/enums/ErrorCodeConstants.java
View File

@ -104,7 +104,7 @@ public interface ErrorCodeConstants {
ErrorCode TASK_REPORT_PARAMS_ERRORBG = new ErrorCode(1_009_009, "开始报工和结束报工操作人员不同，无法报工");
ErrorCode TASK_REPORT_PARAMS_ERRORJD = new ErrorCode(1_009_010, "报工进度不能超过100%");
ErrorCode TASK_REPORT_PARAMS_ERRORSJBG = new ErrorCode(1_009_011, "报工进度不能小于上次报工进度");
ErrorCode TASK_DISPATCH_DETAIL_OWNER_NOT_EXISTS = new ErrorCode(1_009_006,"派工明细不存在");
ErrorCode TASK_DISPATCH_TASK_NOT_EXISTS = new ErrorCode(1_009_004, "任务不存在或已完成");
ErrorCode TASK_DISPATCH_TASK_NO_PERMISSION_FOR_OPERATE = new ErrorCode(1_009_005, "任务不满足操作条件");
ErrorCode TASK_DISPATCH_TASK_IS_OVER = new ErrorCode(1_009_007, "报工数量已完成");

21
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/controller/admin/taskdispatch/TaskDispatchController.java
View File

@ -138,18 +138,29 @@ public class TaskDispatchController {
@GetMapping("/task-dispatch-detail/list-by-dispatch-id")
@Operation(summary = "获得派工明细列表")
@Parameter(name = "dispatchId", description = "派工单id")
@Parameter(name = "dispatchId", description = "派工单id",required = true)
@Parameter(name = "dispatchType", description = "派工单类型",required = false)
@PreAuthorize("@ss.hasPermission('heli:task-dispatch:query')")
public CommonResult<List<TaskDispatchDetailDO>> getTaskDispatchDetailListByDispatchId(@RequestParam("dispatchId") Long dispatchId) {
return success(taskDispatchService.getTaskDispatchDetailListByDispatchId(dispatchId));
public CommonResult<List<TaskDispatchDetailDO>> getTaskDispatchDetailListByDispatchId(@RequestParam("dispatchId") Long dispatchId,@RequestParam("dispatchType") String dispatchType) {
if (dispatchType != null){
return success(taskDispatchService.getTaskDispatchDetailListByDispatchNew(dispatchId));
}else {
return success(taskDispatchService.getTaskDispatchDetailListByDispatchId(dispatchId));
}
}
@DeleteMapping("/task-dispatch-detail/delete")
@Operation(summary = "删除派工单")
@Parameter(name = "id", description = "编号", required = true)
@Parameter(name = "dispatchType", description = "派工单类型",required = false)
@PreAuthorize("@ss.hasPermission('heli:task-dispatch:delete')")
public CommonResult<Boolean> deleteTaskDispatchDetail(@RequestParam("id") Long id) {
taskDispatchService.deleteTaskDispatchDetail(id);
public CommonResult<Boolean> deleteTaskDispatchDetail(@RequestParam("id") Long id,@RequestParam("dispatchType") String dispatchType) {
if (dispatchType != null){
taskDispatchService.deleteTaskDispatchDetailOwner(id);
}else {
taskDispatchService.deleteTaskDispatchDetail(id);
}
return success(true);
}

4
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/controller/admin/taskdispatch/vo/TaskDispatchSaveReqVO.java
View File

@ -1,5 +1,6 @@
package com.chanko.yunxi.mes.module.heli.controller.admin.taskdispatch.vo;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatchdetailowner.TaskDispatchDetailOwnerDO;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
@ -52,7 +53,8 @@ public class TaskDispatchSaveReqVO {
@Schema(description = "派工明细列表")
private List<TaskDispatchDetailDO> taskDispatchDetails;
@Schema(description = "装配派工明细列表")
private List<TaskDispatchDetailOwnerDO> taskDispatchDetailOwnerDOList;
@Schema(description = "操作类型")
@NotBlank(message = "操作类型不能为空")
private String active;

95
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/controller/admin/taskdispatchdetailowner/TaskDispatchDetailOwnerController.java Normal file
View File

@ -0,0 +1,95 @@
package com.chanko.yunxi.mes.module.heli.controller.admin.taskdispatchdetailowner;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.common.pojo.CommonResult;
import com.chanko.yunxi.mes.framework.common.util.object.BeanUtils;
import static com.chanko.yunxi.mes.framework.common.pojo.CommonResult.success;
import com.chanko.yunxi.mes.framework.excel.core.util.ExcelUtils;
import com.chanko.yunxi.mes.framework.operatelog.core.annotations.OperateLog;
import static com.chanko.yunxi.mes.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.chanko.yunxi.mes.module.heli.controller.admin.taskdispatchdetailowner.vo.*;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatchdetailowner.TaskDispatchDetailOwnerDO;
import com.chanko.yunxi.mes.module.heli.service.taskdispatchdetailowner.TaskDispatchDetailOwnerService;
@Tag(name = "管理后台 - 派工明细负责人")
@RestController
@RequestMapping("/heli/task-dispatch-detail-owner")
@Validated
public class TaskDispatchDetailOwnerController {
@Resource
private TaskDispatchDetailOwnerService taskDispatchDetailOwnerService;
@PostMapping("/create")
@Operation(summary = "创建派工明细负责人")
@PreAuthorize("@ss.hasPermission('heli:task-dispatch-detail-owner:create')")
public CommonResult<Long> createTaskDispatchDetailOwner(@Valid @RequestBody TaskDispatchDetailOwnerSaveReqVO createReqVO) {
return success(taskDispatchDetailOwnerService.createTaskDispatchDetailOwner(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新派工明细负责人")
@PreAuthorize("@ss.hasPermission('heli:task-dispatch-detail-owner:update')")
public CommonResult<Boolean> updateTaskDispatchDetailOwner(@Valid @RequestBody TaskDispatchDetailOwnerSaveReqVO updateReqVO) {
taskDispatchDetailOwnerService.updateTaskDispatchDetailOwner(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除派工明细负责人")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('heli:task-dispatch-detail-owner:delete')")
public CommonResult<Boolean> deleteTaskDispatchDetailOwner(@RequestParam("id") Long id) {
taskDispatchDetailOwnerService.deleteTaskDispatchDetailOwner(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得派工明细负责人")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('heli:task-dispatch-detail-owner:query')")
public CommonResult<TaskDispatchDetailOwnerRespVO> getTaskDispatchDetailOwner(@RequestParam("id") Long id) {
TaskDispatchDetailOwnerDO taskDispatchDetailOwner = taskDispatchDetailOwnerService.getTaskDispatchDetailOwner(id);
return success(BeanUtils.toBean(taskDispatchDetailOwner, TaskDispatchDetailOwnerRespVO.class));
}
@GetMapping("/page")
@Operation(summary = "获得派工明细负责人分页")
@PreAuthorize("@ss.hasPermission('heli:task-dispatch-detail-owner:query')")
public CommonResult<PageResult<TaskDispatchDetailOwnerRespVO>> getTaskDispatchDetailOwnerPage(@Valid TaskDispatchDetailOwnerPageReqVO pageReqVO) {
PageResult<TaskDispatchDetailOwnerDO> pageResult = taskDispatchDetailOwnerService.getTaskDispatchDetailOwnerPage(pageReqVO);
return success(BeanUtils.toBean(pageResult, TaskDispatchDetailOwnerRespVO.class));
}
@GetMapping("/export-excel")
@Operation(summary = "导出派工明细负责人 Excel")
@PreAuthorize("@ss.hasPermission('heli:task-dispatch-detail-owner:export')")
@OperateLog(type = EXPORT)
public void exportTaskDispatchDetailOwnerExcel(@Valid TaskDispatchDetailOwnerPageReqVO pageReqVO,
HttpServletResponse response) throws IOException {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<TaskDispatchDetailOwnerDO> list = taskDispatchDetailOwnerService.getTaskDispatchDetailOwnerPage(pageReqVO).getList();
// 导出 Excel
ExcelUtils.write(response, "派工明细负责人.xls", "数据", TaskDispatchDetailOwnerRespVO.class,
BeanUtils.toBean(list, TaskDispatchDetailOwnerRespVO.class));
}
}

74
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/controller/admin/taskdispatchdetailowner/vo/TaskDispatchDetailOwnerPageReqVO.java Normal file
View File

@ -0,0 +1,74 @@
package com.chanko.yunxi.mes.module.heli.controller.admin.taskdispatchdetailowner.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
import java.math.BigDecimal;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.chanko.yunxi.mes.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 派工明细负责人分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class TaskDispatchDetailOwnerPageReqVO extends PageParam {
@Schema(description = "派工单id", example = "29399")
private Long dispatchId;
@Schema(description = "工序id", example = "18588")
private Long procedureId;
@Schema(description = "顺序号")
private Integer sort;
@Schema(description = "负责人")
private Long owner;
@Schema(description = "多个负责人")
private String ownerIds;
@Schema(description = "设备型号")
private Long deviceModel;
@Schema(description = "预计开始日期")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] startTime;
@Schema(description = "预计结束日期")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] endTime;
@Schema(description = "预计工时")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private BigDecimal[] workTime;
@Schema(description = "派工数量")
private BigDecimal amount;
@Schema(description = "工序要点")
private String summary;
@Schema(description = "工序状态 默认|已提交|已完成 0|1|2", example = "2")
private Boolean procedureStatus;
@Schema(description = "状态,1表示正常，2表示禁用", example = "1")
private Boolean status;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
@Schema(description = "报工数量")
private BigDecimal workAmountTotal;
@Schema(description = "报工工时")
private BigDecimal workTimeTotal;
@Schema(description = "产品明细id", example = "30922")
private Long projectSubId;
}

89
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/controller/admin/taskdispatchdetailowner/vo/TaskDispatchDetailOwnerRespVO.java Normal file
View File

@ -0,0 +1,89 @@
package com.chanko.yunxi.mes.module.heli.controller.admin.taskdispatchdetailowner.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.util.*;
import java.math.BigDecimal;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.*;
@Schema(description = "管理后台 - 派工明细负责人 Response VO")
@Data
@ExcelIgnoreUnannotated
public class TaskDispatchDetailOwnerRespVO {
@Schema(description = "自增字段，唯一", requiredMode = Schema.RequiredMode.REQUIRED, example = "27251")
@ExcelProperty("自增字段，唯一")
private Long id;
@Schema(description = "派工单id", requiredMode = Schema.RequiredMode.REQUIRED, example = "29399")
@ExcelProperty("派工单id")
private Long dispatchId;
@Schema(description = "工序id", requiredMode = Schema.RequiredMode.REQUIRED, example = "18588")
@ExcelProperty("工序id")
private Long procedureId;
@Schema(description = "顺序号")
@ExcelProperty("顺序号")
private Integer sort;
@Schema(description = "负责人")
@ExcelProperty("负责人")
private Long owner;
@Schema(description = "多个负责人")
@ExcelProperty("多个负责人")
private String ownerIds;
@Schema(description = "设备型号")
@ExcelProperty("设备型号")
private Long deviceModel;
@Schema(description = "预计开始日期", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("预计开始日期")
private LocalDateTime startTime;
@Schema(description = "预计结束日期", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("预计结束日期")
private LocalDateTime endTime;
@Schema(description = "预计工时", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("预计工时")
private BigDecimal workTime;
@Schema(description = "派工数量", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("派工数量")
private BigDecimal amount;
@Schema(description = "工序要点")
@ExcelProperty("工序要点")
private String summary;
@Schema(description = "工序状态 默认|已提交|已完成 0|1|2", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
@ExcelProperty("工序状态 默认|已提交|已完成 0|1|2")
private Boolean procedureStatus;
@Schema(description = "状态,1表示正常，2表示禁用", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@ExcelProperty("状态,1表示正常，2表示禁用")
private Boolean status;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("创建时间")
private LocalDateTime createTime;
@Schema(description = "报工数量")
@ExcelProperty("报工数量")
private BigDecimal workAmountTotal;
@Schema(description = "报工工时")
@ExcelProperty("报工工时")
private BigDecimal workTimeTotal;
@Schema(description = "产品明细id", example = "30922")
@ExcelProperty("产品明细id")
private Long projectSubId;
}

75
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/controller/admin/taskdispatchdetailowner/vo/TaskDispatchDetailOwnerSaveReqVO.java Normal file
View File

@ -0,0 +1,75 @@
package com.chanko.yunxi.mes.module.heli.controller.admin.taskdispatchdetailowner.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
import java.util.*;
import java.math.BigDecimal;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 派工明细负责人新增/修改 Request VO")
@Data
public class TaskDispatchDetailOwnerSaveReqVO {
@Schema(description = "自增字段，唯一", requiredMode = Schema.RequiredMode.REQUIRED, example = "27251")
private Long id;
@Schema(description = "派工单id", requiredMode = Schema.RequiredMode.REQUIRED, example = "29399")
@NotNull(message = "派工单id不能为空")
private Long dispatchId;
@Schema(description = "工序id", requiredMode = Schema.RequiredMode.REQUIRED, example = "18588")
@NotNull(message = "工序id不能为空")
private Long procedureId;
@Schema(description = "顺序号")
private Integer sort;
@Schema(description = "负责人")
private Long owner;
@Schema(description = "多个负责人")
private String ownerIds;
@Schema(description = "设备型号")
private Long deviceModel;
@Schema(description = "预计开始日期", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "预计开始日期不能为空")
private LocalDateTime startTime;
@Schema(description = "预计结束日期", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "预计结束日期不能为空")
private LocalDateTime endTime;
@Schema(description = "预计工时", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "预计工时不能为空")
private BigDecimal workTime;
@Schema(description = "派工数量", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "派工数量不能为空")
private BigDecimal amount;
@Schema(description = "工序要点")
private String summary;
@Schema(description = "工序状态 默认|已提交|已完成 0|1|2", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
@NotNull(message = "工序状态 默认|已提交|已完成 0|1|2不能为空")
private Boolean procedureStatus;
@Schema(description = "状态,1表示正常，2表示禁用", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@NotNull(message = "状态,1表示正常，2表示禁用不能为空")
private Boolean status;
@Schema(description = "报工数量")
private BigDecimal workAmountTotal;
@Schema(description = "报工工时")
private BigDecimal workTimeTotal;
@Schema(description = "产品明细id", example = "30922")
private Long projectSubId;
}

10
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/dal/dataobject/taskdispatch/TaskDispatchDetailDO.java
View File

@ -7,6 +7,7 @@ import lombok.*;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
/**
* 派工明细 DO
@ -44,6 +45,10 @@ public class TaskDispatchDetailDO extends BaseDO {
* 预计工时
*/
private BigDecimal workTime;
@TableField(exist = false)
private List<Long> owners;
@TableField(exist = false)
private List<String> ownerNames;
/**
* 派工数量
*/
@ -69,12 +74,17 @@ public class TaskDispatchDetailDO extends BaseDO {
*/
@TableField(fill = FieldFill.UPDATE)
private Long deviceModel;
/**
*
*/
@TableField(exist = false)
private Long bomDetailId;
/**
* 预计开始日期
*/
private LocalDateTime startTime;
private Long detailOwnerId;
/**
* 预计结束日期
*/

111
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/dal/dataobject/taskdispatchdetailowner/TaskDispatchDetailOwnerDO.java Normal file
View File

@ -0,0 +1,111 @@
package com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatchdetailowner;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.math.BigDecimal;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.math.BigDecimal;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.*;
import com.chanko.yunxi.mes.framework.mybatis.core.dataobject.BaseDO;
/**
* 派工明细负责人 DO
*
* @author lyw
*/
@TableName("pro_task_dispatch_detail_owner")
@KeySequence("pro_task_dispatch_detail_owner_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库，可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TaskDispatchDetailOwnerDO extends BaseDO {
/**
* 自增字段，唯一
*/
@TableId
private Long id;
/**
* 派工单id
*/
private Long dispatchId;
/**
* 工序id
*/
private Long procedureId;
/**
* 派工数量
*/
private Integer beforeAmount;
/**
* 顺序号
*/
private Integer sort;
/**
* 负责人
*/
private Long owner;
@TableField(exist = false)
private List<Long> owners;
@TableField(exist = false)
private List<String> ownerNames;
/**
* 多个负责人
*/
private String ownerIds;
@TableField(exist = false)
private Long beginProduce;
/**
* 设备型号
*/
private Long deviceModel;
/**
* 预计开始日期
*/
private LocalDateTime startTime;
/**
* 预计结束日期
*/
private LocalDateTime endTime;
/**
* 预计工时
*/
private BigDecimal workTime;
/**
* 派工数量
*/
private Integer amount;
/**
* 工序要点
*/
private String summary;
/**
* 工序状态 默认|已提交|已完成 0|1|2
*/
private Integer procedureStatus;
/**
* 状态,1表示正常，2表示禁用
*/
private Boolean status;
/**
* 报工数量
*/
private BigDecimal workAmountTotal;
/**
* 报工工时
*/
private BigDecimal workTimeTotal;
/**
* 产品明细id
*/
private Long projectSubId;
}

46
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/dal/mysql/taskdispatch/TaskDispatchDetailMapper.java
View File

@ -1,6 +1,7 @@
package com.chanko.yunxi.mes.module.heli.dal.mysql.taskdispatch;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.mybatis.core.mapper.BaseMapperX;
import com.chanko.yunxi.mes.framework.mybatis.core.query.LambdaQueryWrapperX;
@ -15,6 +16,7 @@ import com.chanko.yunxi.mes.module.heli.dal.dataobject.projectorder.ProjectOrder
import com.chanko.yunxi.mes.module.heli.dal.dataobject.projectorder.ProjectOrderSubDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatch.TaskDispatchDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatch.TaskDispatchDetailDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatchdetailowner.TaskDispatchDetailOwnerDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskreport.TaskReportDO;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.ibatis.annotations.Mapper;
@ -121,6 +123,49 @@ public interface TaskDispatchDetailMapper extends BaseMapperX<TaskDispatchDetail
}
public int updateOwnerAndPostIdById(@Param("id") Long id,@Param("type") Integer type);
default int deleteByOwnerId(Long ownerId,Set<String> owner){
UpdateWrapper<TaskDispatchDetailDO> wrapper = new UpdateWrapper();
if (CollUtil.isNotEmpty(owner)){
wrapper.in("owner",owner);
}
wrapper.eq("detail_owner_id",ownerId).set("deleted",1);
return update(wrapper);
}
default int updateByOwner(TaskDispatchDetailOwnerDO taskDispatchDetailOwnerDO, Set<String> owner){
UpdateWrapper<TaskDispatchDetailDO> wrapper = new UpdateWrapper();
wrapper.eq("detail_owner_id",taskDispatchDetailOwnerDO.getId()).in("owner",owner);
if (taskDispatchDetailOwnerDO.getProcedureId() != null) {
wrapper.set("procedure_id", taskDispatchDetailOwnerDO.getProcedureId());
}
if (taskDispatchDetailOwnerDO.getSort() != null){
wrapper.set("sort",taskDispatchDetailOwnerDO.getSort());
}
if (taskDispatchDetailOwnerDO.getDeviceModel() != null) {
wrapper.set("device_model", taskDispatchDetailOwnerDO.getDeviceModel());
}
if (taskDispatchDetailOwnerDO.getStartTime() != null) {
wrapper.set("start_time",taskDispatchDetailOwnerDO.getStartTime());
}
if (taskDispatchDetailOwnerDO.getEndTime() != null) {
wrapper.set("end_time",taskDispatchDetailOwnerDO.getEndTime());
}
if (taskDispatchDetailOwnerDO.getWorkTime() != null) {
wrapper.set("work_time",taskDispatchDetailOwnerDO.getWorkTime());
}
if (taskDispatchDetailOwnerDO.getAmount() != null) {
wrapper.set("amount",taskDispatchDetailOwnerDO.getAmount());
}
if (taskDispatchDetailOwnerDO.getSummary() != null) {
wrapper.set("summary",taskDispatchDetailOwnerDO.getSummary());
}
if (taskDispatchDetailOwnerDO.getProcedureStatus() != null) {
wrapper.set("procedure_status",taskDispatchDetailOwnerDO.getProcedureStatus());
}
if (taskDispatchDetailOwnerDO.getBeforeAmount() != null) {
wrapper.set("before_amount",taskDispatchDetailOwnerDO.getBeforeAmount());
}
return update(wrapper);
}
List<TaskDispatchDetailDO> planBbPage(@Param("reqVO")TaskPlanJDBaoBiaoPageReqVO reqVO);
List<TaskDispatchDetailDO> planBb(@Param("reqVO")TaskPlanJDBaoBiaoPageReqVO reqVO);
// default PageResult<TaskDispatchDetailDO> planBbPage(TaskPlanJDBaoBiaoPageReqVO reqVO) {
@ -291,6 +336,7 @@ public interface TaskDispatchDetailMapper extends BaseMapperX<TaskDispatchDetail
.eq(TaskDispatchDetailDO::getDispatchId, dispatchId);
return selectList(query);
}
default List<TaskDispatchDetailDO> selectListByDispatchIdNew(Long dispatchId) {
MPJLambdaWrapper<TaskDispatchDetailDO> query = new MPJLambdaWrapper<>();
query.selectAll(TaskDispatchDetailDO.class)

57
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/dal/mysql/taskdispatchdetailowner/TaskDispatchDetailOwnerMapper.java Normal file
View File

@ -0,0 +1,57 @@
package com.chanko.yunxi.mes.module.heli.dal.mysql.taskdispatchdetailowner;
import java.util.*;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.chanko.yunxi.mes.framework.mybatis.core.mapper.BaseMapperX;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.procedure.ProcedureDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatch.TaskDispatchDetailDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatchdetailowner.TaskDispatchDetailOwnerDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskreport.TaskReportDO;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.ibatis.annotations.Mapper;
import com.chanko.yunxi.mes.module.heli.controller.admin.taskdispatchdetailowner.vo.*;
/**
* 派工明细负责人 Mapper
*
* @author lyw
*/
@Mapper
public interface TaskDispatchDetailOwnerMapper extends BaseMapperX<TaskDispatchDetailOwnerDO> {
default PageResult<TaskDispatchDetailOwnerDO> selectPage(TaskDispatchDetailOwnerPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<TaskDispatchDetailOwnerDO>()
.eqIfPresent(TaskDispatchDetailOwnerDO::getDispatchId, reqVO.getDispatchId())
.eqIfPresent(TaskDispatchDetailOwnerDO::getProcedureId, reqVO.getProcedureId())
.eqIfPresent(TaskDispatchDetailOwnerDO::getSort, reqVO.getSort())
.eqIfPresent(TaskDispatchDetailOwnerDO::getOwner, reqVO.getOwner())
.eqIfPresent(TaskDispatchDetailOwnerDO::getOwnerIds, reqVO.getOwnerIds())
.eqIfPresent(TaskDispatchDetailOwnerDO::getDeviceModel, reqVO.getDeviceModel())
.betweenIfPresent(TaskDispatchDetailOwnerDO::getStartTime, reqVO.getStartTime())
.betweenIfPresent(TaskDispatchDetailOwnerDO::getEndTime, reqVO.getEndTime())
.betweenIfPresent(TaskDispatchDetailOwnerDO::getWorkTime, reqVO.getWorkTime())
.eqIfPresent(TaskDispatchDetailOwnerDO::getAmount, reqVO.getAmount())
.eqIfPresent(TaskDispatchDetailOwnerDO::getSummary, reqVO.getSummary())
.eqIfPresent(TaskDispatchDetailOwnerDO::getProcedureStatus, reqVO.getProcedureStatus())
.eqIfPresent(TaskDispatchDetailOwnerDO::getStatus, reqVO.getStatus())
.betweenIfPresent(TaskDispatchDetailOwnerDO::getCreateTime, reqVO.getCreateTime())
.eqIfPresent(TaskDispatchDetailOwnerDO::getWorkAmountTotal, reqVO.getWorkAmountTotal())
.eqIfPresent(TaskDispatchDetailOwnerDO::getWorkTimeTotal, reqVO.getWorkTimeTotal())
.eqIfPresent(TaskDispatchDetailOwnerDO::getProjectSubId, reqVO.getProjectSubId())
.orderByDesc(TaskDispatchDetailOwnerDO::getId));
}
default List<TaskDispatchDetailOwnerDO> selectListById(Long dispatchId) {
MPJLambdaWrapper<TaskDispatchDetailOwnerDO> query = new MPJLambdaWrapper<>();
query.selectAll(TaskDispatchDetailOwnerDO.class)
.select("a.is_report as is_report,a.code as procedure_code")
// .select("count(b.amount) as numAmount")
.leftJoin(ProcedureDO.class,"a",ProcedureDO::getId,TaskDispatchDetailOwnerDO::getProcedureId)
// .leftJoin(TaskReportDO.class,"b",TaskReportDO::getDispatchDetailId,TaskDispatchDetailOwnerDO::getId)
.disableSubLogicDel()
.groupBy(TaskDispatchDetailOwnerDO::getId)
.eq(TaskDispatchDetailOwnerDO::getDispatchId, dispatchId);
return selectList(query);
}
}

3
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/dal/mysql/taskreport/TaskReportMapper.java
View File

@ -15,6 +15,7 @@ import com.chanko.yunxi.mes.module.system.dal.dataobject.dept.UserPostDO;
import com.chanko.yunxi.mes.module.system.dal.dataobject.user.AdminUserDO;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.util.StringUtils;
import java.math.BigDecimal;
@ -71,6 +72,6 @@ public interface TaskReportMapper extends BaseMapperX<TaskReportDO> {
query1.eq(TaskReportDO::getDispatchDetailId,dispatchDetailId);
return selectCount(query1);
}
public Long hasReportNew(@Param("ownerId") Long dispatchOwnerId);
}

4
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/service/taskdispatch/TaskDispatchService.java
View File

@ -6,6 +6,7 @@ import com.chanko.yunxi.mes.module.heli.controller.admin.ygjx.vo.YgjxPageReqVO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.fpuserdetail.FpUserDetailDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatch.TaskDispatchDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatch.TaskDispatchDetailDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatchdetailowner.TaskDispatchDetailOwnerDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskreport.TaskReportDO;
import javax.validation.Valid;
@ -74,11 +75,12 @@ public interface TaskDispatchService {
* @return 派工明细列表
*/
List<TaskDispatchDetailDO> getTaskDispatchDetailListByDispatchId(Long dispatchId);
List<TaskDispatchDetailDO> getTaskDispatchDetailListByDispatchNew(Long dispatchId);
void operate(TaskDispatchSaveReqVO operateReqVO);
void deleteTaskDispatchDetail(Long id);
void deleteTaskDispatchDetailOwner(Long id);
PageResult<TaskDispatchDetailDO> getGroupTaskDispatchDetailPage(YgjxPageReqVO pageReqVO);
PageResult<TaskDispatchDetailDO> getTaskDispatchDetailPage(TaskDispatchDetailPageReqVO pageReqVO);
PageResult<TaskDispatchDetailDO> getTaskDispatchDetailPageWx(TaskDispatchDetailPageReqVO pageReqVO);

268
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/service/taskdispatch/TaskDispatchServiceImpl.java
View File

@ -4,6 +4,7 @@ import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.generator.IFill;
import com.chanko.yunxi.mes.framework.common.exception.ErrorCode;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.common.util.object.BeanUtils;
@ -20,6 +21,7 @@ import com.chanko.yunxi.mes.module.heli.dal.dataobject.projectorder.ProjectOrder
import com.chanko.yunxi.mes.module.heli.dal.dataobject.serialnumber.SerialNumberDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatch.TaskDispatchDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatch.TaskDispatchDetailDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatchdetailowner.TaskDispatchDetailOwnerDO;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskreport.TaskReportDO;
import com.chanko.yunxi.mes.module.heli.dal.mysql.bdgzsomthing.bdgzsomthingMapper;
import com.chanko.yunxi.mes.module.heli.dal.mysql.equipmanufacture.EquipManufactureMapper;
@ -29,6 +31,7 @@ import com.chanko.yunxi.mes.module.heli.dal.mysql.procedure.ProcedureMapper;
import com.chanko.yunxi.mes.module.heli.dal.mysql.projectorder.ProjectOrderSubMapper;
import com.chanko.yunxi.mes.module.heli.dal.mysql.taskdispatch.TaskDispatchDetailMapper;
import com.chanko.yunxi.mes.module.heli.dal.mysql.taskdispatch.TaskDispatchMapper;
import com.chanko.yunxi.mes.module.heli.dal.mysql.taskdispatchdetailowner.TaskDispatchDetailOwnerMapper;
import com.chanko.yunxi.mes.module.heli.dal.mysql.taskreport.TaskReportMapper;
import com.chanko.yunxi.mes.module.heli.enums.*;
import com.chanko.yunxi.mes.module.heli.manager.CrossOrderManager;
@ -36,6 +39,7 @@ import com.chanko.yunxi.mes.module.heli.service.pgmaster.PgMasterService;
import com.chanko.yunxi.mes.module.heli.service.serialnumber.SerialNumberService;
import com.chanko.yunxi.mes.module.heli.service.zjpgmaster.ZjPgMasterService;
import com.chanko.yunxi.mes.module.system.dal.dataobject.user.AdminUserDO;
import com.chanko.yunxi.mes.module.system.dal.mysql.user.AdminUserMapper;
import com.chanko.yunxi.mes.module.system.service.user.AdminUserService;
import io.minio.messages.Item;
import org.checkerframework.checker.units.qual.N;
@ -83,8 +87,12 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
@Resource
private FpUserDetailMapper fpUserDetailMapper;
@Resource
private TaskDispatchDetailOwnerMapper taskDispatchDetailOwnerMapper;
@Resource
private PlanMapper planMapper;
@Resource
private AdminUserMapper adminUserMapper;
@Resource
private ZjPgMasterService zjPgMasterService;
@Resource
private PgMasterService pgMasterService;
@ -134,31 +142,52 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
}
// 明细工序状态更新
if(operateTypeEnum == OperateTypeEnum.SUBMIT){
updateReqVO.getTaskDispatchDetails().forEach(taskDispatchDetailDO -> {
if(taskDispatchDetailDO.getProcedureStatus().intValue() == 0||taskDispatchDetailDO.getBeforeAmount()!=taskDispatchDetailDO.getAmount()
){
taskDispatchDetailDO.setBeforeAmount(taskDispatchDetailDO.getAmount());
taskDispatchDetailDO.setProcedureStatus(TaskDispatchProcedureStatusEnum.SUBMITTED.getCode());
}
});
if (updateReqVO.getDispatchType() != null && updateReqVO.getDispatchType().equals("ASSEMBLE")){
updateReqVO.getTaskDispatchDetailOwnerDOList().forEach(taskDispatchDetailDO -> {
if(taskDispatchDetailDO.getProcedureStatus().intValue() == 0 || taskDispatchDetailDO.getBeforeAmount()!=taskDispatchDetailDO.getAmount()
){
taskDispatchDetailDO.setBeforeAmount(taskDispatchDetailDO.getAmount());
taskDispatchDetailDO.setProcedureStatus(TaskDispatchProcedureStatusEnum.SUBMITTED.getCode());
}
});
}else {
updateReqVO.getTaskDispatchDetails().forEach(taskDispatchDetailDO -> {
if(taskDispatchDetailDO.getProcedureStatus().intValue() == 0 || taskDispatchDetailDO.getBeforeAmount()!=taskDispatchDetailDO.getAmount()
){
taskDispatchDetailDO.setBeforeAmount(taskDispatchDetailDO.getAmount());
taskDispatchDetailDO.setProcedureStatus(TaskDispatchProcedureStatusEnum.SUBMITTED.getCode());
}
});
}
}else if (operateTypeEnum == OperateTypeEnum.CANCEL_SUBMIT){
PlanDO planDO = planMapper.selectById(updateReqVO.getPlanId());
if (planDO.getStatus() == 3){
throw exception(new ErrorCode(1_000_099,"计划已完成，不允许取消提交"));
}
updateReqVO.getTaskDispatchDetails().forEach(taskDispatchDetailDO -> {
//2025-01-17 取消提交 - 如果已报工完成的工序，报工状态还是已完成
if (taskDispatchDetailDO.getProcedureStatus() != 2){
taskDispatchDetailDO.setProcedureStatus(TaskDispatchProcedureStatusEnum.DEFAULT.getCode());
if (updateReqVO.getDispatchType() != null && updateReqVO.getDispatchType().equals("ASSEMBLE")){
}else {
updateReqVO.getTaskDispatchDetails().forEach(taskDispatchDetailDO -> {
//2025-01-17 取消提交 - 如果已报工完成的工序，报工状态还是已完成
if (taskDispatchDetailDO.getProcedureStatus() != 2){
taskDispatchDetailDO.setProcedureStatus(TaskDispatchProcedureStatusEnum.DEFAULT.getCode());
}
});
}
});
}
}
updateObj.setDispatchStatus(TaskDispatchStatusEnum.valueOf(updateReqVO.getActive()).getCode());
taskDispatchMapper.updateById(updateObj);
// 更新子表
if(operateTypeEnum != OperateTypeEnum.CANCEL_SUBMIT){
updateTaskDispatchDetailList(updateReqVO.getId(), updateReqVO.getTaskDispatchDetails());
if (updateReqVO.getDispatchType() != null && updateReqVO.getDispatchType().equals("ASSEMBLE")){
//20250515装配派工改为多人，增加owner子表
updateAssembleDetail(operateTypeEnum,updateReqVO.getId(),updateReqVO.getTaskDispatchDetailOwnerDOList());
}else {
updateTaskDispatchDetailList(updateReqVO.getId(), updateReqVO.getTaskDispatchDetails());
}
}
}
@ -326,6 +355,75 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
return taskDispatchDetailDOS;
}
@Override
public List<TaskDispatchDetailDO> getTaskDispatchDetailListByDispatchNew(Long dispatchId) {
List<TaskDispatchDetailOwnerDO> taskDispatchDetailDOS = taskDispatchDetailOwnerMapper.selectListById(dispatchId);
List<Long> ownerDetailIds = new ArrayList<>();
HashMap<Long,String> nameHashMap = new HashMap<>();
taskDispatchDetailDOS.forEach(map ->{
//查一下底下有没有报工完成的数据或者已经开始报工的数据
map.setBeginProduce(taskReportMapper.hasReportNew(map.getId())) ;
ownerDetailIds.add(map.getId());
List<Long> ids = new ArrayList<>();
List<String> names = new ArrayList<>();
if(map.getOwnerIds() != null){
Arrays.stream(map.getOwnerIds().split(",")).forEach(item ->{
if(!StringUtils.isEmpty(item.trim())) {
long ownerId = Long.parseLong(item.trim());
ids.add(ownerId);
if (nameHashMap.get(ownerId) == null) {
String nickname = adminUserMapper.selectById(ownerId).getNickname();
names.add(nickname);
nameHashMap.put(ownerId,nickname);
}else {
names.add(nameHashMap.get(ownerId));
}
}
});
}
map.setOwners(ids);
map.setOwnerNames(names);
});
return copyDispatchDetailOwner(taskDispatchDetailDOS);
// taskDispatchDetailDOS;
}
List<TaskDispatchDetailDO> copyDispatchDetailOwner(List<TaskDispatchDetailOwnerDO> list){
List<TaskDispatchDetailDO> taskDispatchDetailDOList = new ArrayList<>();
for (TaskDispatchDetailOwnerDO taskDispatchDetailOwnerDO : list) {
TaskDispatchDetailDO taskDispatchDetailDO = new TaskDispatchDetailDO();
taskDispatchDetailDO.setId(taskDispatchDetailOwnerDO.getId());
taskDispatchDetailDO.setDispatchId(taskDispatchDetailOwnerDO.getDispatchId());
taskDispatchDetailDO.setProcedureId(taskDispatchDetailOwnerDO.getProcedureId());
if (taskDispatchDetailOwnerDO.getSort() != null){
taskDispatchDetailDO.setSort(taskDispatchDetailOwnerDO.getSort());
}
if (taskDispatchDetailOwnerDO.getDeviceModel() != null){
taskDispatchDetailDO.setDeviceModel(taskDispatchDetailOwnerDO.getDeviceModel());
}
taskDispatchDetailDO.setStartTime(taskDispatchDetailOwnerDO.getStartTime());
taskDispatchDetailDO.setEndTime(taskDispatchDetailOwnerDO.getEndTime());
taskDispatchDetailDO.setWorkTime(taskDispatchDetailOwnerDO.getWorkTime());
taskDispatchDetailDO.setAmount(taskDispatchDetailOwnerDO.getAmount());
if (taskDispatchDetailOwnerDO.getSummary() != null){
taskDispatchDetailDO.setSummary(taskDispatchDetailOwnerDO.getSummary());
}
taskDispatchDetailDO.setProcedureStatus(taskDispatchDetailOwnerDO.getProcedureStatus());
taskDispatchDetailDO.setStatus(false);
taskDispatchDetailDO.setBeforeAmount(taskDispatchDetailOwnerDO.getBeforeAmount());
taskDispatchDetailDO.setBeginProduce(taskDispatchDetailOwnerDO.getBeginProduce());
taskDispatchDetailDO.setOwners(taskDispatchDetailOwnerDO.getOwners());
taskDispatchDetailDO.setOwnerNames(taskDispatchDetailOwnerDO.getOwnerNames());
taskDispatchDetailDO.setBeginProduce(taskDispatchDetailOwnerDO.getBeginProduce());
taskDispatchDetailDOList.add(taskDispatchDetailDO);
}
return taskDispatchDetailDOList;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void operate(TaskDispatchSaveReqVO operateReqVO) {
@ -340,6 +438,11 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
public void deleteTaskDispatchDetail(Long id) {
taskDispatchDetailMapper.deleteByDispatchId(id);
}
@Override
public void deleteTaskDispatchDetailOwner(Long id) {
taskDispatchDetailMapper.deleteByOwnerId(id,null);
taskDispatchDetailOwnerMapper.deleteById(id);
}
@Override
public PageResult<TaskDispatchDetailDO> getGroupTaskDispatchDetailPage(YgjxPageReqVO pageReqVO) {
@ -366,8 +469,9 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
PageResult<TaskDispatchDetailDO> taskDispatchDetailDOPageResult = taskDispatchDetailMapper.selectPageWx(pageReqVO, postIds);
List<TaskDispatchDetailDO> list = taskDispatchDetailDOPageResult.getList();
HashMap<Long, String> hashMap = new HashMap<>();
if (CollUtil.isNotEmpty(list)){
if (CollUtil.isNotEmpty(list) && !pageReqVO.getDispatchType().equals("ASSEMBLE")){
for (TaskDispatchDetailDO taskDispatchDetailDO : list) {
//2025装配的没有顺序号
List<TaskDispatchDetailDO> taskDispatchDetailDOS = taskDispatchDetailMapper.selectList(new LambdaQueryWrapperX<TaskDispatchDetailDO>()
.eq(TaskDispatchDetailDO::getDispatchId, taskDispatchDetailDO.getDispatchId())
.eq(TaskDispatchDetailDO::getSort, taskDispatchDetailDO.getSort() + 1));
@ -448,6 +552,7 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
.orderByDesc(TaskReportDO::getId)
.last("LIMIT 1 ");
}});
TaskDispatchDO taskDispatchDO = taskDispatchMapper.selectById(taskDispatchDetailDO.getDispatchId());
// 校验
if(lastReportDO == null){
@ -462,7 +567,7 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
.ne(TaskReportDO::getAmount, 0);
}});
int historyReportAmount = historyReportList.stream().mapToInt(TaskReportDO::getAmount).sum();
if (taskDispatchDetailDO.getAmount() <= historyReportAmount){
if (!taskDispatchDO.getDispatchType().equals("ASSEMBLE") && taskDispatchDetailDO.getAmount() <= historyReportAmount){
throw exception(TASK_DISPATCH_TASK_IS_OVER);
}
}
@ -481,15 +586,14 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
.ne(TaskReportDO::getAmount, 0);
}});
int historyReportAmount = historyReportList.stream().mapToInt(TaskReportDO::getAmount).sum();
if (taskDispatchDetailDO.getAmount() <= historyReportAmount){
if (!taskDispatchDO.getDispatchType().equals("ASSEMBLE") && taskDispatchDetailDO.getAmount() <= historyReportAmount){
throw exception(TASK_DISPATCH_TASK_IS_OVER);
}
if(taskDispatchDetailDO.getAmount() < (historyReportAmount + operateReqVO.getAmount())){
if(!taskDispatchDO.getDispatchType().equals("ASSEMBLE") && taskDispatchDetailDO.getAmount() < (historyReportAmount + operateReqVO.getAmount())){
throw exception(TASK_DISPATCH_TASK_REPORT_AMOUNT_EXCESS);
}
}
}
TaskDispatchDO taskDispatchDO = taskDispatchMapper.selectById(taskDispatchDetailDO.getDispatchId());
PlanDO planDO = planMapper.selectById(taskDispatchDO.getPlanId());
// 执行
switch (operate){
@ -537,6 +641,21 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
case FINISH:
taskDispatchDetailDO.setProcedureStatus(TaskDispatchProcedureStatusEnum.COMPLETED.getCode());
//装配看看是不是多人，如果是多人，判断一下
if (taskDispatchDO.getDispatchType().equals("ASSEMBLE")){
List<TaskDispatchDetailDO> taskDispatchDetailDOS = taskDispatchDetailMapper.selectList(new LambdaQueryWrapperX<TaskDispatchDetailDO>().eq(TaskDispatchDetailDO::getDetailOwnerId, taskDispatchDetailDO.getDetailOwnerId()));
boolean allOver = true;
for (TaskDispatchDetailDO dispatchDetailDO : taskDispatchDetailDOS) {
if (!dispatchDetailDO.getId().equals(taskDispatchDetailDO.getId()) && !(dispatchDetailDO.getProcedureStatus() == TaskDispatchProcedureStatusEnum.COMPLETED.getCode())){
allOver = false;
}
}
if (allOver){
TaskDispatchDetailOwnerDO taskDispatchDetailOwnerDO = taskDispatchDetailOwnerMapper.selectById(taskDispatchDetailDO.getDetailOwnerId());
taskDispatchDetailOwnerDO.setProcedureStatus(TaskDispatchProcedureStatusEnum.COMPLETED.getCode());
taskDispatchDetailOwnerMapper.updateById(taskDispatchDetailOwnerDO);
}
}
//子项目装配是否完成
List<TaskDispatchDO> taskDispatchAssembleOverList = taskDispatchMapper.selectList(
new LambdaQueryWrapper<TaskDispatchDO>()
@ -544,7 +663,8 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
.eq(TaskDispatchDO::getDispatchType,"ASSEMBLE"));
//零件是否生产完成
List<TaskDispatchDetailDO> taskDispatchDetailDOS = taskDispatchDetailMapper.selectListByDispatchIdNew(taskDispatchDO.getId());
List<TaskDispatchDetailDO> productionList = taskDispatchDetailDOS.stream().filter(e -> !e.getId().equals(taskDispatchDetailDO.getId())).collect(Collectors.toList());
List<TaskDispatchDetailDO> productionList = taskDispatchDetailDOS.stream().filter(e -> !e.getId().equals(taskDispatchDetailDO.getId())).collect(Collectors.toList());
//过程检 零件所有生产派工完成生成
boolean isBomDetailProductionOver = true;
//终检 子项目装配派工都完成
@ -695,7 +815,115 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
public List<TaskDispatchDO> getListJg(Long id, Long projectSubId) {
return taskDispatchMapper.getListJg(id,projectSubId);
}
private void updateAssembleDetail(OperateTypeEnum operateTypeEnum,Long dispatchId, List<TaskDispatchDetailOwnerDO> list) {
list.forEach(o -> o.setDispatchId(dispatchId));
// 分组更新与插入
List<TaskDispatchDetailOwnerDO> updateList = list.stream().filter(o -> o.getId() != null).collect(Collectors.toList());
List<TaskDispatchDetailOwnerDO> insertList = list.stream().filter(o -> o.getId() == null).collect(Collectors.toList());
if(!updateList.isEmpty()){
//更新逻辑，主要是人员更新
List<Long> ids = new ArrayList<>();
for (TaskDispatchDetailOwnerDO taskDispatchDetailOwnerDO : list) {
taskDispatchDetailOwnerDO.setOwnerIds(taskDispatchDetailOwnerDO.getOwners().toString().replace("[","").replace("]",""));
ids.add(taskDispatchDetailOwnerDO.getId());
}
List<TaskDispatchDetailOwnerDO> taskDispatchDetailOwnerDOS = taskDispatchDetailOwnerMapper.selectList(new LambdaQueryWrapperX<TaskDispatchDetailOwnerDO>()
.in(TaskDispatchDetailOwnerDO::getId, ids));
//明细表操作
List<TaskDispatchDetailDO> detailAddList = new ArrayList<>();
HashMap<Long,Set<String>> removeMap = new HashMap<>();
HashMap<TaskDispatchDetailOwnerDO,Set<String>> updateMap = new HashMap<>();
for (TaskDispatchDetailOwnerDO now : updateList) {
for (TaskDispatchDetailOwnerDO before : taskDispatchDetailOwnerDOS) {
if (now.getId().equals(before.getId())) {
//判断人员是否发生了变动，如果少了人，要删除明细表哪个人的数据，如果加了人，要增加,没变化不管
if (!now.getOwnerIds().equals(before.getOwnerIds())) {
String[] beforeOwnerIds = before.getOwnerIds().trim().split(",");
String[] nowOwnerIds = now.getOwnerIds().trim().split(",");
Set<String> beforeSet = new HashSet<>(Arrays.asList(beforeOwnerIds));
Set<String> nowSet = new HashSet<>(Arrays.asList(nowOwnerIds));
//新增的
Set<String> added = new HashSet<>(nowSet);
added.removeAll(beforeSet);
//要删除的
Set<String> removed = new HashSet<>(beforeSet);
removed.removeAll(nowSet);
//要更新的
Set<String> updated = new HashSet<>(beforeSet);
updated.retainAll(nowSet);
if (CollUtil.isNotEmpty(added)){
for (String ownerStr : added) {
TaskDispatchDetailDO tdo = copyDetailDOFromOwnerDO(dispatchId, Long.valueOf(ownerStr.trim()), now);
detailAddList.add(tdo);
}
}
if (CollUtil.isNotEmpty(removed)){
removeMap.put(now.getId(), removed);
}
if (CollUtil.isNotEmpty(updated)){
updateMap.put(now, updated);
}
}
}
}
}
if (CollUtil.isNotEmpty(removeMap)){
for (Long l : removeMap.keySet()) {
taskDispatchDetailMapper.deleteByOwnerId(l,removeMap.get(l));
}
}
if (CollUtil.isNotEmpty(updateMap)){
for (TaskDispatchDetailOwnerDO taskDispatchDetailOwnerDO : updateMap.keySet()) {
taskDispatchDetailMapper.updateByOwner(taskDispatchDetailOwnerDO,updateMap.get(taskDispatchDetailOwnerDO));
}
}
if (CollUtil.isNotEmpty(detailAddList)){
taskDispatchDetailMapper.insertBatch(detailAddList);
}
taskDispatchDetailOwnerMapper.updateBatch(updateList);
}
if(!insertList.isEmpty()) {
List<TaskDispatchDetailDO> detailInsertList = new ArrayList<>();
for (TaskDispatchDetailOwnerDO taskDispatchDetailOwnerDO : insertList) {
taskDispatchDetailOwnerDO.setOwnerIds(taskDispatchDetailOwnerDO.getOwners().toString().replace("[","").replace("]",""));
taskDispatchDetailOwnerDO.setBeforeAmount(taskDispatchDetailOwnerDO.getAmount());
}
taskDispatchDetailOwnerMapper.insertBatch(insertList);
for (TaskDispatchDetailOwnerDO taskDispatchDetailOwnerDO : insertList) {
for (Long owner : taskDispatchDetailOwnerDO.getOwners()) {
TaskDispatchDetailDO tdo = copyDetailDOFromOwnerDO(dispatchId, owner, taskDispatchDetailOwnerDO);
detailInsertList.add(tdo);
}
}
taskDispatchDetailMapper.insertBatch(detailInsertList);
}
}
TaskDispatchDetailDO copyDetailDOFromOwnerDO(Long dispatchId,Long owner,TaskDispatchDetailOwnerDO taskDispatchDetailOwnerDO){
TaskDispatchDetailDO tdo = new TaskDispatchDetailDO();
tdo.setDispatchId(dispatchId);
tdo.setDetailOwnerId(taskDispatchDetailOwnerDO.getId());
tdo.setProcedureId(taskDispatchDetailOwnerDO.getProcedureId());
if (taskDispatchDetailOwnerDO.getSort() != null){
tdo.setSort(taskDispatchDetailOwnerDO.getSort());
}
tdo.setOwner(owner);
if (taskDispatchDetailOwnerDO.getDeviceModel() != null){
tdo.setDeviceModel(taskDispatchDetailOwnerDO.getDeviceModel());
}
tdo.setStartTime(taskDispatchDetailOwnerDO.getStartTime());
tdo.setEndTime(taskDispatchDetailOwnerDO.getEndTime());
tdo.setAmount(taskDispatchDetailOwnerDO.getAmount().intValue());
tdo.setWorkTime(taskDispatchDetailOwnerDO.getWorkTime());
if (taskDispatchDetailOwnerDO.getSummary() != null){
tdo.setSummary(taskDispatchDetailOwnerDO.getSummary());
}
tdo.setBeforeAmount(taskDispatchDetailOwnerDO.getAmount().intValue());
return tdo;
}
private void createTaskDispatchDetailList(Long dispatchId, List<TaskDispatchDetailDO> list) {
// list.forEach(o -> o.setDispatchId(dispatchId));
list = list.stream()

55
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/service/taskdispatchdetailowner/TaskDispatchDetailOwnerService.java Normal file
View File

@ -0,0 +1,55 @@
package com.chanko.yunxi.mes.module.heli.service.taskdispatchdetailowner;
import java.util.*;
import javax.validation.*;
import com.chanko.yunxi.mes.module.heli.controller.admin.taskdispatchdetailowner.vo.*;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatchdetailowner.TaskDispatchDetailOwnerDO;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
/**
* 派工明细负责人 Service 接口
*
* @author lyw
*/
public interface TaskDispatchDetailOwnerService {
/**
* 创建派工明细负责人
*
* @param createReqVO 创建信息
* @return 编号
*/
Long createTaskDispatchDetailOwner(@Valid TaskDispatchDetailOwnerSaveReqVO createReqVO);
/**
* 更新派工明细负责人
*
* @param updateReqVO 更新信息
*/
void updateTaskDispatchDetailOwner(@Valid TaskDispatchDetailOwnerSaveReqVO updateReqVO);
/**
* 删除派工明细负责人
*
* @param id 编号
*/
void deleteTaskDispatchDetailOwner(Long id);
/**
* 获得派工明细负责人
*
* @param id 编号
* @return 派工明细负责人
*/
TaskDispatchDetailOwnerDO getTaskDispatchDetailOwner(Long id);
/**
* 获得派工明细负责人分页
*
* @param pageReqVO 分页查询
* @return 派工明细负责人分页
*/
PageResult<TaskDispatchDetailOwnerDO> getTaskDispatchDetailOwnerPage(TaskDispatchDetailOwnerPageReqVO pageReqVO);
}

74
mes-module-heli/mes-module-heli-biz/src/main/java/com/chanko/yunxi/mes/module/heli/service/taskdispatchdetailowner/TaskDispatchDetailOwnerServiceImpl.java Normal file
View File

@ -0,0 +1,74 @@
package com.chanko.yunxi.mes.module.heli.service.taskdispatchdetailowner;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import com.chanko.yunxi.mes.module.heli.controller.admin.taskdispatchdetailowner.vo.*;
import com.chanko.yunxi.mes.module.heli.dal.dataobject.taskdispatchdetailowner.TaskDispatchDetailOwnerDO;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
import com.chanko.yunxi.mes.framework.common.util.object.BeanUtils;
import com.chanko.yunxi.mes.module.heli.dal.mysql.taskdispatchdetailowner.TaskDispatchDetailOwnerMapper;
import static com.chanko.yunxi.mes.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.chanko.yunxi.mes.module.heli.enums.ErrorCodeConstants.*;
/**
* 派工明细负责人 Service 实现类
*
* @author lyw
*/
@Service
@Validated
public class TaskDispatchDetailOwnerServiceImpl implements TaskDispatchDetailOwnerService {
@Resource
private TaskDispatchDetailOwnerMapper taskDispatchDetailOwnerMapper;
@Override
public Long createTaskDispatchDetailOwner(TaskDispatchDetailOwnerSaveReqVO createReqVO) {
// 插入
TaskDispatchDetailOwnerDO taskDispatchDetailOwner = BeanUtils.toBean(createReqVO, TaskDispatchDetailOwnerDO.class);
taskDispatchDetailOwnerMapper.insert(taskDispatchDetailOwner);
// 返回
return taskDispatchDetailOwner.getId();
}
@Override
public void updateTaskDispatchDetailOwner(TaskDispatchDetailOwnerSaveReqVO updateReqVO) {
// 校验存在
validateTaskDispatchDetailOwnerExists(updateReqVO.getId());
// 更新
TaskDispatchDetailOwnerDO updateObj = BeanUtils.toBean(updateReqVO, TaskDispatchDetailOwnerDO.class);
taskDispatchDetailOwnerMapper.updateById(updateObj);
}
@Override
public void deleteTaskDispatchDetailOwner(Long id) {
// 校验存在
validateTaskDispatchDetailOwnerExists(id);
// 删除
taskDispatchDetailOwnerMapper.deleteById(id);
}
private void validateTaskDispatchDetailOwnerExists(Long id) {
if (taskDispatchDetailOwnerMapper.selectById(id) == null) {
throw exception(TASK_DISPATCH_DETAIL_OWNER_NOT_EXISTS);
}
}
@Override
public TaskDispatchDetailOwnerDO getTaskDispatchDetailOwner(Long id) {
return taskDispatchDetailOwnerMapper.selectById(id);
}
@Override
public PageResult<TaskDispatchDetailOwnerDO> getTaskDispatchDetailOwnerPage(TaskDispatchDetailOwnerPageReqVO pageReqVO) {
return taskDispatchDetailOwnerMapper.selectPage(pageReqVO);
}
}

6
mes-module-heli/mes-module-heli-biz/src/main/resources/mapper/taskreport/TaskReportMapper.xml
View File

@ -14,4 +14,10 @@
#{id}
</foreach>
</delete>
<select id="hasReportNew" resultType="Long" parameterType="Long">
SELECT count(t.id) FROM pro_task_report t
LEFT JOIN pro_task_dispatch_detail g ON t.dispatch_detail_id = g.id AND g.tenant_id = 2
WHERE t.deleted = 0 AND g.deleted = 0 AND g.detail_owner_id = #{ownerId} AND t.tenant_id = 2
</select>
</mapper>

7
mes-ui/mes-ui-admin-vue3/src/api/heli/taskdispatch/index.ts
View File

@ -52,11 +52,16 @@ export const exportTaskDispatch = async (params) => {
export const getTaskDispatchDetailListByDispatchId = async (dispatchId) => {
return await request.get({ url: `/heli/task-dispatch/task-dispatch-detail/list-by-dispatch-id?dispatchId=` + dispatchId })
}
export const getTaskDispatchDetailListByDispatchIdNew = async (dispatchId, dispatchType) => {
return await request.get({ url: `/heli/task-dispatch/task-dispatch-detail/list-by-dispatch-id?dispatchId=` + dispatchId +'&dispatchType='+dispatchType})
}
// 删除派工单
export const deleteTaskDispatchDetail = async (id: number) => {
return await request.delete({ url: `/heli/task-dispatch/task-dispatch-detail/delete?id=` + id })
}
export const deleteTaskDispatchDetailNew = async (id: number,type :string) => {
return await request.delete({ url: `/heli/task-dispatch/task-dispatch-detail/delete?id=` + id+'&dispatchType='+type })
}
export async function operateTaskDispatch(data: TaskDispatchVO) {
return await request.post({ url: `/heli/task-dispatch/operate`, data })
}

58
mes-ui/mes-ui-admin-vue3/src/views/heli/taskdispatch/detail.vue
View File

@ -291,7 +291,7 @@ min="0" :precision="0" class="!w-240px"
<!-- <el-table-column label="负责人" align="center" prop="owner" width="180">
<template #header> <span class="hl-table_header">*</span>负责人</template>
<template #default="{ row, $index }">
<el-form-item :prop="`${$index}.owner`" :rules="subFormRules.owner" class="mb-0px!">-->
<el-form-item :prop="`${$index}.owner`" :rules="subFormRules.owner" class="mb-0px!">-->
<!-- <UserSelect-->
<!--v-model="row.owner" :disabled="detailDisabled || row.procedureStatus != 0"-->
<!-- @update:new-value="handleSelectedUser($index, $event)" />-->
@ -307,12 +307,12 @@ v-for="dict in userInit" :key="dict.id"
<template #header> <span class="hl-table_header">*</span>负责人</template>
<template #default="{ row, $index }">
<el-form-item :prop="`${$index}.ownerNames`" :rules="subFormRules.owner" class="mb-0px!">
<el-input
<el-input
class="!w-265px"
placeholder="负责人"
v-model="row.ownerNames"
readonly
:disabled="detailDisabled "
:disabled="detailDisabled || row.beginProduce != 0 "
@click.prevent="handleClick(row.owners,$index)"
>
<template #append
@ -330,7 +330,7 @@ v-for="dict in userInit" :key="dict.id"
<template #default="{ row, $index }">
<el-form-item :prop="`${$index}.startTime`" :rules="subFormRules.startTime" class="mb-0px!">
<el-date-picker
:disabled="detailDisabled " v-model="row.startTime"
:disabled="detailDisabled || row.beginProduce != 0 " v-model="row.startTime"
type="date" value-format="x" placeholder="选择预计开始日期" />
</el-form-item>
</template>
@ -340,7 +340,7 @@ v-for="dict in userInit" :key="dict.id"
<template #default="{ row, $index }">
<el-form-item :prop="`${$index}.endTime`" :rules="subFormRules.endTime" class="mb-0px!">
<el-date-picker
:disabled="detailDisabled " v-model="row.endTime"
:disabled="detailDisabled || row.beginProduce != 0 " v-model="row.endTime"
type="date" value-format="x" placeholder="选择预计结束日期" />
</el-form-item>
</template>
@ -351,7 +351,7 @@ v-for="dict in userInit" :key="dict.id"
<el-form-item :prop="`${$index}.workTime`" :rules="subFormRules.workTime" class="mb-0px!">
<el-input-number
min="0" :precision="2" class="!w-240px"
:disabled="detailDisabled" v-model="row.workTime"
:disabled="detailDisabled || row.beginProduce != 0 " v-model="row.workTime"
placeholder="请输入预计工时" />
</el-form-item>
</template>
@ -362,7 +362,7 @@ min="0" :precision="2" class="!w-240px"
<el-form-item :prop="`${$index}.amount`" :rules="subFormRules.amount" class="mb-0px!">
<el-input-number
min="0" :max="formData.amount" :precision="0" class="!w-240px"
:disabled="detailDisabled" v-model="row.amount"
:disabled="detailDisabled || row.beginProduce != 0 " v-model="row.amount"
placeholder="请输入派工数量" />
</el-form-item>
</template>
@ -373,7 +373,7 @@ min="0" :precision="2" class="!w-240px"
<EquipmentSelect
v-model="row.deviceModel"
@update:new-value="handleSelectedequip($index, $event)"
:disabled="detailDisabled || (row.beginProduce != 0 && row.procedureStatus != 0)" />
:disabled="(detailDisabled || (row.beginProduce != 0 && row.procedureStatus != 0))" />
</el-form-item>
</template>
</el-table-column>
@ -381,7 +381,7 @@ min="0" :precision="2" class="!w-240px"
<template #default="{ row, $index }">
<el-form-item :prop="`${$index}.summary`" class="mb-0px!">
<el-input
:disabled="detailDisabled ||(row.beginProduce != 0 && row.procedureStatus != 0)" v-model="row.summary"
:disabled="(detailDisabled ||(row.beginProduce != 0 && row.procedureStatus != 0))" v-model="row.summary"
placeholder="请输入工序要点" />
</el-form-item>
</template>
@ -395,7 +395,7 @@ min="0" :precision="2" class="!w-240px"
<el-table-column fixed="right" label="操作" align="center" min-width="100">
<template #default="scope">
<el-button
v-if="'detail' != active && (scope.row.beginProduce == 0 && scope.row.procedureStatus == 0)" link type="danger"
v-if="'detail' != active && (scope.row.beginProduce == 0 && scope.row.procedureStatus == 0) " link type="danger"
size="small" @click.prevent="onDeleteItem(scope.$index)">
删除
</el-button>
@ -603,6 +603,7 @@ const formData = ref({
remark: undefined,
status: 1,
taskDispatchDetails: [],
taskDispatchDetailOwnerDOList:[],
operateLogs: [],
active: undefined,
activeOpinion: '',
@ -863,6 +864,7 @@ const resetForm = () => {
remark: undefined,
status: 1,
taskDispatchDetails: [],
taskDispatchDetailOwnerDOList:[],
operateLogs: [],
active: undefined,
activeOpinion: '',
@ -934,10 +936,9 @@ const queryData = async (id?: number) => {
formData.value = await TaskDispatchApi.getTaskDispatch(id)
if(formData.value.craftContent != null && formData.value.craftContent != ''){
formData.value.craftInfos = JSON.parse(formData.value.craftContent)
console.log(formData.value.craftInfos)
}
formData.value.taskDispatchDetails = await TaskDispatchApi.getTaskDispatchDetailListByDispatchId(id)
formData.value.taskDispatchDetails = await TaskDispatchApi.getTaskDispatchDetailListByDispatchIdNew(id,'ASSEMBLE');
formData.value.bomCode = 'BOM-' + formData.value.projectSubCode
if (formData.value.dispatchStatus == 2) {
detailDisabled.value = true
@ -1004,20 +1005,21 @@ const submitForm = async (operate) => {
}
}
for (let i = 0; i < formData.value.taskDispatchDetails.length-1; i++) {
for (let j = i+1; j < formData.value.taskDispatchDetails.length; j++) {
if (formData.value.taskDispatchDetails[i].sort==formData.value.taskDispatchDetails[j].sort){
message.error("派工工序的顺序号重复,请确认！")
return
}
}
}
for (let i = 0; i < formData.value.taskDispatchDetails.length; i++) {
if (formData.value.taskDispatchDetails[i].sort!=i+1){
message.error("派工工序的顺序号不允许跳数字,请确认！")
return
}
}
// for (let i = 0; i < formData.value.taskDispatchDetails.length-1; i++) {
// for (let j = i+1; j < formData.value.taskDispatchDetails.length; j++) {
// if (formData.value.taskDispatchDetails[i].sort==formData.value.taskDispatchDetails[j].sort){
// message.error("派工工序的顺序号重复,请确认！")
// return
// }
// }
// }
// for (let i = 0; i < formData.value.taskDispatchDetails.length; i++) {
// if (formData.value.taskDispatchDetails[i].sort!=i+1){
// message.error("派工工序的顺序号不允许跳数字,请确认！")
// return
// }
// }
formData.value.taskDispatchDetailOwnerDOList = formData.value.taskDispatchDetails;
const data = formData.value as unknown as TaskDispatchApi.TaskDispatchVO
let dataId = await TaskDispatchApi.operateTaskDispatch(data)
message.success(t('common.operationSuccess'))
@ -1086,7 +1088,7 @@ const goback = () => {
const onDeleteItem = async (index) => {
let deletedItems = formData.value.taskDispatchDetails.splice(index, 1)
let id = deletedItems[0].id
if (id) await TaskDispatchApi.deleteTaskDispatchDetail(id)
if (id) await TaskDispatchApi.deleteTaskDispatchDetailNew(id,'ASSEMBLE')
message.success(t('common.delSuccess'))
}