【派工单】明细工序中负责人多选逻辑处理

dev
siontion 4 months ago
parent c5ff144da1
commit fb2e2d0d97

@ -9,7 +9,9 @@ import com.chanko.yunxi.mes.framework.operatelog.core.annotations.OperateLog;
import com.chanko.yunxi.mes.framework.operatelog.core.enums.OperateTypeEnum;
import com.chanko.yunxi.mes.framework.operatelog.core.service.OperateLogFrameworkService;
import com.chanko.yunxi.mes.module.biz.controller.admin.taskdispatch.vo.*;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch.TaskDispatchDetailOwnerDO;
import com.chanko.yunxi.mes.module.biz.dal.mysql.taskdispatch.TaskDispatchDetailMapper;
import com.chanko.yunxi.mes.module.biz.dal.mysql.taskdispatch.TaskDispatchDetailOwnerMapper;
import com.chanko.yunxi.mes.module.biz.dal.mysql.taskdispatch.TaskDispatchMapper;
import com.chanko.yunxi.mes.module.biz.service.taskdispatch.TaskDispatchService;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch.TaskDispatchDO;
@ -54,8 +56,6 @@ public class TaskDispatchController {
@Resource
private TaskDispatchMapper taskDispatchMapper;
@Resource
private TaskDispatchDetailMapper taskDispatchDetailMapper;
@PostMapping("/create")
@Operation(summary = "创建派工单")
@ -158,7 +158,8 @@ public class TaskDispatchController {
o.setDispatchId(dispatchId);
o.setId(null);
});
taskDispatchDetailMapper.insertBatch(updateReqVO.getTaskDispatchDetails());
taskDispatchService.saveTaskDispatchDetailList(dispatchId,updateReqVO.getTaskDispatchDetails());
}
return success(null);
}
@ -195,7 +196,7 @@ public class TaskDispatchController {
@Operation(summary = "获得派工明细列表")
@Parameter(name = "dispatchId", description = "派工单id")
@PreAuthorize("@ss.hasPermission('biz:task-dispatch:query')")
public CommonResult<List<TaskDispatchDetailDO>> getTaskDispatchDetailListByDispatchId(@RequestParam("dispatchId") Long dispatchId) {
public CommonResult<List<TaskDispatchDetailOwnerDO>> getTaskDispatchDetailListByDispatchId(@RequestParam("dispatchId") Long dispatchId) {
return success(taskDispatchService.getTaskDispatchDetailListByDispatchId(dispatchId));
}
@ -211,8 +212,8 @@ public class TaskDispatchController {
@GetMapping("/task-dispatch-detail/page")
@Operation(summary = "获得派工明细分页")
@PreAuthorize("@ss.hasPermission('biz:task-dispatch:query')")
public CommonResult<PageResult<TaskDispatchDetailDO>> getTaskDispatchPageDetail(@Valid TaskDispatchDetailPageReqVO pageReqVO) {
PageResult<TaskDispatchDetailDO> pageResult = taskDispatchService.getTaskDispatchDetailPage(pageReqVO);
public CommonResult<PageResult<TaskDispatchDetailOwnerDO>> getTaskDispatchPageDetail(@Valid TaskDispatchDetailPageReqVO pageReqVO) {
PageResult<TaskDispatchDetailOwnerDO> pageResult = taskDispatchService.getTaskDispatchDetailPage(pageReqVO);
return success(pageResult);
}
@ -230,9 +231,9 @@ public class TaskDispatchController {
@Operation(summary = "获得派工单明细")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('biz:task-dispatch:query')")
public CommonResult<TaskDispatchDetailDO> getTaskDispatchDetail(@RequestParam("id") Long id) {
TaskDispatchDetailDO taskDispatchDetailDO = taskDispatchService.getTaskDispatchDetail(id);
return success(taskDispatchDetailDO);
public CommonResult<TaskDispatchDetailOwnerDO> getTaskDispatchDetail(@RequestParam("id") Long id) {
TaskDispatchDetailOwnerDO taskDispatchDetailOwnerDO = taskDispatchService.getTaskDispatchDetail(id);
return success(taskDispatchDetailOwnerDO);
}
}

@ -1,6 +1,7 @@
package com.chanko.yunxi.mes.module.biz.controller.admin.taskdispatch.vo;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch.TaskDispatchDetailDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch.TaskDispatchDetailOwnerDO;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
@ -26,7 +27,7 @@ public class TaskDispatchBatchSaveReqVO {
@Schema(description = "派工明细列表")
private List<TaskDispatchDetailDO> taskDispatchDetails;
private List<TaskDispatchDetailOwnerDO> taskDispatchDetails;

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

@ -0,0 +1,136 @@
package com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch;
import com.baomidou.mybatisplus.annotation.*;
import com.chanko.yunxi.mes.framework.mybatis.core.dataobject.BaseDO;
import lombok.*;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
/**
* DO
*
* @author
*/
@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 procedureId;
/**
*
*/
private Integer sort;
/**
*
*/
private Long owner;
@TableField(exist = false)
private List<Long> owners;
@TableField(exist = false)
private List<String> ownerNames;
private String ownerIds;
/**
*
*/
private BigDecimal workTime;
/**
*
*/
private Integer amount;
/**
*
*/
private String summary;
/**
* ,12
*/
private Boolean status;
/**
* id
*/
private Long dispatchId;
/**
*
*/
@TableField(fill = FieldFill.UPDATE)
private Long deviceModel;
/**
*
*/
private LocalDateTime startTime;
/**
*
*/
private LocalDateTime endTime;
/**
* 0 1 2
*/
private Integer procedureStatus;
@TableField(exist = false)
private String projectName;
@TableField(exist = false)
private String projectCode;
@TableField(exist = false)
private String projectSubName;
@TableField(exist = false)
private String projectSubCode;
@TableField(exist = false)
private String materialName;
@TableField(exist = false)
private String procedureName;
@TableField(exist = false)
private Integer totalReportAmount;
@TableField(exist = false)
private BigDecimal totalWorkTime;
@TableField(exist = false)
private String dispatchCode;
@TableField(exist = false)
private String unit;
@TableField(exist = false)
private String spec;
@TableField(exist = false)
private String deviceName;
@TableField(exist = false)
private String workshopName;
@TableField(exist = false)
private String workshopCode;
@TableField(exist = false)
private String productionId;
@TableField(exist = false)
private String productionDetailId;
@TableField(exist = false)
private Boolean allowOver;
}

@ -0,0 +1,95 @@
package com.chanko.yunxi.mes.module.biz.dal.mysql.taskdispatch;
import cn.hutool.core.collection.CollUtil;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.mybatis.core.mapper.BaseMapperX;
import com.chanko.yunxi.mes.module.biz.controller.admin.taskdispatch.vo.TaskDispatchDetailPageReqVO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.material.MaterialDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.procedure.ProcedureDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.projectorder.ProjectOrderDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.projectorder.ProjectOrderSubDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch.TaskDispatchDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch.TaskDispatchDetailOwnerDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskreport.TaskReportDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.workshop.WorkshopDO;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.util.StringUtils;
import java.util.List;
/**
* Mapper
*
* @author
*/
@Mapper
public interface TaskDispatchDetailOwnerMapper extends BaseMapperX<TaskDispatchDetailOwnerDO> {
default PageResult<TaskDispatchDetailOwnerDO> selectPage(TaskDispatchDetailPageReqVO reqVO) {
MPJLambdaWrapper<TaskDispatchDetailOwnerDO> query = new MPJLambdaWrapper<>();
query.selectAll(TaskDispatchDetailOwnerDO.class)
.select("a.code as dispatchCode")
.select("b.code as projectCode")
.select("e.name as procedureName")
.select("COALESCE(sum(f.amount),0) as totalReportAmount")
.select("COALESCE(sum(f.work_time),0) as totalWorkTime")
.select("d.unit","d.spec", "d.name as projectSubName", "d.code as projectSubCode", "c.production_id, c.production_detail_id")
.select("g.name as workshopName")
.leftJoin(TaskDispatchDO.class, "a", TaskDispatchDO::getId, TaskDispatchDetailOwnerDO::getDispatchId)
.leftJoin(ProjectOrderDO.class, "b", ProjectOrderDO::getId, TaskDispatchDO::getProjectId)
.leftJoin(ProjectOrderSubDO.class, "c", ProjectOrderSubDO::getId, TaskDispatchDO::getProjectSubId)
.leftJoin(MaterialDO.class, "d", MaterialDO::getId, ProjectOrderSubDO::getMaterialId)
.leftJoin(ProcedureDO.class, "e", ProcedureDO::getId, TaskDispatchDetailOwnerDO::getProcedureId)
.leftJoin(TaskReportDO.class, "f", TaskReportDO::getDispatchDetailId, TaskDispatchDetailOwnerDO::getId)
.leftJoin(WorkshopDO.class, "g", WorkshopDO::getId, TaskDispatchDO::getWorkshopId)
.groupBy(TaskDispatchDetailOwnerDO::getId)
.orderByDesc(TaskDispatchDetailOwnerDO::getId)
.disableSubLogicDel();
query.in(CollUtil.isNotEmpty(reqVO.getProcedureStatusList()), TaskDispatchDetailOwnerDO::getProcedureStatus, reqVO.getProcedureStatusList())
.eq(reqVO.getIsReport() != null, ProcedureDO::getIsReport, reqVO.getIsReport())
.eq(!StringUtils.isEmpty(reqVO.getDispatchType()), TaskDispatchDO::getDispatchType, reqVO.getDispatchType())
.eq(reqVO.getTaskId() != null, TaskDispatchDO::getTaskId, reqVO.getTaskId())
.eq(reqVO.getBomDetailId() != null, TaskDispatchDO::getBomDetailId, reqVO.getBomDetailId())
.eq(reqVO.getDispatchStatus() != null, TaskDispatchDO::getDispatchStatus, reqVO.getDispatchStatus())
.apply(reqVO.getOwner() != null,"(t.owner={0} or INSTR(t.owner_ids,{0})>0)",reqVO.getOwner())
;
return selectPage(reqVO, query);
}
default List<TaskDispatchDetailOwnerDO> selectListByDispatchId(Long dispatchId) {
return selectList(TaskDispatchDetailOwnerDO::getDispatchId, dispatchId);
}
default int deleteByDispatchId(Long dispatchId) {
return delete(TaskDispatchDetailOwnerDO::getId, dispatchId);
}
default TaskDispatchDetailOwnerDO getTaskDispatchDetail(Long dispatchDetailId){
MPJLambdaWrapper<TaskDispatchDetailOwnerDO> query = new MPJLambdaWrapper<>();
query.selectAll(TaskDispatchDetailOwnerDO.class)
.select("a.code as dispatchCode")
.select("b.code as projectCode")
.select("e.name as procedureName")
.select("COALESCE(sum(f.amount),0) as totalReportAmount")
.select("COALESCE(sum(f.work_time),0) as totalWorkTime")
.select("d.unit","d.spec", "d.name as projectSubName", "d.code as projectSubCode", "c.production_id, c.production_detail_id")
.select("g.name as workshopName", "g.code as workshopCode")
.leftJoin(TaskDispatchDO.class, "a", TaskDispatchDO::getId, TaskDispatchDetailOwnerDO::getDispatchId)
.leftJoin(ProjectOrderDO.class, "b", ProjectOrderDO::getId, TaskDispatchDO::getProjectId)
.leftJoin(ProjectOrderSubDO.class, "c", ProjectOrderSubDO::getId, TaskDispatchDO::getProjectSubId)
.leftJoin(MaterialDO.class, "d", MaterialDO::getId, ProjectOrderSubDO::getMaterialId)
.leftJoin(ProcedureDO.class, "e", ProcedureDO::getId, TaskDispatchDetailOwnerDO::getProcedureId)
.leftJoin(TaskReportDO.class, "f", TaskReportDO::getDispatchDetailId, TaskDispatchDetailOwnerDO::getId)
.leftJoin(WorkshopDO.class, "g", WorkshopDO::getId, TaskDispatchDO::getWorkshopId)
.groupBy(TaskDispatchDetailOwnerDO::getId)
.eq(TaskDispatchDetailOwnerDO::getId, dispatchDetailId)
.disableSubLogicDel()
.last("LIMIT 1")
;
return selectOne(query);
}
}

@ -7,6 +7,7 @@ import com.chanko.yunxi.mes.module.biz.controller.admin.taskdispatch.vo.TaskDisp
import com.chanko.yunxi.mes.module.biz.controller.admin.taskdispatch.vo.TaskDispatchSaveReqVO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch.TaskDispatchDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch.TaskDispatchDetailDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch.TaskDispatchDetailOwnerDO;
import javax.validation.Valid;
import java.util.List;
@ -64,17 +65,19 @@ public interface TaskDispatchService {
* @param dispatchId id
* @return
*/
List<TaskDispatchDetailDO> getTaskDispatchDetailListByDispatchId(Long dispatchId);
List<TaskDispatchDetailOwnerDO> getTaskDispatchDetailListByDispatchId(Long dispatchId);
void operate(TaskDispatchSaveReqVO operateReqVO);
void deleteTaskDispatchDetail(Long id);
PageResult<TaskDispatchDetailDO> getTaskDispatchDetailPage(TaskDispatchDetailPageReqVO pageReqVO);
PageResult<TaskDispatchDetailOwnerDO> getTaskDispatchDetailPage(TaskDispatchDetailPageReqVO pageReqVO);
void operateDetail(TaskDispatchDetailVO operateReqVO);
TaskDispatchDetailDO getTaskDispatchDetail(Long id);
TaskDispatchDetailOwnerDO getTaskDispatchDetail(Long id);
void convertAssembleProcedure(TaskDispatchDO taskDispatchDO);
void saveTaskDispatchDetailList(Long dispatchId, List<TaskDispatchDetailOwnerDO> list);
}

@ -10,10 +10,13 @@ import com.chanko.yunxi.mes.framework.common.util.object.BeanUtils;
import com.chanko.yunxi.mes.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.chanko.yunxi.mes.framework.operatelog.core.enums.OperateTypeEnum;
import com.chanko.yunxi.mes.framework.security.core.util.SecurityFrameworkUtils;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.material.MaterialDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.systemparameters.SystemParametersDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.taskdispatch.TaskDispatchDetailOwnerDO;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.workshop.WorkshopDO;
import com.chanko.yunxi.mes.module.biz.dal.mysql.systemparameters.SystemParametersMapper;
import com.chanko.yunxi.mes.module.biz.dal.mysql.taskdispatch.TaskDispatchDetailMapper;
import com.chanko.yunxi.mes.module.biz.dal.mysql.taskdispatch.TaskDispatchDetailOwnerMapper;
import com.chanko.yunxi.mes.module.biz.dal.mysql.taskdispatch.TaskDispatchMapper;
import com.chanko.yunxi.mes.module.biz.dal.mysql.taskreport.TaskReportMapper;
import com.chanko.yunxi.mes.module.biz.controller.admin.taskdispatch.vo.TaskDispatchDetailPageReqVO;
@ -61,6 +64,8 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
@Resource
private TaskDispatchDetailMapper taskDispatchDetailMapper;
@Resource
private TaskDispatchDetailOwnerMapper taskDispatchDetailOwnerMapper;
@Resource
private TaskReportMapper taskReportMapper;
@Resource
private CrossOrderManager crossOrderManager;
@ -226,22 +231,22 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
// ==================== 子表(派工明细) ====================
@Override
public List<TaskDispatchDetailDO> getTaskDispatchDetailListByDispatchId(Long dispatchId) {
List<TaskDispatchDetailDO> result = taskDispatchDetailMapper.selectListByDispatchId(dispatchId);
// result.forEach(map ->{
// List<Long> ids = new ArrayList<>();
// List<String> names = new ArrayList<>();
// if(map.getOwnerIds() != null){
// Arrays.stream(map.getOwnerIds().split(",")).forEach(item ->{
// ids.add(Long.parseLong(item.trim()));
// names.add(adminUserMapper.selectById(Long.parseLong(item.trim())).getNickname());
// });
// }
//
// map.setOwners(ids);
// map.setOwnerNames(names);
//
// });
public List<TaskDispatchDetailOwnerDO> getTaskDispatchDetailListByDispatchId(Long dispatchId) {
List<TaskDispatchDetailOwnerDO> result = taskDispatchDetailOwnerMapper.selectListByDispatchId(dispatchId);
result.forEach(map ->{
List<Long> ids = new ArrayList<>();
List<String> names = new ArrayList<>();
if(map.getOwnerIds() != null){
Arrays.stream(map.getOwnerIds().split(",")).forEach(item ->{
ids.add(Long.parseLong(item.trim()));
names.add(adminUserMapper.selectById(Long.parseLong(item.trim())).getNickname());
});
}
map.setOwners(ids);
map.setOwnerNames(names);
});
return result;
}
@ -257,15 +262,25 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
@Override
public void deleteTaskDispatchDetail(Long id) {
taskDispatchDetailMapper.deleteByDispatchId(id);
TaskDispatchDetailOwnerDO taskDispatchDetailOwnerDO = taskDispatchDetailOwnerMapper.selectById(id);
List<TaskDispatchDetailDO> doList = taskDispatchDetailMapper.selectList(new LambdaQueryWrapper<TaskDispatchDetailDO>() {{
eq(TaskDispatchDetailDO::getDispatchId, taskDispatchDetailOwnerDO.getDispatchId())
.eq(TaskDispatchDetailDO::getProcedureId, taskDispatchDetailOwnerDO.getProcedureId());
}});
taskDispatchDetailOwnerMapper.deleteByDispatchId(id);
if(!doList.isEmpty()){
doList.forEach(o->{
taskDispatchDetailMapper.deleteById(o.getId());
});
}
}
@Override
public PageResult<TaskDispatchDetailDO> getTaskDispatchDetailPage(TaskDispatchDetailPageReqVO pageReqVO) {
public PageResult<TaskDispatchDetailOwnerDO> getTaskDispatchDetailPage(TaskDispatchDetailPageReqVO pageReqVO) {
// SystemParametersDO systemParametersDO = systemParametersMapper.selectOne("code", SystemParmetersEnum.OVERTASK_CENTER_LIST.getDescription());
//
// PageResult<TaskDispatchDetailDO> result = taskDispatchDetailMapper.selectPage(pageReqVO);
// PageResult<TaskDispatchDetailDO> result = taskDispatchDetailOwnerMapper.selectPage(pageReqVO);
//
// for(TaskDispatchDetailDO item : result.getList()){
// if(systemParametersDO == null){
@ -280,7 +295,7 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
// }
// }
return taskDispatchDetailMapper.selectPage(pageReqVO);
return taskDispatchDetailOwnerMapper.selectPage(pageReqVO);
}
@Override
@ -295,9 +310,9 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
}
}
TaskDispatchDetailDO taskDispatchDetailDO = taskDispatchDetailMapper.selectOne(new LambdaQueryWrapperX<TaskDispatchDetailDO>(){{
eq(TaskDispatchDetailDO::getId, operateReqVO.getId())
.ne(TaskDispatchDetailDO::getProcedureStatus, TaskDispatchProcedureStatusEnum.COMPLETED.getCode())
TaskDispatchDetailOwnerDO taskDispatchDetailDO = taskDispatchDetailOwnerMapper.selectOne(new LambdaQueryWrapperX<TaskDispatchDetailOwnerDO>(){{
eq(TaskDispatchDetailOwnerDO::getId, operateReqVO.getId())
.ne(TaskDispatchDetailOwnerDO::getProcedureStatus, TaskDispatchProcedureStatusEnum.COMPLETED.getCode())
.last("LIMIT 1 FOR UPDATE");
}});
TaskDispatchDO taskDispatchDO = taskDispatchMapper.selectById(taskDispatchDetailDO.getDispatchId());
@ -384,34 +399,66 @@ public class TaskDispatchServiceImpl implements TaskDispatchService {
break;
case FINISH:
taskDispatchDetailDO.setProcedureStatus(TaskDispatchProcedureStatusEnum.COMPLETED.getCode());
taskDispatchDetailMapper.updateById(taskDispatchDetailDO);
taskDispatchDetailOwnerMapper.updateById(taskDispatchDetailDO);
break;
}
}
@Override
public TaskDispatchDetailDO getTaskDispatchDetail(Long id) {
return taskDispatchDetailMapper.getTaskDispatchDetail(id);
public TaskDispatchDetailOwnerDO getTaskDispatchDetail(Long id) {
return taskDispatchDetailOwnerMapper.getTaskDispatchDetail(id);
}
@Override
public void saveTaskDispatchDetailList(Long dispatchId, List<TaskDispatchDetailOwnerDO> list){
createTaskDispatchDetailList(dispatchId,list);
}
private void createTaskDispatchDetailList(Long dispatchId, List<TaskDispatchDetailDO> list) {
private void createTaskDispatchDetailList(Long dispatchId, List<TaskDispatchDetailOwnerDO> list) {
list.forEach(o -> {
o.setDispatchId(dispatchId);
// o.setOwnerIds(o.getOwners().toString().replace("[","").replace("]",""));
o.setOwnerIds(o.getOwners().toString().replace("[","").replace("]",""));
});
// 分组更新与插入
List<TaskDispatchDetailDO> updateList = list.stream().filter(o -> o.getId() != null).collect(Collectors.toList());
List<TaskDispatchDetailDO> insertList = list.stream().filter(o -> o.getId() == null).collect(Collectors.toList());
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()) taskDispatchDetailOwnerMapper.updateBatch(updateList);
if(!insertList.isEmpty()) taskDispatchDetailOwnerMapper.insertBatch(insertList);
// 获取派工单全部明细
List<TaskDispatchDetailDO> detailList = taskDispatchDetailMapper.selectListByDispatchId(dispatchId);
List<TaskDispatchDetailDO> insertDetailList = new ArrayList<>();
list.forEach(o -> {
o.getOwners().forEach(m ->{
TaskDispatchDetailDO taskDispatchDetailDO = BeanUtils.toBean(o,TaskDispatchDetailDO.class);
if(!updateList.isEmpty()) taskDispatchDetailMapper.updateBatch(updateList);
if(!insertList.isEmpty()) taskDispatchDetailMapper.insertBatch(insertList);
if(detailList.stream().filter(n -> n.getOwner().equals(m) && n.getProcedureId().equals(o.getProcedureId())).count()==0){
taskDispatchDetailDO.setId(null);
taskDispatchDetailDO.setOwner(m);
insertDetailList.add(taskDispatchDetailDO);
}
});
List<TaskDispatchDetailDO> removeDetailList = detailList.stream().filter(n -> !o.getOwners().contains(n.getOwner()) && n.getProcedureId().equals(o.getProcedureId())).collect(Collectors.toList());
if(!removeDetailList.isEmpty()){
removeDetailList.forEach(g ->{
taskDispatchDetailMapper.deleteById(g.getId());
});
}
});
if(!insertDetailList.isEmpty()) taskDispatchDetailMapper.insertBatch(insertDetailList);
}
private void updateTaskDispatchDetailList(Long dispatchId, List<TaskDispatchDetailDO> list) {
private void updateTaskDispatchDetailList(Long dispatchId, List<TaskDispatchDetailOwnerDO> list) {
createTaskDispatchDetailList(dispatchId, list);
}
private void deleteTaskDispatchDetailByDispatchId(Long dispatchId) {
taskDispatchDetailOwnerMapper.deleteByDispatchId(dispatchId);
taskDispatchDetailMapper.deleteByDispatchId(dispatchId);
}

Loading…
Cancel
Save