package com.chinaztt.mes.production.state.productout;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.chinaztt.mes.basic.entity.Part;
|
import com.chinaztt.mes.basic.entity.Workstation;
|
import com.chinaztt.mes.basic.entity.WorkstationLocation;
|
import com.chinaztt.mes.basic.mapper.PartMapper;
|
import com.chinaztt.mes.basic.mapper.WorkstationLocationMapper;
|
import com.chinaztt.mes.basic.mapper.WorkstationMapper;
|
import com.chinaztt.mes.common.handler.StateMachineHandler;
|
import com.chinaztt.mes.plan.entity.MoRoutingOperation;
|
import com.chinaztt.mes.plan.mapper.MoRoutingOperationMapper;
|
import com.chinaztt.mes.production.dto.OperationTaskDTO;
|
import com.chinaztt.mes.production.dto.OperationTaskMaterialDTO;
|
import com.chinaztt.mes.production.entity.OperationTask;
|
import com.chinaztt.mes.production.entity.OperationTaskMaterial;
|
import com.chinaztt.mes.production.entity.ProductMain;
|
import com.chinaztt.mes.production.entity.ProductOutput;
|
import com.chinaztt.mes.production.mapper.OperationTaskMapper;
|
import com.chinaztt.mes.production.mapper.OperationTaskMaterialMapper;
|
import com.chinaztt.mes.production.mapper.ProductMainMapper;
|
import com.chinaztt.mes.production.mapper.ProductOutputMapper;
|
import com.chinaztt.mes.production.state.productmain.constant.ProductMainStateStringValues;
|
import com.chinaztt.mes.production.state.productout.constant.ProductOutEvents;
|
import com.chinaztt.mes.production.state.productout.constant.ProductOutStateStringValues;
|
import com.chinaztt.mes.quality.dto.ApplyDTO;
|
import com.chinaztt.mes.quality.dto.ApplyPartDTO;
|
import com.chinaztt.mes.quality.entity.Apply;
|
import com.chinaztt.mes.quality.entity.ApplyPart;
|
import com.chinaztt.mes.quality.entity.Result;
|
import com.chinaztt.mes.quality.entity.TestRule;
|
import com.chinaztt.mes.quality.mapper.ApplyMapper;
|
import com.chinaztt.mes.quality.mapper.ApplyPartMapper;
|
import com.chinaztt.mes.quality.mapper.ResultMapper;
|
import com.chinaztt.mes.quality.mapper.TestRuleMapper;
|
import com.chinaztt.mes.quality.service.ApplyPartService;
|
import com.chinaztt.mes.quality.service.ApplyService;
|
import com.chinaztt.mes.quality.state.result.constant.ResultStateStringValues;
|
import com.chinaztt.mes.quality.utils.ResultUtils;
|
import com.chinaztt.mes.quality.utils.TestApplyRuleUtils;
|
import com.chinaztt.mes.technology.entity.RoutingOperation;
|
import com.chinaztt.mes.technology.mapper.RoutingOperationMapper;
|
import com.chinaztt.mes.warehouse.dto.StockAddDTO;
|
import com.chinaztt.mes.warehouse.entity.Stock;
|
import com.chinaztt.mes.warehouse.mapper.StockMapper;
|
import com.chinaztt.mes.warehouse.service.impl.JoinStockOrderServiceImpl;
|
import com.chinaztt.mes.warehouse.util.StockUtils;
|
import com.chinaztt.mes.warehouse.util.TransactionType;
|
import com.google.common.collect.Lists;
|
import lombok.AllArgsConstructor;
|
import org.springframework.messaging.Message;
|
import org.springframework.statemachine.StateMachine;
|
import org.springframework.statemachine.annotation.OnTransition;
|
import org.springframework.statemachine.annotation.WithStateMachine;
|
import org.springframework.stereotype.Component;
|
import org.springframework.transaction.interceptor.TransactionAspectSupport;
|
import org.springframework.util.CollectionUtils;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
|
/**
|
* @Author: zhangxy
|
* @Date: 2020-08-24 9:51
|
*/
|
@AllArgsConstructor
|
@Component
|
@WithStateMachine(id = "productOutStateMachine")
|
public class ProductOutStateListener {
|
|
private ProductOutputMapper productOutputMapper;
|
private RoutingOperationMapper routingOperationMapper;
|
private ProductMainMapper productMainMapper;
|
private WorkstationLocationMapper workstationLocationMapper;
|
private StockUtils stockUtils;
|
private ResultUtils resultUtils;
|
private PartMapper partMapper;
|
private TestRuleMapper testRuleMapper;
|
private ResultMapper resultMapper;
|
private WorkstationMapper workstationMapper;
|
private ApplyService applyService;
|
private OperationTaskMaterialMapper operationTaskMaterialMapper;
|
private OperationTaskMapper operationTaskMapper;
|
private JoinStockOrderServiceImpl joinStockOrderService;
|
private StockMapper stockMapper;
|
private ApplyPartMapper applyPartMapper;
|
private ApplyMapper applyMapper;
|
private MoRoutingOperationMapper moRoutingOperationMapper;
|
private TestApplyRuleUtils testApplyRuleUtils;
|
|
/**
|
* 提交到草稿
|
*
|
* @param stateMachine
|
* @param msg
|
* @return
|
*/
|
@OnTransition(source = ProductOutStateStringValues.SUBMITTED, target = ProductOutStateStringValues.DRAFT)
|
public boolean start(StateMachine stateMachine, Message<ProductOutEvents> msg) {
|
ProductOutput productOutput = (ProductOutput) msg.getHeaders().get("productOutput");
|
ProductMain productMain = productMainMapper.selectById(productOutput.getProductMainId());
|
//判断报工主表的状态
|
if (ProductMainStateStringValues.SUBMITTED.equals(productMain.getState())) {
|
stateMachine.getExtendedState().getVariables().put(StateMachineHandler.ERROR_KEY, "报工已提交不可撤回");
|
return false;
|
}
|
//判断是否检测
|
Integer resultNum = resultMapper.selectCount(Wrappers.<Result>lambdaQuery()
|
.eq(Result::getSystemNo, productOutput.getSystemNo())
|
//.eq(Result::getApplyType, Apply.OUTPUT_APPLY)//解除工作台提交时与尾检的琐定【2022-09-20】
|
.eq(Result::getApplyType, testApplyRuleUtils.getApplyTypeBySystemNo(productOutput.getSystemNo()))
|
.isNotNull(Result::getIsQualified));
|
if (resultNum > 0) {
|
stateMachine.getExtendedState().getVariables().put(StateMachineHandler.ERROR_KEY, "已检测不可撤回");
|
return false;
|
}
|
//工作台报工数据删除时需要先校验，是否已经进行了检测汇报
|
List<ApplyPart> applyPartList = applyPartMapper.selectApplyApertByInspState(productOutput.getOutBatchNo(), Apply.OUTPUT_APPLY);//这里的检测类型传参无效，无需解锁
|
if (!CollectionUtils.isEmpty(applyPartList)) {
|
List<ApplyPart> applyPartListChecked = applyPartList.stream().filter(e -> null != e.getReportId()).collect(Collectors.toList());
|
if (CollectionUtils.isEmpty(applyPartListChecked)) {
|
//没有进行检测汇报，先删除检测申请数据，再删除报工数据
|
List<Long> applyIds = applyPartList.stream().map(ApplyPart::getApplyId).collect(Collectors.toList());
|
List<Long> applyPartIds = applyPartList.stream().map(ApplyPart::getId).collect(Collectors.toList());
|
if (!CollectionUtils.isEmpty(applyIds)) {
|
applyMapper.deleteBatchIds(applyIds);
|
}
|
if (!CollectionUtils.isEmpty(applyPartIds)) {
|
applyPartMapper.deleteBatchIds(applyPartIds);
|
}
|
//删除检测结果
|
resultMapper.deleteBySystemNo(productOutput.getSystemNo());
|
} else {
|
stateMachine.getExtendedState().getVariables().put(StateMachineHandler.ERROR_KEY, "已经检测汇报，请先删除检测汇报");
|
return false;
|
}
|
}
|
//修改状态
|
productOutput.setState(ProductOutStateStringValues.DRAFT);
|
productOutputMapper.updateById(productOutput);
|
try {
|
//自动反向报检
|
autoInspection(productOutput, true);
|
} catch (RuntimeException e) {
|
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
|
stateMachine.getExtendedState().getVariables().put(StateMachineHandler.ERROR_KEY, e.getMessage());
|
return false;
|
}
|
return true;
|
}
|
|
/**
|
* 草稿到提交
|
*
|
* @param stateMachine
|
* @param msg
|
* @return
|
*/
|
@OnTransition(source = ProductOutStateStringValues.DRAFT, target = ProductOutStateStringValues.SUBMITTED)
|
public boolean complete(StateMachine stateMachine, Message<ProductOutEvents> msg) {
|
ProductOutput productOutput = (ProductOutput) msg.getHeaders().get("productOutput");
|
//修改状态
|
productOutput.setState(ProductOutStateStringValues.SUBMITTED);
|
productOutputMapper.updateById(productOutput);
|
// 自动报检和自动移库
|
try {
|
autoInspection(productOutput, false);
|
} catch (RuntimeException e) {
|
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
|
stateMachine.getExtendedState().getVariables().put(StateMachineHandler.ERROR_KEY, e.getMessage());
|
return false;
|
}
|
return true;
|
}
|
|
/**
|
* 草稿到交班
|
*
|
* @param stateMachine
|
* @param msg
|
* @return
|
*/
|
@OnTransition(source = ProductOutStateStringValues.DRAFT, target = ProductOutStateStringValues.CHANGESHIFT)
|
public boolean draftToChangeShift(StateMachine stateMachine, Message<ProductOutEvents> msg) {
|
ProductOutput productOutput = (ProductOutput) msg.getHeaders().get("productOutput");
|
//修改状态
|
productOutput.setState(ProductOutStateStringValues.CHANGESHIFT);
|
productOutputMapper.updateById(productOutput);
|
return true;
|
}
|
|
/**
|
* 交班到草稿
|
*
|
* @param stateMachine
|
* @param msg
|
* @return
|
*/
|
@OnTransition(source = ProductOutStateStringValues.CHANGESHIFT, target = ProductOutStateStringValues.DRAFT)
|
public boolean ChangeShiftTodraft(StateMachine stateMachine, Message<ProductOutEvents> msg) {
|
ProductOutput productOutput = (ProductOutput) msg.getHeaders().get("productOutput");
|
Integer shiftedNumber = productOutputMapper.getShiftedNumberByOutputIds(Lists.newArrayList(productOutput.getId()));
|
if (shiftedNumber > 0) {
|
stateMachine.getExtendedState().getVariables().put(StateMachineHandler.ERROR_KEY, "交班后产出已提交无法撤销");
|
return false;
|
}
|
// 清空交班id数据
|
productOutputMapper.clearShiftOutputId(productOutput.getId());
|
|
//修改状态
|
productOutput.setState(ProductOutStateStringValues.DRAFT);
|
productOutputMapper.updateById(productOutput);
|
return true;
|
}
|
|
/**
|
* 自动报检
|
*
|
* @param productOutput
|
* @param revoke
|
*/
|
private void autoInspection(ProductOutput productOutput, boolean revoke) {
|
//1.根据产出查工单-制造订单-工艺工序的配置（检验/自动报检）
|
MoRoutingOperation routingOperation = moRoutingOperationMapper.findByProductMainId(productOutput.getProductMainId());
|
ProductMain productMain = productMainMapper.selectById(productOutput.getProductMainId());
|
if (routingOperation != null) {
|
if (routingOperation.getInspection() == null || routingOperation.getInspection() == false) {
|
//不检测进行的操作
|
addStock(productMain, WorkstationLocation.QUALIFIED_LOCATION, productOutput, revoke, routingOperation.getIsLast());
|
//解除工作台提交时与尾检的琐定【2022-09-20】
|
//resultUtils.addOrUpdateResult(productOutput.getSystemNo(), productOutput.getOutBatchNo(), ResultStateStringValues.NOTEST, null, null, true, null, productOutput.getPartId(), null, Apply.OUTPUT_APPLY);
|
if(!revoke){
|
//撤销产出时不去创建检测结果【2022-09-20】
|
resultUtils.addOrUpdateResult(productOutput.getSystemNo(), productOutput.getOutBatchNo(), ResultStateStringValues.NOTEST, null, null, true, null, productOutput.getPartId(), null, testApplyRuleUtils.getApplyTypeBySystemNo(productOutput.getSystemNo()));
|
}
|
} else {
|
//自动报检进行的操作
|
addStock(productMain, WorkstationLocation.INSPECTION_LOCATION, productOutput, revoke, routingOperation.getIsLast());
|
if (routingOperation.getAutoInspection() == null || !routingOperation.getAutoInspection()) {
|
//3.检验，手动报检：不做处理，手动报检时生成检测记录（防止首检这种的，还没产出就要检验）
|
} else {
|
//4.检验，自动报检：
|
//解除工作台提交时与尾检的琐定【2022-09-20】
|
//resultUtils.addOrUpdateResult(productOutput.getSystemNo(), productOutput.getOutBatchNo(), null, null, null, null, productMain.getWorkstationId(), productOutput.getPartId(), null, Apply.OUTPUT_APPLY);
|
if(!revoke){
|
//撤销产出时不去创建检测结果【2022-09-20】
|
resultUtils.addOrUpdateResult(productOutput.getSystemNo(), productOutput.getOutBatchNo(), null, null, null, null, productMain.getWorkstationId(), productOutput.getPartId(), null, testApplyRuleUtils.getApplyTypeBySystemNo(productOutput.getSystemNo()));
|
}
|
// 查零件对应的检验规则
|
int inspectQuantity = 1;
|
Long partId = productOutput.getPartId();
|
Part part = partMapper.selectById(partId);
|
if (part != null && part.getTestRuleId() != null) {
|
//查询报检数量
|
TestRule testRule = testRuleMapper.selectById(part.getTestRuleId());
|
if (testRule != null) {
|
inspectQuantity = testRule.getInspectQuantity().intValue();
|
}
|
}
|
//解除工作台提交时与尾检的琐定【2022-09-20】
|
//resultUtils.addOrUpdateResult(productOutput.getSystemNo(), productOutput.getOutBatchNo(), null, null, null, null, productMain.getWorkstationId(), partId, null, Apply.OUTPUT_APPLY);
|
if(!revoke){
|
//撤销产出时不去创建检测结果【2022-09-20】
|
resultUtils.addOrUpdateResult(productOutput.getSystemNo(), productOutput.getOutBatchNo(), null, null, null, null, productMain.getWorkstationId(), partId, null, testApplyRuleUtils.getApplyTypeBySystemNo(productOutput.getSystemNo()));
|
}
|
//查询当前机台未报检的零件，按报检数量分组自动生成质检申请
|
if (!revoke) {
|
List<Result> resultList = resultMapper.selectList(Wrappers.<Result>query().lambda()
|
.eq(Result::getPartId, partId)
|
.eq(Result::getWorkstationId, productMain.getWorkstationId())
|
//.eq(Result::getApplyType, Apply.OUTPUT_APPLY)//解除工作台提交时与尾检的琐定【2022-09-20】
|
.eq(Result::getApplyType, testApplyRuleUtils.getApplyTypeBySystemNo(productOutput.getSystemNo()))
|
.eq(Result::getIsErp, false)
|
.eq(Result::getSystemNo,productOutput.getSystemNo())//通过锁定产出系统编号暂时使原有的抽检规则失效【2022-09-20】
|
.isNull(Result::getCheckStatus)
|
.orderByAsc(Result::getId));
|
if (CollectionUtil.isNotEmpty(resultList)) {
|
Workstation workstation = workstationMapper.selectById(productMain.getWorkstationId());
|
int count = 0;
|
List<Result> group = new ArrayList<Result>();
|
for (Result result : resultList) {
|
group.add(result);
|
count += 1;
|
if (count == inspectQuantity) {
|
// 创建质检申请
|
ApplyDTO applyDTO = new ApplyDTO();
|
//applyDTO.setApplyType(Apply.OUTPUT_APPLY);//解除工作台提交时与尾检的琐定【2022-09-20】
|
applyDTO.setApplyType(testApplyRuleUtils.getApplyTypeBySystemNo(productOutput.getSystemNo()));
|
applyDTO.setRemark("自动报检：" + workstation.getName());
|
List<ApplyPartDTO> applyPartList = new ArrayList<ApplyPartDTO>();
|
group.stream().forEach(e -> {
|
ApplyPartDTO applyPartDTO = new ApplyPartDTO();
|
applyPartDTO.setSystemNo(e.getSystemNo());
|
applyPartList.add(applyPartDTO);
|
});
|
applyDTO.setApplyPartList(applyPartList);
|
if(applyService.saveDto(applyDTO)){
|
group.stream().forEach(e -> {
|
e.setApplyId(applyDTO.getId());
|
resultMapper.updateById(e);
|
});
|
}
|
group.clear();
|
count = 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* 产出自动进库(不检验进合格，其他进待检)
|
*
|
* @param productMain
|
* @param locationType
|
* @param revoke
|
*/
|
private void addStock(ProductMain productMain, Long locationType, ProductOutput productOutput, boolean revoke, Boolean isLast) {
|
WorkstationLocation workstationLocation = workstationLocationMapper.selectOne(Wrappers.<WorkstationLocation>query().lambda()
|
.eq(WorkstationLocation::getWorkstationId, productMain.getWorkstationId())
|
.eq(WorkstationLocation::getLocationType, locationType));
|
if (workstationLocation == null) {
|
throw new RuntimeException("机台未配置库位，请配置库位后再操作");
|
}
|
OperationTaskDTO operationInfo = operationTaskMapper.getOperationInfoById(productMain.getOperationTaskId());
|
BigDecimal stockQuantityIncrement = productOutput.getProductQty();
|
BigDecimal sstockQuantityIncrement = productOutput.getSproductQty();
|
// 判断是否存在交班产出，叠加交班产出
|
if (productOutput.getShiftOutputId() != null) {
|
List<ProductOutput> shifts = productOutputMapper.selectList(Wrappers.<ProductOutput>lambdaQuery()
|
.eq(ProductOutput::getOutBatchNo, productOutput.getOutBatchNo())
|
.eq(ProductOutput::getState, ProductOutStateStringValues.CHANGESHIFT));
|
stockQuantityIncrement = stockQuantityIncrement.add(shifts.stream().map(ProductOutput::getProductQty).reduce(BigDecimal.ZERO, BigDecimal::add));
|
sstockQuantityIncrement = sstockQuantityIncrement.add(shifts.stream().map(ProductOutput::getSproductQty).reduce(BigDecimal.ZERO, BigDecimal::add));
|
}
|
if (revoke) {
|
stockQuantityIncrement = stockQuantityIncrement.negate();
|
sstockQuantityIncrement = sstockQuantityIncrement.negate();
|
}
|
// 合格库位增加/删除产出
|
if (workstationLocation != null && workstationLocation.getLocationId() != null) {
|
StockAddDTO stockAdd = new StockAddDTO();
|
stockAdd.setPartsId(productOutput.getPartId());
|
stockAdd.setNewLocationId(workstationLocation.getLocationId());
|
stockAdd.setNewPartBatchNo(productOutput.getOutBatchNo());
|
stockAdd.setNewSystemNo(productOutput.getSystemNo());
|
stockAdd.setReelNumber(productOutput.getReelNumber());
|
stockAdd.setCustomerOrderNo(operationInfo.getCustomerOrderNo());
|
stockAdd.setMpsNo(operationInfo.getMpsNo());
|
stockAdd.setOuterColor(operationInfo.getOuterColor());
|
stockAdd.setInsulationColor(operationInfo.getInsulationColor());
|
|
Stock stock = stockUtils.query(stockAdd);
|
|
//将实时库存中的ifs批次号更新成与产出记录中的ifs批次号一致
|
stock.setIfsBatchNo(productOutput.getIfsBatchNo());
|
stockMapper.updateById(stock);
|
|
stockUtils.updateById(stock.getId(), stockQuantityIncrement, BigDecimal.ZERO, sstockQuantityIncrement, BigDecimal.ZERO, null, TransactionType.PRODUCT_SUBMIT.getValue());
|
// 设置是否工序库存
|
setOperationStockStatus(stock, isLast);
|
List<OperationTask> operationTaskList = operationTaskMapper.getLastOperationTask(productMain.getOperationTaskId());
|
if (CollectionUtil.isNotEmpty(operationTaskList)) {
|
for (OperationTask operationTask : operationTaskList) {
|
//如果触发自动预留，实时库存需要预留的数量
|
BigDecimal number = BigDecimal.ZERO;
|
Stock newStock = stockMapper.selectById(stock.getId());
|
RoutingOperation routingOperation = routingOperationMapper.selectById(operationTask.getRoutingOperationId());
|
if (routingOperation != null) {
|
//如果当前工单绑定的工艺路线配置了自动预留并且是提交的时候,计算出预留的数量
|
if (routingOperation.getReserved() && !revoke) {
|
QueryWrapper<OperationTaskMaterialDTO> wrapper = new QueryWrapper<>();
|
OperationTaskMaterialDTO operationTaskMaterial =
|
operationTaskMaterialMapper.getMaterial(wrapper.lambda()
|
.eq(OperationTaskMaterialDTO::getOperationTaskId, operationTask.getId())
|
.eq(OperationTaskMaterialDTO::getPartId, productOutput.getPartId())).get(0);
|
if (operationTaskMaterial != null) { //需求数量 //已预留
|
BigDecimal needNumber = operationTaskMaterial.getQuantityRequired().subtract(operationTaskMaterial.getReservedQuantity());
|
if (needNumber.compareTo(BigDecimal.ZERO) > 0) {
|
if (needNumber.compareTo(newStock.getAvailableStockQuantity()) < 0) {//可用库存数量
|
number = needNumber;
|
} else {
|
number = newStock.getAvailableStockQuantity();
|
}
|
}
|
}
|
}
|
}
|
//如果当前工单绑定的工艺路线配置了自动预留并且是提交的时候,新增工单预留
|
if (routingOperation.getReserved() && !revoke) {
|
joinStockOrderService.addJoinStock(operationTask.getId(), stock, number);
|
}
|
}
|
}
|
}
|
}
|
|
|
private void setOperationStockStatus(Stock stock, Boolean isLast) {
|
if (stock.getOperationStockStatus() == null) {
|
Stock update = new Stock();
|
update.setId(stock.getId());
|
if (isLast != null) {
|
update.setOperationStockStatus(!isLast);
|
} else {
|
update.setOperationStockStatus(true);
|
}
|
stockMapper.updateById(update);
|
}
|
}
|
}
|
