|
|
@@ -31,6 +31,7 @@ import org.springframework.transaction.annotation.Transactional;
|
|
|
import javax.servlet.http.HttpServletRequest;
|
|
|
import java.math.BigDecimal;
|
|
|
import java.util.*;
|
|
|
+import java.util.concurrent.ConcurrentHashMap;
|
|
|
import java.util.concurrent.TimeUnit;
|
|
|
import java.util.concurrent.atomic.AtomicReference;
|
|
|
import java.util.stream.Collectors;
|
|
|
@@ -53,6 +54,13 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
|
|
|
implements ApsProcessOperationProcessEquService {
|
|
|
public static final String CHANGING_WIRES_ERROR_MSG = "订单%s-%s的作业%s已完工，不能换线";
|
|
|
private final Logger log = LoggerFactory.getLogger(this.getClass().getName());
|
|
|
+
|
|
|
+ //换线锁
|
|
|
+ private final ConcurrentHashMap<String, String> changeWiresLock = new ConcurrentHashMap<>();
|
|
|
+
|
|
|
+ //拆分锁
|
|
|
+ private final ConcurrentHashMap<String, String> splitLock = new ConcurrentHashMap<>();
|
|
|
+
|
|
|
@Autowired
|
|
|
private ApsProcessOperationProcessEquDao apsProcessOperationProcessEquDao;
|
|
|
@Autowired
|
|
|
@@ -279,183 +287,247 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
|
|
|
}
|
|
|
// 工序作业明细ID
|
|
|
List<String> detailIds = changingWiresVos.stream().map(ChangingWiresVo::getId).collect(Collectors.toList());
|
|
|
- // 需要返回的相关ID
|
|
|
- List<String> returnAboutIds = changingWiresVos.stream().map(ChangingWiresVo::getReturnAboutIds).flatMap(Collection::stream).collect(Collectors.toList());
|
|
|
- if (detailIds.isEmpty()) {
|
|
|
- log.error("需要换线的工序作业id为空");
|
|
|
- return R.error("需要换线的工序作业id为空");
|
|
|
- }
|
|
|
- // 换线作业受影响的工序作业ID
|
|
|
- List<String> affectedIdList = new ArrayList<>(detailIds);
|
|
|
- affectedIdList.addAll(returnAboutIds);
|
|
|
-
|
|
|
- // 获取工序作业明细
|
|
|
- List<ApsProcessOperationProcessEquDo> apsProcessOperationProcessEquDos = this.baseMapper.selectBatchIds(detailIds);
|
|
|
- if (apsProcessOperationProcessEquDos.isEmpty()) {
|
|
|
- log.error("无法获取到工序作业明细");
|
|
|
- return R.error("无法获取到工序作业明细");
|
|
|
- }
|
|
|
- if (apsProcessOperationProcessEquDos.size() != changingWiresVos.size()) {
|
|
|
- log.error("本次换线操作存在无法获取作业明细的数据");
|
|
|
- return R.error("本次换线操作存在无法获取作业明细的数据!请联系系统管理员");
|
|
|
- }
|
|
|
- // 校验是否存在已完工的工序作业
|
|
|
- boolean hasCompletedWork = apsProcessOperationProcessEquDos.stream()
|
|
|
- .anyMatch(info -> JOBSTATUS_TO_BE_END.equals(info.getWorkstatus()));
|
|
|
- if (hasCompletedWork) {
|
|
|
- log.error("存在已完工的工序作业无法换线");
|
|
|
- return R.error("存在已完工的工序作业无法换线");
|
|
|
- }
|
|
|
- //对于换线作业的数据进行排序
|
|
|
- Optional<Date> minDate = apsProcessOperationProcessEquDos.stream()
|
|
|
- .map(ApsProcessOperationProcessEquDo::getPlanstartdate).min(Comparator.naturalOrder());
|
|
|
- // 获取开工时间间隔=所选作业明细最早计划开工时间-所选加工开始时间
|
|
|
- long timeInterval = minDate.get().getTime() - changingWiresVos.get(0).getProcessingTime().getTime();
|
|
|
- Set<String> blankIds = new HashSet<>();
|
|
|
- // 是否需要清空备份
|
|
|
- AtomicReference<Boolean> emptyBackup = new AtomicReference<>(false);
|
|
|
- List<CheckConflictVo> checkConflictVos = new ArrayList<>();
|
|
|
- List<ApsProcessOperationProcessEquDo> saveList = new ArrayList<>();
|
|
|
- List<UpdateConflictVo> updateConflictVoList = new ArrayList<>();
|
|
|
- UpdateConflictVo updateConflictVo;
|
|
|
- for (ChangingWiresVo changingWiresVo : changingWiresVos) {
|
|
|
- updateConflictVo = new UpdateConflictVo();
|
|
|
- // 工序作业明细
|
|
|
- ApsProcessOperationProcessEquDo processEqus = apsProcessOperationProcessEquDos.stream()
|
|
|
- .filter(info -> changingWiresVo.getId().equals(info.getId()))
|
|
|
- .findFirst().orElse(null);
|
|
|
- if (processEqus == null) {
|
|
|
- log.error("无法根据ID：{}找到对应的工序作业明细信息", changingWiresVo.getId());
|
|
|
- throw new RuntimeException("无法获取到正确的工序作业明细信息");
|
|
|
+// SysUserVo nowWorkUser = CXCommonUtils.getCurrentUser();
|
|
|
+// for (String equId:detailIds){
|
|
|
+// if (changeWiresLock.containsKey(equId)) {
|
|
|
+// log.error("该作业明细已被：{}其他操作员换线", changeWiresLock.get(equId));
|
|
|
+// return R.error("该作业明细已被其他操作员换线");
|
|
|
+// }
|
|
|
+// changeWiresLock.put(equId, nowWorkUser.getId());
|
|
|
+// }
|
|
|
+// try {
|
|
|
+ // 需要返回的相关ID
|
|
|
+ List<String> returnAboutIds = changingWiresVos.stream().map(ChangingWiresVo::getReturnAboutIds).flatMap(Collection::stream).collect(Collectors.toList());
|
|
|
+ if (detailIds.isEmpty()) {
|
|
|
+ log.error("需要换线的工序作业id为空");
|
|
|
+ return R.error("需要换线的工序作业id为空");
|
|
|
}
|
|
|
- // 加工中切设备不变 不更新作业
|
|
|
- if (JOBSTATUS_TO_BE_STARTING.equals(processEqus.getWorkstatus()) &&
|
|
|
- processEqus.getProcessdeviceid().equals(changingWiresVo.getEquId())) {
|
|
|
- log.debug("该工序作业明细：{}加工中且设备未发生变化无需换线", processEqus.getId());
|
|
|
- continue;
|
|
|
+ // 换线作业受影响的工序作业ID
|
|
|
+ List<String> affectedIdList = new ArrayList<>(detailIds);
|
|
|
+ affectedIdList.addAll(returnAboutIds);
|
|
|
+
|
|
|
+ // 获取工序作业明细
|
|
|
+ List<ApsProcessOperationProcessEquDo> apsProcessOperationProcessEquDos = this.baseMapper.selectBatchIds(detailIds);
|
|
|
+ if (apsProcessOperationProcessEquDos.isEmpty()) {
|
|
|
+ log.error("无法获取到工序作业明细");
|
|
|
+ return R.error("无法获取到工序作业明细");
|
|
|
}
|
|
|
- // 加工卷数 = 已报工卷数+已取消卷数时 不更新作业
|
|
|
- if (processEqus.getPlanprocessrall() == processEqus.getStartingroll() + processEqus.getCancelroll()) {
|
|
|
- log.debug("该工序作业明细：{}已全部报工无需换线", processEqus.getId());
|
|
|
- continue;
|
|
|
+ if (apsProcessOperationProcessEquDos.size() != changingWiresVos.size()) {
|
|
|
+ log.error("本次换线操作存在无法获取作业明细的数据");
|
|
|
+ return R.error("本次换线操作存在无法获取作业明细的数据!请联系系统管理员");
|
|
|
}
|
|
|
- blankIds.add(processEqus.getBlankid());
|
|
|
- // 获取该工序作业最早的计划开始时间
|
|
|
- Date planstartdate = processEqus.getPlanstartdate();
|
|
|
- Date planenddate = processEqus.getPlanenddate();
|
|
|
- ApsProcessOperationDo apsProcessOperationDo = apsProcessOperationService.getById(processEqus.getProcessid());
|
|
|
- String processWay = apsProcessOperationDo.getProcessway();
|
|
|
- // 单卷加工时长
|
|
|
- BigDecimal onceprocessmin = apsProcessOperationDo.getOnceprocessmin();
|
|
|
- updateConflictVo.setOldPlanEnddate(planstartdate);
|
|
|
- updateConflictVo.setOldPlanStartdate(planenddate);
|
|
|
- updateConflictVo.setCurrentProcessWay(processWay);
|
|
|
- updateConflictVo.setOldEquId(processEqus.getProcessdeviceid());
|
|
|
- // 待开工的直接修改
|
|
|
- if (JOBSTATUS_TO_BE_START.equals(processEqus.getWorkstatus())) {
|
|
|
- // 待开工的工序作业明细 直接更换加工设备 和车间
|
|
|
- processEqus.setProcessworkshopid(changingWiresVo.getWorkshopId());
|
|
|
- processEqus.setProcessworkshop(changingWiresVo.getWorkshopName());
|
|
|
- processEqus.setProcessdeviceid(changingWiresVo.getEquId());
|
|
|
- processEqus.setProcessdevice(changingWiresVo.getEquName());
|
|
|
- // 计划开工时间=计划开工时间-开工时间间隔
|
|
|
- processEqus.setPlanstartdate(new Date(planstartdate.getTime() - timeInterval));
|
|
|
- // 计划完工时间=计划完工时间-开工时间间隔
|
|
|
- processEqus.setPlanenddate(new Date(processEqus.getPlanenddate().getTime() - timeInterval));
|
|
|
-
|
|
|
- checkConflictVos.add(new CheckConflictVo(processEqus.getId(), processEqus.getProcessdeviceid(),
|
|
|
- processEqus.getPlanstartdate(), processEqus.getPlanenddate()));
|
|
|
- saveList.add(processEqus);
|
|
|
- updateConflictVo.setApsProcessOperationProcessEquDo(processEqus);
|
|
|
- updateConflictVoList.add(updateConflictVo);
|
|
|
+ // 校验是否存在已完工的工序作业
|
|
|
+ boolean hasCompletedWork = apsProcessOperationProcessEquDos.stream()
|
|
|
+ .anyMatch(info -> JOBSTATUS_TO_BE_END.equals(info.getWorkstatus()));
|
|
|
+ if (hasCompletedWork) {
|
|
|
+ log.error("存在已完工的工序作业无法换线");
|
|
|
+ return R.error("存在已完工的工序作业无法换线");
|
|
|
}
|
|
|
- //加工中的状态 将未加工的改变为重新生成
|
|
|
- if (JOBSTATUS_TO_BE_STARTING.equals(processEqus.getWorkstatus())) {
|
|
|
- emptyBackup.set(true);
|
|
|
- // 获取加工时长
|
|
|
- // long processingTime = DateUtil.between(processEqus.getPlanenddate(), processEqus.getPlanstartdate(), DateUnit.SECOND, false);
|
|
|
- // 需要拆分工序作业
|
|
|
- if (processEqus.getPlanprocessrall() - processEqus.getStartingroll() - processEqus.getCancelroll() > 0) {
|
|
|
- ApsProcessOperationProcessEquDo newProcessEqu = new ApsProcessOperationProcessEquDo();
|
|
|
- BeanUtils.copyProperties(processEqus, newProcessEqu);
|
|
|
- newProcessEqu.setId(SecurityUtil.getUUID());
|
|
|
- newProcessEqu.setProcessworkshopid(changingWiresVo.getWorkshopId());
|
|
|
- newProcessEqu.setProcessworkshop(changingWiresVo.getWorkshopName());
|
|
|
- newProcessEqu.setProcessdeviceid(changingWiresVo.getEquId());
|
|
|
- newProcessEqu.setProcessdevice(changingWiresVo.getEquName());
|
|
|
- newProcessEqu.setActualstartdate(null);
|
|
|
- newProcessEqu.setActualfinishdate(null);
|
|
|
- newProcessEqu.setCancelroll(0);
|
|
|
- //计划加工卷数=计划加工卷数-已开工卷数
|
|
|
- newProcessEqu.setPlanprocessrall(newProcessEqu.getPlanprocessrall() - newProcessEqu.getStartingroll());
|
|
|
+ //对于换线作业的数据进行排序
|
|
|
+ Optional<Date> minDate = apsProcessOperationProcessEquDos.stream()
|
|
|
+ .map(ApsProcessOperationProcessEquDo::getPlanstartdate).min(Comparator.naturalOrder());
|
|
|
+ // 获取开工时间间隔=所选作业明细最早计划开工时间-所选加工开始时间
|
|
|
+ long timeInterval = minDate.get().getTime() - changingWiresVos.get(0).getProcessingTime().getTime();
|
|
|
+ Set<String> blankIds = new HashSet<>();
|
|
|
+ // 是否需要清空备份
|
|
|
+ AtomicReference<Boolean> emptyBackup = new AtomicReference<>(false);
|
|
|
+ List<CheckConflictVo> checkConflictVos = new ArrayList<>();
|
|
|
+ List<ApsProcessOperationProcessEquDo> saveList = new ArrayList<>();
|
|
|
+ List<UpdateConflictVo> updateConflictVoList = new ArrayList<>();
|
|
|
+ UpdateConflictVo updateConflictVo;
|
|
|
+ for (ChangingWiresVo changingWiresVo : changingWiresVos) {
|
|
|
+ updateConflictVo = new UpdateConflictVo();
|
|
|
+ // 工序作业明细
|
|
|
+ ApsProcessOperationProcessEquDo processEqus = apsProcessOperationProcessEquDos.stream()
|
|
|
+ .filter(info -> changingWiresVo.getId().equals(info.getId()))
|
|
|
+ .findFirst().orElse(null);
|
|
|
+ if (processEqus == null) {
|
|
|
+ log.error("无法根据ID：{}找到对应的工序作业明细信息", changingWiresVo.getId());
|
|
|
+ throw new RuntimeException("无法获取到正确的工序作业明细信息");
|
|
|
+ }
|
|
|
+ // 加工中切设备不变 不更新作业
|
|
|
+ if (JOBSTATUS_TO_BE_STARTING.equals(processEqus.getWorkstatus()) &&
|
|
|
+ processEqus.getProcessdeviceid().equals(changingWiresVo.getEquId())) {
|
|
|
+ log.debug("该工序作业明细：{}加工中且设备未发生变化无需换线", processEqus.getId());
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // 加工卷数 = 已报工卷数+已取消卷数时 不更新作业
|
|
|
+ if (processEqus.getPlanprocessrall() == processEqus.getStartingroll() + processEqus.getCancelroll()) {
|
|
|
+ log.debug("该工序作业明细：{}已全部报工无需换线", processEqus.getId());
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ blankIds.add(processEqus.getBlankid());
|
|
|
+ // 获取该工序作业最早的计划开始时间
|
|
|
+ Date planstartdate = processEqus.getPlanstartdate();
|
|
|
+ Date planenddate = processEqus.getPlanenddate();
|
|
|
+ ApsProcessOperationDo apsProcessOperationDo = apsProcessOperationService.getById(processEqus.getProcessid());
|
|
|
+ String processWay = apsProcessOperationDo.getProcessway();
|
|
|
+ // 单卷加工时长
|
|
|
+ BigDecimal onceprocessmin = apsProcessOperationDo.getOnceprocessmin();
|
|
|
+ updateConflictVo.setOldPlanEnddate(planstartdate);
|
|
|
+ updateConflictVo.setOldPlanStartdate(planenddate);
|
|
|
+ updateConflictVo.setCurrentProcessWay(processWay);
|
|
|
+ updateConflictVo.setOldEquId(processEqus.getProcessdeviceid());
|
|
|
+ // 待开工的直接修改
|
|
|
+ if (JOBSTATUS_TO_BE_START.equals(processEqus.getWorkstatus())) {
|
|
|
+ // 待开工的工序作业明细 直接更换加工设备 和车间
|
|
|
+ processEqus.setProcessworkshopid(changingWiresVo.getWorkshopId());
|
|
|
+ processEqus.setProcessworkshop(changingWiresVo.getWorkshopName());
|
|
|
+ processEqus.setProcessdeviceid(changingWiresVo.getEquId());
|
|
|
+ processEqus.setProcessdevice(changingWiresVo.getEquName());
|
|
|
+ // 计划开工时间=计划开工时间-开工时间间隔
|
|
|
+ processEqus.setPlanstartdate(new Date(planstartdate.getTime() - timeInterval));
|
|
|
+ // 计划完工时间=计划完工时间-开工时间间隔
|
|
|
+ processEqus.setPlanenddate(new Date(processEqus.getPlanenddate().getTime() - timeInterval));
|
|
|
+
|
|
|
+ checkConflictVos.add(new CheckConflictVo(processEqus.getId(), processEqus.getProcessdeviceid(),
|
|
|
+ processEqus.getPlanstartdate(), processEqus.getPlanenddate()));
|
|
|
+ saveList.add(processEqus);
|
|
|
+ updateConflictVo.setApsProcessOperationProcessEquDo(processEqus);
|
|
|
+ updateConflictVoList.add(updateConflictVo);
|
|
|
+ }
|
|
|
+ //加工中的状态 将未加工的改变为重新生成
|
|
|
+ if (JOBSTATUS_TO_BE_STARTING.equals(processEqus.getWorkstatus())) {
|
|
|
+ emptyBackup.set(true);
|
|
|
+ // 获取加工时长
|
|
|
+ // long processingTime = DateUtil.between(processEqus.getPlanenddate(), processEqus.getPlanstartdate(), DateUnit.SECOND, false);
|
|
|
+ // 需要拆分工序作业
|
|
|
+ /**
|
|
|
+ * 新增需求：计算剩余待开工/报工卷数
|
|
|
+ * 剩余待开工卷数=计划加工卷数-已开工卷数-已取消卷数合计
|
|
|
+ * 剩余待报工卷数=计划加工卷数-已报工卷数-已取消卷数合计
|
|
|
+ * 如果剩余待开工卷数=0，则完工状态=已完工
|
|
|
+ * 如果剩余待开工卷数>0，则完工状态=未完工
|
|
|
+ * 临时计算待加工料卷批次号数量
|
|
|
+ * 如果剩余待开工卷数<待加工料卷批次号数量，则表示有多余的批次号，去掉待加工料卷批次号最后多余的{待加工料卷批次号数量-剩余待开工卷数}个批次号，给拆分的新的作业明细
|
|
|
+ */
|
|
|
+ Integer newPlanProcessRall = processEqus.getPlanprocessrall()-(processEqus.getPlanprocessrall()-processEqus.getStartingroll()-processEqus.getCancelroll());
|
|
|
+ Integer leaveWaitWorkRoll = newPlanProcessRall-processEqus.getStartingroll()-processEqus.getCancelroll();
|
|
|
+ Integer leaveWaitJobRoll = newPlanProcessRall-processEqus.getReportroll()-processEqus.getCancelroll();
|
|
|
+ processEqus.setLeavewaitworkroll(leaveWaitWorkRoll);
|
|
|
+ processEqus.setLeavewaitjobroll(leaveWaitJobRoll);
|
|
|
+ List<String> newBachMaterProcess = new ArrayList<>();
|
|
|
+ if (ObjectUtil.isNotEmpty(processEqus.getBachmaterialprocess())){
|
|
|
+ String[] bachMaterialProcessArr = processEqus.getBachmaterialprocess().split(",");
|
|
|
+ if (leaveWaitWorkRoll < bachMaterialProcessArr.length) {
|
|
|
+ List<String> newBach = new ArrayList<>();
|
|
|
+ List<String> oldBach = new ArrayList<>();
|
|
|
+ for (String mater : bachMaterialProcessArr) {
|
|
|
+ if (oldBach.size() < leaveWaitWorkRoll) {
|
|
|
+ oldBach.add(mater);
|
|
|
+ }else {
|
|
|
+ newBach.add(mater);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ newBachMaterProcess = newBach;
|
|
|
+ processEqus.setBachmaterialprocess(String.join(",", oldBach));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (processEqus.getPlanprocessrall() - processEqus.getStartingroll() - processEqus.getCancelroll() > 0) {
|
|
|
+ ApsProcessOperationProcessEquDo newProcessEqu = new ApsProcessOperationProcessEquDo();
|
|
|
+ BeanUtils.copyProperties(processEqus, newProcessEqu);
|
|
|
+ newProcessEqu.setId(SecurityUtil.getUUID());
|
|
|
+ newProcessEqu.setProcessworkshopid(changingWiresVo.getWorkshopId());
|
|
|
+ newProcessEqu.setProcessworkshop(changingWiresVo.getWorkshopName());
|
|
|
+ newProcessEqu.setProcessdeviceid(changingWiresVo.getEquId());
|
|
|
+ newProcessEqu.setProcessdevice(changingWiresVo.getEquName());
|
|
|
+ newProcessEqu.setActualstartdate(null);
|
|
|
+ newProcessEqu.setActualfinishdate(null);
|
|
|
+ newProcessEqu.setCancelroll(0);
|
|
|
+ //计划加工卷数=计划加工卷数-已开工卷数
|
|
|
+ newProcessEqu.setPlanprocessrall(newProcessEqu.getPlanprocessrall() - newProcessEqu.getStartingroll());
|
|
|
+ // 更新计划完工时间
|
|
|
+ if (PROCESS_WAY_MERGE.equals(apsProcessOperationDo.getProcessway())) {
|
|
|
+ // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷加工时长 - 开工时间间隔
|
|
|
+ newProcessEqu.setPlanenddate(new Date(newProcessEqu.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(onceprocessmin.intValue()) - timeInterval));
|
|
|
+ } else {
|
|
|
+ // 如果工序作业的加工方式不是合并加工，则计划完工时间=计划开工时间+工序作业单卷加工时长*（计划加工卷数） - 开工时间间隔
|
|
|
+ newProcessEqu.setPlanenddate(new Date(newProcessEqu.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis((long) timeInterval * newProcessEqu.getPlanprocessrall()) - timeInterval));
|
|
|
+ }
|
|
|
+ newProcessEqu.setPlanstartdate(new Date(newProcessEqu.getPlanstartdate().getTime() - timeInterval));
|
|
|
+ newProcessEqu.setStartingroll(0);
|
|
|
+ newProcessEqu.setReportroll(0);
|
|
|
+ newProcessEqu.setCheckoutroll(0);
|
|
|
+
|
|
|
+ newProcessEqu.setUnfinishroll(newProcessEqu.getPlanprocessrall());
|
|
|
+ newProcessEqu.setWorkstatus(JOBSTATUS_TO_BE_START);
|
|
|
+ newProcessEqu.setClosestatus(UNFINISHED);
|
|
|
+ /**
|
|
|
+ * 新增需求：已借调卷数=0，已取消卷数=0，输入不合格卷数=0，输入已取消卷数=0，已取消卷数合计=0,剩余待开工卷数=计划加工卷数,剩余待报工卷数=计划加工卷数
|
|
|
+ * 如果原作业有多余的待加工料卷批次号，则待加工料卷批次号=原作业明细的多余的待加工料卷批次号
|
|
|
+ */
|
|
|
+ newProcessEqu.setWaitreportid(null);
|
|
|
+ newProcessEqu.setDoingbatchnumber(null);
|
|
|
+ newProcessEqu.setReportbatchnumber(null);
|
|
|
+ newProcessEqu.setSecondroll(0);
|
|
|
+ newProcessEqu.setCancelrollno(0);
|
|
|
+ newProcessEqu.setInputunqualifiednum(0);
|
|
|
+ newProcessEqu.setInputunqualifiedroll(0);
|
|
|
+ newProcessEqu.setCancelroll(0);
|
|
|
+ newProcessEqu.setLeavewaitworkroll(newProcessEqu.getPlanprocessrall());
|
|
|
+ newProcessEqu.setLeavewaitjobroll(newProcessEqu.getPlanprocessrall());
|
|
|
+ if (ObjectUtil.isNotEmpty(newBachMaterProcess)){
|
|
|
+ newProcessEqu.setBachmaterialprocess(String.join(",", newBachMaterProcess));
|
|
|
+ }
|
|
|
+ affectedIdList.add(newProcessEqu.getId());
|
|
|
+ updateConflictVo.setApsProcessOperationProcessEquDo(newProcessEqu);
|
|
|
+ checkConflictVos.add(new CheckConflictVo(processEqus.getId(), newProcessEqu.getProcessdeviceid(),
|
|
|
+ newProcessEqu.getPlanstartdate(), newProcessEqu.getPlanenddate()));
|
|
|
+ saveList.add(newProcessEqu);
|
|
|
+ updateConflictVoList.add(updateConflictVo);
|
|
|
+ // 获取上一个工序作业明细ID
|
|
|
+ String previousprocessesids = newProcessEqu.getPreviousprocessesids();
|
|
|
+ if (StringUtils.isNotBlank(previousprocessesids)) {
|
|
|
+ ApsProcessOperationProcessEquDo previousProcessEqu = this.getById(previousprocessesids);
|
|
|
+ if (previousProcessEqu == null) {
|
|
|
+ throw new CustomException("无法找到上一个工序作业明细信息");
|
|
|
+ }
|
|
|
+ this.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
|
|
|
+ .eq(ApsProcessOperationProcessEquDo::getId, previousprocessesids)
|
|
|
+ .set(ApsProcessOperationProcessEquDo::getNextprocessesids,
|
|
|
+ strAppendListConvertStr(previousProcessEqu.getNextprocessesids(), Arrays.asList(previousprocessesids))));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /************更新换线后工序作业的信息********************/
|
|
|
+
|
|
|
+ //更新计划加工卷数
|
|
|
+ processEqus.setPlanprocessrall(processEqus.getStartingroll() + processEqus.getCancelroll());
|
|
|
+
|
|
|
// 更新计划完工时间
|
|
|
if (PROCESS_WAY_MERGE.equals(apsProcessOperationDo.getProcessway())) {
|
|
|
- // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷加工时长 - 开工时间间隔
|
|
|
- newProcessEqu.setPlanenddate(new Date(newProcessEqu.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(onceprocessmin.intValue()) - timeInterval));
|
|
|
+ // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷加工时长
|
|
|
+ processEqus.setPlanenddate(new Date(processEqus.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(onceprocessmin.intValue())));
|
|
|
} else {
|
|
|
- // 如果工序作业的加工方式不是合并加工，则计划完工时间=计划开工时间+工序作业单卷加工时长*（计划加工卷数） - 开工时间间隔
|
|
|
- newProcessEqu.setPlanenddate(new Date(newProcessEqu.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis((long) timeInterval * newProcessEqu.getPlanprocessrall()) - timeInterval));
|
|
|
+ // 如果工序作业的加工方式不是合并加工，则计划完工时间=计划开工时间+工序作业单卷加工时长*计划加工卷数
|
|
|
+ processEqus.setPlanenddate(new Date(processEqus.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis((long) onceprocessmin.intValue() * processEqus.getPlanprocessrall())));
|
|
|
}
|
|
|
- newProcessEqu.setPlanstartdate(new Date(newProcessEqu.getPlanstartdate().getTime() - timeInterval));
|
|
|
- newProcessEqu.setStartingroll(0);
|
|
|
- newProcessEqu.setReportroll(0);
|
|
|
- newProcessEqu.setCheckoutroll(0);
|
|
|
-
|
|
|
- newProcessEqu.setUnfinishroll(newProcessEqu.getPlanprocessrall());
|
|
|
- newProcessEqu.setWorkstatus(JOBSTATUS_TO_BE_START);
|
|
|
- newProcessEqu.setClosestatus(UNFINISHED);
|
|
|
- affectedIdList.add(newProcessEqu.getId());
|
|
|
- updateConflictVo.setApsProcessOperationProcessEquDo(newProcessEqu);
|
|
|
- checkConflictVos.add(new CheckConflictVo(processEqus.getId(), newProcessEqu.getProcessdeviceid(),
|
|
|
- newProcessEqu.getPlanstartdate(), newProcessEqu.getPlanenddate()));
|
|
|
- saveList.add(newProcessEqu);
|
|
|
- updateConflictVoList.add(updateConflictVo);
|
|
|
- // 获取上一个工序作业明细ID
|
|
|
- String previousprocessesids = newProcessEqu.getPreviousprocessesids();
|
|
|
- if (StringUtils.isNotBlank(previousprocessesids)) {
|
|
|
- ApsProcessOperationProcessEquDo previousProcessEqu = this.getById(previousprocessesids);
|
|
|
- if (previousProcessEqu == null) {
|
|
|
- throw new CustomException("无法找到上一个工序作业明细信息");
|
|
|
+ processEqus.setPlanstartdate(new Date(processEqus.getPlanstartdate().getTime() - timeInterval));
|
|
|
+ // 更新未完工卷数
|
|
|
+ processEqus.setUnfinishroll(processEqus.getPlanprocessrall() - processEqus.getReportroll());
|
|
|
+ // 作业状态
|
|
|
+ processEqus.setWorkstatus(processEqus.getUnfinishroll() - processEqus.getCancelroll() == 0 ? JOBSTATUS_TO_BE_END : JOBSTATUS_TO_BE_STARTING);
|
|
|
+ /**
|
|
|
+ * 更新完工状态
|
|
|
+ * 如果作业明细的完工状态=未完工，并且作业明细的已开工卷数=0，则作业状态=待开工；
|
|
|
+ * 如果作业明细的完工状态=未完工，并且作业明细的已开工卷数>0，则作业状态=加工中；
|
|
|
+ * 如果作业明细的完工状态=已完工，则作业状态=已完工
|
|
|
+ */
|
|
|
+ if (JOBSTATUS_TO_BE_END.equals(processEqus.getWorkstatus())) {
|
|
|
+ processEqus.setClosestatus(JOBSTATUS_TO_BE_END);
|
|
|
+ } else {
|
|
|
+ processEqus.setClosestatus(processEqus.getStartingroll() > 0 ? JOBSTATUS_TO_BE_STARTING : JOBSTATUS_TO_BE_START);
|
|
|
+ }
|
|
|
+ if (leaveWaitJobRoll>0){
|
|
|
+ processEqus.setClosestatus("未完工");
|
|
|
+ }else {
|
|
|
+ if (leaveWaitJobRoll==0){
|
|
|
+ processEqus.setClosestatus("已完工");
|
|
|
}
|
|
|
- this.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
|
|
|
- .eq(ApsProcessOperationProcessEquDo::getId, previousprocessesids)
|
|
|
- .set(ApsProcessOperationProcessEquDo::getNextprocessesids,
|
|
|
- strAppendListConvertStr(previousProcessEqu.getNextprocessesids(), Arrays.asList(previousprocessesids))));
|
|
|
}
|
|
|
+ saveList.add(processEqus);
|
|
|
}
|
|
|
- /************更新换线后工序作业的信息********************/
|
|
|
-
|
|
|
- //更新计划加工卷数
|
|
|
- processEqus.setPlanprocessrall(processEqus.getStartingroll() + processEqus.getCancelroll());
|
|
|
-
|
|
|
- // 更新计划完工时间
|
|
|
- if (PROCESS_WAY_MERGE.equals(apsProcessOperationDo.getProcessway())) {
|
|
|
- // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷加工时长
|
|
|
- processEqus.setPlanenddate(new Date(processEqus.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(onceprocessmin.intValue())));
|
|
|
- } else {
|
|
|
- // 如果工序作业的加工方式不是合并加工，则计划完工时间=计划开工时间+工序作业单卷加工时长*计划加工卷数
|
|
|
- processEqus.setPlanenddate(new Date(processEqus.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis((long) onceprocessmin.intValue() * processEqus.getPlanprocessrall())));
|
|
|
- }
|
|
|
- processEqus.setPlanstartdate(new Date(processEqus.getPlanstartdate().getTime() - timeInterval));
|
|
|
- // 更新未完工卷数
|
|
|
- processEqus.setUnfinishroll(processEqus.getPlanprocessrall() - processEqus.getReportroll());
|
|
|
- // 作业状态
|
|
|
- processEqus.setWorkstatus(processEqus.getUnfinishroll() - processEqus.getCancelroll() == 0 ? JOBSTATUS_TO_BE_END : JOBSTATUS_TO_BE_STARTING);
|
|
|
- /**
|
|
|
- * 更新完工状态
|
|
|
- * 如果作业明细的完工状态=未完工，并且作业明细的已开工卷数=0，则作业状态=待开工；
|
|
|
- * 如果作业明细的完工状态=未完工，并且作业明细的已开工卷数>0，则作业状态=加工中；
|
|
|
- * 如果作业明细的完工状态=已完工，则作业状态=已完工
|
|
|
- */
|
|
|
- if (JOBSTATUS_TO_BE_END.equals(processEqus.getWorkstatus())) {
|
|
|
- processEqus.setClosestatus(JOBSTATUS_TO_BE_END);
|
|
|
- } else {
|
|
|
- processEqus.setClosestatus(processEqus.getStartingroll() > 0 ? JOBSTATUS_TO_BE_STARTING : JOBSTATUS_TO_BE_START);
|
|
|
- }
|
|
|
- saveList.add(processEqus);
|
|
|
}
|
|
|
- }
|
|
|
- // 换线拆单后 需要校验 是否存在冲突 如果存在冲突 提示
|
|
|
+ // 换线拆单后 需要校验 是否存在冲突 如果存在冲突 提示
|
|
|
// if (!checkConflictVos.isEmpty()) {
|
|
|
// List<String> promptInformation = this.baseMapper.checkConflict(checkConflictVos);
|
|
|
// if (!promptInformation.isEmpty()) {
|
|
|
@@ -464,34 +536,39 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
|
|
|
// //return R.error(promptInformation.get(0));
|
|
|
// }
|
|
|
// }
|
|
|
- if (emptyBackup.get()) {
|
|
|
- SysUserVo currentUser = CXCommonUtils.getCurrentUser();
|
|
|
- // 删除工序作业备份
|
|
|
- ApsUtils.clearBackup(currentUser);
|
|
|
- }
|
|
|
- if (!saveList.isEmpty()) {
|
|
|
- this.saveOrUpdateBatch(saveList);
|
|
|
- }
|
|
|
- if (!updateConflictVoList.isEmpty()) {
|
|
|
- updateConflictVoList.forEach(data -> {
|
|
|
- ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo = data.getApsProcessOperationProcessEquDo();
|
|
|
- affectedIdList.addAll(checkProcessingTimeConflict(apsProcessOperationProcessEquDo,
|
|
|
- data.getOldPlanStartdate(), data.getOldPlanEnddate(), data.getOldEquId(), data.getCurrentProcessWay(),returnAboutIds));
|
|
|
- // 判断是否存在设备不可用
|
|
|
- inspectionEquipmentIsAvailable(apsProcessOperationProcessEquDo,
|
|
|
- apsProcessOperationProcessEquDo.getProcessdeviceid(),
|
|
|
- apsProcessOperationProcessEquDo.getPlanstartdate(),
|
|
|
- apsProcessOperationProcessEquDo.getPlanenddate());
|
|
|
+ if (emptyBackup.get()) {
|
|
|
+ SysUserVo currentUser = CXCommonUtils.getCurrentUser();
|
|
|
+ // 删除工序作业备份
|
|
|
+ ApsUtils.clearBackup(currentUser);
|
|
|
+ }
|
|
|
+ if (!saveList.isEmpty()) {
|
|
|
+ this.saveOrUpdateBatch(saveList);
|
|
|
+ }
|
|
|
+ if (!updateConflictVoList.isEmpty()) {
|
|
|
+ updateConflictVoList.forEach(data -> {
|
|
|
+ ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo = data.getApsProcessOperationProcessEquDo();
|
|
|
+ affectedIdList.addAll(checkProcessingTimeConflict(apsProcessOperationProcessEquDo,
|
|
|
+ data.getOldPlanStartdate(), data.getOldPlanEnddate(), data.getOldEquId(), data.getCurrentProcessWay(),returnAboutIds));
|
|
|
+ // 判断是否存在设备不可用
|
|
|
+ inspectionEquipmentIsAvailable(apsProcessOperationProcessEquDo,
|
|
|
+ apsProcessOperationProcessEquDo.getProcessdeviceid(),
|
|
|
+ apsProcessOperationProcessEquDo.getPlanstartdate(),
|
|
|
+ apsProcessOperationProcessEquDo.getPlanenddate());
|
|
|
+ });
|
|
|
+ }
|
|
|
+ List<String> aboutIds= affectedIdList.stream().distinct().collect(Collectors.toList());
|
|
|
+ blankIds.forEach(data -> {
|
|
|
+ // 更新坯料交货期
|
|
|
+ aboutIds.addAll(apsBlankOrderService.updateBlankDeliveryDate(null, data));
|
|
|
});
|
|
|
- }
|
|
|
- List<String> aboutIds= affectedIdList.stream().distinct().collect(Collectors.toList());
|
|
|
- blankIds.forEach(data -> {
|
|
|
- // 更新坯料交货期
|
|
|
- aboutIds.addAll(apsBlankOrderService.updateBlankDeliveryDate(null, data));
|
|
|
- });
|
|
|
|
|
|
- // 重新获取甘特图数据并返回前段
|
|
|
- return R.ok(ganttService.getListById(aboutIds));
|
|
|
+ // 重新获取甘特图数据并返回前段
|
|
|
+ return R.ok(ganttService.getListById(aboutIds));
|
|
|
+// }finally {
|
|
|
+// for (String equId:detailIds){
|
|
|
+// changeWiresLock.remove(equId);
|
|
|
+// }
|
|
|
+// }
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
@@ -774,210 +851,275 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
|
|
|
log.error("无法找到对应工序作业明细");
|
|
|
throw new CustomException("参数异常,工序作业明细ID为空");
|
|
|
}
|
|
|
- // 所有的工序作业明细
|
|
|
- List<ApsProcessOperationProcessEquDo> apsProcessOperationProcessEquDos = (List<ApsProcessOperationProcessEquDo>) this.listByIds(ids);
|
|
|
- // 前一个工序作业明细Id
|
|
|
- List<String> previousIds = apsProcessOperationProcessEquDos.stream()
|
|
|
- .map(ApsProcessOperationProcessEquDo::getPreviousprocessesids)
|
|
|
- .distinct()
|
|
|
- .filter(StringUtils::isNotBlank)
|
|
|
- .collect(Collectors.toList());
|
|
|
- if (previousIds.isEmpty()) {
|
|
|
- log.error("无法找到当前工序作业明细的上一个工序作业明细信息");
|
|
|
- throw new CustomException("无法找到前道工序作业明细信息");
|
|
|
- }
|
|
|
- List<ApsProcessOperationProcessEquDo> previousApsProcessOperationProcessEquDos = this.getBaseMapper().selectBatchIds(previousIds);
|
|
|
- // 获取工序作业信息
|
|
|
- List<String> processId = apsProcessOperationProcessEquDos.stream()
|
|
|
- .map(ApsProcessOperationProcessEquDo::getProcessid)
|
|
|
- .distinct()
|
|
|
- .filter(StringUtils::isNotBlank)
|
|
|
- .collect(Collectors.toList());
|
|
|
- if (processId.isEmpty()) {
|
|
|
- log.error("无法根据工序作业明细获取工序作业信息");
|
|
|
- throw new CustomException("无法获取到工序作业信息");
|
|
|
- }
|
|
|
- List<ApsProcessOperationDo> apsProcessOperationDos = (List<ApsProcessOperationDo>) apsProcessOperationService.listByIds(processId);
|
|
|
- // 合并加工
|
|
|
- boolean mergeProcessing = apsProcessOperationDos.stream().anyMatch(data -> !PROCESS_WAY_MERGE.equals(data.getProcessway()));
|
|
|
- if (mergeProcessing) {
|
|
|
- log.error("存在非合并加工的工序作业无法拆分");
|
|
|
- throw new CustomException("存在非合并加工的工序作业无法拆分");
|
|
|
- }
|
|
|
- List<String> affectedIdList = new ArrayList<>();
|
|
|
- List<ApsProcessOperationProcessEquDo> newDataList = new ArrayList<>();
|
|
|
- processOperationDetailSplitVos.forEach(data -> {
|
|
|
- affectedIdList.addAll(data.getReturnAboutIds());
|
|
|
- int splitQty = data.getSplitQty();
|
|
|
- ApsProcessOperationProcessEquDo currentProcessEquDo = apsProcessOperationProcessEquDos.stream()
|
|
|
- .filter(equs -> equs.getId().equals(data.getId()))
|
|
|
- .findFirst()
|
|
|
- .orElse(null);
|
|
|
- if (currentProcessEquDo == null) {
|
|
|
- log.error("无法根据id:{}获取到工序作业明细", data.getId());
|
|
|
- throw new CustomException("无法获取到工序作业明细！请联系系统管理员");
|
|
|
- }
|
|
|
- // 当前的工序作业信息
|
|
|
- ApsProcessOperationDo currentProcessOperationDo = apsProcessOperationDos.stream()
|
|
|
- .filter(process -> process.getId().equals(currentProcessEquDo.getProcessid()))
|
|
|
- .findFirst()
|
|
|
- .orElse(null);
|
|
|
- if (currentProcessOperationDo == null) {
|
|
|
- log.error("无法获取工序作业明细:{}所对应的工序作业信息", currentProcessOperationDo.getId());
|
|
|
- throw new CustomException("找不到对应工序作业信息！请联系系统管理员");
|
|
|
- }
|
|
|
- // 剩余待加工卷数
|
|
|
- int unFinishRoll = currentProcessEquDo.getPlanprocessrall() - currentProcessEquDo.getStartingroll() - currentProcessEquDo.getCancelroll();
|
|
|
- if (unFinishRoll <= 0) {
|
|
|
- log.error("当前暂无可拆分的卷数信息");
|
|
|
- throw new CustomException("该作业已全部开工，不能拆分");
|
|
|
- }
|
|
|
- if (splitQty > unFinishRoll) {
|
|
|
- log.error("拆分数量:{}大于待加工卷数:{}", splitQty, unFinishRoll);
|
|
|
- throw new CustomException("拆分数量大于待加工卷数，不能拆分");
|
|
|
+// SysUserVo nowWorkUser = CXCommonUtils.getCurrentUser();
|
|
|
+// for (String equId:ids){
|
|
|
+// if (splitLock.containsKey(equId)) {
|
|
|
+// log.error("该作业明细已被：{}其他操作员拆分", splitLock.get(equId));
|
|
|
+// throw new CustomException("该作业明细已被其他操作员拆分");
|
|
|
+// }
|
|
|
+// splitLock.put(equId, nowWorkUser.getId());
|
|
|
+// }
|
|
|
+// try {
|
|
|
+ // 所有的工序作业明细
|
|
|
+ List<ApsProcessOperationProcessEquDo> apsProcessOperationProcessEquDos = (List<ApsProcessOperationProcessEquDo>) this.listByIds(ids);
|
|
|
+ // 前一个工序作业明细Id
|
|
|
+ List<String> previousIds = apsProcessOperationProcessEquDos.stream()
|
|
|
+ .map(ApsProcessOperationProcessEquDo::getPreviousprocessesids)
|
|
|
+ .distinct()
|
|
|
+ .filter(StringUtils::isNotBlank)
|
|
|
+ .collect(Collectors.toList());
|
|
|
+ if (previousIds.isEmpty()) {
|
|
|
+ log.error("无法找到当前工序作业明细的上一个工序作业明细信息");
|
|
|
+ throw new CustomException("无法找到前道工序作业明细信息");
|
|
|
}
|
|
|
- ApsProcessOperationProcessEquDo newDo = new ApsProcessOperationProcessEquDo();
|
|
|
- BeanUtils.copyProperties(currentProcessEquDo, newDo);
|
|
|
- if (StringUtils.isNotBlank(data.getEquName())) {
|
|
|
- newDo.setProcessdevice(data.getEquName());
|
|
|
- } else {
|
|
|
- newDo.setProcessdevice(currentProcessEquDo.getProcessdevice());
|
|
|
+ List<ApsProcessOperationProcessEquDo> previousApsProcessOperationProcessEquDos = this.getBaseMapper().selectBatchIds(previousIds);
|
|
|
+ // 获取工序作业信息
|
|
|
+ List<String> processId = apsProcessOperationProcessEquDos.stream()
|
|
|
+ .map(ApsProcessOperationProcessEquDo::getProcessid)
|
|
|
+ .distinct()
|
|
|
+ .filter(StringUtils::isNotBlank)
|
|
|
+ .collect(Collectors.toList());
|
|
|
+ if (processId.isEmpty()) {
|
|
|
+ log.error("无法根据工序作业明细获取工序作业信息");
|
|
|
+ throw new CustomException("无法获取到工序作业信息");
|
|
|
}
|
|
|
-
|
|
|
- if (StringUtils.isNotBlank(data.getEquId())) {
|
|
|
- newDo.setProcessdeviceid(data.getEquId());
|
|
|
- } else {
|
|
|
- newDo.setProcessdeviceid(currentProcessEquDo.getProcessdeviceid());
|
|
|
+ List<ApsProcessOperationDo> apsProcessOperationDos = (List<ApsProcessOperationDo>) apsProcessOperationService.listByIds(processId);
|
|
|
+ // 合并加工
|
|
|
+ boolean mergeProcessing = apsProcessOperationDos.stream().anyMatch(data -> !PROCESS_WAY_MERGE.equals(data.getProcessway()));
|
|
|
+ if (mergeProcessing) {
|
|
|
+ log.error("存在非合并加工的工序作业无法拆分");
|
|
|
+ throw new CustomException("存在非合并加工的工序作业无法拆分");
|
|
|
}
|
|
|
-
|
|
|
- if (StringUtils.isNotBlank(data.getWorkshopName())) {
|
|
|
- newDo.setProcessworkshop(data.getWorkshopName());
|
|
|
- } else {
|
|
|
- newDo.setProcessworkshop(currentProcessEquDo.getProcessworkshop());
|
|
|
- }
|
|
|
-
|
|
|
- if (StringUtils.isNotBlank(data.getWorkshopId())) {
|
|
|
- newDo.setProcessworkshopid(data.getWorkshopId());
|
|
|
- } else {
|
|
|
- newDo.setProcessworkshop(currentProcessEquDo.getProcessworkshop());
|
|
|
- }
|
|
|
- // 数量和待加工数量相同直接修改原数据
|
|
|
- if (splitQty == unFinishRoll) {
|
|
|
- newDo.setId(currentProcessEquDo.getId());
|
|
|
- if (data.getPlanStartTime() != null) {
|
|
|
- newDo.setPlanstartdate(data.getPlanStartTime());
|
|
|
- // 自动计算计划完工时间=原完工时间+新计划开工时间-原计划开工时间
|
|
|
- newDo.setPlanenddate(new Date(newDo.getPlanenddate().getTime() +
|
|
|
- data.getPlanStartTime().getTime() - currentProcessEquDo.getPlanstartdate().getTime()));
|
|
|
+ List<String> affectedIdList = new ArrayList<>();
|
|
|
+ List<ApsProcessOperationProcessEquDo> newDataList = new ArrayList<>();
|
|
|
+ processOperationDetailSplitVos.forEach(data -> {
|
|
|
+ affectedIdList.addAll(data.getReturnAboutIds());
|
|
|
+ int splitQty = data.getSplitQty();
|
|
|
+ ApsProcessOperationProcessEquDo currentProcessEquDo = apsProcessOperationProcessEquDos.stream()
|
|
|
+ .filter(equs -> equs.getId().equals(data.getId()))
|
|
|
+ .findFirst()
|
|
|
+ .orElse(null);
|
|
|
+ if (currentProcessEquDo == null) {
|
|
|
+ log.error("无法根据id:{}获取到工序作业明细", data.getId());
|
|
|
+ throw new CustomException("无法获取到工序作业明细！请联系系统管理员");
|
|
|
}
|
|
|
- newDo.setCreatedate(new Date());
|
|
|
- newDo.setModifydate(new Date());
|
|
|
- newDataList.add(newDo);
|
|
|
- this.updateById(newDo);
|
|
|
- affectedIdList.add(newDo.getId());
|
|
|
- // 增加受影响的工序作业信息
|
|
|
- affectedIdList.addAll(checkProcessingTimeConflict(newDo, currentProcessEquDo.getPlanstartdate(),
|
|
|
- currentProcessEquDo.getPlanenddate(), currentProcessEquDo.getProcessdeviceid(),
|
|
|
- currentProcessOperationDo.getProcessway(),new ArrayList<>()));
|
|
|
- } else {
|
|
|
- /**************************拆分逻辑处理***********************************/
|
|
|
- newDo.setId(SecurityUtil.getUUID());
|
|
|
- newDo.setPlanprocessrall(splitQty);
|
|
|
- newDo.setCancelroll(0);
|
|
|
- if (data.getPlanStartTime() != null) {
|
|
|
- newDo.setPlanstartdate(data.getPlanStartTime());
|
|
|
- } else {
|
|
|
- newDo.setPlanstartdate(currentProcessOperationDo.getPlanstartdate());
|
|
|
+ // 当前的工序作业信息
|
|
|
+ ApsProcessOperationDo currentProcessOperationDo = apsProcessOperationDos.stream()
|
|
|
+ .filter(process -> process.getId().equals(currentProcessEquDo.getProcessid()))
|
|
|
+ .findFirst()
|
|
|
+ .orElse(null);
|
|
|
+ if (currentProcessOperationDo == null) {
|
|
|
+ log.error("无法获取工序作业明细:{}所对应的工序作业信息", currentProcessOperationDo.getId());
|
|
|
+ throw new CustomException("找不到对应工序作业信息！请联系系统管理员");
|
|
|
+ }
|
|
|
+ // 剩余待加工卷数
|
|
|
+ int unFinishRoll = currentProcessEquDo.getPlanprocessrall() - currentProcessEquDo.getStartingroll() - currentProcessEquDo.getCancelroll();
|
|
|
+ if (unFinishRoll <= 0) {
|
|
|
+ log.error("当前暂无可拆分的卷数信息");
|
|
|
+ throw new CustomException("该作业已全部开工，不能拆分");
|
|
|
}
|
|
|
- if (PROCESS_WAY_MERGE.equals(currentProcessOperationDo.getProcessway())) {
|
|
|
- // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长
|
|
|
- newDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue())));
|
|
|
+ if (splitQty > unFinishRoll) {
|
|
|
+ log.error("拆分数量:{}大于待加工卷数:{}", splitQty, unFinishRoll);
|
|
|
+ throw new CustomException("拆分数量大于待加工卷数，不能拆分");
|
|
|
+ }
|
|
|
+ ApsProcessOperationProcessEquDo newDo = new ApsProcessOperationProcessEquDo();
|
|
|
+ BeanUtils.copyProperties(currentProcessEquDo, newDo);
|
|
|
+ if (StringUtils.isNotBlank(data.getEquName())) {
|
|
|
+ newDo.setProcessdevice(data.getEquName());
|
|
|
} else {
|
|
|
- // 如果工序作业的加工方式不是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长*（计划加工卷数-已取消卷数）
|
|
|
- newDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue() * splitQty)));
|
|
|
+ newDo.setProcessdevice(currentProcessEquDo.getProcessdevice());
|
|
|
}
|
|
|
- newDo.setStartingroll(0);
|
|
|
- newDo.setReportroll(0);
|
|
|
- newDo.setCheckoutroll(0);
|
|
|
- newDo.setUnfinishroll(splitQty);
|
|
|
- newDo.setWorkstatus(JOBSTATUS_TO_BE_START);
|
|
|
- newDo.setClosestatus(UNFINISHED);
|
|
|
- newDo.setActualstartdate(null);
|
|
|
- newDo.setWaitreportid(null);
|
|
|
- newDo.setBachmaterialprocess(null);
|
|
|
- newDo.setCreatedate(new Date());
|
|
|
- newDo.setModifydate(new Date());
|
|
|
- affectedIdList.add(newDo.getId());
|
|
|
- // 增加受影响的工序作业信息
|
|
|
- affectedIdList.addAll(checkProcessingTimeConflict(newDo, newDo.getPlanstartdate(),
|
|
|
- newDo.getPlanenddate(), newDo.getProcessdeviceid(),
|
|
|
- currentProcessOperationDo.getProcessway(),new ArrayList<>()));
|
|
|
- this.save(newDo);
|
|
|
- newDataList.add(newDo);
|
|
|
- /**************************原数据逻辑处理***********************************/
|
|
|
- ApsProcessOperationProcessEquDo oldDo = new ApsProcessOperationProcessEquDo();
|
|
|
- oldDo.setId(currentProcessEquDo.getId());
|
|
|
- oldDo.setPlanprocessrall(unFinishRoll - splitQty);
|
|
|
- if (data.getPlanStartTime() != null) {
|
|
|
- oldDo.setPlanstartdate(data.getPlanStartTime());
|
|
|
+
|
|
|
+ if (StringUtils.isNotBlank(data.getEquId())) {
|
|
|
+ newDo.setProcessdeviceid(data.getEquId());
|
|
|
} else {
|
|
|
- oldDo.setPlanstartdate(currentProcessEquDo.getPlanstartdate());
|
|
|
+ newDo.setProcessdeviceid(currentProcessEquDo.getProcessdeviceid());
|
|
|
}
|
|
|
- if (PROCESS_WAY_MERGE.equals(currentProcessOperationDo.getProcessway())) {
|
|
|
- // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长
|
|
|
- oldDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() +
|
|
|
- TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue())));
|
|
|
+
|
|
|
+ if (StringUtils.isNotBlank(data.getWorkshopName())) {
|
|
|
+ newDo.setProcessworkshop(data.getWorkshopName());
|
|
|
} else {
|
|
|
- // 如果工序作业的加工方式不是合并加工，计划开工时间+工序作业单卷作业时长*（计划加工卷数-已取消卷数）
|
|
|
- oldDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() +
|
|
|
- TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue() * oldDo.getPlanprocessrall())));
|
|
|
+ newDo.setProcessworkshop(currentProcessEquDo.getProcessworkshop());
|
|
|
}
|
|
|
- oldDo.setUnfinishroll(oldDo.getPlanprocessrall() - currentProcessEquDo.getReportroll());
|
|
|
- // 完工状态更新
|
|
|
- if (oldDo.getPlanprocessrall() - currentProcessEquDo.getReportroll() - currentProcessEquDo.getCancelroll() > 0) {
|
|
|
- oldDo.setClosestatus(UNFINISHED);
|
|
|
+
|
|
|
+ if (StringUtils.isNotBlank(data.getWorkshopId())) {
|
|
|
+ newDo.setProcessworkshopid(data.getWorkshopId());
|
|
|
} else {
|
|
|
- oldDo.setClosestatus(SaveConstans.CloseStatus.COMPLETED);
|
|
|
+ newDo.setProcessworkshop(currentProcessEquDo.getProcessworkshop());
|
|
|
}
|
|
|
- if (SaveConstans.CloseStatus.COMPLETED.equals(oldDo.getClosestatus())) {
|
|
|
- // 作业状态更新
|
|
|
- oldDo.setWorkstatus(JOBSTATUS_TO_BE_END);
|
|
|
+ // 数量和待加工数量相同直接修改原数据
|
|
|
+ if (splitQty == unFinishRoll) {
|
|
|
+ newDo.setId(currentProcessEquDo.getId());
|
|
|
+ if (data.getPlanStartTime() != null) {
|
|
|
+ newDo.setPlanstartdate(data.getPlanStartTime());
|
|
|
+ // 自动计算计划完工时间=原完工时间+新计划开工时间-原计划开工时间
|
|
|
+ newDo.setPlanenddate(new Date(newDo.getPlanenddate().getTime() +
|
|
|
+ data.getPlanStartTime().getTime() - currentProcessEquDo.getPlanstartdate().getTime()));
|
|
|
+ }
|
|
|
+ newDo.setCreatedate(new Date());
|
|
|
+ newDo.setModifydate(new Date());
|
|
|
+ newDataList.add(newDo);
|
|
|
+ this.updateById(newDo);
|
|
|
+ affectedIdList.add(newDo.getId());
|
|
|
+ // 增加受影响的工序作业信息
|
|
|
+ affectedIdList.addAll(checkProcessingTimeConflict(newDo, currentProcessEquDo.getPlanstartdate(),
|
|
|
+ currentProcessEquDo.getPlanenddate(), currentProcessEquDo.getProcessdeviceid(),
|
|
|
+ currentProcessOperationDo.getProcessway(),new ArrayList<>()));
|
|
|
} else {
|
|
|
- oldDo.setWorkstatus(currentProcessEquDo.getReportroll() == 0 ? JOBSTATUS_TO_BE_START : JOBSTATUS_TO_BE_STARTING);
|
|
|
+ /**************************原数据逻辑处理***********************************/
|
|
|
+ ApsProcessOperationProcessEquDo oldDo = new ApsProcessOperationProcessEquDo();
|
|
|
+ oldDo.setId(currentProcessEquDo.getId());
|
|
|
+ oldDo.setPlanprocessrall(currentProcessEquDo.getPlanprocessrall() - splitQty);
|
|
|
+ if (data.getPlanStartTime() != null) {
|
|
|
+ oldDo.setPlanstartdate(data.getPlanStartTime());
|
|
|
+ } else {
|
|
|
+ oldDo.setPlanstartdate(currentProcessEquDo.getPlanstartdate());
|
|
|
+ }
|
|
|
+ if (PROCESS_WAY_MERGE.equals(currentProcessOperationDo.getProcessway())) {
|
|
|
+ // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长
|
|
|
+ oldDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() +
|
|
|
+ TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue())));
|
|
|
+ } else {
|
|
|
+ // 如果工序作业的加工方式不是合并加工，计划开工时间+工序作业单卷作业时长*（计划加工卷数-已取消卷数）
|
|
|
+ oldDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() +
|
|
|
+ TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue() * oldDo.getPlanprocessrall())));
|
|
|
+ }
|
|
|
+ oldDo.setUnfinishroll(oldDo.getPlanprocessrall() - currentProcessEquDo.getReportroll());
|
|
|
+ // 完工状态更新
|
|
|
+ if (oldDo.getPlanprocessrall() - currentProcessEquDo.getReportroll() - currentProcessEquDo.getCancelroll() > 0) {
|
|
|
+ oldDo.setClosestatus(UNFINISHED);
|
|
|
+ } else {
|
|
|
+ oldDo.setClosestatus(SaveConstans.CloseStatus.COMPLETED);
|
|
|
+ }
|
|
|
+ if (SaveConstans.CloseStatus.COMPLETED.equals(oldDo.getClosestatus())) {
|
|
|
+ // 作业状态更新
|
|
|
+ oldDo.setWorkstatus(JOBSTATUS_TO_BE_END);
|
|
|
+ } else {
|
|
|
+ oldDo.setWorkstatus(currentProcessEquDo.getReportroll() == 0 ? JOBSTATUS_TO_BE_START : JOBSTATUS_TO_BE_STARTING);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * 新增需求：计算剩余待开工/报工卷数
|
|
|
+ * 剩余待开工卷数=计划加工卷数-已开工卷数-已取消卷数合计
|
|
|
+ * 剩余待报工卷数=计划加工卷数-已报工卷数-已取消卷数合计
|
|
|
+ * 如果剩余待开工卷数=0，则完工状态=已完工
|
|
|
+ * 如果剩余待开工卷数>0，则完工状态=未完工
|
|
|
+ * 临时计算待加工料卷批次号数量
|
|
|
+ * 如果剩余待开工卷数<待加工料卷批次号数量，则表示有多余的批次号，去掉待加工料卷批次号最后多余的{待加工料卷批次号数量-剩余待开工卷数}个批次号，给拆分的新的作业明细
|
|
|
+ */
|
|
|
+ Integer leaveWaitWorkRoll = oldDo.getPlanprocessrall()-currentProcessEquDo.getStartingroll()-currentProcessEquDo.getCancelroll();
|
|
|
+ Integer leaveWaitJobRoll = oldDo.getPlanprocessrall()-currentProcessEquDo.getReportroll()-currentProcessEquDo.getCancelroll();
|
|
|
+ oldDo.setLeavewaitworkroll(leaveWaitWorkRoll);
|
|
|
+ oldDo.setLeavewaitjobroll(leaveWaitJobRoll);
|
|
|
+ if (leaveWaitJobRoll>0){
|
|
|
+ oldDo.setClosestatus("未完工");
|
|
|
+ }else {
|
|
|
+ if (leaveWaitJobRoll==0){
|
|
|
+ oldDo.setClosestatus("已完工");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ List<String> newBachMaterProcess = new ArrayList<>();
|
|
|
+ if (ObjectUtil.isNotEmpty(currentProcessEquDo.getBachmaterialprocess())){
|
|
|
+ String[] bachMaterialProcessArr = currentProcessEquDo.getBachmaterialprocess().split(",");
|
|
|
+ if (leaveWaitWorkRoll < bachMaterialProcessArr.length) {
|
|
|
+ List<String> newBach = new ArrayList<>();
|
|
|
+ List<String> oldBach = new ArrayList<>();
|
|
|
+ for (String mater : bachMaterialProcessArr) {
|
|
|
+ if (oldBach.size() < leaveWaitWorkRoll) {
|
|
|
+ oldBach.add(mater);
|
|
|
+ }else {
|
|
|
+ newBach.add(mater);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ newBachMaterProcess = newBach;
|
|
|
+ oldDo.setBachmaterialprocess(String.join(",", oldBach));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ affectedIdList.add(oldDo.getId());
|
|
|
+ oldDo.setModifydate(new Date());
|
|
|
+ this.updateById(oldDo);
|
|
|
+// // 增加受影响的工序作业信息
|
|
|
+// affectedIdList.addAll(checkProcessingTimeConflict(oldDo,
|
|
|
+// currentProcessEquDo.getPlanstartdate(), currentProcessEquDo.getPlanenddate(),
|
|
|
+// oldDo.getProcessdeviceid(), currentProcessOperationDo.getProcessway(),new ArrayList<>()));
|
|
|
+ /**************************拆分逻辑处理***********************************/
|
|
|
+ newDo.setId(SecurityUtil.getUUID());
|
|
|
+ newDo.setPlanprocessrall(splitQty);
|
|
|
+ newDo.setCancelroll(0);
|
|
|
+ if (data.getPlanStartTime() != null) {
|
|
|
+ newDo.setPlanstartdate(data.getPlanStartTime());
|
|
|
+ } else {
|
|
|
+ newDo.setPlanstartdate(currentProcessOperationDo.getPlanstartdate());
|
|
|
+ }
|
|
|
+ if (PROCESS_WAY_MERGE.equals(currentProcessOperationDo.getProcessway())) {
|
|
|
+ // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长
|
|
|
+ newDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue())));
|
|
|
+ } else {
|
|
|
+ // 如果工序作业的加工方式不是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长*（计划加工卷数-已取消卷数）
|
|
|
+ newDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue() * splitQty)));
|
|
|
+ }
|
|
|
+ newDo.setStartingroll(0);
|
|
|
+ newDo.setReportroll(0);
|
|
|
+ newDo.setCheckoutroll(0);
|
|
|
+ newDo.setUnfinishroll(splitQty);
|
|
|
+ /**
|
|
|
+ * 新增需求：已借调卷数=0，已取消卷数=0，输入不合格卷数=0，输入已取消卷数=0，已取消卷数合计=0,剩余待开工卷数=计划加工卷数,剩余待报工卷数=计划加工卷数
|
|
|
+ * 如果原作业有多余的待加工料卷批次号，则待加工料卷批次号=原作业明细的多余的待加工料卷批次号
|
|
|
+ */
|
|
|
+ newDo.setSecondroll(0);
|
|
|
+ newDo.setCancelrollno(0);
|
|
|
+ newDo.setInputunqualifiednum(0);
|
|
|
+ newDo.setInputunqualifiedroll(0);
|
|
|
+ newDo.setCancelroll(0);
|
|
|
+ newDo.setLeavewaitworkroll(splitQty);
|
|
|
+ newDo.setLeavewaitjobroll(splitQty);
|
|
|
+ if (ObjectUtil.isNotEmpty(newBachMaterProcess)){
|
|
|
+ newDo.setBachmaterialprocess(String.join(",", newBachMaterProcess));
|
|
|
+ }
|
|
|
+ newDo.setWorkstatus(JOBSTATUS_TO_BE_START);
|
|
|
+ newDo.setClosestatus(UNFINISHED);
|
|
|
+ newDo.setActualstartdate(null);
|
|
|
+ newDo.setWaitreportid(null);
|
|
|
+ newDo.setReportbatchnumber(null);
|
|
|
+ newDo.setCreatedate(new Date());
|
|
|
+ newDo.setModifydate(new Date());
|
|
|
+ affectedIdList.add(newDo.getId());
|
|
|
+ // 增加受影响的工序作业信息
|
|
|
+ affectedIdList.addAll(checkProcessingTimeConflict(newDo, newDo.getPlanstartdate(),
|
|
|
+ newDo.getPlanenddate(), newDo.getProcessdeviceid(),
|
|
|
+ currentProcessOperationDo.getProcessway(),new ArrayList<>()));
|
|
|
+ this.save(newDo);
|
|
|
+ newDataList.add(newDo);
|
|
|
}
|
|
|
- affectedIdList.add(oldDo.getId());
|
|
|
- oldDo.setModifydate(new Date());
|
|
|
- this.updateById(oldDo);
|
|
|
- // 增加受影响的工序作业信息
|
|
|
- affectedIdList.addAll(checkProcessingTimeConflict(oldDo,
|
|
|
- currentProcessEquDo.getPlanstartdate(), currentProcessEquDo.getPlanenddate(),
|
|
|
- oldDo.getProcessdeviceid(), currentProcessOperationDo.getProcessway(),new ArrayList<>()));
|
|
|
- }
|
|
|
- });
|
|
|
- this.saveOrUpdateBatch(newDataList);
|
|
|
- newDataList.forEach(newDo -> {
|
|
|
- // 判断是否存在设备不可用
|
|
|
- inspectionEquipmentIsAvailable(newDo, newDo.getProcessdeviceid()
|
|
|
- , newDo.getPlanstartdate(), newDo.getPlanenddate());
|
|
|
- });
|
|
|
- List<String> aboutIds= affectedIdList.stream().distinct().collect(Collectors.toList());
|
|
|
- apsProcessOperationDos.forEach(data -> {
|
|
|
- // 更新坯料交货期
|
|
|
- aboutIds.addAll(apsBlankOrderService.updateBlankDeliveryDate(null, data.getBlankid()));
|
|
|
- });
|
|
|
- // 将工序作业明细ID 加入到上一个工序作业信息的中
|
|
|
- Map<String, List<ApsProcessOperationProcessEquDo>> collect = newDataList.stream().collect(Collectors.groupingBy(ApsProcessOperationProcessEquDo::getPreviousprocessesids));
|
|
|
- collect.forEach((k, v) -> {
|
|
|
- List<String> collect1 = v.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
|
|
|
- ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo = previousApsProcessOperationProcessEquDos.stream()
|
|
|
- .filter(info -> k.equals(info.getId()))
|
|
|
- .findFirst()
|
|
|
- .orElse(null);
|
|
|
- this.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
|
|
|
- .eq(ApsProcessOperationProcessEquDo::getId, k)
|
|
|
- .set(ApsProcessOperationProcessEquDo::getNextprocessesids, strAppendListConvertStr(apsProcessOperationProcessEquDo.getNextprocessesids(), collect1)));
|
|
|
- });
|
|
|
- return R.ok(this.ganttService.getListById(aboutIds));
|
|
|
+ });
|
|
|
+ this.saveOrUpdateBatch(newDataList);
|
|
|
+ newDataList.forEach(newDo -> {
|
|
|
+ // 判断是否存在设备不可用
|
|
|
+ inspectionEquipmentIsAvailable(newDo, newDo.getProcessdeviceid()
|
|
|
+ , newDo.getPlanstartdate(), newDo.getPlanenddate());
|
|
|
+ });
|
|
|
+ List<String> aboutIds= affectedIdList.stream().distinct().collect(Collectors.toList());
|
|
|
+ apsProcessOperationDos.forEach(data -> {
|
|
|
+ // 更新坯料交货期
|
|
|
+ aboutIds.addAll(apsBlankOrderService.updateBlankDeliveryDate(null, data.getBlankid()));
|
|
|
+ });
|
|
|
+ // 将工序作业明细ID 加入到上一个工序作业信息的中
|
|
|
+ Map<String, List<ApsProcessOperationProcessEquDo>> collect = newDataList.stream().collect(Collectors.groupingBy(ApsProcessOperationProcessEquDo::getPreviousprocessesids));
|
|
|
+ collect.forEach((k, v) -> {
|
|
|
+ List<String> collect1 = v.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
|
|
|
+ ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo = previousApsProcessOperationProcessEquDos.stream()
|
|
|
+ .filter(info -> k.equals(info.getId()))
|
|
|
+ .findFirst()
|
|
|
+ .orElse(null);
|
|
|
+ this.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
|
|
|
+ .eq(ApsProcessOperationProcessEquDo::getId, k)
|
|
|
+ .set(ApsProcessOperationProcessEquDo::getNextprocessesids, strAppendListConvertStr(apsProcessOperationProcessEquDo.getNextprocessesids(), collect1)));
|
|
|
+ });
|
|
|
+ return R.ok(this.ganttService.getListById(aboutIds));
|
|
|
+// }finally {
|
|
|
+// for (String equId:ids){
|
|
|
+// splitLock.remove(equId);
|
|
|
+// }
|
|
|
+// }
|
|
|
}
|
|
|
|
|
|
public void updateBlank(String processOperationId) {
|
