/*
|
* Copyright (c) 2018-2025, ztt All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are met:
|
*
|
* Redistributions of source code must retain the above copyright notice,
|
* this list of conditions and the following disclaimer.
|
* Redistributions in binary form must reproduce the above copyright
|
* notice, this list of conditions and the following disclaimer in the
|
* documentation and/or other materials provided with the distribution.
|
* Neither the name of the pig4cloud.com developer nor the names of its
|
* contributors may be used to endorse or promote products derived from
|
* this software without specific prior written permission.
|
* Author: ztt
|
*/
|
package com.chinaztt.mes.production.service.impl;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.core.date.DatePattern;
|
import cn.hutool.core.date.DateUtil;
|
import cn.hutool.core.io.FileUtil;
|
import cn.hutool.core.io.IoUtil;
|
import cn.hutool.core.util.IdUtil;
|
import cn.hutool.core.util.StrUtil;
|
import com.alibaba.excel.util.CollectionUtils;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.chinaztt.mes.basic.entity.Part;
|
import com.chinaztt.mes.basic.entity.Template;
|
import com.chinaztt.mes.basic.entity.Workstation;
|
import com.chinaztt.mes.basic.mapper.BasicParamTemplateMapper;
|
import com.chinaztt.mes.basic.mapper.PartMapper;
|
import com.chinaztt.mes.basic.mapper.WorkstationMapper;
|
import com.chinaztt.mes.common.constant.Constant;
|
import com.chinaztt.mes.common.handler.StateMachineHandler;
|
import com.chinaztt.mes.common.numgen.NumberGenerator;
|
import com.chinaztt.mes.common.util.StateResult;
|
import com.chinaztt.mes.plan.dto.ManufacturingOrderDTO;
|
import com.chinaztt.mes.plan.dto.ManufacturingOrderOperationTemplateDTO;
|
import com.chinaztt.mes.plan.dto.MoTestStandardDTO;
|
import com.chinaztt.mes.plan.dto.MoTestStandardParamDTO;
|
import com.chinaztt.mes.plan.entity.*;
|
import com.chinaztt.mes.plan.mapper.*;
|
import com.chinaztt.mes.plan.service.ManufacturingOrderService;
|
import com.chinaztt.mes.plan.state.manufacturing.constant.ManufacturingOrderStateStringValues;
|
import com.chinaztt.mes.production.dto.*;
|
import com.chinaztt.mes.production.dto.mould.BasicInfoForPdaFeedDTO;
|
import com.chinaztt.mes.production.entity.*;
|
import com.chinaztt.mes.production.mapper.*;
|
import com.chinaztt.mes.production.service.OperationTaskParamService;
|
import com.chinaztt.mes.production.service.OperationTaskRecordService;
|
import com.chinaztt.mes.production.service.OperationTaskService;
|
import com.chinaztt.mes.production.state.operationtask.OperationTaskStateMachineConfig;
|
import com.chinaztt.mes.production.state.operationtask.constant.OperationTaskEvents;
|
import com.chinaztt.mes.production.state.operationtask.constant.OperationTaskStateStringValues;
|
import com.chinaztt.mes.production.state.operationtask.constant.OperationTaskStates;
|
import com.chinaztt.mes.production.vo.OperationTaskScreenVO;
|
import com.chinaztt.mes.quality.entity.*;
|
import com.chinaztt.mes.quality.mapper.*;
|
import com.chinaztt.mes.quality.service.impl.ReportServiceImpl;
|
import com.chinaztt.mes.technology.entity.Operation;
|
import com.chinaztt.mes.technology.mapper.OperationMapper;
|
import com.chinaztt.mes.warehouse.dto.PalletTransportsMaterialDTO;
|
import com.chinaztt.mes.warehouse.entity.JoinStockOrder;
|
import com.chinaztt.mes.warehouse.entity.Stock;
|
import com.chinaztt.mes.warehouse.mapper.JoinStockOrderMapper;
|
import com.chinaztt.mes.warehouse.mapper.StockMapper;
|
import com.chinaztt.ztt.admin.api.feign.RemoteParamService;
|
import com.chinaztt.ztt.common.core.constant.SecurityConstants;
|
import com.chinaztt.ztt.common.core.util.R;
|
import com.chinaztt.ztt.common.oss.OssProperties;
|
import com.chinaztt.ztt.common.oss.service.OssTemplate;
|
import com.chinaztt.ztt.common.sequence.sequence.Sequence;
|
import com.google.gson.Gson;
|
import lombok.AllArgsConstructor;
|
import org.apache.http.HttpEntity;
|
import org.apache.http.client.methods.CloseableHttpResponse;
|
import org.apache.http.client.methods.HttpPost;
|
import org.apache.http.entity.ContentType;
|
import org.apache.http.entity.StringEntity;
|
import org.apache.http.impl.client.CloseableHttpClient;
|
import org.apache.http.impl.client.HttpClientBuilder;
|
import org.apache.http.util.EntityUtils;
|
import org.springframework.core.env.Environment;
|
import org.springframework.messaging.Message;
|
import org.springframework.messaging.support.MessageBuilder;
|
import org.springframework.statemachine.config.StateMachineFactory;
|
import org.springframework.statemachine.persist.StateMachinePersister;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.interceptor.TransactionAspectSupport;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.lang.reflect.Array;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.Duration;
|
import java.time.LocalDateTime;
|
import java.time.temporal.ChronoUnit;
|
import java.util.*;
|
import java.util.Map.Entry;
|
import java.util.stream.Collectors;
|
|
/**
|
* 工序任务
|
*
|
* @author zhangxy
|
* @date 2020-09-18 09:26:35
|
*/
|
@Service
|
@AllArgsConstructor
|
@Transactional(rollbackFor = Exception.class)
|
public class OperationTaskServiceImpl extends ServiceImpl<OperationTaskMapper, OperationTask> implements OperationTaskService {
|
private ApplyPartMapper applyPartMapper;
|
private BasicParamTemplateMapper basicParamTemplateMapper;
|
private CustomerOrderMapper customerOrderMapper;
|
private CustomerOrderParamMapper customerOrderParamMapper;
|
private JoinStockOrderMapper joinStockOrderMapper;
|
private ManufacturingOrderMapper manufacturingOrderMapper;
|
private ManufacturingOrderService manufacturingOrderService;
|
private MoStructureComponentMapper moStructureComponentMapper;
|
private MoRoutingOperationMapper moRoutingOperationMapper;
|
private MoRoutingMapper moRoutingMapper;
|
private ManufacturingOrderOperationTemplateMapper manufacturingOrderOperationTemplateMapper;
|
private ManufacturingOrderOperationParamMapper manufacturingOrderOperationParamMapper;
|
private MoTestStandardParamMapper moTestStandardParamMapper;
|
private MoTestStandardMapper moTestStandardMapper;
|
private NumberGenerator<ReportSample> reportSampleNumberGenerator;
|
private OperationTaskAttachmentMapper operationTaskAttachmentMapper;
|
private OperationTaskSupplyMapper supplyMapper;
|
private OperationTaskParamMapper operationTaskParamMapper;
|
private OperationTaskProduceMapper operationTaskProduceMapper;
|
private OperationTaskRecordMapper operationTaskRecordMapper;
|
private OperationTaskMaterialMapper operationTaskMaterialMapper;
|
private OperationTaskSupplyMapper operationTaskSupplyMapper;
|
private OperationTaskMapper operationTaskMapper;
|
private OperationMapper operationMapper;
|
private ProductOutputMapper productOutputMapper;
|
private PartMapper partMapper;
|
private ReportSampleMapper reportSampleMapper;
|
private ReportServiceImpl reportService;
|
private ReportMeasuringToolMapper reportMeasuringToolMapper;
|
private RemoteParamService remoteParamService;
|
private ReportSampleItemMapper reportSampleItemMapper;
|
private ReportMapper reportMapper;
|
private StateMachineFactory<OperationTaskStates, OperationTaskEvents> operationTaskStateMachineFactory;
|
private StateMachinePersister<OperationTaskStates, OperationTaskEvents, OperationTask> persister;
|
private Sequence opTaskSequence;
|
private WorkstationMapper workstationMapper;
|
private StockMapper stockMapper;
|
private SegmentationTaskRecordMapper segmentationTaskRecordMapper;
|
private OperationTaskRecordService operationTaskRecordService;
|
private OperationTaskParamService operationTaskParamService;
|
private Environment environment;
|
|
private final OssProperties ossProperties;
|
private final OssTemplate minioTemplate;
|
|
public static final String BUCKET_NAME = "mes";
|
|
@Override
|
public IPage<List<OperationTaskDTO>> getPage(Page page, QueryWrapper<OperationTaskDTO> ew) {
|
return baseMapper.queryPage(page, ew);
|
}
|
|
@Override
|
public List<OperationTaskDTO> getOperationTask(Long workstationId, String productSn, String salesOrder,
|
String productName, String outBatchNo, String mpsNo) {
|
List<OperationTaskDTO> opreturn = new ArrayList<>();
|
if (workstationId == null) {
|
return opreturn;
|
}
|
Workstation workstation = workstationMapper.selectById(workstationId);
|
if (workstation == null) {
|
return opreturn;
|
}
|
Boolean operationStockStatus = null;
|
if (StringUtils.isNotBlank(outBatchNo)) {
|
List<Stock> stockList = stockMapper.selectList(Wrappers.<Stock>lambdaQuery()
|
.eq(Stock::getPartBatchNo, outBatchNo));
|
if (CollectionUtil.isNotEmpty(stockList)) {
|
operationStockStatus = stockList.get(0).getOperationStockStatus();
|
}
|
}
|
//对应工作中心工单下面工作站位空的工单 和 对应的当前工作站的工单
|
QueryWrapper gen = Wrappers.<OperationTask>query().eq("oot.work_center", workstation.getWorkCenter());
|
List<OperationTaskDTO> operationTaskDTOS = baseMapper.getOperationTask(gen, true, productSn, salesOrder,
|
productName, outBatchNo, mpsNo, operationStockStatus);
|
operationTaskDTOS.forEach(operationTaskDTO -> {
|
if (operationTaskDTO.getWorkstationId() == null) {
|
opreturn.add(operationTaskDTO);
|
} else {
|
if (workstationId.equals(operationTaskDTO.getWorkstationId())) {
|
opreturn.add(operationTaskDTO);
|
}
|
}
|
});
|
return opreturn;
|
}
|
|
@Override
|
public boolean changeState(List<Long> ids, String event) {
|
if (CollectionUtil.isEmpty(ids)) {
|
throw new RuntimeException("请选择至少一条工单");
|
}
|
for (Long id : ids) {
|
changeStateCommon(id, event);
|
}
|
return true;
|
}
|
|
@Override
|
public boolean changeState(Long id, String event) {
|
if (id == null) {
|
throw new RuntimeException("请选择一条工单");
|
}
|
changeStateCommon(id, event);
|
return true;
|
}
|
|
public void changeStateCommon(Long id, String event) {
|
OperationTask operationTask = baseMapper.selectById(id);
|
// String moIfsNeedSync = remoteParamService.getByKey(Constant.MO_IFS_NEED_SYNC, SecurityConstants.FROM_IN).getData();
|
if (event.equals("UNSUBMIT")) {
|
// String taskMoNo = baseMapper.getTaskMoNo(id);
|
// ManufacturingOrder manufacturingOrder = manufacturingOrderMapper.selectOne(Wrappers.<ManufacturingOrder>lambdaQuery()
|
// .eq(ManufacturingOrder::getMoNo, taskMoNo));
|
// if (StringUtils.isBlank(manufacturingOrder.getIfsOrderNo()) && !org.apache.commons.lang3.StringUtils.equals(moIfsNeedSync, "false")) {
|
// throw new RuntimeException("车间订单没有同步IFS");
|
// }
|
// 调用 ERP派工单新增接口
|
ylErpJobOrderSave(id);
|
operationTask.setState(OperationTaskStates.PENDING.getValue());
|
updateById(operationTask);
|
} else if (event.equals("UNSUBMIT")) {
|
operationTask.setState(OperationTaskStates.UNSUBMIT.getValue());
|
updateById(operationTask);
|
} else {
|
Message<OperationTaskEvents> message = MessageBuilder.withPayload(OperationTaskEvents.valueOf(event)).setHeader("operationTask", operationTask).build();
|
StateMachineHandler handler = new StateMachineHandler(operationTaskStateMachineFactory, persister, OperationTaskStateMachineConfig.MACHINE_ID, operationTask);
|
StateResult res = handler.sendEvent(message, operationTask.getId());
|
if (!res.isSuccess()) {
|
throw new RuntimeException(res.getMsg());
|
}
|
}
|
//修改排程时间
|
changePlanTime(operationTask, event);
|
}
|
|
/**
|
* 对接鹰联ERP派工
|
*
|
* @param id 工单id
|
*/
|
private void ylErpJobOrderSave(Long id) {
|
CustomerOrder customerOrder = customerOrderMapper.getCustomerOrderNoByOperationTaskId(id);
|
if (null == customerOrder) {
|
return;
|
}
|
if (null == customerOrder.getCustomerOrderNo()) {
|
return;
|
}
|
//区分一下是不是鹰联的订单 鹰联订单开头是YL
|
if (!customerOrder.getCustomerOrderNo().startsWith("YL")) {
|
return;
|
}
|
List<OperationTaskMaterial> operationTaskMaterials = operationTaskMaterialMapper.selectList(new LambdaQueryWrapper<OperationTaskMaterial>().eq(OperationTaskMaterial::getOperationTaskId, id));
|
if (CollectionUtil.isEmpty(operationTaskMaterials)) {
|
throw new RuntimeException("没有所需物料信息");
|
}
|
List<Long> partIds = operationTaskMaterials.stream().map(OperationTaskMaterial::getPartId).collect(Collectors.toList());
|
List<Part> parts = partMapper.selectBatchIds(partIds);
|
SaveWorkAssignsEntity saveWorkAssignsEntity = new SaveWorkAssignsEntity();
|
saveWorkAssignsEntity.setIsHasXLH(true);
|
saveWorkAssignsEntity.setTitle("派工单" + id);
|
saveWorkAssignsEntity.setCode(id + "");
|
saveWorkAssignsEntity.setHtid(customerOrder.getCustomerOrderNo());
|
List<SaveWorkAssignsEntity.WorkAssignItems> workAssignItems = new ArrayList<>();
|
List<SaveWorkAssignsEntity.WorkAssignWFPs> workAssignWFPs = new ArrayList<>();
|
|
BigDecimal num = new BigDecimal(0);
|
for (OperationTaskMaterial operationTaskMaterial : operationTaskMaterials) {
|
SaveWorkAssignsEntity.WorkAssignItems item = new SaveWorkAssignsEntity.WorkAssignItems();
|
item.setNeedNum(operationTaskMaterial.getQuantityRequired());
|
Long productID = parts.stream().filter(e -> e.getId().equals(operationTaskMaterial.getPartId())).findFirst().get().getPartFamilyId();
|
item.setProductID(productID);
|
workAssignItems.add(item);
|
num = num.add(operationTaskMaterial.getQuantityRequired());
|
|
SaveWorkAssignsEntity.WorkAssignWFPs wfPs = new SaveWorkAssignsEntity.WorkAssignWFPs();
|
wfPs.setNumMake(operationTaskMaterial.getQuantityRequired());
|
wfPs.setIsOut(0);
|
wfPs.setUnitID(2);
|
workAssignWFPs.add(wfPs);
|
}
|
saveWorkAssignsEntity.setWorkAssignItems(workAssignItems);
|
saveWorkAssignsEntity.setWorkAssignWFPs(workAssignWFPs);
|
saveWorkAssignsEntity.setNumMake(num);
|
R r = addERPJobOrder(saveWorkAssignsEntity);
|
if (r.getCode() != 0) {
|
throw new RuntimeException(r.getMsg());
|
}
|
}
|
|
/**
|
* @param saveWorkAssignsEntity
|
* @return
|
*/
|
private R addERPJobOrder(SaveWorkAssignsEntity saveWorkAssignsEntity) {
|
CloseableHttpClient httpClient = HttpClientBuilder.create().build();
|
String syncErpUrl = environment.getProperty("addErpJobOrder");
|
HttpPost httpPost = new HttpPost(syncErpUrl);
|
String jsonParams = new Gson().toJson(saveWorkAssignsEntity);
|
// 设置请求体为JSON格式
|
StringEntity requestEntity = new StringEntity(jsonParams, ContentType.APPLICATION_JSON);
|
httpPost.setEntity(requestEntity);
|
String responseString = null;
|
CloseableHttpResponse response = null;
|
try {
|
response = httpClient.execute(httpPost);
|
HttpEntity entity = response.getEntity();
|
responseString = EntityUtils.toString(entity, "UTF-8");
|
return new Gson().fromJson(responseString, R.class);
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
return R.failed();
|
}
|
|
/**
|
* 工单开始结束之后 修改计划开始结束时间
|
*
|
* @param operationTask
|
* @param event
|
*/
|
private void changePlanTime(OperationTask operationTask, String event) {
|
LocalDateTime localDateTime = LocalDateTime.now();
|
//完成
|
if ("COMPLETE".equals(event)) {
|
List<OperationTask> operationTaskList = operationTaskMapper.selectList(Wrappers.<OperationTask>lambdaQuery()
|
.orderByAsc(OperationTask::getPlannedFinishDate)
|
.in(OperationTask::getState, Arrays.asList("07unsubmit", "01pending", "02inProgress", "03interrupted"))
|
.eq(OperationTask::getWorkstationId, operationTask.getWorkstationId()));
|
if (null != operationTask.getPlannedFinishDate()) {
|
//获取时间的差值 分钟数 当前时间 - 计划完成时间
|
Duration dur = Duration.between(operationTask.getPlannedFinishDate(), localDateTime);
|
Long mis = dur.toMinutes();
|
for (OperationTask taskChange : operationTaskList) {
|
// 计划开始时间 = 计划开始时间 + 差值
|
if (null != taskChange.getPlannedStartDate()) {
|
taskChange.setPlannedStartDate(taskChange.getPlannedStartDate().plusMinutes(mis));
|
}
|
// 计划完成时间 = 计划完成时间 + 差值
|
if (null != taskChange.getPlannedFinishDate()) {
|
taskChange.setPlannedFinishDate(taskChange.getPlannedFinishDate().plusMinutes(mis));
|
}
|
baseMapper.updateById(taskChange);
|
}
|
}
|
}
|
}
|
|
|
@Override
|
public OperationTaskDTO getOperation(Long id) {
|
OperationTaskDTO operationTaskDTO = baseMapper.getOperationTaskDTO(id);
|
operationTaskDTO.setLocalDateTimes(Arrays.asList(operationTaskDTO.getPlannedStartDate(), operationTaskDTO.getPlannedFinishDate()));
|
operationTaskDTO.setOutPutBatchList(operationTaskProduceMapper.selectList(Wrappers.<OperationTaskProduce>lambdaQuery()
|
.eq(OperationTaskProduce::getOperationTaskId, operationTaskDTO.getId())));
|
return operationTaskDTO;
|
}
|
|
/**
|
* 新增工单
|
*
|
* @param operationTaskDTO
|
* @return
|
*/
|
private String saveSingle(OperationTaskDTO operationTaskDTO) {
|
//如果前台没有指定工单类型默认是 M 制造
|
if (StringUtils.isBlank(operationTaskDTO.getOperationTaskType())) {
|
operationTaskDTO.setOperationTaskType("M");
|
}
|
//判断工单类型和符不符合当前工序
|
// 将IFS接口调用，放到最后一步，防止调用IFS接口成功，本地事务报错回滚，导致IFS接口数据无法回滚
|
ManufacturingOrder manufacturingOrder = manufacturingOrderMapper.selectById(operationTaskDTO.getMoId());
|
//if (manufacturingOrder.getState().equals(ManufacturingOrderStateStringValues.PLANNED)) {
|
// manufacturingOrder.setState(ManufacturingOrderStateStringValues.ISSUED);
|
// //调用ifs修改ifs车间订单状态
|
// R result = manufacturingOrderService.changeState(manufacturingOrder, "RELEASE");
|
// if (result.getCode() == 1) {
|
// throw new RuntimeException(manufacturingOrder.getMoNo() + result.getMsg());
|
// }
|
//}
|
if (!checkTaskType(operationTaskDTO, manufacturingOrder)) {
|
throw new RuntimeException("工序为：" + operationTaskDTO.getOperationName() + "的工单类型不符合");
|
}
|
operationTaskDTO.setOptaskNo(opTaskSequence.nextNo());
|
operationTaskDTO.setState(OperationTaskStates.UNSUBMIT.getValue());
|
baseMapper.insert(operationTaskDTO);
|
// 设置优先级
|
baseMapper.updateNextPriority(operationTaskDTO.getId());
|
OperationTask operationTask = baseMapper.selectOne(Wrappers.<OperationTask>lambdaQuery().eq(OperationTask::getOptaskNo, operationTaskDTO.getOptaskNo()));
|
OperationTaskSupply operationTaskSupply = new OperationTaskSupply();
|
operationTaskSupply.setMoId(operationTaskDTO.getMoId());
|
operationTaskSupply.setOperationTaskId(operationTask.getId());
|
operationTaskSupply.setQuantitySupply(operationTaskDTO.getPlannedQuantity());
|
operationTaskSupplyMapper.insert(operationTaskSupply);
|
//添加工单所需物料
|
addMoStructureComponent(operationTaskDTO.getMoId(), operationTaskDTO.getPartId(), operationTask);
|
// 更新制造订单主表的当前工序名称
|
//if (null != manufacturingOrder && !org.springframework.util.StringUtils.isEmpty(operationTaskDTO.getOperationName())) {
|
// manufacturingOrder.setCurrentOperation(operationTaskDTO.getOperationName());
|
//}
|
//manufacturingOrderMapper.updateById(manufacturingOrder);
|
//修改段长关联关系
|
// List<OperationTaskProduce> operationTaskProduceList = operationTaskDTO.getOutPutBatchList();
|
// if (CollectionUtil.isNotEmpty(operationTaskProduceList)) {
|
// for (OperationTaskProduce operationTaskProduce : operationTaskProduceList) {
|
// operationTaskProduce.setOperationTaskId(operationTaskDTO.getId());
|
// operationTaskProduceMapper.updateById(operationTaskProduce);
|
// }
|
// }
|
return operationTaskDTO.getOptaskNo();
|
}
|
|
/**
|
* 单个工单新增
|
*
|
* @param operationTaskDTO
|
* @return
|
*/
|
@Override
|
public String fullSave(OperationTaskDTO operationTaskDTO) {
|
return batchFullSave(Collections.singletonList(operationTaskDTO)).get(0);
|
}
|
|
|
/**
|
* 制造类型的车间订单的最后一道工序禁止创建【类型】为修理的工单
|
* 修理类型的车间订单则没有这个要求
|
* 判断当前工单是不是最后一道工序
|
* M ：制造
|
* F ：修理
|
*
|
* @param operationTaskDTO
|
* @return
|
*/
|
private boolean checkTaskType(OperationTaskDTO operationTaskDTO, ManufacturingOrder manufacturingOrder) {
|
boolean isLast = true;
|
//查询当前工序
|
MoRoutingOperation moRoutingOperation = moRoutingOperationMapper.selectById(operationTaskDTO.getMoRoutingOperationId());
|
//设置工艺路线id
|
operationTaskDTO.setRoutingOperationId(moRoutingOperation.getTechnologyRoutingOperationId());
|
//如果车间订单类型是M 并且 工单是 F 类型
|
if ("M".equals(manufacturingOrder.getWorkshopTypeCode()) && "F".equals(operationTaskDTO.getOperationTaskType())) {
|
//查询最后一道工序
|
MoRoutingOperation moRoutingOperationLast = moRoutingMapper.getLastMoRoutingOperation(operationTaskDTO.getMoId());
|
//如果两个工序的id 不一样 那就不是最后一道工序
|
if (moRoutingOperationLast.getId().equals(moRoutingOperation.getId())) {
|
isLast = false;
|
}
|
}
|
return isLast;
|
}
|
|
/**
|
* 批量新增工单
|
*
|
* @param operationTaskDTOList
|
* @return
|
*/
|
@Override
|
public List<String> batchFullSave(List<OperationTaskDTO> operationTaskDTOList) {
|
List<String> opTaskNoList = new ArrayList<>();
|
operationTaskDTOList.forEach(operationTaskDTO -> {
|
opTaskNoList.add(saveSingle(operationTaskDTO));
|
});
|
releaseManufacturingOrder(operationTaskDTOList.get(0));
|
return opTaskNoList;
|
}
|
|
private void releaseManufacturingOrder(OperationTaskDTO operationTaskDTO) {
|
//判断工单类型和符不符合当前工序
|
ManufacturingOrder manufacturingOrder = manufacturingOrderMapper.selectById(operationTaskDTO.getMoId());
|
if (manufacturingOrder.getState().equals(ManufacturingOrderStateStringValues.PLANNED)) {
|
manufacturingOrder.setState(ManufacturingOrderStateStringValues.ISSUED);
|
//调用ifs修改ifs车间订单状态
|
// R result = manufacturingOrderService.changeState(manufacturingOrder, "RELEASE");
|
// if (result.getCode() == 1) {
|
// throw new RuntimeException(manufacturingOrder.getMoNo() + result.getMsg());
|
// }
|
}
|
//if (!checkTaskType(operationTaskDTO, manufacturingOrder)) {
|
// throw new RuntimeException("工序为：" + operationTaskDTO.getOperationName() + "的工单类型不符合");
|
//}
|
// 更新制造订单主表的当前工序名称
|
if (null != manufacturingOrder && !org.springframework.util.StringUtils.isEmpty(operationTaskDTO.getOperationName())) {
|
manufacturingOrder.setCurrentOperation(operationTaskDTO.getOperationName());
|
}
|
manufacturingOrderMapper.updateById(manufacturingOrder);
|
}
|
|
// public void addMoStructureComponent(Long moId, Long partId, OperationTask operationTask) {
|
// ManufacturingOrder manufacturingOrder = manufacturingOrderMapper.selectById(moId);
|
//// 计算出需要的根节点的数量 用计划数量 除以这个零件所有涉及到的qpa
|
//// 先找到当前零件的所在节点
|
// List<MoStructureComponent> moStructureComponentList = moStructureComponentMapper.selectList(Wrappers.<MoStructureComponent>lambdaQuery()
|
// .eq(MoStructureComponent::getPlanManufacturingOrderId, manufacturingOrder.getId()).eq(MoStructureComponent::getPartId, partId));
|
// if (CollectionUtil.isNotEmpty(moStructureComponentList)) {
|
// BigDecimal sumUnitQpa = moStructureComponentList.stream().map(MoStructureComponent::getQpa).reduce(BigDecimal.ZERO, BigDecimal::add);
|
// BigDecimal unitAcount = operationTask.getPlannedQuantity().divide(sumUnitQpa, 3, BigDecimal.ROUND_HALF_UP);
|
// List<OperationTaskMaterial> materials = new ArrayList<>();
|
// for (MoStructureComponent moStructureComponent : moStructureComponentList) {
|
// //找到当前零件的下级节点
|
// List<MoStructureComponent> newMoStructureComponentList = moStructureComponentMapper.selectList(Wrappers.<MoStructureComponent>lambdaQuery()
|
// .eq(MoStructureComponent::getPlanManufacturingOrderId, manufacturingOrder.getId())
|
// .eq(MoStructureComponent::getParent, moStructureComponent.getId()));
|
// if (CollectionUtil.isNotEmpty(newMoStructureComponentList)) {
|
// for (MoStructureComponent newMoStructureComponent : newMoStructureComponentList) {
|
// //工单所需物料保存
|
// OperationTaskMaterial material = new OperationTaskMaterial();
|
// material.setOperationTaskId(operationTask.getId());
|
// material.setPartId(newMoStructureComponent.getPartId());
|
// material.setQpa(newMoStructureComponent.getQpa().divide(moStructureComponent.getQpa(), 3, BigDecimal.ROUND_HALF_UP));
|
// material.setQuantityRequired((newMoStructureComponent.getQpa().multiply(unitAcount)));
|
// materials.add(material);
|
// }
|
// }
|
// }
|
// Map<Long, List<OperationTaskMaterial>> group = materials.stream().collect(Collectors.groupingBy(OperationTaskMaterial::getPartId));
|
// for (Map.Entry<Long, List<OperationTaskMaterial>> map : group.entrySet()) {
|
// OperationTaskMaterial material = new OperationTaskMaterial();
|
// BigDecimal quantityRequired = BigDecimal.ZERO;
|
// for (OperationTaskMaterial operationTaskMaterial : map.getValue()) {
|
// material.setOperationTaskId(operationTaskMaterial.getOperationTaskId());
|
// material.setPartId(operationTaskMaterial.getPartId());
|
// material.setQpa(operationTaskMaterial.getQpa());
|
// quantityRequired = quantityRequired.add(operationTaskMaterial.getQuantityRequired());
|
// }
|
// material.setQuantityRequired(quantityRequired);
|
// operationTaskMaterialMapper.insert(material);
|
// }
|
// }
|
//}
|
|
|
public void addMoStructureComponent(Long moId, Long partId, OperationTask operationTask) {
|
MoRoutingOperation moRoutingOperation = moRoutingOperationMapper.selectById(operationTask.getMoRoutingOperationId());
|
Operation operation = operationMapper.selectById(moRoutingOperation.getOperationId());
|
if (operation == null) {
|
throw new RuntimeException("工序丢失");
|
}
|
// 根据零件id 和 车间订单id 查询产品结构半成品节点
|
List<MoStructureComponent> currentStrucList =
|
moStructureComponentMapper.selectList(Wrappers.<MoStructureComponent>lambdaQuery()
|
.eq(MoStructureComponent::getPlanManufacturingOrderId, moId)
|
.eq(MoStructureComponent::getPartId, partId)
|
.and(wrapper -> wrapper.ne(MoStructureComponent::getOperationId, moRoutingOperation.getOperationId()).or(w -> w.isNull(MoStructureComponent::getOperationId))));
|
// 零件id 的list
|
if (CollectionUtil.isEmpty(currentStrucList)) {
|
throw new RuntimeException("工序为：" + operation.getName() + "的工单生产的零件不存在车间订单bom中");
|
}
|
//if (operationTask.getOperationTaskType().equals("M")) {
|
List<Long> partIds = new ArrayList<>();
|
for (MoStructureComponent currentStruc : currentStrucList) {
|
// 根据父节点id 和 消耗工序 车间订单id
|
List<MoStructureComponent> childStrucList = moStructureComponentMapper.selectList(Wrappers.<MoStructureComponent>lambdaQuery()
|
.eq(MoStructureComponent::getPlanManufacturingOrderId, moId)
|
.eq(MoStructureComponent::getParent, currentStruc.getId())
|
.eq(MoStructureComponent::getOperationId, moRoutingOperation.getOperationId()));
|
for (MoStructureComponent childStruc : childStrucList) {
|
OperationTaskMaterial operationTaskMaterial = new OperationTaskMaterial();
|
operationTaskMaterial.setOperationTaskId(operationTask.getId());
|
operationTaskMaterial.setPartId(childStruc.getPartId());
|
operationTaskMaterial.setQpa(childStruc.getQpa().divide(currentStruc.getQpa(), 3, BigDecimal.ROUND_HALF_UP));
|
operationTaskMaterial.setQuantityRequired(operationTaskMaterial.getQpa().multiply(operationTask.getPlannedQuantity()));
|
partIds.add(childStruc.getPartId());
|
operationTaskMaterialMapper.insert(operationTaskMaterial);
|
}
|
//查找当前工序的上一道工序的产出
|
MoRoutingOperation moRoutingOperationLast = getLastMoRoutingOperation(moId, operationTask.getMoRoutingOperationId());
|
if (null != moRoutingOperationLast.getPartId()) {
|
if (!partIds.contains(moRoutingOperationLast.getPartId())) {
|
OperationTaskMaterial operationTaskMaterial = new OperationTaskMaterial();
|
operationTaskMaterial.setOperationTaskId(operationTask.getId());
|
operationTaskMaterial.setPartId(moRoutingOperationLast.getPartId());
|
operationTaskMaterial.setQpa(BigDecimal.ONE);
|
operationTaskMaterial.setQuantityRequired(operationTask.getPlannedQuantity());
|
partIds.add(moRoutingOperationLast.getPartId());
|
operationTaskMaterialMapper.insert(operationTaskMaterial);
|
}
|
}
|
}
|
//}
|
//如果是修理就获取当前节点的零件
|
//if (operationTask.getOperationTaskType().equals("F")) {
|
// OperationTaskMaterial operationTaskMaterial = new OperationTaskMaterial();
|
// operationTaskMaterial.setOperationTaskId(operationTask.getId());
|
// operationTaskMaterial.setPartId(partId);
|
// operationTaskMaterial.setQpa(BigDecimal.ONE);
|
// operationTaskMaterial.setQuantityRequired(operationTask.getPlannedQuantity());
|
// operationTaskMaterialMapper.insert(operationTaskMaterial);
|
//}
|
}
|
|
/**
|
* 根据工艺路线工序id 获取上一道工序
|
*
|
* @param moId
|
* @param id
|
* @return
|
*/
|
private MoRoutingOperation getLastMoRoutingOperation(Long moId, Long id) {
|
MoRoutingOperation moRoutingOperation = new MoRoutingOperation();
|
List<MoRoutingOperation> moRoutingOperationList = moRoutingOperationMapper.selectList(Wrappers.<MoRoutingOperation>lambdaQuery()
|
.eq(MoRoutingOperation::getMoId, moId)
|
.orderByAsc(MoRoutingOperation::getOperationOrder));
|
if (moRoutingOperationList.size() > 1) {
|
for (int i = 1; i < moRoutingOperationList.size(); i++) {
|
if (id.equals(moRoutingOperationList.get(i).getId())) {
|
moRoutingOperation = moRoutingOperationList.get(i - 1);
|
break;
|
}
|
}
|
}
|
return moRoutingOperation;
|
}
|
|
|
@Override
|
public String fullUpdate(OperationTaskDTO operationTaskDTO) {
|
OperationTask operationTask = baseMapper.selectById(operationTaskDTO.getId());
|
baseMapper.updateById(operationTaskDTO);
|
OperationTask newOperationTask = baseMapper.selectById(operationTaskDTO.getId());
|
OperationTaskSupply operationTaskSupply = operationTaskSupplyMapper.selectOne(Wrappers.<OperationTaskSupply>lambdaQuery()
|
.eq(OperationTaskSupply::getOperationTaskId, operationTaskDTO.getId()));
|
if (!operationTask.getRoutingOperationId().equals(newOperationTask.getRoutingOperationId())) {
|
operationTaskMaterialMapper.delete(Wrappers.<OperationTaskMaterial>lambdaQuery().eq(OperationTaskMaterial::getOperationTaskId, operationTaskDTO.getId()));
|
if (operationTaskSupply == null || operationTaskSupply.getMoId() == null) {
|
throw new RuntimeException("工单不存在对应制造订单，添加对应的所需物料");
|
}
|
//添加工单所需物料
|
addMoStructureComponent(operationTaskSupply.getMoId(), operationTaskDTO.getPartId(), newOperationTask);
|
}
|
if (operationTask.getPlannedQuantity().compareTo(newOperationTask.getPlannedQuantity()) != 0) {
|
List<OperationTaskMaterial> operationTaskMaterialList = operationTaskMaterialMapper.selectList(Wrappers.<OperationTaskMaterial>lambdaQuery()
|
.eq(OperationTaskMaterial::getOperationTaskId, operationTaskDTO.getId()));
|
for (OperationTaskMaterial operationTaskMaterial : operationTaskMaterialList) {
|
operationTaskMaterial.setQuantityRequired(operationTaskMaterial.getQuantityRequired().subtract(operationTaskMaterial.getQuantityRequired())
|
.add(operationTaskMaterial.getQpa().multiply(newOperationTask.getPlannedQuantity())));
|
operationTaskMaterialMapper.updateById(operationTaskMaterial);
|
}
|
operationTaskSupply.setQuantitySupply(operationTaskDTO.getPlannedQuantity());
|
operationTaskSupplyMapper.updateById(operationTaskSupply);
|
}
|
return operationTask.getOptaskNo();
|
}
|
|
@Override
|
public boolean fullDelete(Long id) {
|
baseMapper.deleteOperationById(id);
|
|
return false;
|
}
|
|
@Override
|
public List<ManufacturingOrderDTO> getOperationSupplyById(Long id) {
|
List<ManufacturingOrderDTO> manufacturingOrderDTO = manufacturingOrderMapper.getOperationSupplyById(id);
|
return manufacturingOrderDTO;
|
}
|
|
@Override
|
public List<OperationTaskMaterialDTO> getMaterial(QueryWrapper<OperationTaskMaterialDTO> gen) {
|
return operationTaskMaterialMapper.getMaterial(gen);
|
}
|
|
@Override
|
public IPage<List<OperationTaskDTO>> pdaPage(Page page, QueryWrapper<OperationTaskDTO> gen) {
|
return baseMapper.pdaPage(page, gen);
|
}
|
|
@Override
|
public List<JSONObject> pdaMaterial(QueryWrapper<OperationTaskMaterialDTO> gen) {
|
return operationTaskMaterialMapper.pdaMaterial(gen);
|
}
|
|
@Override
|
public List<OperationTaskMaterial> getOperationMaterialById(Long id) {
|
return operationTaskMaterialMapper.getOperationMaterialById(id);
|
}
|
|
@Override
|
public OperationTaskMaterial getOperationMaterialByMaterialId(Long id) {
|
return operationTaskMaterialMapper.getOperationMaterialByMaterialId(id);
|
}
|
|
@Override
|
public R addOperationMaterial(OperationTaskMaterial operationTaskMaterial) {
|
judgePartAndOperationTask(operationTaskMaterial.getPartId(), operationTaskMaterial.getOperationTaskId());
|
BigDecimal quantityRequired = calQuantityRequired(operationTaskMaterial.getOperationTaskId(), operationTaskMaterial.getQpa());
|
operationTaskMaterial.setQuantityRequired(quantityRequired);
|
if (operationTaskMaterialMapper.insert(operationTaskMaterial) == 1) {
|
return R.ok();
|
} else {
|
return R.failed();
|
}
|
}
|
|
@Override
|
public R updateOperationMaterial(OperationTaskMaterial operationTaskMaterial) {
|
judgePartAndOperationTask(operationTaskMaterial.getPartId(), operationTaskMaterial.getOperationTaskId());
|
BigDecimal quantityRequired = calQuantityRequired(operationTaskMaterial.getOperationTaskId(), operationTaskMaterial.getQpa());
|
operationTaskMaterial.setQuantityRequired(quantityRequired);
|
if (operationTaskMaterialMapper.updateById(operationTaskMaterial) == 1) {
|
return R.ok();
|
} else {
|
return R.failed();
|
}
|
|
}
|
|
|
/**
|
* 判断零件和工序任务是否存在
|
*
|
* @param partId
|
* @param operationTaskId
|
*/
|
public void judgePartAndOperationTask(Long partId, Long operationTaskId) {
|
Part part = partMapper.selectById(partId);
|
OperationTask operationTask = operationTaskMapper.selectById(operationTaskId);
|
if (part == null || operationTask == null) {
|
throw new RuntimeException("没有此零件或者此工序任务！");
|
}
|
}
|
|
/**
|
* 计算需求数量
|
*
|
* @param operationTaskId
|
* @param qpa
|
*/
|
public BigDecimal calQuantityRequired(Long operationTaskId, BigDecimal qpa) {
|
OperationTask operationTask = operationTaskMapper.selectById(operationTaskId);
|
BigDecimal quantityRequired = operationTask.getPlannedQuantity().multiply(qpa).setScale(6, RoundingMode.HALF_UP);
|
return quantityRequired;
|
}
|
|
|
@Override
|
public R deleteOperationMaterial(Long id) {
|
if (operationTaskMaterialMapper.deleteById(id) == 1) {
|
return R.ok();
|
} else {
|
return R.failed();
|
}
|
}
|
|
|
@Override
|
public List<ManufacturingOrderOperationTemplateDTO> getTemplate(Long id) {
|
List<ManufacturingOrderOperationTemplateDTO> manufacturingOrderOperationTemplateDTOList = manufacturingOrderOperationTemplateMapper.getTemplate(id);
|
if (CollectionUtil.isNotEmpty(manufacturingOrderOperationTemplateDTOList)) {
|
for (ManufacturingOrderOperationTemplateDTO manufacturingOrderOperationTemplateDTO : manufacturingOrderOperationTemplateDTOList) {
|
List<ManufacturingOrderOperationParam> manufacturingOrderOperationParamList = manufacturingOrderOperationParamMapper.selectList(Wrappers.<ManufacturingOrderOperationParam>lambdaQuery().eq(ManufacturingOrderOperationParam::getMoRoutingOperationId, manufacturingOrderOperationTemplateDTO.getMoRoutingOperationId())
|
.eq(ManufacturingOrderOperationParam::getOperationTemplateId, manufacturingOrderOperationTemplateDTO.getId()));
|
if (CollectionUtil.isNotEmpty(manufacturingOrderOperationParamList)) {
|
manufacturingOrderOperationTemplateDTO.setParamList(manufacturingOrderOperationParamList);
|
} else {
|
manufacturingOrderOperationTemplateDTO.setParamList(null);
|
}
|
}
|
}
|
return manufacturingOrderOperationTemplateDTOList;
|
}
|
|
@Override
|
public IPage<List<Template>> getTemplateUpdate(Page page, Long id, Template template) {
|
return basicParamTemplateMapper.getTemplateUpdate(page, id, template);
|
}
|
|
@Override
|
public IPage<List<Template>> getTemplateByType(Page page, QueryWrapper<Template> gen) {
|
return basicParamTemplateMapper.getTemplateByType(page, gen);
|
}
|
|
@Override
|
public List<OperationTaskRecordDTO> getTemplateRecord(OperationTaskRecordDTO operationTaskRecordDTO) {
|
QueryWrapper<OperationTaskRecordDTO> queryWrapper = Wrappers.<OperationTaskRecordDTO>query()
|
.eq(null != operationTaskRecordDTO.getWorkstationId(), "ew.workstation_id", operationTaskRecordDTO.getWorkstationId())
|
.eq(null != operationTaskRecordDTO.getTemplateType(), "ew.template_type", operationTaskRecordDTO.getTemplateType())
|
.eq(null != operationTaskRecordDTO.getDutyRecordId(), "ew.duty_record_id", operationTaskRecordDTO.getDutyRecordId())
|
.eq(null != operationTaskRecordDTO.getOperationTaskId(), "ew.operation_task_id", operationTaskRecordDTO.getOperationTaskId())
|
.like(StringUtils.isNotBlank(operationTaskRecordDTO.getOutBatchNo()), "ew.out_batch_no", operationTaskRecordDTO.getOutBatchNo())
|
.eq(null != operationTaskRecordDTO.getProductOutId(), "ew.product_out_id", operationTaskRecordDTO.getProductOutId())
|
.like(StringUtils.isNotBlank(operationTaskRecordDTO.getTemplateName()), "ew.template_name", operationTaskRecordDTO.getTemplateName())
|
.like(StringUtils.isNotBlank(operationTaskRecordDTO.getCreateUser()), "ew.create_user", operationTaskRecordDTO.getCreateUser())
|
.eq(null != operationTaskRecordDTO.getSegmentationId(), "ew.segmentation_id", operationTaskRecordDTO.getSegmentationId())
|
.orderByDesc("ew.create_time");
|
if (null != operationTaskRecordDTO.getStartTime() && null != operationTaskRecordDTO.getEndTime()) {
|
queryWrapper.between(null != operationTaskRecordDTO.getStartTime() && null != operationTaskRecordDTO.getEndTime()
|
, "ew.create_time"
|
, DateUtil.parse(operationTaskRecordDTO.getStartTime() + " 00:00:00", "yyyy-MM-dd HH:mm:ss")
|
, DateUtil.parse(operationTaskRecordDTO.getEndTime() + " 23:59:59", "yyyy-MM-dd HH:mm:ss"));
|
}
|
return operationTaskRecordMapper.getTemplateRecord(queryWrapper);
|
}
|
|
|
@Override
|
public boolean updateTemplateParam(List<OperationTaskParam> operationTaskParamList) {
|
for (OperationTaskParam operationTaskParam : operationTaskParamList) {
|
if (operationTaskParam.getId() != null) {
|
if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
|
operationTaskParamMapper.updateById(operationTaskParam);
|
} else {
|
operationTaskParamMapper.deleteById(operationTaskParam);
|
}
|
} else {
|
if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
|
operationTaskParamMapper.insert(operationTaskParam);
|
}
|
}
|
}
|
return false;
|
}
|
|
@Override
|
public Object getOperationTaskById(Long id) {
|
OperationTask operationTask = baseMapper.selectById(id);
|
String status = "04completed";
|
String newStatus = "05canceled";
|
JSONObject order = new JSONObject();
|
if (operationTask == null) {
|
order.put("status", "1");
|
} else {
|
if (status.equals(operationTask.getState())) {
|
order.put("status", "1");
|
} else if (newStatus.equals(operationTask.getState())) {
|
order.put("status", "1");
|
} else {
|
order.put("status", "0");
|
}
|
}
|
return order;
|
}
|
|
@Override
|
public List<OperationTaskParamDTO> getTemplateParam(OperationTaskParamDTO operationTaskParamDTO) {
|
OperationTaskRecord operationTaskRecord = operationTaskRecordMapper.selectById(operationTaskParamDTO.getOperationTaskRecordId());
|
List<OperationTaskParamDTO> operationTaskParamDTOList = operationTaskParamMapper.getTemplateParamUpdate(operationTaskParamDTO, operationTaskRecord.getOperationTemplateId());
|
List<OperationTaskAttachment> operationTaskAttachmentList = operationTaskAttachmentMapper.selectList(Wrappers.<OperationTaskAttachment>lambdaQuery().eq(OperationTaskAttachment::getOperationTaskRecordId, operationTaskParamDTO.getOperationTaskRecordId()));
|
operationTaskParamDTOList.get(0).setOperationTaskAttachmentList(operationTaskAttachmentList);
|
return operationTaskParamDTOList;
|
}
|
|
@Override
|
public OperationTaskRecord addTemplateParam(OperationTaskRecordDTO
|
operationTaskRecordDTO, List<MultipartFile> file) {
|
OperationTaskRecord operationTaskRecord = new OperationTaskRecord();
|
String name = null;
|
if (operationTaskRecordDTO.getOperationTemplateId() != null) {
|
Template template = basicParamTemplateMapper.selectById(operationTaskRecordDTO.getOperationTemplateId());
|
name = template.getTemplateType();
|
}
|
if (operationTaskRecordDTO.getId() == null) {
|
operationTaskRecord.setWorkstationId(operationTaskRecordDTO.getWorkstationId());
|
operationTaskRecord.setPartId(operationTaskRecordDTO.getPartId());
|
operationTaskRecord.setWorkstationId(operationTaskRecordDTO.getWorkstationId());
|
operationTaskRecord.setDutyRecordId(operationTaskRecordDTO.getDutyRecordId());
|
operationTaskRecord.setName(DateUtil.format(LocalDateTime.now(), DatePattern.NORM_DATETIME_PATTERN) + "的" + name);
|
operationTaskRecord.setOperationTaskId(operationTaskRecordDTO.getOperationTaskId());
|
operationTaskRecord.setOperationTemplateId(operationTaskRecordDTO.getOperationTemplateId());
|
operationTaskRecord.setProductOutId(operationTaskRecordDTO.getProductOutId());
|
operationTaskRecord.setOutBatchNo(operationTaskRecordDTO.getOutBatchNo());
|
operationTaskRecordMapper.insert(operationTaskRecord);
|
for (OperationTaskParam operationTaskParam : operationTaskRecordDTO.getOperationTaskParamList()) {
|
if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
|
operationTaskParam.setOperationTaskRecordId(operationTaskRecord.getId());
|
operationTaskParamMapper.insert(operationTaskParam);
|
}
|
}
|
} else {
|
operationTaskRecord = operationTaskRecordMapper.selectById(operationTaskRecordDTO.getId());
|
if (CollectionUtil.isNotEmpty(operationTaskRecordDTO.getOperationTaskParamList())) {
|
for (OperationTaskParam operationTaskParam : operationTaskRecordDTO.getOperationTaskParamList()) {
|
if (operationTaskParam.getId() != null) {
|
if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
|
operationTaskParamMapper.updateById(operationTaskParam);
|
} else {
|
operationTaskParamMapper.deleteById(operationTaskParam);
|
}
|
} else {
|
if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
|
// 查找是否存在已保存参数
|
OperationTaskParam oldParam = operationTaskParamMapper.selectOne(Wrappers.<OperationTaskParam>lambdaQuery()
|
.eq(OperationTaskParam::getOperationTemplateId, operationTaskParam.getOperationTemplateId())
|
.eq(OperationTaskParam::getTechnologyOperationParamId, operationTaskParam.getTechnologyOperationParamId()));
|
if (oldParam != null) {
|
operationTaskParam.setId(oldParam.getId());
|
operationTaskParamMapper.updateById(operationTaskParam);
|
} else {
|
operationTaskParam.setOperationTaskRecordId(operationTaskRecord.getId());
|
operationTaskParamMapper.insert(operationTaskParam);
|
}
|
}
|
}
|
}
|
}
|
}
|
if (CollectionUtil.isNotEmpty(file)) {
|
uploadFile(file, operationTaskRecord.getId());
|
}
|
return operationTaskRecord;
|
}
|
|
@Override
|
public OperationTaskRecord addTemplateParam(Long operationTaskId, Long dutyRecordId, Long workstationId, Long
|
productOutId, String operationTaskParamList, Long operationTemplateId, Long id, List<MultipartFile> file) {
|
OperationTaskRecordDTO operationTaskRecordDTO = new OperationTaskRecordDTO();
|
if (null != productOutId) {
|
ProductOutput productOutput = productOutputMapper.selectById(productOutId);
|
if (null != productOutput.getPartId()) {
|
operationTaskRecordDTO.setPartId(productOutput.getPartId());
|
operationTaskRecordDTO.setProductOutId(productOutput.getId());
|
operationTaskRecordDTO.setOutBatchNo(productOutput.getOutBatchNo());
|
}
|
}
|
if (null != workstationId) {
|
operationTaskRecordDTO.setWorkstationId(workstationId);
|
}
|
operationTaskRecordDTO.setId(id);
|
operationTaskRecordDTO.setOperationTaskId(operationTaskId);
|
operationTaskRecordDTO.setDutyRecordId(dutyRecordId);
|
if (operationTaskParamList != null) {
|
List<OperationTaskParam> operationTaskParam = JSONArray.parseArray(operationTaskParamList).toJavaList(OperationTaskParam.class);
|
operationTaskRecordDTO.setOperationTaskParamList(operationTaskParam);
|
} else {
|
operationTaskRecordDTO.setOperationTaskParamList(new ArrayList<>());
|
}
|
operationTaskRecordDTO.setOperationTemplateId(operationTemplateId);
|
return addTemplateParam(operationTaskRecordDTO, file);
|
}
|
|
|
@Override
|
public List<OperationTaskRecord> batchAddTemplateRecord(TemplateRecordInputDTO templateRecordInputDTO) {
|
String name = null;
|
if (templateRecordInputDTO.getOperationTemplateId() != null) {
|
Template template = basicParamTemplateMapper.selectById(templateRecordInputDTO.getOperationTemplateId());
|
name = template.getTemplateType();
|
}
|
//产出表增加生产记录
|
List<ProductOutput> productOutputList = new ArrayList<>();
|
if (CollectionUtil.isNotEmpty(templateRecordInputDTO.getProductOutIdList())) {
|
productOutputList = productOutputMapper.selectBatchIds(templateRecordInputDTO.getProductOutIdList());
|
}
|
List<OperationTaskRecord> operationTaskRecordList = new ArrayList<>();
|
for (ProductOutput productOutput : productOutputList) {
|
OperationTaskRecord operationTaskRecord = new OperationTaskRecord();
|
operationTaskRecord.setWorkstationId(templateRecordInputDTO.getWorkstationId());
|
operationTaskRecord.setDutyRecordId(templateRecordInputDTO.getDutyRecordId());
|
operationTaskRecord.setName(DateUtil.format(LocalDateTime.now(), DatePattern.NORM_DATETIME_PATTERN) + "的" + name);
|
operationTaskRecord.setOperationTemplateId(templateRecordInputDTO.getOperationTemplateId());
|
operationTaskRecord.setPartId(productOutput.getPartId());
|
operationTaskRecord.setOperationTaskId(templateRecordInputDTO.getOperationTaskId());
|
operationTaskRecord.setProductOutId(productOutput.getId());
|
operationTaskRecord.setOutBatchNo(productOutput.getOutBatchNo());
|
operationTaskRecordList.add(operationTaskRecord);
|
}
|
//分割任务产出表增加生产记录
|
List<SegmentationTaskRecord> segmentationTaskRecordList = new ArrayList<>();
|
if (CollectionUtil.isNotEmpty(templateRecordInputDTO.getSegmentationIdList())) {
|
segmentationTaskRecordList = segmentationTaskRecordMapper.selectBatchIds(templateRecordInputDTO.getSegmentationIdList());
|
}
|
for (SegmentationTaskRecord segmentationTaskRecord : segmentationTaskRecordList) {
|
OperationTaskRecord operationTaskRecord = new OperationTaskRecord();
|
operationTaskRecord.setWorkstationId(templateRecordInputDTO.getWorkstationId());
|
operationTaskRecord.setDutyRecordId(templateRecordInputDTO.getDutyRecordId());
|
operationTaskRecord.setName(DateUtil.format(LocalDateTime.now(), DatePattern.NORM_DATETIME_PATTERN) + "的" + name);
|
operationTaskRecord.setOperationTemplateId(templateRecordInputDTO.getOperationTemplateId());
|
operationTaskRecord.setPartId(segmentationTaskRecord.getPartId());
|
operationTaskRecord.setSegmentationId(segmentationTaskRecord.getId());
|
operationTaskRecord.setOutBatchNo(segmentationTaskRecord.getPartBatchNo());
|
operationTaskRecordList.add(operationTaskRecord);
|
}
|
//未添加产出零件和分割任务零件的记录
|
if (CollectionUtil.isEmpty(templateRecordInputDTO.getSegmentationIdList()) && CollectionUtil.isEmpty(templateRecordInputDTO.getProductOutIdList())) {
|
OperationTaskRecord operationTaskRecord = new OperationTaskRecord();
|
operationTaskRecord.setWorkstationId(templateRecordInputDTO.getWorkstationId());
|
operationTaskRecord.setDutyRecordId(templateRecordInputDTO.getDutyRecordId());
|
operationTaskRecord.setName(DateUtil.format(LocalDateTime.now(), DatePattern.NORM_DATETIME_PATTERN) + "的" + name);
|
operationTaskRecord.setOperationTemplateId(templateRecordInputDTO.getOperationTemplateId());
|
operationTaskRecord.setOperationTaskId(templateRecordInputDTO.getOperationTaskId());
|
operationTaskRecordList.add(operationTaskRecord);
|
}
|
|
operationTaskRecordService.saveBatch(operationTaskRecordList);
|
|
//生产记录参数添加
|
if (templateRecordInputDTO.getOperationTaskParamList() != null) {
|
List<OperationTaskParam> operationTaskParamList = JSONArray.parseArray(templateRecordInputDTO.getOperationTaskParamList()).toJavaList(OperationTaskParam.class);
|
for (OperationTaskParam operationTaskParam : operationTaskParamList) {
|
if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
|
List<OperationTaskParam> paramList = new ArrayList<>();
|
for (OperationTaskRecord record : operationTaskRecordList) {
|
OperationTaskParam param = new OperationTaskParam();
|
BeanUtil.copyProperties(operationTaskParam, param);
|
param.setOperationTaskRecordId(record.getId());
|
paramList.add(param);
|
}
|
operationTaskParamService.saveBatch(paramList);
|
}
|
}
|
}
|
|
//附件
|
/* if (CollectionUtil.isNotEmpty(templateRecordInputDTO.getFile())) {
|
operationTaskRecordList.stream().forEach(a->{
|
uploadFile(templateRecordInputDTO.getFile(), a.getId());
|
});
|
}*/
|
return operationTaskRecordList;
|
}
|
|
|
@Override
|
public Boolean batchUpdateTemplateRecord(TemplateRecordInputDTO templateRecordInputDTO) {
|
List<OperationTaskParam> operationTaskParamList = JSONArray.parseArray(templateRecordInputDTO.getOperationTaskParamList()).toJavaList(OperationTaskParam.class);
|
if (CollectionUtil.isNotEmpty(templateRecordInputDTO.getIdList())) {
|
//删除原生产记录绑定的生产记录参数
|
operationTaskParamMapper.delete(Wrappers.<OperationTaskParam>lambdaQuery().in(OperationTaskParam::getOperationTaskRecordId, templateRecordInputDTO.getIdList()));
|
//批量新增生产记录参数
|
for (OperationTaskParam operationTaskParam : operationTaskParamList) {
|
if (StringUtils.isNotBlank(operationTaskParam.getParamValue())) {
|
List<OperationTaskParam> paramList = new ArrayList<>();
|
for (Long id : templateRecordInputDTO.getIdList()) {
|
OperationTaskParam param = new OperationTaskParam();
|
BeanUtil.copyProperties(operationTaskParam, param);
|
param.setOperationTaskRecordId(id);
|
paramList.add(param);
|
}
|
operationTaskParamService.saveBatch(paramList);
|
}
|
}
|
|
}
|
|
return true;
|
}
|
|
|
@Override
|
public Boolean deleteBatchTemplateRecord(List<Long> idList) {
|
operationTaskRecordMapper.deleteBatchIds(idList);
|
operationTaskParamMapper.delete(Wrappers.<OperationTaskParam>lambdaQuery().in(OperationTaskParam::getOperationTaskRecordId, idList));
|
return true;
|
}
|
|
|
@Override
|
public Boolean deleteTemplateRecord(OperationTaskRecordDTO operationTaskRecordDTO) {
|
operationTaskRecordMapper.deleteById(operationTaskRecordDTO.getId());
|
operationTaskParamMapper.delete(Wrappers.<OperationTaskParam>lambdaQuery().eq(OperationTaskParam::getOperationTaskRecordId, operationTaskRecordDTO.getId()));
|
return true;
|
}
|
|
@Override
|
public R uploadFile(List<MultipartFile> file, Long operationTaskRecordId) {
|
for (MultipartFile multipartFile : file) {
|
String fileName = IdUtil.simpleUUID() + StrUtil.DOT + FileUtil.extName(multipartFile.getOriginalFilename());
|
String url = String.format("/mes/operationTask/%s/%s", BUCKET_NAME, fileName);
|
try {
|
minioTemplate.putObject(BUCKET_NAME, fileName, multipartFile.getInputStream());
|
if (operationTaskRecordId != null) {
|
OperationTaskAttachment operationTaskAttachment = new OperationTaskAttachment();
|
operationTaskAttachment.setUrl(url);
|
operationTaskAttachment.setFileName(fileName);
|
operationTaskAttachment.setOriginal(multipartFile.getOriginalFilename());
|
operationTaskAttachment.setOperationTaskRecordId(operationTaskRecordId);
|
operationTaskAttachmentMapper.insert(operationTaskAttachment);
|
}
|
} catch (Exception e) {
|
log.error("上传失败", e);
|
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
|
return R.failed(e.getLocalizedMessage());
|
}
|
}
|
return R.ok();
|
}
|
|
@Override
|
public R<Boolean> deleteFile(OperationTaskAttachment operationTaskAttachment) {
|
try {
|
minioTemplate.removeObject(ossProperties.getBucketName(), operationTaskAttachment.getFileName());
|
operationTaskAttachment.deleteById(operationTaskAttachment.getId());
|
} catch (Exception e) {
|
log.error("删除文件失败", e);
|
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
|
return R.failed(e.getLocalizedMessage());
|
}
|
return R.ok();
|
}
|
|
@Override
|
public R getFile(String bucket, String fileName, HttpServletResponse response) {
|
try (InputStream inputStream = minioTemplate.getObject(bucket, fileName)) {
|
response.setContentType("application/octet-stream; charset=UTF-8");
|
IoUtil.copy(inputStream, response.getOutputStream());
|
} catch (Exception e) {
|
log.error("文件读取异常: {}", e);
|
return R.failed(e.getLocalizedMessage());
|
}
|
return R.ok();
|
}
|
|
@Override
|
public R combineOperationTask(List<Long> ids) {
|
List<OperationTaskDTO> operationTasks = this.baseMapper.selectByIds(ids);
|
if (operationTasks.stream().anyMatch(e -> e.getOperationId() == null || e.getWorkstationId() == null || e.getPartId() == null)) {
|
return R.failed("选择工单缺少零件、工序或者工作站信息!");
|
}
|
OperationTask combineTask = new OperationTask();
|
BigDecimal totalPlannedQuantity = BigDecimal.ZERO;
|
Long totalDiscNum = 0L;
|
List<OperationTask> updateList = new ArrayList<>();
|
List<String> optaskNos = new ArrayList<>();
|
for (int i = 0; i < operationTasks.size(); i++) {
|
if (!operationTasks.get(i).getState().equals(OperationTaskStateStringValues.PENDING)) {
|
return R.failed("工单不在等待中无法合并");
|
}
|
if (i > 0) {
|
// 零件，工作站，工序相同就可以
|
if (!operationTasks.get(i).getPartId().equals(operationTasks.get(i - 1).getPartId())
|
|| !operationTasks.get(i).getOperationId().equals(operationTasks.get(i - 1).getOperationId())
|
|| !operationTasks.get(i).getWorkstationId().equals(operationTasks.get(i - 1).getWorkstationId())) {
|
return R.failed("工单存在差异无法合并");
|
}
|
}
|
List<JoinStockOrder> joinStockOrders = joinStockOrderMapper.selectList(Wrappers.<JoinStockOrder>lambdaQuery().eq(JoinStockOrder::getOperationTaskId, operationTasks.get(i).getId()));
|
if (!joinStockOrders.isEmpty()) {
|
return R.failed("工单存在预留物料无法合并，请取消预留后合并");
|
}
|
|
totalPlannedQuantity = totalPlannedQuantity.add(operationTasks.get(i).getPlannedQuantity());
|
Long dicNum = operationTasks.get(i).getDiscNum() == null ? new Long(0) : operationTasks.get(i).getDiscNum();
|
totalDiscNum += dicNum;
|
OperationTask update = new OperationTask();
|
BeanUtil.copyProperties(operationTasks.get(i), update);
|
update.setCombineState(OperationTask.COMBINE_STATE_SON);
|
update.setState(OperationTaskStateStringValues.COMBINED);
|
updateList.add(update);
|
|
optaskNos.add(operationTasks.get(i).getOptaskNo());
|
}
|
BeanUtil.copyProperties(operationTasks.get(0), combineTask);
|
combineTask.setOptaskNo(opTaskSequence.nextNo());
|
combineTask.setPlannedQuantity(totalPlannedQuantity);
|
combineTask.setDiscNum(totalDiscNum);
|
combineTask.setCombineState(OperationTask.COMBINE_STATE_MAIN);
|
combineTask.setRemark("被合并工单编号为：" + org.apache.commons.lang3.StringUtils.join(optaskNos, ","));
|
this.baseMapper.insert(combineTask);
|
|
// 生成关联表数据
|
OperationTaskSupply supply = new OperationTaskSupply();
|
supply.setOperationTaskId(combineTask.getId());
|
OperationTaskSupply oldSupply = supplyMapper.selectOne(Wrappers.<OperationTaskSupply>lambdaQuery().eq(OperationTaskSupply::getOperationTaskId, operationTasks.get(0).getId()));
|
supply.setMoId(oldSupply.getMoId());
|
supply.setQuantitySupply(totalPlannedQuantity);
|
supplyMapper.insert(supply);
|
|
// 累加工序所需物料数据
|
List<OperationTaskMaterial> materials = operationTaskMaterialMapper.selectList(Wrappers.<OperationTaskMaterial>lambdaQuery().in(OperationTaskMaterial::getOperationTaskId, ids));
|
Map<Long, List<OperationTaskMaterial>> collect = materials.stream().collect(Collectors.groupingBy(OperationTaskMaterial::getPartId));
|
for (Entry<Long, List<OperationTaskMaterial>> map : collect.entrySet()) {
|
OperationTaskMaterial operationTaskMaterial = new OperationTaskMaterial();
|
operationTaskMaterial.setOperationTaskId(combineTask.getId());
|
operationTaskMaterial.setPartId(map.getKey());
|
operationTaskMaterial.setQpa(map.getValue().get(0).getQpa());
|
operationTaskMaterial.setQuantityRequired(BigDecimal.ZERO);
|
for (OperationTaskMaterial material : map.getValue()) {
|
operationTaskMaterial.setQuantityRequired(operationTaskMaterial.getQuantityRequired().add(material.getQuantityRequired()));
|
}
|
operationTaskMaterialMapper.insert(operationTaskMaterial);
|
}
|
|
updateList.forEach(task -> {
|
task.setCombineTaskId(combineTask.getId());
|
task.setCombineTaskNo(combineTask.getOptaskNo());
|
if (StringUtils.isNotBlank(task.getRemark())) {
|
if (StringUtils.endsWith(task.getRemark(), "。")) {
|
task.setRemark(task.getRemark() + "合并工单编号为：" + combineTask.getOptaskNo());
|
} else {
|
task.setRemark(task.getRemark() + "。合并工单编号为：" + combineTask.getOptaskNo());
|
}
|
} else {
|
task.setRemark("合并工单编号为：" + combineTask.getOptaskNo());
|
}
|
});
|
this.updateBatchById(updateList);
|
return R.ok();
|
}
|
|
@Override
|
public List<OperationTaskDTO> getCombinedOperationTaskInfo(Long id) {
|
OperationTask task = this.getById(id);
|
if (!task.getCombineState().equals(OperationTask.COMBINE_STATE_MAIN)) {
|
throw new RuntimeException("非合并订单");
|
}
|
return this.getBaseMapper().getCombinedOperationTaskInfo(id);
|
}
|
|
|
//*************************************************************************对接数据采集终端
|
@Override
|
public R getAllMessage(ProductOutputDTO productOutput) {
|
//跳线车间SN码用的是system_no字段，现有系统SN码用的是out_batch_no字段
|
//标准系统统一通过out_batch_no对应SN号，后面跳线车间需要修改
|
|
if (StringUtils.isBlank(productOutput.getSystemNo()) || StringUtils.isBlank(productOutput.getInspectionType())) {
|
return R.failed("查询参数systemNo或inspectionType为空");
|
}
|
|
InfosOfferDetectionTerminalDTO infosOfferDetectionTerminalDTO = new InfosOfferDetectionTerminalDTO();//new一个接口返回的数据对象，下面的操作就是往这个类里面set数据
|
productOutput.setOutBatchNo(productOutput.getSystemNo());//对外的接口标准就不动了，内部进行校正，将systemNo值set到outBatchNo
|
|
//判断该SN号是否已经有工序报工产出记录
|
List<ProductOutputDTO> productOutputDTOList = productOutputMapper.getProductOutDetailsBySN(productOutput.getOutBatchNo());
|
if (CollectionUtil.isEmpty(productOutputDTOList)) {
|
return R.failed("该SN号查无工序报工产出明细");
|
}
|
|
infosOfferDetectionTerminalDTO.setSystemNo(productOutput.getOutBatchNo());//载入SN号（对外的字段标准不动，还是用systemNo）
|
|
//根据报工产出的SN号查询客户订单信息
|
CustomerOrder customerOrder = customerOrderMapper.getCustomerOrderByProductOutput(productOutput.getOutBatchNo());
|
if (customerOrder != null) {
|
infosOfferDetectionTerminalDTO.setCustomerOrderNo(customerOrder.getCustomerOrderNo());
|
infosOfferDetectionTerminalDTO.setCustomerName(customerOrder.getCustomerName());
|
//根据客户订单id查询客户订单参数
|
List<CustomerOrderParam> customerOrderParamList = customerOrderParamMapper.selectList(Wrappers.<CustomerOrderParam>lambdaQuery().eq(CustomerOrderParam::getOrderId, customerOrder.getId()));
|
//如果存在则取值
|
if (CollectionUtil.isNotEmpty(customerOrderParamList)) {
|
for (CustomerOrderParam customerOrderParam : customerOrderParamList) {
|
//如果客户订单参数对象的field字段值=EntityName，则获取其参数值字段value（获取订单项目实体名称）
|
if ("EntityName".equals(customerOrderParam.getField())) {
|
infosOfferDetectionTerminalDTO.setEneityName(customerOrderParam.getValue());
|
}
|
}
|
}
|
}
|
|
//根据报工产出的SN号查询报工产出
|
ProductOutput newProductOutput = productOutputMapper.selectOne(Wrappers.<ProductOutput>lambdaQuery().eq(ProductOutput::getOutBatchNo, productOutput.getOutBatchNo()).last("limit 1"));
|
if (newProductOutput != null) {
|
infosOfferDetectionTerminalDTO.setManufactureDate(newProductOutput.getCreateTime());
|
infosOfferDetectionTerminalDTO.setPartId(newProductOutput.getPartId());
|
Part part = partMapper.selectById(newProductOutput.getPartId());
|
if (part != null) {
|
//给operationTaskDTO的零件名称、零件号、长度赋值
|
infosOfferDetectionTerminalDTO.setPartName(part.getPartName());
|
infosOfferDetectionTerminalDTO.setPartNo(part.getPartNo());
|
//infosOfferDetectionTerminalDTO.setLength(part.getLength());//现有系统的零件基础数据中没有长度这个字段
|
}
|
infosOfferDetectionTerminalDTO.setLength(productOutputMapper.sumProdOutQtyByBatchNo(newProductOutput.getOutBatchNo()));//长度
|
}
|
|
//根据报工产出的SN号查询制造订单下的检测标准
|
List<MoTestStandardDTO> moTestStandardList = manufacturingOrderMapper.getManufacturingOrder(productOutput.getOutBatchNo());
|
List<MoTestStandardDTO> moTestStandardListNew = new ArrayList<>();
|
if (CollectionUtil.isNotEmpty(moTestStandardList)) {
|
//根据检测类型剔除不匹配的检测标准（但检测标准数大于1时再去做剔除操作，增加业务的容错率）
|
if (moTestStandardList.size() > 1) {
|
moTestStandardListNew = moTestStandardList.stream().filter(o -> o.getInspectionType().equals(productOutput.getInspectionType())).collect(Collectors.toList());
|
} else {
|
moTestStandardListNew = moTestStandardList;
|
}
|
|
|
//取车间订单下所有检测标准对应的检测项目
|
//遍历检测标准
|
for (MoTestStandardDTO moTestStandardDTO : moTestStandardListNew) {
|
//获取检测标准下的检测项目
|
moTestStandardDTO.setMoTestStandardParamList(moTestStandardParamMapper.getTestStandardParam(moTestStandardDTO.getId()));
|
}
|
}
|
infosOfferDetectionTerminalDTO.setMoTestStandardList(moTestStandardListNew);//获取到了车间订单下的检测标准
|
|
//Gson gson = new Gson();
|
//JSONObject jsonObject = JSONObject.parseObject(gson.toJson(infosOfferDetectionTerminalDTO));//过滤掉无效字段
|
|
return R.ok(infosOfferDetectionTerminalDTO);
|
}
|
|
|
@Override
|
public R saveReport(InfosOfferDetectionTerminalDTO infosOfferDetectionTerminalDTO) {
|
String testResult = "合格";//与采集终端程序约定好的（前期跳线车间已经约定好）
|
|
//根据SN号查询检测汇报
|
Report reportNew = reportMapper.selectOne(Wrappers.<Report>lambdaQuery().eq(Report::getOutBatchNo, infosOfferDetectionTerminalDTO.getSystemNo()).last("limit 1"));
|
if (reportNew == null) {
|
//不存在则创建
|
|
//创建检测申请汇报表
|
Report report = new Report();
|
report.setOutBatchNo(infosOfferDetectionTerminalDTO.getSystemNo());//SN
|
report.setRemark(infosOfferDetectionTerminalDTO.getSystemNo());//备注
|
report.setReportPerson(infosOfferDetectionTerminalDTO.getTestPeople());//汇报人
|
report.setReportType(infosOfferDetectionTerminalDTO.getReportType());//检测汇报类型
|
report.setCheckState("01checked");//检测状态=已检测
|
reportService.save(report);
|
|
//创建检测汇报零件
|
ApplyPart applyPart = new ApplyPart();
|
applyPart.setReportId(report.getId());//检测汇报id
|
applyPart.setLotBatchNo(infosOfferDetectionTerminalDTO.getSystemNo());//批次号
|
applyPart.setPartId(infosOfferDetectionTerminalDTO.getPartId());//零件id
|
//通过SN号获取产出数量
|
BigDecimal prodOutQty = baseMapper.getProdOutQtyByBatchNo(infosOfferDetectionTerminalDTO.getSystemNo());
|
if (testResult.equals(infosOfferDetectionTerminalDTO.getConclusion())) {
|
applyPart.setIsQualified(true);//合格
|
applyPart.setQtyArrived(prodOutQty + "");//合格数量
|
applyPart.setUnqualifiedArrived("0");//不合格数量
|
} else {
|
applyPart.setIsQualified(false);//不合格
|
applyPart.setQtyArrived("0");//合格数量
|
applyPart.setUnqualifiedArrived(prodOutQty + "");//不合格数量
|
}
|
Long operationId = baseMapper.getOperationId(infosOfferDetectionTerminalDTO.getSystemNo());
|
if (null != operationId) {
|
applyPart.setOperationId(operationId);//工序id
|
}
|
|
Part part = partMapper.selectById(infosOfferDetectionTerminalDTO.getPartId());
|
|
if (part != null) {
|
//applyPart.setPartDesc(part.getDescription());//零件描述
|
applyPart.setPartDesc(part.getPartName());//零件基础数据中的【零件描述】字段已基本被废弃
|
applyPart.setPartNo(part.getPartNo());//零件号
|
}
|
|
//通过SN查产出
|
ProductOutput productOutput = productOutputMapper.selectOne(Wrappers.<ProductOutput>lambdaQuery().eq(ProductOutput::getOutBatchNo, infosOfferDetectionTerminalDTO.getSystemNo()).last("limit 1"));
|
if (productOutput != null) {
|
applyPart.setSystemNo(productOutput.getSystemNo());//报工产出系统编号
|
}
|
|
//创建检测汇报样品
|
ReportSample reportSample = new ReportSample();
|
reportSample.setSampleNo(reportSampleNumberGenerator.generateNumberWithPrefix(ReportSample.DIGIT, ReportSample.PREFIX, ReportSample::getSampleNo));//样品编号
|
reportSample.setReportId(report.getId());//检测汇报id
|
|
|
if (CollectionUtil.isNotEmpty(infosOfferDetectionTerminalDTO.getMoTestStandardParamList())) {
|
//检测汇报样品
|
reportSample.setTestStandardId(infosOfferDetectionTerminalDTO.getMoTestStandardParamList().get(0).getMoTestStandardId());//检测标准id
|
//检测汇报零件
|
applyPart.setMoTestStandardId(infosOfferDetectionTerminalDTO.getMoTestStandardParamList().get(0).getMoTestStandardId());//检测标准id
|
//查询制造订单的检测标准主表
|
MoTestStandard moTestStandard = moTestStandardMapper.selectById(infosOfferDetectionTerminalDTO.getMoTestStandardParamList().get(0).getMoTestStandardId());
|
if (moTestStandard != null) {
|
applyPart.setTestStandardNo(moTestStandard.getStandardNo());//检测标准编号
|
reportSample.setTestStandardNo(moTestStandard.getStandardNo());//检测标准编号
|
reportSample.setRemark(moTestStandard.getRemark());//检测标准备注
|
}
|
}
|
|
applyPartMapper.insert(applyPart);//创建检测汇报零件
|
if (null != productOutput) {
|
reportSample.setSystemNo(productOutput.getSystemNo());
|
}
|
reportSampleMapper.insert(reportSample);//创建检测汇报样品
|
|
//创建检测汇报样品对应的检测项目
|
saveReportSampleItem(infosOfferDetectionTerminalDTO, reportSample);
|
//创建检测汇报测量器具
|
saveReportSampleMeasuringTool(infosOfferDetectionTerminalDTO, report, reportSample);
|
|
} else {
|
//存在则删除后创建
|
//根据检测汇报id获取检测汇报样品
|
ReportSample reportSample = reportSampleMapper.selectOne(Wrappers.<ReportSample>lambdaQuery().eq(ReportSample::getReportId, reportNew.getId()).last("limit 1"));
|
//根据检测汇报样品id删除检测汇报样品检测项
|
reportSampleItemMapper.deleteReportSampleTestItemsBySampleId(reportSample.getId());
|
//根据检测汇报id删除检测汇报测量器具
|
reportMeasuringToolMapper.deleteByReportId(reportNew.getId());
|
//重新创建检测汇报样品检测项明细
|
saveReportSampleItem(infosOfferDetectionTerminalDTO, reportSample);
|
//创建检测汇报测量器具
|
saveReportSampleMeasuringTool(infosOfferDetectionTerminalDTO, reportNew, reportSample);
|
|
}
|
return R.ok();
|
}
|
|
/**
|
* 创建检测汇报样品检测项目明细
|
*
|
* @param infosOfferDetectionTerminalDTO
|
* @param reportSample
|
*/
|
public void saveReportSampleItem(InfosOfferDetectionTerminalDTO infosOfferDetectionTerminalDTO, ReportSample
|
reportSample) {
|
if (CollectionUtil.isNotEmpty(infosOfferDetectionTerminalDTO.getMoTestStandardParamList())) {
|
for (MoTestStandardParamDTO moTestStandardParam : infosOfferDetectionTerminalDTO.getMoTestStandardParamList()) {
|
ReportSampleItem reportSampleItem = new ReportSampleItem();
|
MoTestStandardParam testStandardParam = moTestStandardParamMapper.selectById(moTestStandardParam.getId());//根据制造订单检测标准参数id获取检测标准参数
|
if (testStandardParam != null) {
|
reportSampleItem.setSort(testStandardParam.getIndex());//排序
|
reportSampleItem.setAisle(testStandardParam.getAisle());//通道
|
reportSampleItem.setPosition(testStandardParam.getPosition());//位置
|
}
|
if ("采集项".equals(moTestStandardParam.getParamType())) {
|
reportSampleItem.setTestUser(infosOfferDetectionTerminalDTO.getCollectPeople());//检测人
|
}
|
if ("互调采集".equals(moTestStandardParam.getParamType())) {
|
reportSampleItem.setTestUser(infosOfferDetectionTerminalDTO.getInterpolationPeople());//检测人
|
}
|
reportSampleItem.setReportSampleId(reportSample.getId());//检测汇报样品id
|
reportSampleItem.setItemsId(moTestStandardParam.getId());//检测项id
|
reportSampleItem.setItemCode(moTestStandardParam.getCode());//检测项目编号
|
reportSampleItem.setItemType(moTestStandardParam.getType());//检测项目类型
|
reportSampleItem.setItemName(moTestStandardParam.getParameterItem());//检测项目
|
reportSampleItem.setItemReference(moTestStandardParam.getReferenceValue());//参考值
|
reportSampleItem.setItemValue(moTestStandardParam.getItemValue());//检测值
|
reportSampleItem.setParamType(moTestStandardParam.getParamType());//参数项的检测类型
|
reportSampleItem.setTestValue(moTestStandardParam.getTestValue());//计算值
|
reportSampleItemMapper.insert(reportSampleItem);//创建检测汇报样品检测项
|
}
|
}
|
}
|
|
/**
|
* 创建检测汇报测量器具明细
|
*
|
* @param infosOfferDetectionTerminalDTO
|
* @param report
|
* @param reportSample
|
*/
|
public void saveReportSampleMeasuringTool(InfosOfferDetectionTerminalDTO infosOfferDetectionTerminalDTO, Report
|
report, ReportSample reportSample) {
|
if (CollectionUtil.isNotEmpty(infosOfferDetectionTerminalDTO.getMeasuringToolList())) {
|
for (MeasuringToolDTO measuringToolDTO : infosOfferDetectionTerminalDTO.getMeasuringToolList()) {
|
//创建检测汇报测量器具
|
ReportMeasuringTool reportMeasuringTool = new ReportMeasuringTool();
|
reportMeasuringTool.setReportId(report.getId());//检测汇报id
|
reportMeasuringTool.setReportSampleId(reportSample.getId());//检测汇报样品id
|
reportMeasuringTool.setMeasuringToolCode(measuringToolDTO.getMeasuringToolCode());//测量器具代码
|
reportMeasuringTool.setMeasuringToolName(measuringToolDTO.getMeasuringToolName());//测量器具名称
|
reportMeasuringToolMapper.insert(reportMeasuringTool);//创建检测汇报测量器具
|
}
|
}
|
}
|
|
@Override
|
public R getApplyReportType() {
|
ApplyReportTypeDTO applyReportTypeDTO = new ApplyReportTypeDTO();
|
List<ApplyReportTypeDetailDTO> applyReportTypeDetailDTOList = operationTaskMapper.getApplyReportType();
|
applyReportTypeDTO.setApplyReportTypeList(applyReportTypeDetailDTOList);
|
return R.ok(applyReportTypeDTO);
|
}
|
|
//*************************************************************************对接数据采集终端
|
@Override
|
public R getFromMoOptionByMoId(Long moId) {
|
return R.ok(baseMapper.getFromMoOptionByMoId(moId));
|
}
|
|
@Override
|
public R addReserve(List<Long> ids) {
|
List<OperationTaskMaterialDTO> operationTaskMaterialDTOList = operationTaskMaterialMapper.getOperationMaterialByIds(ids);
|
Map<Long, PalletTransportsMaterialDTO> materialMap = new HashMap<>();
|
//根据零件id 合并需求数量
|
for (OperationTaskMaterialDTO operationTaskMaterialDTO : operationTaskMaterialDTOList) {
|
PalletTransportsMaterialDTO palletTransportsMaterialDTO = new PalletTransportsMaterialDTO();
|
palletTransportsMaterialDTO.setDemandQuantity(BigDecimal.ZERO);
|
palletTransportsMaterialDTO.setPartNo(operationTaskMaterialDTO.getPartNo());
|
palletTransportsMaterialDTO.setPartName(operationTaskMaterialDTO.getPartName());
|
palletTransportsMaterialDTO.setUnit(operationTaskMaterialDTO.getUnit());
|
palletTransportsMaterialDTO.setPartId(operationTaskMaterialDTO.getPartId());
|
if (materialMap.get(operationTaskMaterialDTO.getPartId()) != null) {
|
palletTransportsMaterialDTO = materialMap.get(operationTaskMaterialDTO.getPartId());
|
}
|
palletTransportsMaterialDTO.setDemandQuantity(operationTaskMaterialDTO.getQuantityRequired().add(palletTransportsMaterialDTO.getDemandQuantity()));
|
materialMap.put(operationTaskMaterialDTO.getPartId(), palletTransportsMaterialDTO);
|
}
|
return R.ok(materialMap.values());
|
}
|
|
@Override
|
public R getPalletOptaskCode(List<Long> ids) {
|
List<String> operationTaskNos = baseMapper.getPalletOptaskCode(ids);
|
if (CollectionUtils.isEmpty(operationTaskNos)) {
|
return R.ok();
|
} else {
|
String msg = String.join(",", operationTaskNos);
|
return R.failed("工单：" + msg + "已存在物料需求！");
|
}
|
}
|
|
@Override
|
public R getBasicInfoForPdaFeedByWorkstationNo(String workstationNo) {
|
BasicInfoForPdaFeedDTO basicInfoForPdaFeedDTO = new BasicInfoForPdaFeedDTO();
|
String msg = "";
|
//根据工作站编号查询线边仓
|
basicInfoForPdaFeedDTO.setLocationList(baseMapper.getFeedLocationListByWorkstationNo(workstationNo));
|
//根据工作站编号查询工单（工单直接指定了工作站）
|
basicInfoForPdaFeedDTO.setOperationTaskList(baseMapper.getActiveOperationTaskListByWorkstationNo(workstationNo));
|
//根据工作站编号查询工单（工单没有直接指定工作站，而是指定了工作中心）
|
List<OperationTask> operationTaskList = baseMapper.getActiveOperationTaskListUnPointWorkstationByWorkstationNo(workstationNo);
|
for (OperationTask operationTask : operationTaskList) {
|
basicInfoForPdaFeedDTO.getOperationTaskList().add(operationTask);
|
}
|
//按计划开始时间正序排
|
operationTaskList = basicInfoForPdaFeedDTO.getOperationTaskList().stream().sorted(Comparator.comparing(OperationTask::getPlannedStartDate)).collect(Collectors.toList());
|
basicInfoForPdaFeedDTO.setOperationTaskList(operationTaskList);
|
|
if (CollectionUtil.isEmpty(basicInfoForPdaFeedDTO.getLocationList()) || CollectionUtil.isEmpty(basicInfoForPdaFeedDTO.getOperationTaskList())) {
|
msg = "工作站=" + workstationNo + "->对应的线边仓||可用的工单为空";
|
}
|
return R.ok(basicInfoForPdaFeedDTO, msg);
|
}
|
|
@Override
|
public List<OperationTaskDTO> getByPalletTransId(Long id) {
|
return baseMapper.getByPalletTransId(id);
|
}
|
|
@Override
|
public Boolean batchUpdatePriority(List<OperationTask> operationTaskList) {
|
List<OperationTask> updateList = new ArrayList<>();
|
for (OperationTask operationTask : operationTaskList) {
|
OperationTask update = new OperationTask();
|
update.setId(operationTask.getId());
|
update.setPriority(operationTask.getPriority());
|
updateList.add(update);
|
}
|
this.updateBatchById(updateList);
|
return true;
|
}
|
|
@Override
|
public Boolean checkIsStart(Long id, Long workstationId) {
|
OperationTask task = this.getById(id);
|
List<OperationTaskDTO> operationTask = this.getOperationTask(workstationId, null, null, null, null, null);
|
List<OperationTaskDTO> collect = operationTask.stream().filter(p -> p.getPriority().compareTo(task.getPriority()) < 0).collect(Collectors.toList());
|
if (!collect.isEmpty()) {
|
for (OperationTaskDTO check : collect) {
|
if (check.getState().equals(OperationTaskStateStringValues.PENDING) || check.getState().equals(OperationTaskStateStringValues.INPROGRESS)) {
|
return false;
|
}
|
}
|
}
|
return true;
|
}
|
|
@Override
|
public void checkStatus(Long id, String event) {
|
if (id == null) {
|
throw new RuntimeException("请选择一条工单");
|
}
|
if (("COMPLETE").equals(event)) {
|
OperationTask operationTask = baseMapper.selectById(id);
|
if (operationTask != null) {
|
if (operationTask.getCompletedQuantity().compareTo(operationTask.getPlannedQuantity()) < 0) {
|
throw new RuntimeException("完成数量小于计划数量，不允许结束工单");
|
}
|
}
|
}
|
}
|
|
|
@Override
|
public List<OperationTaskScreenVO> getByCustomerOrderId(Long customerOrderId) {
|
return baseMapper.getByCustomerOrderId(customerOrderId);
|
}
|
}
|
