package com.example.erp.service.pp;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.dynamic.datasource.annotation.DS;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.example.erp.common.AsyncQueryExecutor;
|
import com.example.erp.common.Constants;
|
import com.example.erp.common.Result;
|
import com.example.erp.dto.pp.OrderNumberTransferDTO;
|
import com.example.erp.dto.sd.OrderProcessSortDTO;
|
import com.example.erp.entity.pp.*;
|
import com.example.erp.entity.sd.BasicData;
|
import com.example.erp.entity.sd.Order;
|
import com.example.erp.entity.sd.OrderDetail;
|
import com.example.erp.entity.sd.OrderProcessDetail;
|
import com.example.erp.entity.userInfo.Log;
|
import com.example.erp.entity.userInfo.SysError;
|
import com.example.erp.exception.ServiceException;
|
import com.example.erp.mapper.mm.FinishedOperateLogMapper;
|
import com.example.erp.mapper.pp.*;
|
import com.example.erp.mapper.sd.*;
|
import com.example.erp.mapper.userInfo.LogMapper;
|
import com.example.erp.service.mm.FinishedGoodsInventoryService;
|
import com.example.erp.service.sd.OrderProcessDetailService;
|
import com.example.erp.service.userInfo.LogService;
|
import com.example.erp.service.userInfo.SysErrorService;
|
import com.example.erp.tools.JacksonUtil;
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
import com.fasterxml.jackson.core.type.TypeReference;
|
import com.github.yulichang.wrapper.MPJLambdaWrapper;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.data.redis.core.RedisCallback;
|
import org.springframework.data.redis.core.StringRedisTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.interceptor.TransactionAspectSupport;
|
import org.springframework.web.client.RestTemplate;
|
|
import javax.annotation.Resource;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.concurrent.CompletableFuture;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
@Service
|
@DS("pp")
|
@RequiredArgsConstructor
|
public class ReportingWorkService {
|
private final ReportingWorkTransferMapper reportingWorkTransferMapper;
|
private final ReportingWorkMapper reportingWorkMapper;
|
private final BasicDateProduceMapper basicDateProduceMapper;
|
private final DamageDetailsMapper damageDetailsMapper;
|
private final OrderProcessDetailMapper orderProcessDetailMapper;
|
private final ReportingWorkDetailMapper reportingWorkDetailMapper;
|
private final OrderMapper orderMapper;
|
private final OrderDetailMapper orderDetailMapper;
|
private final FlowCardMapper flowCardMapper;
|
private final OrderProcessDetailService orderProcessDetailService;
|
private final LogService logService;
|
private final LogMapper logMapper;
|
private final OrderGlassDetailMapper orderGlassDetailMapper;
|
private final SysErrorService sysErrorService;
|
private final FinishedOperateLogMapper finishedOperateLogMapper;
|
private final RestTemplate restTemplate;
|
private final PatchLogMapper patchLogMapper;
|
private final ReworkMapper reworkMapper;
|
private final BasicDataMapper basicDataMapper;
|
private final FinishedGoodsInventoryService finishedGoodsInventoryService;
|
private final StringRedisTemplate stringRedisTemplate;
|
|
@Resource
|
private AsyncQueryExecutor asyncExecutor;
|
/*public ReportingWorkService(ReportingWorkMapper reportingWorkMapper, BasicDateProduceMapper basicDateProduceMapper, DamageDetailsMapper damageDetailsMapper, ReportingWorkDetailMapper reportingWorkDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, OrderProcessDetailService orderProcessDetailService, OrderMapper orderMapper, FlowCardMapper flowCardMapper, LogService logService, LogMapper logMapper, OrderGlassDetailMapper orderGlassDetailMapper, SysErrorService sysErrorService, OrderDetailMapper orderDetailMapper, FinishedOperateLogMapper finishedOperateLogMapper, ReportingWorkTransferMapper reportingWorkTransferMapper) {
|
this.reportingWorkMapper = reportingWorkMapper;
|
this.basicDateProduceMapper = basicDateProduceMapper;
|
this.damageDetailsMapper = damageDetailsMapper;
|
this.reportingWorkDetailMapper = reportingWorkDetailMapper;
|
this.orderProcessDetailMapper = orderProcessDetailMapper;
|
this.orderProcessDetailService = orderProcessDetailService;
|
this.orderMapper = orderMapper;
|
this.flowCardMapper = flowCardMapper;
|
this.logService = logService;
|
this.logMapper = logMapper;
|
this.orderGlassDetailMapper = orderGlassDetailMapper;
|
this.sysErrorService = sysErrorService;
|
this.orderDetailMapper = orderDetailMapper;
|
this.finishedOperateLogMapper = finishedOperateLogMapper;
|
this.reportingWorkTransferMapper = reportingWorkTransferMapper;
|
}*/
|
|
//将层数字符串用逗号隔开
|
public static String splitTechNumbers(String input) {
|
if (input == null || input.isEmpty()) {
|
return "";
|
}
|
|
List<String> result = new ArrayList<>();
|
for (int i = 0; i < input.length(); i++) {
|
// 特殊处理 "10"
|
if (input.charAt(i) == '1' && i + 1 < input.length() && input.charAt(i + 1) == '0') {
|
result.add("10");
|
i++; // 跳过下一个字符
|
} else {
|
result.add(String.valueOf(input.charAt(i)));
|
}
|
}
|
|
return String.join(",", result);
|
}
|
|
public Map<String, Object> AddSelectLastWorkSv(String processIdStr, String technologyStr, String process, String reportType) {
|
Map<String, Object> map = new HashMap<>();
|
//获取报工工序是否为复合工程
|
String laminating = reportingWorkMapper.getProcessLaminating(process);
|
//查询流程卡工艺流程
|
String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(processIdStr,splitTechNumbers(technologyStr));
|
|
if (technologicalProcess!=null || !technologicalProcess.equals("")){
|
String[] processList = technologicalProcess.split("->");
|
//获取工艺流程第一个工序
|
String interceptProcess = processList[0];
|
int length = processList.length;
|
|
//定义当前工序上下工序
|
String previousProcess = "";
|
String nextProcess = "";
|
|
//循环该流程卡工艺流程
|
for (int i = 0; i < length; i++) {
|
//当到当前工序时
|
if (processList[i].equals(process)) {
|
//获取当前工序的上一道工序
|
if (i - 1 < 0) {
|
previousProcess = "";
|
} else {
|
previousProcess = processList[i - 1];
|
}
|
//获取当前工序的下一道工序
|
if (i + 1 > length - 1) {
|
nextProcess = "";
|
} else {
|
nextProcess = processList[i + 1];
|
}
|
//查询当前工序的表头数据
|
map.put("data", reportingWorkMapper.AddSelectLastWorkMp(processIdStr, splitTechNumbers(technologyStr), previousProcess, nextProcess, process,reportType));
|
map.put("thisProcess", processList);
|
break;
|
}
|
}
|
|
//工艺流程
|
map.put("technologicalProcess", technologicalProcess);
|
|
//获取服务器时间
|
map.put("reportingWorkTiem", LocalDateTime.now());
|
//设备下拉框
|
map.put("device", reportingWorkMapper.SelectWorkBasicDeviceMp(process));
|
//班组下拉框
|
map.put("teams", reportingWorkMapper.SelectWorkBasicTeamsMp(process));
|
//次破类型
|
map.put("breakageType", reportingWorkMapper.selectBasicNameByType("breakagetype"));
|
//次破原因
|
map.put("breakageReason", reportingWorkMapper.selectBasicNameByType("breakagereason"));
|
|
//查询本工序报工需要哪几层，上工序是什么
|
String obtainTechnology = reportingWorkMapper.SelectWorkTechnologyMp(processIdStr);
|
|
map.put("numberList", flowCardMapper.getGlassNumber(splitTechNumbers(technologyStr),processIdStr));
|
|
//判断本工序是不是第一道工序
|
if (interceptProcess.equals(process)) {
|
//是第一道工序，查询流程卡数据
|
map.put("Detail", reportingWorkMapper.SelectTechnologicalNumMp(processIdStr, splitTechNumbers(technologyStr), process,reportType));
|
} else {
|
ReportingWork retrievedData = (ReportingWork) map.get("data");
|
if (retrievedData!=null){
|
Integer reviewedState = retrievedData.getReviewedState();
|
//根据审核状态查询未审核数据
|
// if (reviewedState==1){//已审核
|
//不是第一道工序，查询报工数据
|
List<Map<String,String>> details = reportingWorkMapper.SelectReworlDetailMp(processIdStr, splitTechNumbers(technologyStr), process,previousProcess,laminating);
|
if(process.equals("中空")){
|
//获取该流程卡订单号
|
String orderId = reportingWorkMapper.selectOrderid(processIdStr);
|
details.forEach( detail -> {
|
Integer glassId = orderGlassDetailMapper.
|
getMinIdByGroup(orderId,
|
String.valueOf(detail.get("order_number")),
|
String.valueOf(detail.get("group")));
|
int listGlassId = Integer.parseInt(String.valueOf(detail.get("glassId")));
|
if(listGlassId !=glassId){
|
detail.put("rowClass","latter");
|
}
|
});
|
}
|
map.put("Detail",details );
|
// }else {
|
// //不是第一道工序，查询报工数据
|
// List<Map<String,String>> details = reportingWorkMapper.SelectReworlDetailMpReview(processIdStr, technologyStr, process,previousProcess,laminating);
|
// if(process.equals("中空")){
|
// String orderId = reportingWorkMapper.selectOrderid(processIdStr);
|
// details.forEach( detail -> {
|
// Integer glassId = orderGlassDetailMapper.
|
// getMinIdByGroup(orderId,
|
// String.valueOf(detail.get("order_number")),
|
// String.valueOf(detail.get("group")));
|
// int listGlassId = Integer.parseInt(String.valueOf(detail.get("glassId")));
|
// if(listGlassId !=glassId){
|
// detail.put("rowClass","latter");
|
// }
|
// });
|
// }
|
// map.put("Detail",details );
|
// }
|
}
|
}
|
|
// 第一道工序（流程卡数+补片数量-完工数-次破数-返工未完成数-禁用数量）
|
|
// 后续工序（上工序报工数-完工数-次破数-返工未完成数）
|
|
//获取该流程卡号历史报工工序
|
String historyProcess = reportingWorkMapper.historyProcessMp(processIdStr);
|
//历史报工工序设备
|
map.put("historyDevice", reportingWorkMapper.historyDeviceMp(historyProcess, process));
|
//历史报工工序班组
|
map.put("historyTeams", reportingWorkMapper.historyTeamsMp(processIdStr, process));
|
//历史工序
|
map.put("historyProcess", reportingWorkMapper.SelectHistoryProcessMp(historyProcess, process));
|
//是否合片工序
|
map.put("laminating", laminating);
|
}
|
return map;
|
}
|
|
//查询工序
|
public Map<String, Object> SelectProcessSv(String userId) {
|
Map<String, Object> map = new HashMap<>();
|
String process = reportingWorkMapper.selectUserProcess(userId);
|
//工序列表
|
List<Map<String, Object>> processNameList = flowCardMapper.getProcessNameList();
|
if (process==null) {
|
map.put("process", reportingWorkMapper.SelectProcessMp());
|
}
|
else {
|
//对指定工序单独查询
|
if (process.equals("夹胶")){
|
map.put("process",reportingWorkMapper.getSelectProcessJiajiao() );
|
}
|
if (process.equals("技术部多曲")){
|
map.put("process",reportingWorkMapper.getSelectProcessDuoqu() );
|
}
|
}
|
map.put("processNameList", processNameList);
|
return map;
|
}
|
|
|
@Transactional(rollbackFor = Exception.class)
|
public boolean SaveReportingWorkSv(Map<String, Object> reportingWorkMap) {
|
// 接收解析主附表信息
|
JSONObject reportingWorkJson = new JSONObject(reportingWorkMap);
|
ReportingWork reportingWork = JSONObject.parseObject(
|
JSONObject.toJSONString(reportingWorkJson.get("title")), ReportingWork.class);
|
List<ReportingWorkDetail> reportingWorkDetails = JSONArray.parseArray(
|
JSONObject.toJSONString(reportingWorkJson.get("detail")), ReportingWorkDetail.class);
|
|
|
|
// 处理工序 ID
|
String[] processIdStr = reportingWork.getProcessId() != null
|
? reportingWork.getProcessId().split("/")
|
: new String[]{""};
|
reportingWork.setProcessId(processIdStr[0]); // 保底只取第一个
|
reportingWork.setThisWornQuantity(0);
|
reportingWork.setThisCompletedQuantity(0);
|
|
// 审核状态
|
Integer reviewState = reportingWorkJson.getInteger("type");
|
if (reviewState != null && reviewState == 1) { // 审核通过
|
reportingWork.setReviewed(reportingWork.getCreator());
|
reportingWork.setReviewedState(1);
|
} else {
|
reportingWork.setReviewedState(0);
|
}
|
|
// 时间为空则补上当前时间
|
if (reportingWork.getReportingWorkTime() == null) {
|
reportingWork.setReportingWorkTime(LocalDateTime.now());
|
}
|
|
// 是否现补 1现补 0未现补
|
int isPatch = reportingWorkJson.getInteger("isPatch") != null
|
? reportingWorkJson.getInteger("isPatch") : 0;
|
|
// 报工编号
|
Integer maxId = reportingWorkMapper.selectMaxReportingWorkId();
|
if (maxId == null) {
|
maxId = 0;
|
}
|
String formattedNumber = String.format("%04d", maxId + 1);
|
|
// 格式化当前日期
|
Date currentDate = new Date();
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
|
String formattedDate = dateFormat.format(currentDate);
|
String reportingWorkId = "BG" + formattedDate + formattedNumber;
|
reportingWork.setReportingWorkId(reportingWorkId);
|
|
// 主表插入
|
reportingWorkMapper.insert(reportingWork);
|
|
// 副表循环插入，并处理次破逻辑
|
final Integer[] maxTechnologyNumber = {0, 0};
|
reportingWorkDetails.forEach(reportingWorkDetail -> {
|
if (reportingWorkDetail == null) return;
|
|
// 统一用安全数值，避免 null 报错
|
int completedQty = Optional.ofNullable(reportingWorkDetail.getCompletedQuantity()).orElse(0);
|
int breakageQty = Optional.ofNullable(reportingWorkDetail.getBreakageQuantity()).orElse(0);
|
|
// 合片数量汇总减少
|
try {
|
int techNum = Integer.parseInt(reportingWorkDetail.getTechnologyNumber());
|
if (techNum > maxTechnologyNumber[0]) {
|
maxTechnologyNumber[0] = techNum;
|
maxTechnologyNumber[1] += 1;
|
}
|
} catch (NumberFormatException ignored) {
|
}
|
|
reportingWork.setThisCompletedQuantity(reportingWork.getThisCompletedQuantity() + completedQty);
|
reportingWork.setThisWornQuantity(reportingWork.getThisWornQuantity() + breakageQty);
|
|
int qualityInsStatus = reportingWorkJson.getInteger("qualityInsStatus") != null
|
? reportingWorkJson.getInteger("qualityInsStatus") : 0;
|
|
reportingWorkDetail.setReportingWorkId(reportingWorkId);
|
List<DamageDetails> damageDetails = reportingWorkDetail.getDamageDetails();
|
|
reportingWork.setNextProcess(orderProcessDetailMapper.selectNextProcess(
|
processIdStr[0],
|
processIdStr.length > 1 ? processIdStr[1] : "",
|
reportingWork.getThisProcess(),
|
reportingWorkDetail.getOrderNumber()
|
));
|
|
// 次破明细表插入数据
|
if (damageDetails != null && !damageDetails.isEmpty()) {
|
damageDetails.forEach(damageDetail -> {
|
if (damageDetail == null) return;
|
damageDetail.setReportingWorkId(reportingWorkId);
|
damageDetail.setOrderNumber(reportingWorkDetail.getOrderNumber());
|
damageDetail.setProcessId(reportingWork.getProcessId());
|
damageDetail.setTechnologyNumber(reportingWorkDetail.getTechnologyNumber());
|
|
if (!Objects.equals(damageDetail.getResponsibleProcess(), reportingWork.getThisProcess())
|
&& qualityInsStatus == 2) {
|
damageDetail.setQualityInsStatus(1);
|
}
|
if (isPatch == 1) {
|
damageDetail.setQualityInsStatus(2);
|
}
|
damageDetailsMapper.insert(damageDetail);
|
});
|
}
|
|
// 查询工艺流程
|
String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(
|
reportingWork.getProcessId(), reportingWorkDetail.getTechnologyNumber());
|
String interceptProcess;
|
if (technologicalProcess != null) {
|
int index = technologicalProcess.indexOf("-");
|
interceptProcess = (index < 0) ? technologicalProcess : technologicalProcess.substring(0, index);
|
} else {
|
interceptProcess = "";
|
}
|
|
// 判断是否第一道工序
|
int processNum;
|
if (interceptProcess.equals(reportingWork.getThisProcess())) {
|
processNum = reportingWorkMapper.selectFlowCardNum(
|
reportingWorkDetail.getOrderNumber(),
|
reportingWorkDetail.getTechnologyNumber(),
|
reportingWork.getProcessId(),
|
reportingWork.getThisProcess()
|
);
|
} else {
|
processNum = reportingWorkMapper.selectGlassProcessNum(
|
reportingWorkDetail.getOrderNumber(),
|
reportingWorkDetail.getTechnologyNumber(),
|
reportingWork.getProcessId(),
|
reportingWork.getThisProcess()
|
);
|
}
|
|
// 校验数量合法性
|
if (processNum < (breakageQty + completedQty)) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("orderNumber", reportingWorkDetail.getOrderNumber());
|
map.put("technologyNumber", reportingWorkDetail.getTechnologyNumber()); // 修复错误
|
map.put("processNum", processNum);
|
map.put("sumNum", breakageQty + completedQty);
|
String msg = JSON.toJSONString(map);
|
throw new ServiceException(Constants.Code_600, msg);
|
}
|
|
OrderProcessDetail orderProcessDetail = new OrderProcessDetail();
|
orderProcessDetail.setBrokenNum(breakageQty);
|
orderProcessDetail.setReportingWorkNum(completedQty);
|
orderProcessDetail.setReportingWorkNumCount(completedQty);
|
|
// 未现补：更新小片流程数量
|
if (isPatch == 0) {
|
LambdaUpdateWrapper<OrderProcessDetail> updateWrapper = new LambdaUpdateWrapper<>();
|
updateWrapper.eq(OrderProcessDetail::getOrderNumber, reportingWorkDetail.getOrderNumber())
|
.eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId())
|
.eq(OrderProcessDetail::getOrderId, reportingWork.getOrderId())
|
.eq(OrderProcessDetail::getProcess, reportingWork.getThisProcess())
|
.eq(OrderProcessDetail::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())
|
.setSql("reporting_work_num_count = reporting_work_num_count +" + completedQty)
|
.setSql("reporting_work_num = reporting_work_num +" + completedQty)
|
.setSql("update_time = now()")
|
.setSql("broken_num = broken_num +" + breakageQty);
|
orderProcessDetailMapper.update(null, updateWrapper);
|
}
|
|
// 判断完工数量和次破数量是否为0，为0则不插入
|
if (!(completedQty == 0 && breakageQty == 0)) {
|
reportingWorkDetailMapper.insert(reportingWorkDetail);
|
}
|
|
// 判断最后一道工序，更新流程卡报工数量
|
if (reportingWork.getNextProcess() == null || reportingWork.getNextProcess().isEmpty()) {
|
LambdaUpdateWrapper<FlowCard> flowCardLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
|
flowCardLambdaUpdateWrapper
|
.eq(FlowCard::getProcessId, reportingWork.getProcessId())
|
.eq(FlowCard::getOrderNumber, reportingWorkDetail.getOrderNumber())
|
.eq(FlowCard::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())
|
.setSql("inventory_quantity = inventory_quantity +" + completedQty);
|
flowCardMapper.update(null, flowCardLambdaUpdateWrapper);
|
}
|
});
|
|
// 获取报工工序是否为复合工程
|
if (maxTechnologyNumber[1] != 0) {
|
reportingWork.setThisCompletedQuantity(
|
reportingWork.getThisCompletedQuantity() / maxTechnologyNumber[1]);
|
}
|
|
reportingWorkMapper.update(reportingWork, new LambdaUpdateWrapper<ReportingWork>()
|
.eq(ReportingWork::getId, reportingWork.getId()));
|
|
// 保存日志
|
Log log = new Log();
|
log.setContent(JSON.toJSONString(reportingWorkMap));
|
log.setFunction("saveReportingWork报工新增");
|
log.setOperatorId(reportingWorkJson.getString("userId"));
|
log.setOperator(reportingWorkJson.getString("userName"));
|
logService.saveLog(log);
|
|
return true;
|
}
|
|
|
//报工新增
|
// @Transactional(rollbackFor = Exception.class)
|
// public boolean SaveReportingWorkSv(Map<String, Object> reportingWorkMap) {
|
// //接收解析主附表信息
|
// JSONObject reportingWorkJson = new JSONObject(reportingWorkMap);
|
// ReportingWork reportingWork = JSONObject.parseObject(JSONObject.toJSONString(reportingWorkJson.get("title")), ReportingWork.class);
|
// List<ReportingWorkDetail> reportingWorkDetails = JSONArray.parseArray(JSONObject.toJSONString(reportingWorkJson.get("detail")), ReportingWorkDetail.class);
|
// //获取当前最大报工单号生成报工单号
|
// String formattedNumber = String.format("%04d", reportingWorkMapper.selectMaxReportingWorkId() + 1);
|
// //格式化当前日期
|
// Date currentDate = new Date();
|
// SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
|
// String formattedDate = dateFormat.format(currentDate);
|
// String reportingWorkId = "BG" + formattedDate + formattedNumber;
|
// reportingWork.setReportingWorkId(reportingWorkId);
|
// String[] processIdStr = reportingWork.getProcessId().split("/");
|
// reportingWork.setProcessId(processIdStr[0]);
|
// reportingWork.setThisWornQuantity(0);
|
// reportingWork.setThisCompletedQuantity(0);
|
//
|
// int reviewState = (int) reportingWorkJson.get("type");
|
// if (reviewState == 1) {//审核通过
|
// reportingWork.setReviewed(reportingWork.getCreator());
|
// reportingWork.setReviewedState(1);
|
// } else {
|
// reportingWork.setReviewedState(0);
|
// }
|
// if(reportingWork.getReportingWorkTime()==null){
|
// LocalDateTime localDateTime = LocalDateTime.now();
|
// reportingWork.setReportingWorkTime(localDateTime);
|
// }
|
// //是否线补 1现补 0未现补
|
// int isPatch = (reportingWorkJson.get("isPatch") != null) ? (int) reportingWorkJson.get("isPatch") : 0;
|
//
|
// //主表插入
|
// reportingWorkMapper.insert(reportingWork);
|
// //副表循环插入，并且插入次破信息表。再根据次破信息修改订单玻璃流程表的完工数量与刺破数量
|
// final Integer[] maxTechnologyNumber = {0,0};
|
// reportingWorkDetails.forEach(reportingWorkDetail -> {
|
// //合片数量汇总减少
|
// if(Integer.parseInt(reportingWorkDetail.getTechnologyNumber()) > maxTechnologyNumber[0]){
|
// maxTechnologyNumber[0] = Integer.valueOf(reportingWorkDetail.getTechnologyNumber());
|
// maxTechnologyNumber[1]+=1;
|
// }
|
// reportingWork.setThisCompletedQuantity(reportingWork.getThisCompletedQuantity() + reportingWorkDetail.getCompletedQuantity());
|
// reportingWork.setThisWornQuantity(reportingWork.getThisWornQuantity() + reportingWorkDetail.getBreakageQuantity());
|
// int qualityInsStatus = (int) reportingWorkJson.get("qualityInsStatus");
|
// reportingWorkDetail.setReportingWorkId(reportingWorkId);
|
// List<DamageDetails> damageDetails = reportingWorkDetail.getDamageDetails();
|
// reportingWork.setNextProcess(orderProcessDetailMapper.selectNextProcess(processIdStr[0],processIdStr[1],reportingWork.getThisProcess(),reportingWorkDetail.getOrderNumber()));
|
//
|
// //次破明细表插入数据
|
// if (damageDetails != null && !damageDetails.isEmpty()) {
|
// damageDetails.forEach(damageDetail -> {
|
// damageDetail.setReportingWorkId(reportingWorkId);
|
// damageDetail.setOrderNumber(reportingWorkDetail.getOrderNumber());
|
// damageDetail.setProcessId(reportingWork.getProcessId());
|
// damageDetail.setTechnologyNumber(reportingWorkDetail.getTechnologyNumber());
|
// //跨工序次破修改质检状态
|
// if (!damageDetail.getResponsibleProcess().equals(reportingWork.getThisProcess()) && qualityInsStatus==2) {
|
// damageDetail.setQualityInsStatus(1);
|
// }
|
// if (isPatch == 1){
|
// damageDetail.setQualityInsStatus(2);
|
// }
|
// damageDetailsMapper.insert(damageDetail);
|
// });
|
// }
|
// //查询流程卡工艺流程
|
// String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(reportingWork.getProcessId(), reportingWorkDetail.getTechnologyNumber());
|
//
|
// int index = technologicalProcess.indexOf("-");
|
// String interceptProcess = "";
|
// if (index <0){
|
// interceptProcess = technologicalProcess;
|
// }
|
// else {
|
// //获取工艺流程第一个工序
|
// interceptProcess = technologicalProcess.substring(0, index);
|
// }
|
//
|
//
|
// //判断当前工序是否为第一道工序工序，使用流程卡表数量或者小片流程表上工序数量
|
// int processNum = 0;
|
// if (interceptProcess.equals(reportingWork.getThisProcess())) {
|
// processNum = reportingWorkMapper.selectFlowCardNum(
|
// reportingWorkDetail.getOrderNumber(),
|
// reportingWorkDetail.getTechnologyNumber(),
|
// reportingWork.getProcessId(),
|
// reportingWork.getThisProcess()
|
// );
|
// } else {
|
// processNum = reportingWorkMapper.selectGlassProcessNum(
|
// reportingWorkDetail.getOrderNumber(),
|
// reportingWorkDetail.getTechnologyNumber(),
|
// reportingWork.getProcessId(),
|
// reportingWork.getThisProcess()
|
// );
|
// }
|
//
|
//
|
// //判断是否大于当前数量并且抛出异常
|
// if (processNum < (reportingWorkDetail.getBreakageQuantity() + reportingWorkDetail.getCompletedQuantity())) {
|
// Map<String, Object> map = new HashMap<>();
|
// map.put("orderNumber", reportingWorkDetail.getOrderNumber());
|
// map.put("technologyNumber", reportingWorkDetail.getOrderNumber());
|
// map.put("processNum", processNum);
|
// map.put("sumNum", reportingWorkDetail.getBreakageQuantity() + reportingWorkDetail.getCompletedQuantity());
|
// String msg = JSON.toJSONString(map);
|
// throw new ServiceException(Constants.Code_600, msg);
|
// }
|
//
|
// OrderProcessDetail orderProcessDetail = new OrderProcessDetail();
|
// orderProcessDetail.setBrokenNum(reportingWorkDetail.getBreakageQuantity());
|
// orderProcessDetail.setReportingWorkNum(reportingWorkDetail.getCompletedQuantity());
|
// orderProcessDetail.setReportingWorkNumCount(reportingWorkDetail.getCompletedQuantity());
|
//
|
//
|
// if (isPatch == 0){//未现补
|
// //根据订单id，订单序号，以及小片序号 更新小片流程的完工数量以及刺破数量
|
// LambdaUpdateWrapper<OrderProcessDetail> updateWrapper = new LambdaUpdateWrapper<>();
|
// updateWrapper.eq(OrderProcessDetail::getOrderNumber, reportingWorkDetail.getOrderNumber())
|
// .eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId())
|
// .eq(OrderProcessDetail::getOrderId, reportingWork.getOrderId())
|
// .eq(OrderProcessDetail::getProcess, reportingWork.getThisProcess())
|
// .eq(OrderProcessDetail::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())
|
// .setSql("reporting_work_num_count = reporting_work_num_count +" + orderProcessDetail.getReportingWorkNum())
|
// .setSql("reporting_work_num =reporting_work_num +" + orderProcessDetail.getReportingWorkNum())
|
// .setSql("update_time = now()")
|
// .setSql("broken_num =broken_num +" + orderProcessDetail.getBrokenNum());
|
// orderProcessDetailMapper.update(null, updateWrapper);
|
// }
|
//
|
// //判断完工数量和刺破数量是否为0，为0则不插入到数据库
|
// if (!(reportingWorkDetail.getCompletedQuantity() == 0 && reportingWorkDetail.getBreakageQuantity() == 0)) {
|
// reportingWorkDetailMapper.insert(reportingWorkDetail);
|
// }
|
//
|
// //更新流程卡表的报工数量
|
// if (reportingWork.getNextProcess() == null || reportingWork.getNextProcess().isEmpty()) {
|
// LambdaUpdateWrapper<FlowCard> flowCardLambdaUpdateWrapper =
|
// new LambdaUpdateWrapper<>();
|
// flowCardLambdaUpdateWrapper
|
// .eq(FlowCard::getProcessId, reportingWork.getProcessId())
|
// .eq(FlowCard::getOrderNumber, reportingWorkDetail.getOrderNumber())
|
// .eq(FlowCard::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())
|
// .setSql("inventory_quantity = inventory_quantity +" + orderProcessDetail.getReportingWorkNum());
|
// flowCardMapper.update(null, flowCardLambdaUpdateWrapper);
|
// }
|
//
|
//
|
// });
|
// //获取报工工序是否为复合工程
|
//
|
// reportingWork.setThisCompletedQuantity(reportingWork.getThisCompletedQuantity()/maxTechnologyNumber[1]);
|
//
|
//
|
// reportingWorkMapper.update(reportingWork, new LambdaUpdateWrapper<ReportingWork>()
|
// .eq(ReportingWork::getId, reportingWork.getId()));
|
//
|
// //保存日志
|
// Log log = new Log();
|
// log.setContent(reportingWorkMap.toString());
|
// log.setFunction("saveReportingWork报工新增");
|
// log.setOperatorId((String) reportingWorkJson.get("userId"));
|
// log.setOperator((String) reportingWorkJson.get("userName"));
|
// logService.saveLog(log);
|
// return true;
|
// }
|
|
//下工序审核方法
|
public boolean ReviewReportingWorkSv(Map<String, String> reportingWork) {
|
|
String processId = reportingWork.get("processId");
|
String thisProcess = reportingWork.get("thisProcess");
|
String userName=reportingWork.get("userName");
|
int index = processId.lastIndexOf("/") + 1;
|
String result = processId.substring(index);
|
String technologyStr = reportingWork.get("technologyStr");
|
String[] processIdStr = processId.split("/");
|
String nowDate = LocalDate.now().toString();
|
//获取报工工序是否为复合工程
|
String laminating = reportingWorkMapper.getProcessLaminating(thisProcess);
|
//合片工序
|
if (laminating.indexOf("step")!=-1){
|
LambdaUpdateWrapper
|
<ReportingWork> updateWrapper = new LambdaUpdateWrapper<>();
|
updateWrapper
|
.eq(ReportingWork::getProcessId, processIdStr[0])
|
.eq(ReportingWork::getThisProcess, reportingWork.get("process"))
|
.eq(ReportingWork::getReviewedState, 0)
|
.setSql("reviewed_state =1")
|
.set(ReportingWork::getReviewed, userName)
|
.set(ReportingWork::getExamineTime, nowDate);
|
reportingWorkMapper.update(null, updateWrapper);
|
}else {
|
reportingWorkMapper.ReviewReportingWorkMp(processIdStr[0],reportingWork.get("process"),technologyStr,userName);
|
|
}
|
return true;
|
}
|
|
//报工修改查询
|
public Map<String, Object> selectUpdateReportingWorkSv(String reportingWorkId) {
|
//查询报工主表信息
|
ReportingWork reportingWork = reportingWorkMapper.selectOne(new LambdaQueryWrapper<ReportingWork>()
|
.eq(ReportingWork::getReportingWorkId, reportingWorkId));
|
//根据报工信息查询订单主表信息
|
reportingWork.setOrder(
|
orderMapper.selectOne(new LambdaQueryWrapper<Order>()
|
.eq(Order::getOrderId, reportingWork.getOrderId())));
|
reportingWork.setFlowCard(new FlowCard());
|
|
|
|
|
List<Map<String, Object>> reportingWorkDetails = reportingWorkMapper.selectByReportingWorkId(reportingWorkId, reportingWork.getNextProcess(),reportingWork.getOrderId());
|
reportingWorkDetails.forEach(reportingWorkDetail -> {
|
List<DamageDetails> damageDetailsList = new ArrayList<>();
|
damageDetailsList = damageDetailsMapper.selectList(new LambdaQueryWrapper<DamageDetails>()
|
.eq(DamageDetails::getReportingWorkId, reportingWorkId)
|
.eq(DamageDetails::getOrderNumber, reportingWorkDetail.get("order_number"))
|
.eq(DamageDetails::getTechnologyNumber, reportingWorkDetail.get("technology_number"))
|
);
|
reportingWorkDetail.put("damageDetails", damageDetailsList);
|
|
});
|
|
Map<String, Object> map = new HashMap<>();
|
//报工主表
|
map.put("reportingWork", reportingWork);
|
//报工明细
|
map.put("reportingWorkDetails", reportingWorkDetails);
|
//报工下拉框数据
|
map.put("basic", getReportingWorkBase(reportingWork.getProcessId(), reportingWork.getThisProcess()));
|
//根据报工编号获取层
|
map.put("layer", reportingWorkMapper.selectLayerByReportingWorkId(reportingWorkId));
|
map.put("numberList", flowCardMapper.getGlassNumber(reportingWorkMapper.selectLayerByReportingWorkId(reportingWorkId),reportingWork.getProcessId()));
|
map.put("title", "补片状态");
|
return map;
|
|
}
|
|
//报工下拉框数据
|
private Map<String, Object> getReportingWorkBase(String processId, String thisProcess) {
|
Map<String, Object> map = new HashMap<>();
|
//设备下拉框
|
map.put("deviceType", reportingWorkMapper.SelectWorkBasicDeviceMp(thisProcess));
|
//班组下拉框
|
map.put("teamsType", reportingWorkMapper.SelectWorkBasicTeamsMp(thisProcess));
|
//次破类型
|
map.put("breakageType", reportingWorkMapper.selectBasicNameByType("breakagetype"));
|
//次破原因
|
map.put("breakageReason", reportingWorkMapper.selectBasicNameByType("breakagereason"));
|
|
//获取该流程卡号历史报工工序
|
String historyProcess = reportingWorkMapper.historyProcessMp(processId);
|
//历史报工工序设备
|
map.put("historyDevice", reportingWorkMapper.historyDeviceMp(historyProcess, thisProcess));
|
//历史报工工序班组
|
map.put("historyTeams", reportingWorkMapper.historyTeamsMp(processId, thisProcess));
|
//历史工序
|
map.put("historyProcess", reportingWorkMapper.SelectHistoryProcessMp(historyProcess, thisProcess));
|
|
return map;
|
}
|
|
|
@Transactional
|
//报工修改
|
public Boolean updateReportingWork(Map<String, Object> reportingWorkMap, String reviewState) {
|
//接收解析主附表信息
|
JSONObject reportingWorkJson = new JSONObject(reportingWorkMap);
|
ReportingWork reportingWork = JSONObject.parseObject(JSONObject.toJSONString(reportingWorkJson.get("title")), ReportingWork.class);
|
List<ReportingWorkDetail> reportingWorkDetails = JSONArray.parseArray(JSONObject.toJSONString(reportingWorkJson.get("detail")), ReportingWorkDetail.class);
|
|
|
ReportingWork reportingWork1 = reportingWorkMapper.selectOne(new LambdaQueryWrapper<ReportingWork>()
|
.eq(ReportingWork::getReportingWorkId, reportingWork.getReportingWorkId()));
|
reportingWork.setCreatorId(reportingWork1.getCreatorId());
|
reportingWork.setCreator(reportingWork1.getCreator());
|
reportingWork.setUpdateTime(LocalDateTime.now());
|
|
//查询该报工是否为报工转移订单
|
Integer transferState = reportingWorkMapper.selectReviewedState(reportingWork.getReportingWorkId());
|
if (transferState !=3){
|
//删除刺破明细表刺破数据
|
damageDetailsMapper.delete(
|
new LambdaQueryWrapper<DamageDetails>()
|
.eq(DamageDetails::getReportingWorkId, reportingWork.getReportingWorkId())
|
);
|
//修改小片流程表数量
|
orderProcessDetailMapper.updateQuantity(reportingWork.getReportingWorkId(), reportingWork.getThisProcess(), "delete");
|
//删除报工明细表数据
|
reportingWorkDetailMapper
|
.delete(new LambdaQueryWrapper<ReportingWorkDetail>()
|
.eq(ReportingWorkDetail::getReportingWorkId, reportingWork.getReportingWorkId()));
|
|
//更新报工主表
|
int qualityInsStatus = (int) reportingWorkJson.get("qualityInsStatus");
|
reportingWorkMapper.updateById(reportingWork);
|
reportingWorkDetails.forEach(reportingWorkDetail -> {
|
reportingWorkDetail.setReportingWorkId(reportingWork.getReportingWorkId());
|
List<DamageDetails> damageDetails = reportingWorkDetail.getDamageDetails();
|
//每一条报工数据循环插入次破明细表
|
if (damageDetails != null && !damageDetails.isEmpty()) {
|
damageDetails.forEach(damageDetail -> {
|
damageDetail.setReportingWorkId(reportingWork.getReportingWorkId());
|
damageDetail.setProcessId(reportingWork.getProcessId());
|
damageDetail.setOrderNumber(reportingWorkDetail.getOrderNumber());
|
damageDetail.setTechnologyNumber(reportingWorkDetail.getTechnologyNumber());
|
//是否修改质检状态
|
if (!Objects.equals(reportingWork.getThisProcess(), damageDetail.getResponsibleProcess()) && qualityInsStatus==2) {
|
damageDetail.setQualityInsStatus(1);
|
}
|
if (Objects.equals(reviewState, "review")) {
|
damageDetail.setQualityInsStatus(2);
|
}
|
|
damageDetailsMapper.insert(damageDetail);
|
});
|
}
|
//插入报工数据
|
reportingWorkDetailMapper.insert(reportingWorkDetail);
|
orderProcessDetailMapper.insertByReportingWorkDetail(reportingWorkDetail,reportingWork.getProcessId(),reportingWork.getThisProcess());
|
//修改包装时修改库存数量
|
if (reportingWork.getNextProcess()==null || reportingWork.getNextProcess().isEmpty()){
|
//获取该报工修改后的可入库数量
|
Integer inventory = reportingWorkDetailMapper.selectInventory(reportingWork.getProcessId(),Integer.parseInt(reportingWorkDetail.getOrderNumber()),Integer.parseInt(reportingWorkDetail.getTechnologyNumber()),reportingWork.getThisProcess());
|
//修改流程卡表库存数量
|
flowCardMapper.updateInventory(reportingWork.getProcessId(),reportingWorkDetail.getOrderNumber(),reportingWorkDetail.getTechnologyNumber(),inventory);
|
}
|
});
|
//获取质检时间
|
if (Objects.equals(reviewState, "review")) {
|
LocalDateTime
|
currentDate = LocalDateTime.now();
|
reportingWork.setQualityInsTime(currentDate);
|
reportingWorkMapper.updateById(reportingWork);
|
}
|
|
//修改小片流程表数量为报工明细表数量
|
//orderProcessDetailMapper.updateQuantity(reportingWork.getReportingWorkId(), reportingWork.getThisProcess(), "add");
|
//保存日志
|
Log log = new Log();
|
log.setContent(reportingWorkMap.toString());
|
log.setFunction("updateReportingWork报工修改");
|
log.setOperatorId((String) reportingWorkJson.get("userId"));
|
log.setOperator((String) reportingWorkJson.get("userName"));
|
logService.saveLog(log);
|
|
return true;
|
} else {
|
return false;
|
}
|
|
}
|
|
//报工管理查询
|
// public Map<String, Object> selectReportingWorkSv(Integer pageNum, Integer pageSize, List<String> selectDate, String orderId, ReportingWork reportingWork) {
|
// Integer offset = (pageNum - 1) * pageSize;
|
// if ("null".equals(orderId)) {
|
// orderId = "";
|
// }
|
// String endDate = LocalDate.now().toString();
|
// String startDate = LocalDate.now().minusDays(3).toString();
|
// if(selectDate !=null && selectDate.size()==2){
|
// if(!selectDate.get(0).isEmpty()){
|
// startDate = selectDate.get(0);
|
// }
|
// if(!selectDate.get(1).isEmpty()){
|
// endDate = selectDate.get(1);
|
// }
|
// }
|
// Map<String, Object> map = new HashMap<>();
|
// map.put("data", reportingWorkMapper.selectReportingWorkMp(offset, pageSize, startDate, endDate, orderId, reportingWork));
|
// map.put("total" ,reportingWorkMapper.getFootSum(offset, pageSize, startDate, endDate, orderId, reportingWork));
|
// List<String> list = new ArrayList<>();
|
// list.add(startDate);
|
// list.add(endDate);
|
// map.put("selectDate",list);
|
// return map;
|
// }
|
|
|
public Map<String, Object> selectReportingWorkSv(
|
Integer pageNum, Integer pageSize,
|
List<String> selectDate, String orderId,
|
ReportingWork reportingWork) {
|
|
Integer offset = (pageNum - 1) * pageSize;
|
|
if ("null".equals(orderId)) {
|
orderId = "";
|
}
|
|
// 默认时间：最近 3 天
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(3).toString();
|
|
// 如果传入自定义日期
|
if (selectDate != null && selectDate.size() == 2) {
|
if (!selectDate.get(0).isEmpty()) {
|
startDate = selectDate.get(0);
|
}
|
if (!selectDate.get(1).isEmpty()) {
|
endDate = selectDate.get(1);
|
}
|
}
|
|
Map<String, Object> result = new HashMap<>();
|
|
try {
|
// 并行执行两条 SQL 查询
|
String finalStartDate = startDate;
|
String finalEndDate = endDate;
|
String finalOrderId = orderId;
|
CompletableFuture<List<ReportingWork>> dataFuture =
|
asyncExecutor.runAsync(() ->
|
reportingWorkMapper.selectReportingWorkMp(
|
offset, pageSize, finalStartDate, finalEndDate, finalOrderId, reportingWork));
|
|
CompletableFuture<Map<String, Float>> totalFuture =
|
asyncExecutor.runAsync(() ->
|
reportingWorkMapper.getFootSum(
|
offset, pageSize, finalStartDate, finalEndDate, finalOrderId, reportingWork));
|
|
// 等待全部完成
|
CompletableFuture.allOf(dataFuture, totalFuture).join();
|
|
result.put("data", dataFuture.get());
|
result.put("total", totalFuture.get());
|
|
// 日期范围
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
result.put("selectDate", list);
|
|
} catch (Exception e) {
|
e.printStackTrace();
|
throw new RuntimeException("并行查询报工记录异常：" + e.getMessage(), e);
|
}
|
|
return result;
|
}
|
|
//删除报工
|
public Boolean deleteWorkSv(String reportingWorkId, String processId, String thisProcess, String userId, String userName) {
|
if (!reportingWorkId.isEmpty() && !processId.isEmpty() && !thisProcess.isEmpty()) {
|
//获取当前报工编号下工序
|
String nextProcess = reportingWorkMapper.selectNextProcess(reportingWorkId);
|
//查询当前报工编号下工序是否报工
|
Integer count = reportingWorkMapper.selectCountByProcessId(processId, nextProcess);
|
//获取最后一道工序
|
String lastProcess = reportingWorkMapper.selectLastProcess(processId);
|
//获取是否有已补片或返工
|
Integer countStates= Integer.valueOf(reportingWorkMapper.getPatchConditionMp(reportingWorkId));
|
//查询该报工是否为报工转移订单
|
Integer transferState = reportingWorkMapper.selectReviewedState(reportingWorkId);
|
if (transferState !=3){
|
//判断是否有补片返工数据
|
if (countStates==0){
|
//当下工序未审核则删除本工序
|
ReportingWork reportingWork = reportingWorkMapper.selectOne(new LambdaQueryWrapper<ReportingWork>()
|
.eq(ReportingWork::getReportingWorkId, reportingWorkId));
|
//保存日志
|
Log log = new Log();
|
log.setContent(reportingWorkId+"-"+processId+"-"+thisProcess);
|
log.setFunction("deleteWork报工删除");
|
log.setOperatorId(userId);
|
log.setOperator(userName);
|
|
|
//判断是否是入库工序
|
if (lastProcess.equals(thisProcess)) {//是入库工序
|
//查询该流程卡数量、可入库数量、已入库数量
|
Map<String, Object> list = reportingWorkMapper.selectReceiptQuantity(processId);
|
if (list.get("quantity") == list.get("receiptQuantity")) {
|
return false;
|
} else {
|
//转换类型:已入库数量
|
Integer receiptQuantity = Integer.parseInt(list.get("receivedQuantity").toString());
|
//转换类型:可入库数量
|
Integer inventoryQuantity = Integer.parseInt(list.get("inventoryQuantity").toString());
|
//查询该报工编号本工序完工数量
|
Integer completedQuantity = reportingWorkMapper.selectCompletedQuantity(reportingWorkId);
|
//当该工序完工数量小于等于已入库数量时
|
//可入库数量-已入库数量>=报工编号本工序完工数量
|
if (inventoryQuantity - receiptQuantity >= completedQuantity) {
|
//查询当前报工编号完工次破数量的数据
|
List<Map<String, Object>> workDateList = reportingWorkMapper.reportingWorkDate(reportingWorkId);
|
for (Map<String, Object> item : workDateList) {
|
//更新流程卡可入库数量
|
reportingWorkMapper.updateInventoryQuantity(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"));
|
//更新报工流程表数据
|
reportingWorkMapper.updateWorkProcess(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"), item.get("breakage_quantity"), thisProcess);
|
}
|
//删除报工，将审核状态改为-1
|
reportingWorkMapper.deleteWork(reportingWorkId);
|
logService.saveLog(log);
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
} else {//不是入库工序
|
if(reportingWork.getReviewedState()==0){
|
//查询当前报工编号完工次破数量的数据
|
List<Map<String, Object>> workDateList = reportingWorkMapper.reportingWorkDate(reportingWorkId);
|
for (Map<String, Object> item : workDateList) {
|
//更新报工流程表数据
|
reportingWorkMapper.updateWorkProcess(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"), item.get("breakage_quantity"), thisProcess);
|
}
|
//删除报工，将审核状态改为-1
|
reportingWorkMapper.deleteWork(reportingWorkId);
|
logService.saveLog(log);
|
return true;
|
}
|
|
if (count == 0) {
|
//查询当前报工编号完工次破数量的数据
|
List<Map<String, Object>> workDateList = reportingWorkMapper.reportingWorkDate(reportingWorkId);
|
for (Map<String, Object> item : workDateList) {
|
//更新报工流程表数据
|
reportingWorkMapper.updateWorkProcess(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"), item.get("breakage_quantity"), thisProcess);
|
}
|
//删除报工，将审核状态改为-1
|
reportingWorkMapper.deleteWork(reportingWorkId);
|
|
|
logService.saveLog(log);
|
return true;
|
} else {
|
return false;
|
}
|
}
|
}
|
else {
|
return false;
|
}
|
} else {
|
return false;
|
}
|
} else {
|
return false;
|
}
|
}
|
|
//查询质检审核
|
public Map<String, Object> selectQualityTestingSv(Integer pageNum, Integer pageSize, List<String> selectDate, Integer state, String processId, ReportingWork reportingWork) {
|
Integer offset = (pageNum - 1) * pageSize;
|
if ("null".equals(processId)) {
|
processId = "";
|
}
|
String endDate = LocalDate.now().toString();
|
String startDate = LocalDate.now().minusDays(3).toString();
|
if(selectDate !=null && selectDate.size()==2){
|
if(!selectDate.get(0).isEmpty()){
|
startDate = selectDate.get(0);
|
}
|
if(!selectDate.get(1).isEmpty()){
|
endDate = selectDate.get(1);
|
}
|
}
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", reportingWorkMapper.selectQualityTestingMp(offset, pageSize, startDate, endDate, state, processId, reportingWork));
|
map.put("total", reportingWorkMapper.getQualityPageTotal(offset, pageSize, startDate, endDate, state, processId, reportingWork));
|
List<String> list = new ArrayList<>();
|
list.add(startDate);
|
list.add(endDate);
|
map.put("selectDate",list);
|
return map;
|
}
|
|
public Map<String, Object> qualityReviewSearchSv() {
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", reportingWorkMapper.qualityReviewSearchMp());
|
return map;
|
}
|
|
//修改质检审核状态
|
public Boolean updateQualityStatusSv(String reportingWorkId, String username) {
|
if (!reportingWorkId.isEmpty()) {
|
reportingWorkMapper.updateQualityStatusMp(reportingWorkId, username);
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
//查询质检明细（未使用）
|
public Map<String, Object> detailsQualitySv(String reportingWorkId, String processId, String thisProcess, ReportingWork reportingWork) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", reportingWorkMapper.detailsQualityMp(reportingWorkId, reportingWork));
|
map.put("basic", getReportingWorkBase(processId, thisProcess));
|
|
return map;
|
}
|
|
public String getPatchConditionSv(String reportingWorkId) {
|
String count=reportingWorkMapper.getPatchConditionMp(reportingWorkId);
|
return count;
|
}
|
@Transactional(rollbackFor = Exception.class , noRollbackFor = ServiceException.class)
|
public Boolean mesReportingWorkSv(Map<String,Object> reportingWorkMap) {
|
//设置回滚点
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try{
|
//接收解析主附表信息
|
JSONObject reportingWorkJson = new JSONObject(reportingWorkMap);
|
ReportingWork reportingWork = JSONObject.parseObject(JSONObject.toJSONString(reportingWorkJson.get("title")), ReportingWork.class);
|
ReportingWorkDetail reportingWorkDetail =JSON.parseObject(JSONObject.toJSONString(reportingWorkJson.get("detail")), ReportingWorkDetail.class);
|
|
//查询流程卡工艺流程
|
String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(reportingWork.getProcessId(), reportingWorkDetail.getTechnologyNumber());
|
|
int index = technologicalProcess.indexOf("-");
|
String interceptProcess = "";
|
if (index <0){
|
interceptProcess = technologicalProcess;
|
}
|
else {
|
//获取工艺流程第一个工序
|
interceptProcess = technologicalProcess.substring(0, index);
|
}
|
int processNum =0;
|
if (interceptProcess.equals(reportingWork.getThisProcess())) {
|
processNum = reportingWorkMapper.selectFlowCardNum(
|
reportingWorkDetail.getOrderNumber(),
|
reportingWorkDetail.getTechnologyNumber(),
|
reportingWork.getProcessId(),
|
reportingWork.getThisProcess()
|
);
|
}else{
|
processNum = reportingWorkMapper.selectGlassProcessNum(
|
reportingWorkDetail.getOrderNumber(),
|
reportingWorkDetail.getTechnologyNumber(),
|
reportingWork.getProcessId(),
|
reportingWork.getThisProcess()
|
);
|
}
|
|
//获取可报数量
|
|
//判断是否大于当前数量并且抛出异常
|
if (processNum < (reportingWorkDetail.getBreakageQuantity() + reportingWorkDetail.getCompletedQuantity())) {
|
return false;
|
}
|
//查询报工数据
|
List<ReportingWork> ReportingWorks = reportingWorkMapper.selectJoinList(ReportingWork.class,
|
new MPJLambdaWrapper<ReportingWork>()
|
.select(ReportingWork::getReportingWorkId)
|
.leftJoin(ReportingWorkDetail.class,
|
ReportingWorkDetail::getReportingWorkId,
|
ReportingWork::getReportingWorkId)
|
.eq(ReportingWork::getProcessId,reportingWork.getProcessId())
|
.eq(ReportingWork::getThisProcess,reportingWork.getThisProcess())
|
.eq(ReportingWork::getDeviceName,reportingWork.getDeviceName())
|
.eq(ReportingWork::getReviewedState,0)//审核状态等于0，未删除
|
.eq(ReportingWork::getThisWornQuantity,0)
|
.eq(ReportingWorkDetail::getTechnologyNumber,reportingWorkDetail.getTechnologyNumber())
|
.orderByDesc(ReportingWork::getId)
|
|
);
|
|
|
//判断报工表是否存在，不存在则新增报工主副表数据，存在则修改副表数据
|
if(ReportingWorks.isEmpty()){
|
//获取当前最大报工单号生成报工单号
|
String reportingWorkId = this.getTodayMaxReportingId();
|
|
reportingWork.setReportingWorkId(reportingWorkId);
|
reportingWorkDetail.setReportingWorkId(reportingWorkId);
|
|
reportingWorkMapper.insert(reportingWork);
|
reportingWorkDetailMapper.insert(reportingWorkDetail);
|
}else{
|
|
ReportingWorkDetail reportingWorkDetail1 = reportingWorkDetailMapper.selectOne(
|
new LambdaQueryWrapper<ReportingWorkDetail>()
|
.eq(ReportingWorkDetail::getReportingWorkId,ReportingWorks.get(0).getReportingWorkId())
|
.eq(ReportingWorkDetail::getOrderNumber,reportingWorkDetail.getOrderNumber())
|
.eq(ReportingWorkDetail::getTechnologyNumber,reportingWorkDetail.getTechnologyNumber())
|
);
|
|
if(reportingWorkDetail1 == null){
|
reportingWorkDetail.setReportingWorkId(ReportingWorks.get(0).getReportingWorkId());
|
reportingWorkDetailMapper.insert(reportingWorkDetail);
|
}else{
|
LambdaUpdateWrapper<ReportingWorkDetail> detailLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
|
detailLambdaUpdateWrapper.eq(ReportingWorkDetail::getReportingWorkId, ReportingWorks.get(0).getReportingWorkId() )
|
.eq(ReportingWorkDetail::getOrderNumber,reportingWorkDetail.getOrderNumber())
|
.eq(ReportingWorkDetail::getTechnologyNumber,reportingWorkDetail.getTechnologyNumber())
|
.setSql("completed_quantity = completed_quantity+" + reportingWorkDetail.getCompletedQuantity());
|
reportingWorkDetailMapper.update(null, detailLambdaUpdateWrapper);
|
}
|
|
|
|
|
LambdaUpdateWrapper<ReportingWork> reportingWorkLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
|
reportingWorkLambdaUpdateWrapper
|
.eq(ReportingWork::getReportingWorkId, ReportingWorks.get(0).getReportingWorkId() )
|
.setSql("this_completed_quantity = this_completed_quantity+" + reportingWorkDetail.getCompletedQuantity());
|
reportingWorkMapper.update(null, reportingWorkLambdaUpdateWrapper);
|
|
}
|
|
|
|
OrderProcessDetail orderProcessDetail = new OrderProcessDetail();
|
orderProcessDetail.setBrokenNum(reportingWorkDetail.getBreakageQuantity());
|
orderProcessDetail.setReportingWorkNum(reportingWorkDetail.getCompletedQuantity());
|
orderProcessDetail.setReportingWorkNumCount(reportingWorkDetail.getCompletedQuantity());
|
|
//根据订单id，订单序号，以及小片序号 更新小片流程的完工数量以及刺破数量
|
LambdaUpdateWrapper<OrderProcessDetail> updateWrapper = new LambdaUpdateWrapper<>();
|
updateWrapper.eq(OrderProcessDetail::getOrderNumber, reportingWorkDetail.getOrderNumber())
|
.eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId())
|
.eq(OrderProcessDetail::getOrderId, reportingWork.getOrderId())
|
.eq(OrderProcessDetail::getProcess, reportingWork.getThisProcess())
|
.eq(OrderProcessDetail::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())
|
.setSql("reporting_work_num_count = reporting_work_num_count +" + orderProcessDetail.getReportingWorkNum())
|
.setSql("reporting_work_num =reporting_work_num +" + orderProcessDetail.getReportingWorkNum());
|
|
orderProcessDetailMapper.update(null, updateWrapper);
|
return true;
|
} catch (Exception e) {
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
//将异常传入数据库
|
SysError sysError = new SysError();
|
sysError.setError(e +Arrays.toString(e.getStackTrace()));
|
sysError.setFunc("mes报工");
|
sysErrorService.insert(sysError);
|
throw new ServiceException(Constants.Code_500, "数据请求异常，请检查");
|
|
}
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public Object reportingWorkTransferSv(Map<String, String> reportingWork) {
|
Map<String, Object> result = new HashMap<>();
|
|
Order oldOrder = orderMapper.selectOrderId(reportingWork.get("oldOrderId"));
|
OrderDetail oldOrderDetail = orderDetailMapper.selectOne(
|
new QueryWrapper<OrderDetail>()
|
.eq("order_id", reportingWork.get("oldOrderId"))
|
.eq("order_number", reportingWork.get("oldOrderNumber"))
|
);
|
if(oldOrder == null){
|
result.put("msg","旧订单不存在");
|
result.put("data",false);
|
return result;
|
}
|
if(oldOrderDetail == null){
|
result.put("msg","旧订单次序号不存在");
|
result.put("data",false);
|
return result;
|
}
|
|
Order newOrder = orderMapper.selectOrderId(reportingWork.get("newOrderId"));
|
OrderDetail newOrderDetail = orderDetailMapper.selectOne(
|
new QueryWrapper<OrderDetail>()
|
.eq("order_id", reportingWork.get("newOrderId"))
|
.eq("order_number", reportingWork.get("newOrderNumber"))
|
);
|
if (newOrder == null){
|
result.put("msg","新订单不存在");
|
result.put("data",false);
|
return result;
|
}
|
if(newOrderDetail == null){
|
result.put("msg","新订单次序号不存在");
|
result.put("data",false);
|
return result;
|
}
|
if(Objects.equals(oldOrder.getOrderId(), newOrder.getOrderId())){
|
result.put("msg","新旧订单号一致");
|
result.put("data",false);
|
return result;
|
}
|
|
if(!Objects.equals(oldOrder.getCustomerId(), newOrder.getCustomerId())){
|
result.put("msg","新旧订单客户不一致");
|
result.put("data",false);
|
return result;
|
}
|
if(!Objects.equals(oldOrderDetail.getProductId(), newOrderDetail.getProductId())){
|
result.put("msg","新旧订单产品不一致");
|
result.put("data",false);
|
return result;
|
}
|
if (!Objects.equals(oldOrderDetail.getWidth(), newOrderDetail.getWidth())
|
|| !Objects.equals(oldOrderDetail.getHeight(), newOrderDetail.getHeight())){
|
result.put("msg","新旧订单尺寸不一致");
|
result.put("data",false);
|
return result;
|
}
|
|
|
//获取旧订单是否流程卡是否存在
|
List<OrderProcessDetail> oldOrderProcessDetailList = orderProcessDetailMapper
|
.selectList(new QueryWrapper<OrderProcessDetail>()
|
.eq("order_id", reportingWork.get("oldOrderId"))
|
.eq("order_number", reportingWork.get("oldOrderNumber"))
|
);
|
if(oldOrderProcessDetailList.isEmpty()){
|
result.put("msg","旧订单未分流程卡");
|
result.put("data",false);
|
return result;
|
}
|
//获取新订单是否流程卡是否存在
|
List<OrderProcessDetail> newOrderProcessDetailList = orderProcessDetailMapper
|
.selectList(new QueryWrapper<OrderProcessDetail>()
|
.eq("order_id", reportingWork.get("newOrderId"))
|
.eq("order_number", reportingWork.get("newOrderNumber"))
|
);
|
if(newOrderProcessDetailList.isEmpty()){
|
result.put("msg","新订单未分流程卡");
|
result.put("data",false);
|
return result;
|
}
|
//新订单是否存在已经排版序号
|
List<FlowCard> newFlowCardLayoutStatus = flowCardMapper.selectList(new QueryWrapper<FlowCard>()
|
.eq("order_id", reportingWork.get("newOrderId"))
|
.eq("order_number", reportingWork.get("newOrderNumber"))
|
.gt("layout_status",0)
|
);
|
if(!newFlowCardLayoutStatus.isEmpty()){
|
result.put("msg","新订单此序号存在排版");
|
result.put("data",false);
|
return result;
|
}
|
List<ReportingWorkTransfer> reportingWorkTransferList = reportingWorkTransferMapper
|
.selectList(new QueryWrapper<ReportingWorkTransfer>()
|
.eq("old_order", reportingWork.get("newOrderId"))
|
.eq("old_order_number", reportingWork.get("newOrderNumber"))
|
);
|
if(!reportingWorkTransferList.isEmpty()){
|
result.put("msg","新订单序号之前已转出报工数据，无法进行转入");
|
result.put("data",false);
|
return result;
|
}
|
|
//获取旧订单报工数据汇总
|
List<OrderProcessDetail> oldOrderProcessDetailForReport = orderProcessDetailMapper
|
.selectList(new QueryWrapper<OrderProcessDetail>()
|
.eq( "order_id", reportingWork.get("oldOrderId"))
|
.eq("order_number", reportingWork.get("oldOrderNumber"))
|
.gt("reporting_work_num",0)
|
);
|
|
if (oldOrderProcessDetailForReport.isEmpty()){
|
result.put("msg","旧订单没有可转出的报工数据");
|
result.put("data",false);
|
return result;
|
}
|
List<String> oldOrderProcessIdList = new ArrayList<>();
|
oldOrderProcessDetailList.forEach(oldOrderProcessDetail -> oldOrderProcessIdList.add(oldOrderProcessDetail.getProcessId()));
|
|
//获取旧数据破损表是否存在破损
|
List<DamageDetails> damageDetails = damageDetailsMapper.selectList(
|
new QueryWrapper<DamageDetails>()
|
.in("process_id",oldOrderProcessIdList)
|
.eq("order_number", reportingWork.get("oldOrderNumber"))
|
.eq("quantity",0)
|
);
|
if(!damageDetails.isEmpty()){
|
result.put("msg","旧订单存在报工未处理破损数据");
|
result.put("data",false);
|
return result;
|
}
|
//获取补片表是否存在补片未审核状态
|
List<PatchLog> patchLogs = patchLogMapper.selectList(
|
new QueryWrapper<PatchLog>()
|
.eq("order_id", reportingWork.get("oldOrderId"))
|
.eq("order_sort", reportingWork.get("oldOrderNumber"))
|
.eq("review_status",0)
|
);
|
if (!patchLogs.isEmpty()){
|
result.put("msg","旧订单存在补片未审核数据");
|
result.put("data",false);
|
return result;
|
}
|
List<Rework> reworks = reworkMapper.selectList(
|
new QueryWrapper<Rework>()
|
.eq("order_id", reportingWork.get("oldOrderId"))
|
.eq("order_sort", reportingWork.get("oldOrderNumber"))
|
.eq("review_status",0)
|
);
|
if (!patchLogs.isEmpty()){
|
result.put("msg","旧订单存在返工未审核数据，请先审核报工后再进行转出");
|
result.put("data",false);
|
return result;
|
}
|
|
|
Map<String,Object> log = new HashMap<>();
|
log.put("oldOrderBeforeChange",oldOrderProcessDetailForReport);
|
|
Map<String,Object> newOrderLog = new HashMap<>();
|
newOrderLog.put("newOrderBeforeChange",newOrderProcessDetailList);
|
|
//传给mes流程卡数量集合
|
List<OrderNumberTransferDTO> orderNumberTransferList = new ArrayList<>();
|
|
oldOrderProcessDetailForReport.forEach(oldOrderProcessDetail -> {
|
//修改报工状态为3
|
reportingWorkMapper.update(null,new UpdateWrapper<ReportingWork>()
|
.set("reviewed_state",3)
|
.eq("process_id",oldOrderProcessDetail.getProcessId())
|
.gt("reviewed_state",0)
|
);
|
|
|
int maxNum = 0;
|
for(OrderProcessDetail newOrderProcessDetail : newOrderProcessDetailList){
|
if(oldOrderProcessDetail.getReportingWorkNum() == 0){
|
break;
|
}
|
//判断小片是否一致，工序是否一致
|
if(newOrderProcessDetail.getProcess().equals(oldOrderProcessDetail.getProcess()) &&
|
Objects.equals(newOrderProcessDetail.getTechnologyNumber(), oldOrderProcessDetail.getTechnologyNumber())){
|
//判断是否为第一道工序，给可转移最大值赋值
|
if(oldOrderProcessDetail.getProcess().equals("切割")){
|
FlowCard thisFlowCard = flowCardMapper.selectOne(new QueryWrapper<FlowCard>()
|
.eq("process_id", newOrderProcessDetail.getProcessId())
|
.eq("order_number", newOrderProcessDetail.getOrderNumber())
|
.eq("technology_number",newOrderProcessDetail.getTechnologyNumber())
|
);
|
maxNum = thisFlowCard.getQuantity()+thisFlowCard.getExportNumber()
|
-thisFlowCard.getImportNumber();
|
}else{
|
//当不是第一道工序则，拿上一道工序减去当前工序作为最大值
|
maxNum = orderProcessDetailMapper.selectById(newOrderProcessDetail.getId()-1).getReportingWorkNum()
|
-orderProcessDetailMapper.selectById(newOrderProcessDetail.getId()).getReportingWorkNum()
|
;
|
}
|
//判断被转移的数量是否大于可转移的数量最大值
|
int transferNum = 0;
|
if(oldOrderProcessDetail.getReportingWorkNum() > maxNum){
|
transferNum = maxNum;
|
oldOrderProcessDetail.setReportingWorkNum(oldOrderProcessDetail.getReportingWorkNum()-maxNum);
|
oldOrderProcessDetail.setReportingWorkNumCount(oldOrderProcessDetail.getReportingWorkNumCount()-maxNum);
|
}else{
|
transferNum = oldOrderProcessDetail.getReportingWorkNum();
|
oldOrderProcessDetail.setReportingWorkNum(0);
|
oldOrderProcessDetail.setReportingWorkNumCount(0);
|
}
|
//更新旧订单小片流程表的报工数量
|
orderProcessDetailMapper.update(null,new UpdateWrapper<OrderProcessDetail>()
|
.set("reporting_work_num",oldOrderProcessDetail.getReportingWorkNum())
|
.set("reporting_work_num_count",oldOrderProcessDetail.getReportingWorkNumCount())
|
.eq("id",oldOrderProcessDetail.getId())
|
);
|
//更新新订单小片流程表的报工数量
|
orderProcessDetailMapper.update(null,new UpdateWrapper<OrderProcessDetail>()
|
.set("reporting_work_num",transferNum)
|
.set("reporting_work_num_count",transferNum)
|
.eq("id",newOrderProcessDetail.getId())
|
);
|
if(oldOrderProcessDetail.getProcess().equals("切割")){
|
//更新旧订单流程卡转出数量
|
flowCardMapper.update(null,new UpdateWrapper<FlowCard>()
|
.setSql("export_number = export_number + "+transferNum)
|
.eq("process_id", oldOrderProcessDetail.getProcessId())
|
.eq("order_number", oldOrderProcessDetail.getOrderNumber())
|
.eq("technology_number",oldOrderProcessDetail.getTechnologyNumber())
|
);
|
//更新新订单流程卡转出数量
|
flowCardMapper.update(null,new UpdateWrapper<FlowCard>()
|
.setSql("import_number = import_number + "+transferNum)
|
.eq("process_id", newOrderProcessDetail.getProcessId())
|
.eq("order_number", newOrderProcessDetail.getOrderNumber())
|
.eq("technology_number",newOrderProcessDetail.getTechnologyNumber())
|
);
|
|
//传给mes数据赋值
|
OrderNumberTransferDTO orderNumberTransfer = new OrderNumberTransferDTO();
|
orderNumberTransfer.setChangeNumber(transferNum);
|
orderNumberTransfer.setOldProcessId(oldOrderProcessDetail.getProcessId());
|
orderNumberTransfer.setNewProcessId(newOrderProcessDetail.getProcessId());
|
orderNumberTransfer.setOldOrderNumber(oldOrderProcessDetail.getOrderNumber());
|
orderNumberTransfer.setNewOrderNumber(newOrderProcessDetail.getOrderNumber());
|
orderNumberTransfer.setOldTechnologyNumber(oldOrderProcessDetail.getTechnologyNumber());
|
orderNumberTransfer.setNewTechnologyNumber(newOrderProcessDetail.getTechnologyNumber());
|
orderNumberTransferList.add(orderNumberTransfer);
|
|
}
|
}
|
}
|
});
|
|
|
//把旧订单数据和新订单数据传到日志表当中
|
log.put("oldOrderChange",JSON.toJSONString(oldOrderProcessDetailForReport));
|
|
newOrderLog.put("newOrderChange",orderProcessDetailMapper
|
.selectList(new QueryWrapper<OrderProcessDetail>()
|
.eq("order_id", reportingWork.get("newOrderId"))
|
.eq("order_number", reportingWork.get("newOrderNumber"))
|
));
|
//旧订单信息传入日志
|
ReportingWorkTransfer reportingWorkTransfer = new ReportingWorkTransfer();
|
reportingWorkTransfer.setOldOrder(reportingWork.get("oldOrderId"));
|
reportingWorkTransfer.setOldOrderNumber(Integer.valueOf(reportingWork.get("oldOrderNumber")));
|
reportingWorkTransfer.setOldReportContent(JSON.toJSONString(log));
|
|
//新订单信息传入日志
|
reportingWorkTransfer.setNewOrder(reportingWork.get("newOrderId"));
|
reportingWorkTransfer.setNewOrderNumber(Integer.valueOf(reportingWork.get("newOrderNumber")));
|
reportingWorkTransfer.setNewReportContent(JSON.toJSONString(newOrderLog));
|
reportingWorkTransferMapper.insert(reportingWorkTransfer);
|
//restTemplate.postForObject("http://localhost:8086/order/test",orderNumberTransferList,String.class);
|
|
//向mes发送http请求
|
/*ResponseEntity<OrderNumberTransferDTO> response =restTemplate.exchange(
|
"http://localhost:88/api/loadGlass/order/order/orderChange",
|
HttpMethod.POST,
|
new HttpEntity<>(orderNumberTransferList),
|
OrderNumberTransferDTO.class);
|
|
if(response.getStatusCode() == HttpStatus.OK){
|
OrderNumberTransferDTO responseBody = response.getBody();
|
result.put("data",true);
|
}else{
|
result.put("msg","连接mes响应超时");
|
result.put("data",false);
|
}*/
|
|
result.put("data",true);
|
return result;
|
|
}
|
|
public Map<String, Object> selectShiftQuantitySv(Map<String, Object> reportingWork) {
|
String creatorId = (String) reportingWork.get("userId");
|
List<LocalDateTime> dateList = (List<LocalDateTime>) reportingWork.get("searchDate");
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
|
String startDate = LocalDateTime.now().with(LocalTime.MIN).format(formatter);
|
String endDate = LocalDateTime.now().format(formatter);
|
if (dateList.get(0)!=null){
|
startDate = String.valueOf(dateList.get(0));
|
}
|
if (dateList.get(1)!=null){
|
endDate = String.valueOf(dateList.get(1));
|
}
|
List<String> date = new ArrayList<>();
|
date.add(startDate);
|
date.add(endDate);
|
Map<String, Object> result = new HashMap<>();
|
BasicData basicData = basicDataMapper
|
.selectOne(new QueryWrapper<BasicData>()
|
.eq("basic_name", reportingWork.get("process"))
|
.last("limit 1")
|
);
|
result.put("data",orderProcessDetailMapper.selectShiftQuantitySv(creatorId, startDate, endDate,basicData==null?null:basicData.getNickname()));
|
result.put("date",date);
|
return result;
|
}
|
|
public Map<String, Object> selectReportingWorkRecordByPhoneSv(Map<String,Object> reportingWork) {
|
List<LocalDateTime> dateList = (List<LocalDateTime>) reportingWork.get("searchDate");
|
String startDate = LocalDate.now().minusDays(14).toString();
|
String endDate = LocalDate.now().toString();
|
if (dateList.get(0)!=null){
|
startDate = String.valueOf(dateList.get(0));
|
}
|
if (dateList.get(1)!=null){
|
endDate = String.valueOf(dateList.get(1));
|
}
|
List<String> date = new ArrayList<>();
|
date.add(startDate);
|
date.add(endDate);
|
Map<String, Object> result = new HashMap<>();
|
List<ReportingWork> reportingWorkList = reportingWorkMapper.selectList(
|
new QueryWrapper<ReportingWork>().nested(
|
reportingWork.get("process")!=null,
|
wrapper-> wrapper.eq("creator_id",reportingWork.get("userId"))//当工序为空时，查询所有报工信息
|
)
|
.gt("reviewed_state",-1)
|
.between("date(reporting_work_time)",startDate,endDate)
|
.orderByDesc("id"));
|
reportingWorkList.forEach(reportingWork1 -> {
|
String Plies = reportingWorkDetailMapper.getGlassPliesCount(reportingWork1.getReportingWorkId());
|
reportingWork1.setProcessId(reportingWork1.getProcessId()+'/'+Plies);
|
});
|
|
result.put("data",reportingWorkList);
|
result.put("date",date);
|
|
return result;
|
|
}
|
|
public List<BasicDataProduce> selectEquipmentByProcessSv(String process) {
|
return reportingWorkMapper.SelectWorkBasicDeviceMp(process);
|
}
|
|
public String saveWorkStorage(Map<String, Object> object) {
|
//List<Map<String, Object>> flowCard = reportingWorkMapper.getStorageData();
|
//finishedGoodsInventoryService.addSelectWarehousing(object);
|
return null;
|
}
|
|
public Map<String, Object> mesBasicDataSv() {
|
Map<String, Object> map = new HashMap<>();
|
//工序
|
map.put("process",flowCardMapper.getProcessNameList());
|
//设备下拉框
|
map.put("device", reportingWorkMapper.mesSelectWorkBasicDeviceMp());
|
//班组下拉框
|
map.put("teams", reportingWorkMapper.mesSelectWorkBasicTeamsMp());
|
//次破类型
|
map.put("breakageType", reportingWorkMapper.selectBasicNameByType("breakagetype"));
|
//次破原因
|
map.put("breakageReason", reportingWorkMapper.selectBasicNameByType("breakagereason"));
|
return map;
|
}
|
|
|
//@Transactional(rollbackFor = Exception.class , noRollbackFor = ServiceException.class)
|
public Result mesReportingWorkSvToRedis(Map<String, Object> reportingWorkMap) throws JsonProcessingException, InterruptedException {
|
|
//设置回滚点
|
//Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
//接收解析主附表信息
|
String titleJson = JacksonUtil.writeValueAsString(reportingWorkMap.get("title"));
|
String detailJson = JacksonUtil.writeValueAsString(reportingWorkMap.get("detail"));
|
ReportingWork reportingWork = JacksonUtil.readValue(titleJson, ReportingWork.class);
|
ReportingWorkDetail reportingWorkDetail = JacksonUtil.readValue(detailJson, ReportingWorkDetail.class);
|
String Base_KEY = "reportingWork:"+reportingWork.getProcessId()+"/"+reportingWorkDetail.getTechnologyNumber()+":"+reportingWork.getThisProcess()+":"+reportingWork.getDeviceName();
|
String reportingWork_KEY = Base_KEY+":title";
|
String reportingWorkDetail_KEY = Base_KEY+":detail:"+reportingWorkDetail.getOrderNumber();
|
|
String process_KEY = "reportingWork:"+reportingWork.getProcessId()+"/"+reportingWorkDetail.getTechnologyNumber()+":process";
|
|
//判断锁是否存在，存在等待5秒
|
if(Boolean.TRUE.equals(stringRedisTemplate.hasKey("lock:reportingWork"))){
|
Thread.sleep(5*1000);
|
if(Boolean.TRUE.equals(stringRedisTemplate.hasKey("lock:reportingWork"))){
|
throw new ServiceException(Constants.Code_600, "当前服务器正在处理报工数据，请稍后重试！");
|
}
|
}
|
|
|
//判断工序是否存在redis中
|
if(!Boolean.TRUE.equals(stringRedisTemplate.hasKey(process_KEY+":"+reportingWork.getThisProcess()))){
|
List<OrderProcessSortDTO> orderProcessSortDTOList = orderProcessDetailMapper.selectProcessSort(
|
reportingWork.getOrderId(),
|
reportingWork.getProcessId(),
|
reportingWorkDetail.getOrderNumber(),
|
reportingWorkDetail.getTechnologyNumber()
|
);
|
if (orderProcessSortDTOList.isEmpty()){
|
throw new ServiceException(Constants.Code_600, "未检测到流程卡信息，请检查");
|
}
|
|
orderProcessSortDTOList.forEach(orderProcessSortDTO -> {
|
Map<String, String> map = new HashMap<>();
|
map.put("sort",orderProcessSortDTO.getSort());
|
map.put("recombination",orderProcessSortDTO.getRecombination());
|
stringRedisTemplate.opsForHash().putAll(process_KEY+":"+orderProcessSortDTO.getProcess(), map);
|
});
|
}
|
String recombination = (String) stringRedisTemplate.opsForHash().get(process_KEY+":"+reportingWork.getThisProcess(),"recombination");
|
|
if (!recombination.isEmpty()){
|
throw new ServiceException(Constants.Code_600, "复合工序请到ERP中进行报工");
|
}
|
|
|
|
|
|
//判断是否redis此报工编号key是否存在
|
if(Boolean.TRUE.equals(stringRedisTemplate.hasKey(reportingWork_KEY))){
|
stringRedisTemplate.opsForHash().increment(
|
reportingWork_KEY,
|
"thisCompletedQuantity",
|
reportingWork.getThisCompletedQuantity()
|
);
|
}
|
else{
|
stringRedisTemplate.opsForHash().putAll(
|
reportingWork_KEY,
|
JacksonUtil.readValueObjectToString(reportingWork,new TypeReference<Map<String, String>>() {})
|
);
|
}
|
//获取可报数量
|
|
//判断是否redis此报工明细中key是否存在
|
if(Boolean.TRUE.equals(stringRedisTemplate.hasKey(reportingWorkDetail_KEY))){
|
stringRedisTemplate.opsForHash().increment(
|
reportingWorkDetail_KEY,
|
"completedQuantity",
|
reportingWorkDetail.getCompletedQuantity()
|
);
|
}else {
|
stringRedisTemplate.opsForHash().putAll(
|
reportingWorkDetail_KEY,
|
JacksonUtil.readValueObjectToString(reportingWorkDetail,new TypeReference<Map<String, String>>() {})
|
);
|
}
|
return Result.success("提交成功");
|
}
|
|
public void redisToMysqlReportingWork() throws InterruptedException {
|
if(Boolean.TRUE.equals(stringRedisTemplate.hasKey("lock:reportingWork"))){
|
throw new ServiceException(Constants.Code_600, "定时任务:当前服务器正在处理报工数据，请稍后重试！");
|
}
|
//获取所有key
|
String pattern = "reportingWork:*";
|
Set<String> keys = stringRedisTemplate.keys(pattern);
|
|
//判断redis中是否存在报工数据,存在则添加锁 并且修改key转移到上传mysql的key中
|
if (keys != null && !keys.isEmpty()) {
|
//添加锁
|
stringRedisTemplate.opsForValue().set("lock:reportingWork","1",60, TimeUnit.SECONDS);
|
|
if(Boolean.FALSE.equals(stringRedisTemplate.hasKey("upload:*" ))){
|
keys.forEach(key -> {
|
stringRedisTemplate.rename(key, "upload:" + key);
|
});
|
}
|
}else{
|
return;
|
}
|
//添加暂停时间，方式获取map时，redis中数据还在变化
|
Thread.sleep(200);
|
|
|
// 保存日志，把redis中的数据保存到日志中
|
Map<String, Map<Object, Object>> map = this.getAllHashesByPattern("upload:reportingWork:*");
|
Log log = new Log();
|
log.setContent(JacksonUtil.writeValueAsString(map));
|
log.setFunction("reportingWorkRedisToMysql");
|
log.setOperator("自动定时报工");
|
logService.saveLog(log);
|
//删除锁，让接口继续接收报工
|
stringRedisTemplate.delete("lock:reportingWork");
|
|
//获取到所有参数后清空redis库
|
// stringRedisTemplate.getConnectionFactory().getConnection().flushDb();
|
|
//从redis中获取所有报工主表数据
|
String titleKeyString = "upload:reportingWork:*:title";
|
Set<String> titleKeys = stringRedisTemplate.keys(titleKeyString);
|
if (titleKeys != null) {
|
titleKeys.forEach(titleKey -> {
|
ReportingWork reportingWork = JSON.parseObject(
|
JSONObject.toJSONString(stringRedisTemplate.opsForHash().entries(titleKey))
|
, ReportingWork.class
|
);
|
//获取当天一共有多少个报工编号
|
String reportingWorkId = this.getTodayMaxReportingId();
|
//添加报工编号
|
reportingWork.setReportingWorkId(reportingWorkId);
|
//往主表插入报工主数据
|
reportingWorkMapper.insert(reportingWork);
|
|
String detailKeyString = titleKey.replace(":title", ":detail:*");
|
Set<String> detailKeys = stringRedisTemplate.keys(detailKeyString);
|
if (detailKeys != null) {
|
detailKeys.forEach(detailKey -> {
|
|
ReportingWorkDetail reportingWorkDetail = JSON.parseObject(
|
JSONObject.toJSONString(stringRedisTemplate.opsForHash().entries(detailKey))
|
, ReportingWorkDetail.class
|
);
|
reportingWorkDetail.setReportingWorkId(reportingWorkId);
|
reportingWorkDetailMapper.insert(reportingWorkDetail);
|
|
//根据订单id，订单序号，以及小片序号 更新小片流程的完工数量以及刺破数量
|
LambdaUpdateWrapper<OrderProcessDetail> updateWrapper = new LambdaUpdateWrapper<>();
|
updateWrapper.eq(OrderProcessDetail::getOrderNumber, reportingWorkDetail.getOrderNumber())
|
.eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId())
|
.eq(OrderProcessDetail::getOrderId, reportingWork.getOrderId())
|
.eq(OrderProcessDetail::getProcess, reportingWork.getThisProcess())
|
.eq(OrderProcessDetail::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())
|
.setSql("reporting_work_num_count = reporting_work_num_count +" + reportingWorkDetail.getCompletedQuantity())
|
.setSql("reporting_work_num =reporting_work_num +" + reportingWorkDetail.getCompletedQuantity());
|
|
orderProcessDetailMapper.update(null, updateWrapper);
|
});
|
}
|
|
});
|
}
|
Set<String> uploadKeys = stringRedisTemplate.keys("upload:reportingWork:*");
|
if (uploadKeys != null) {
|
stringRedisTemplate.delete(uploadKeys);
|
}
|
|
}
|
|
public String getTodayMaxReportingId() {
|
String formattedNumber = String.format("%04d", reportingWorkMapper.selectMaxReportingWorkId() + 1);
|
//格式化当前日期
|
Date currentDate = new Date();
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
|
String formattedDate = dateFormat.format(currentDate);
|
return "BG" + formattedDate + formattedNumber;
|
|
}
|
|
|
/*获取所有的参数转*/
|
public Map<String, Map<Object, Object>> getAllHashesByPattern(String pattern) {
|
Set<String> keys = stringRedisTemplate.keys(pattern);
|
Map<String, Map<Object, Object>> result = new HashMap<>();
|
|
if (keys != null) {
|
for (String key : keys) {
|
Map<Object, Object> hashData = stringRedisTemplate.opsForHash().entries(key);
|
result.put(key, hashData);
|
}
|
}
|
|
return result;
|
}
|
}
|
