Yangwl
/
lanju-cloud
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

计划模块(优化)

Browse Source
master
wws 2 years ago
parent 473f789631
commit 9229c77301
4 changed files with 220 additions and 214 deletions
Show Stats Download Patch File Download Diff File

3
op-modules/op-plan/src/main/java/com/op/plan/controller/ProOrderController.java
Unescape Escape View File

@ -42,6 +42,7 @@ public class ProOrderController extends BaseController {
/** /**
* 通过订单Code查询级联订单信息并封装返回 * 通过订单Code查询级联订单信息并封装返回
*
* @param orderCode * @param orderCode
* @return * @return
*/ */
@ -146,6 +147,7 @@ public class ProOrderController extends BaseController {
/** /**
* 通过订单物料号code查询对应工艺 * 通过订单物料号code查询对应工艺
*
* @param prodCode * @param prodCode
* @return * @return
*/ */
@ -166,6 +168,7 @@ public class ProOrderController extends BaseController {
/** /**
* 通过工艺编码获取设备信息list * 通过工艺编码获取设备信息list
*
* @param routeCode * @param routeCode
* @return * @return
*/ */

277
op-modules/op-plan/src/main/java/com/op/plan/controller/ProOrderWorkorderController.java
Unescape Escape View File

@ -38,155 +38,156 @@ import com.op.common.core.web.page.TableDataInfo;
@RestController @RestController
@RequestMapping("/pro/workorder") @RequestMapping("/pro/workorder")
public class ProOrderWorkorderController extends BaseController { public class ProOrderWorkorderController extends BaseController {
@Autowired @Autowired
private IProOrderWorkorderService proOrderWorkorderService; private IProOrderWorkorderService proOrderWorkorderService;
@Autowired @Autowired
private IProWetMaterialPlanDetailService proWetMaterialPlanDetailService; private IProWetMaterialPlanDetailService proWetMaterialPlanDetailService;
/** /**
* 通过子工单code查询并返回所有级联工单 * 通过子工单code查询并返回所有级联工单
* @param code *
* @return * @param code
*/ * @return
@GetMapping("/getWorkOrders/{code}") */
public AjaxResult getWorkOrders(@PathVariable("code") String code) { @GetMapping("/getWorkOrders/{code}")
return proOrderWorkorderService.getWorkOrders(code); public AjaxResult getWorkOrders(@PathVariable("code") String code) {
} return proOrderWorkorderService.getWorkOrders(code);
}
/** /**
* 校验工单是否可以修改 * 校验工单是否可以修改
* *
* @return * @return
*/ */
@GetMapping("/checkWorkOrder/{id}") @GetMapping("/checkWorkOrder/{id}")
public AjaxResult checkWorkOrder(@PathVariable("id") String id){ public AjaxResult checkWorkOrder(@PathVariable("id") String id) {
return proOrderWorkorderService.checkWorkOrder(id); return proOrderWorkorderService.checkWorkOrder(id);
} }
/** /**
* 提交修改工单接口 * 提交修改工单接口
* *
* @param splitOrderDTO * @param splitOrderDTO
* @return * @return
*/ */
@PostMapping("/subChangeWorkOrder") @PostMapping("/subChangeWorkOrder")
@RequiresPermissions("mes:pro:workorder:edit") @RequiresPermissions("mes:pro:workorder:edit")
@Log(title = "修改工单", businessType = BusinessType.UPDATE) @Log(title = "修改工单", businessType = BusinessType.UPDATE)
public AjaxResult subChangeWorkOrder(@RequestBody SplitOrderDTO splitOrderDTO){ public AjaxResult subChangeWorkOrder(@RequestBody SplitOrderDTO splitOrderDTO) {
return proOrderWorkorderService.subChangeWorkOrder(splitOrderDTO); return proOrderWorkorderService.subChangeWorkOrder(splitOrderDTO);
} }
/** /**
* 通过子工单获取批次信息list（父工单批次信息） * 通过子工单获取批次信息list（父工单批次信息）
* *
* @param proOrderWorkorder * @param proOrderWorkorder
* @return * @return
*/ */
@PostMapping("/getWorkBatchList") @PostMapping("/getWorkBatchList")
public AjaxResult getWorkBatchList(@RequestBody ProOrderWorkorder proOrderWorkorder){ public AjaxResult getWorkBatchList(@RequestBody ProOrderWorkorder proOrderWorkorder) {
return proOrderWorkorderService.getWorkBatchList(proOrderWorkorder); return proOrderWorkorderService.getWorkBatchList(proOrderWorkorder);
} }
/** /**
* 通过子工单信息查询订单信息和工单信息 * 通过子工单信息查询订单信息和工单信息
* *
* @param proOrderWorkorder * @param proOrderWorkorder
* @return * @return
*/ */
@PostMapping("/getOrderAndWorkInfo") @PostMapping("/getOrderAndWorkInfo")
public AjaxResult getOrderAndWorkInfo(@RequestBody ProOrderWorkorder proOrderWorkorder){ public AjaxResult getOrderAndWorkInfo(@RequestBody ProOrderWorkorder proOrderWorkorder) {
return proOrderWorkorderService.getOrderAndWorkInfo(proOrderWorkorder); return proOrderWorkorderService.getOrderAndWorkInfo(proOrderWorkorder);
} }
/** /**
* 查询生产工单列表 * 查询生产工单列表
*/ */
@RequiresPermissions("mes:pro:proworkorder:list") @RequiresPermissions("mes:pro:proworkorder:list")
@GetMapping("/list") @GetMapping("/list")
public TableDataInfo list(ProOrderWorkorder proOrderWorkorder) { public TableDataInfo list(ProOrderWorkorder proOrderWorkorder) {
startPage(); startPage();
List<ProOrderWorkorder> list = proOrderWorkorderService.selectProOrderWorkorderList(proOrderWorkorder); List<ProOrderWorkorder> list = proOrderWorkorderService.selectProOrderWorkorderList(proOrderWorkorder);
return getDataTable(list); return getDataTable(list);
} }
/** /**
* 导出生产工单列表 * 导出生产工单列表
*/ */
@RequiresPermissions("mes:pro:workorder:export") @RequiresPermissions("mes:pro:workorder:export")
@Log(title = "生产工单", businessType = BusinessType.EXPORT) @Log(title = "生产工单", businessType = BusinessType.EXPORT)
@PostMapping("/export") @PostMapping("/export")
public void export(HttpServletResponse response, ProOrderWorkorder proOrderWorkorder) { public void export(HttpServletResponse response, ProOrderWorkorder proOrderWorkorder) {
List<ProOrderWorkorder> list = proOrderWorkorderService.selectProOrderWorkorderList(proOrderWorkorder); List<ProOrderWorkorder> list = proOrderWorkorderService.selectProOrderWorkorderList(proOrderWorkorder);
ExcelUtil<ProOrderWorkorder> util = new ExcelUtil<ProOrderWorkorder>(ProOrderWorkorder.class); ExcelUtil<ProOrderWorkorder> util = new ExcelUtil<ProOrderWorkorder>(ProOrderWorkorder.class);
util.exportExcel(response, list, "生产工单数据"); util.exportExcel(response, list, "生产工单数据");
} }
/** /**
* 获取生产工单详细信息 * 获取生产工单详细信息
*/ */
@RequiresPermissions("mes:pro:workorder:query") @RequiresPermissions("mes:pro:workorder:query")
@GetMapping(value = "/{workorderId}") @GetMapping(value = "/{workorderId}")
public AjaxResult getInfo(@PathVariable("workorderId") String workorderId) { public AjaxResult getInfo(@PathVariable("workorderId") String workorderId) {
return success(proOrderWorkorderService.selectProOrderWorkorderByWorkorderId(workorderId)); return success(proOrderWorkorderService.selectProOrderWorkorderByWorkorderId(workorderId));
} }
/** /**
* 新增生产工单 * 新增生产工单
*/ */
@RequiresPermissions("mes:pro:workorder:add") @RequiresPermissions("mes:pro:workorder:add")
@Log(title = "生产工单", businessType = BusinessType.INSERT) @Log(title = "生产工单", businessType = BusinessType.INSERT)
@PostMapping @PostMapping
public AjaxResult add(@RequestBody ProOrderWorkorder proOrderWorkorder) { public AjaxResult add(@RequestBody ProOrderWorkorder proOrderWorkorder) {
return toAjax(proOrderWorkorderService.insertProOrderWorkorder(proOrderWorkorder)); return toAjax(proOrderWorkorderService.insertProOrderWorkorder(proOrderWorkorder));
} }
/** /**
* 修改生产工单 * 修改生产工单
*/ */
@RequiresPermissions("mes:pro:workorder:edit") @RequiresPermissions("mes:pro:workorder:edit")
@Log(title = "生产工单", businessType = BusinessType.UPDATE) @Log(title = "生产工单", businessType = BusinessType.UPDATE)
@PutMapping @PutMapping
public AjaxResult edit(@RequestBody ProOrderWorkorder proOrderWorkorder) { public AjaxResult edit(@RequestBody ProOrderWorkorder proOrderWorkorder) {
return toAjax(proOrderWorkorderService.updateProOrderWorkorder(proOrderWorkorder)); return toAjax(proOrderWorkorderService.updateProOrderWorkorder(proOrderWorkorder));
} }
/** /**
* 删除生产工单 * 删除生产工单
*/ */
@RequiresPermissions("mes:pro:workorder:remove") @RequiresPermissions("mes:pro:workorder:remove")
@Log(title = "生产工单", businessType = BusinessType.DELETE) @Log(title = "生产工单", businessType = BusinessType.DELETE)
@DeleteMapping("/{workorderIds}") @DeleteMapping("/{workorderIds}")
public AjaxResult remove(@PathVariable String[] workorderIds) { public AjaxResult remove(@PathVariable String[] workorderIds) {
//什么时候可以删除工单？TODO;没进入生产之前都可以？ //什么时候可以删除工单？TODO;没进入生产之前都可以？
// 根据工单的ids查工单的信息 // 根据工单的ids查工单的信息
List<ProOrderWorkorder> proOrderWorkorders = proOrderWorkorderService.selectProOrderWorkorderByWorkIds(workorderIds); List<ProOrderWorkorder> proOrderWorkorders = proOrderWorkorderService.selectProOrderWorkorderByWorkIds(workorderIds);
if (ObjectUtils.isEmpty(proOrderWorkorders)){ if (ObjectUtils.isEmpty(proOrderWorkorders)) {
throw new ServiceException("所查询的工单为空！！"); throw new ServiceException("所查询的工单为空！！");
} }
ArrayList<String> strings = new ArrayList<>(); ArrayList<String> strings = new ArrayList<>();
for (ProOrderWorkorder proOrderWorkorder : proOrderWorkorders) { for (ProOrderWorkorder proOrderWorkorder : proOrderWorkorders) {
String status = proOrderWorkorder.getStatus(); String status = proOrderWorkorder.getStatus();
if (status.equals("w0")){ if (status.equals("w0")) {
strings.add(proOrderWorkorder.getWorkorderId()); strings.add(proOrderWorkorder.getWorkorderId());
} else { } else {
throw new ServiceException("工单已经下发，不能删除！"); throw new ServiceException("工单已经下发，不能删除！");
} }
// 判断是否含有湿料计划 boolean值（存在为true，不存在为false） // 判断是否含有湿料计划 boolean值（存在为true，不存在为false）
if (proWetMaterialPlanDetailService.selectProWetMaterialPlanDetailByWorkId(proOrderWorkorder.getWorkorderId())) { if (proWetMaterialPlanDetailService.selectProWetMaterialPlanDetailByWorkId(proOrderWorkorder.getWorkorderId())) {
throw new ServiceException("工单已创建湿料计划，不能删除！"); throw new ServiceException("工单已创建湿料计划，不能删除！");
} }
} }
String[] orderWorkerIds= strings.toArray(new String[0]); String[] orderWorkerIds = strings.toArray(new String[0]);
return toAjax(proOrderWorkorderService.deleteProOrderWorkorderByWorkorderIds(orderWorkerIds)); return toAjax(proOrderWorkorderService.deleteProOrderWorkorderByWorkorderIds(orderWorkerIds));
} }
/** /**
* 下发生产工单 * 下发生产工单
*/ */
@RequiresPermissions("mes:pro:workorder:edit") @RequiresPermissions("mes:pro:workorder:edit")
@Log(title = "下发生产工单", businessType = BusinessType.OTHER) @Log(title = "下发生产工单", businessType = BusinessType.OTHER)
@PostMapping("/downWorkorder/{workorderIds}") @PostMapping("/downWorkorder/{workorderIds}")
public AjaxResult downWorkorder(@PathVariable String[] workorderIds) { public AjaxResult downWorkorder(@PathVariable String[] workorderIds) {
return toAjax(proOrderWorkorderService.downProOrderWorkorderByWorkorderIds(workorderIds)); return toAjax(proOrderWorkorderService.downProOrderWorkorderByWorkorderIds(workorderIds));
} }
} }

153
op-modules/op-plan/src/main/java/com/op/plan/service/impl/ProOrderWorkorderServiceImpl.java
Unescape Escape View File

@ -55,6 +55,7 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
private ProWetMaterialPlanDetailMapper proWetMaterialPlanDetailMapper; private ProWetMaterialPlanDetailMapper proWetMaterialPlanDetailMapper;
@Autowired @Autowired
private RemoteSapService remoteSapService; private RemoteSapService remoteSapService;
/** /**
* 查询生产工单 * 查询生产工单
* *
@ -81,14 +82,14 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
String prodLineName = ""; String prodLineName = "";
String equipCods = "'"; String equipCods = "'";
JSONArray codeArray = JSONArray.parseArray(workorder.getProdLineCode()); JSONArray codeArray = JSONArray.parseArray(workorder.getProdLineCode());
for(int c=0;c<codeArray.size();c++){ for (int c = 0; c < codeArray.size(); c++) {
equipCods += codeArray.getJSONArray(c).getString(1)+"','"; equipCods += codeArray.getJSONArray(c).getString(1) + "','";
} }
Map<String, CascaderDTO> equipMap = proOrderMapper.getEquipInfoByCodes(equipCods.substring(1));//设备字典 Map<String, CascaderDTO> equipMap = proOrderMapper.getEquipInfoByCodes(equipCods.substring(1));//设备字典
Set<String> keys = equipMap.keySet(); Set<String> keys = equipMap.keySet();
for (String key : keys) { for (String key : keys) {
prodLineName += equipMap.get(key).getLabel()+","; prodLineName += equipMap.get(key).getLabel() + ",";
} }
workorder.setProdLineName(prodLineName); workorder.setProdLineName(prodLineName);
// // 通过设备code查询出机型名称 // // 通过设备code查询出机型名称
@ -135,39 +136,39 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
@DS("#header.poolName") @DS("#header.poolName")
@Transactional(rollbackFor = Exception.class) @Transactional(rollbackFor = Exception.class)
public int deleteProOrderWorkorderByWorkorderIds(String[] workorderIds) { public int deleteProOrderWorkorderByWorkorderIds(String[] workorderIds) {
for(String workorderId:workorderIds){ for (String workorderId : workorderIds) {
//要删除的工单id们 //要删除的工单id们
List<String> delteIds = new ArrayList<>(); List<String> delteIds = new ArrayList<>();
delteIds.add(workorderId); delteIds.add(workorderId);
//最底级，用来还原订单拆分数量 //最底级，用来还原订单拆分数量
List<ProOrderWorkorder> workers = new ArrayList<>(); List<ProOrderWorkorder> workers = new ArrayList<>();
ProOrderWorkorder work = proOrderWorkorderMapper.selectProOrderWorkorderByWorkorderId(workorderId); ProOrderWorkorder work = proOrderWorkorderMapper.selectProOrderWorkorderByWorkorderId(workorderId);
if(work != null){ if (work != null) {
workers.add(work); workers.add(work);
ProOrderWorkorder bottomWork = work; ProOrderWorkorder bottomWork = work;
Boolean run = true; Boolean run = true;
while(run){ while (run) {
//上级 //上级
ProOrderWorkorder topworkers = proOrderWorkorderMapper.selectWorkOrderByCode(bottomWork.getParentOrder()); ProOrderWorkorder topworkers = proOrderWorkorderMapper.selectWorkOrderByCode(bottomWork.getParentOrder());
//有上级code //有上级code
if(topworkers!=null) { if (topworkers != null) {
workers.add(topworkers); workers.add(topworkers);
delteIds.add(topworkers.getWorkorderId()); delteIds.add(topworkers.getWorkorderId());
bottomWork.setParentOrder(topworkers.getParentOrder()); bottomWork.setParentOrder(topworkers.getParentOrder());
}else{ } else {
run = false; run = false;
} }
} }
} }
String[] workorderIds0 = (String[])delteIds.toArray(new String[delteIds.size()]); String[] workorderIds0 = (String[]) delteIds.toArray(new String[delteIds.size()]);
if(workorderIds0.length>0){ if (workorderIds0.length > 0) {
//删除工单(字母)pro_order_workorder //删除工单(字母)pro_order_workorder
proOrderWorkorderMapper.deleteProOrderWorkorderByWorkorderIds(workorderIds0); proOrderWorkorderMapper.deleteProOrderWorkorderByWorkorderIds(workorderIds0);
//删除批次pro_order_workorder_batch //删除批次pro_order_workorder_batch
proOrderWorkorderBatchMapper.deleteProOrderWorkorderBatchByWorkorderIds(workorderIds0); proOrderWorkorderBatchMapper.deleteProOrderWorkorderBatchByWorkorderIds(workorderIds0);
} }
if(!CollectionUtils.isEmpty(workers)){ if (!CollectionUtils.isEmpty(workers)) {
//释放订单拆分数pro_order //释放订单拆分数pro_order
proOrderMapper.updateOrderBatch(workers); proOrderMapper.updateOrderBatch(workers);
} }
@ -192,6 +193,7 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
/** /**
* 下发生产工单信息 * 下发生产工单信息
* (附：回传sap工单，获取工单对应的领料单) * (附：回传sap工单，获取工单对应的领料单)
*
* @param workorderIds 生产工单主键 * @param workorderIds 生产工单主键
* @return 结果 * @return 结果
*/ */
@ -201,12 +203,12 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
public int downProOrderWorkorderByWorkorderIds(String[] workorderIds) { public int downProOrderWorkorderByWorkorderIds(String[] workorderIds) {
List<ProOrderWorkorder> workorders = proOrderWorkorderMapper.getWorkOrderByIds(workorderIds); List<ProOrderWorkorder> workorders = proOrderWorkorderMapper.getWorkOrderByIds(workorderIds);
for(ProOrderWorkorder workorder:workorders){ for (ProOrderWorkorder workorder : workorders) {
//关联工艺 //关联工艺
if(StringUtils.isNotBlank(workorder.getRouteCode())){ if (StringUtils.isNotBlank(workorder.getRouteCode())) {
List<ProWorkorderProcessDetail> workDetails = proWorkorderProcessDetailMapper.getWorkOrderDetailsByRouteCode(workorder); List<ProWorkorderProcessDetail> workDetails = proWorkorderProcessDetailMapper.getWorkOrderDetailsByRouteCode(workorder);
if(!CollectionUtils.isEmpty(workDetails)){ if (!CollectionUtils.isEmpty(workDetails)) {
workDetails.forEach(str->{ workDetails.forEach(str -> {
str.setRecordId(IdUtils.fastSimpleUUID()); str.setRecordId(IdUtils.fastSimpleUUID());
str.setWorkorderId(workorder.getWorkorderId()); str.setWorkorderId(workorder.getWorkorderId());
str.setStatus("s0");//未执行 str.setStatus("s0");//未执行
@ -220,54 +222,54 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
} }
List<SapCreateOrder> sapList = null;//回传给sap的工单 List<SapCreateOrder> sapList = null;//回传给sap的工单
//如果是白坯生成备料单 //如果是白坯生成备料单
for(String workorderId:workorderIds){ for (String workorderId : workorderIds) {
ProOrderWorkorder whiteOrder = proOrderWorkorderMapper.selectProOrderWorkorderByWorkorderId(workorderId); ProOrderWorkorder whiteOrder = proOrderWorkorderMapper.selectProOrderWorkorderByWorkorderId(workorderId);
if(whiteOrder!=null&&"white".equals(whiteOrder.getProdType())){//是白坯订单，自主生成领料单； if (whiteOrder != null && "white".equals(whiteOrder.getProdType())) {//是白坯订单，自主生成领料单；
//备(领)料主单 //备(领)料主单
MesPrepareDTO mesPrepare = new MesPrepareDTO(); MesPrepareDTO mesPrepare = new MesPrepareDTO();
BeanUtils.copyBeanProp(mesPrepare,whiteOrder); BeanUtils.copyBeanProp(mesPrepare, whiteOrder);
mesPrepare.setPrepareId(whiteOrder.getWorkorderCode()+"L");//领料单号 mesPrepare.setPrepareId(whiteOrder.getWorkorderCode() + "L");//领料单号
mesPrepare.setWorkorderCode(whiteOrder.getWorkorderCode()); mesPrepare.setWorkorderCode(whiteOrder.getWorkorderCode());
mesPrepare.setCreateBy(SecurityUtils.getUsername()); mesPrepare.setCreateBy(SecurityUtils.getUsername());
mesPrepare.setCreateTime(DateUtils.getNowDate()); mesPrepare.setCreateTime(DateUtils.getNowDate());
mesPrepare.setStatus("L0");//待确认 mesPrepare.setStatus("L0");//待确认
proOrderWorkorderMapper.createPrepare(mesPrepare); proOrderWorkorderMapper.createPrepare(mesPrepare);
//备(领)料明细 //备(领)料明细
ProWetMaterialPlanDetail planDetail= proWetMaterialPlanDetailMapper.getWetInfo(workorderId); ProWetMaterialPlanDetail planDetail = proWetMaterialPlanDetailMapper.getWetInfo(workorderId);
List<MesPrepareDetailDTO> details = new ArrayList<>(); List<MesPrepareDetailDTO> details = new ArrayList<>();
MesPrepareDetailDTO detail = new MesPrepareDetailDTO(); MesPrepareDetailDTO detail = new MesPrepareDetailDTO();
detail.setCreateTime(DateUtils.getNowDate()); detail.setCreateTime(DateUtils.getNowDate());
detail.setCreateBy(SecurityUtils.getUsername()); detail.setCreateBy(SecurityUtils.getUsername());
detail.setRecordId(IdUtils.fastSimpleUUID()); detail.setRecordId(IdUtils.fastSimpleUUID());
if(planDetail != null){ if (planDetail != null) {
detail.setMaterailName(planDetail.getMaterialName()); detail.setMaterailName(planDetail.getMaterialName());
detail.setMaterialCode(planDetail.getMaterialCode()); detail.setMaterialCode(planDetail.getMaterialCode());
detail.setProductDate(planDetail.getProductDate()); detail.setProductDate(planDetail.getProductDate());
detail.setShiftId(planDetail.getShiftId()+""); detail.setShiftId(planDetail.getShiftId() + "");
detail.setProdType("white"); detail.setProdType("white");
detail.setFactoryCode(planDetail.getFactoryCode()); detail.setFactoryCode(planDetail.getFactoryCode());
} }
details.add(detail); details.add(detail);
proOrderWorkorderMapper.createPrepareDetails(details); proOrderWorkorderMapper.createPrepareDetails(details);
}else if(whiteOrder!=null){//成品的母工单回传sap } else if (whiteOrder != null) {//成品的母工单回传sap
sapList = new ArrayList<>(); sapList = new ArrayList<>();
SapCreateOrder sap = new SapCreateOrder(); SapCreateOrder sap = new SapCreateOrder();
sap.setWerks(whiteOrder.getFactoryCode());//工厂编码 sap.setWerks(whiteOrder.getFactoryCode());//工厂编码
sap.setAufpar(whiteOrder.getProdType());//订单类型 sap.setAufpar(whiteOrder.getProdType());//订单类型
sap.setMatnr(whiteOrder.getProductCode());//物料编号 sap.setMatnr(whiteOrder.getProductCode());//物料编号
sap.setQuantity(whiteOrder.getQuantitySplit()+"");//数量 sap.setQuantity(whiteOrder.getQuantitySplit() + "");//数量
sap.setDates(DateUtils.parseDateToStr("yyyy-MM-dd",whiteOrder.getProductDate()));//开始时间 sap.setDates(DateUtils.parseDateToStr("yyyy-MM-dd", whiteOrder.getProductDate()));//开始时间
sap.setDatee(DateUtils.parseDateToStr("yyyy-MM-dd",whiteOrder.getProductDate()));//完成时间 sap.setDatee(DateUtils.parseDateToStr("yyyy-MM-dd", whiteOrder.getProductDate()));//完成时间
sapList.add(sap); sapList.add(sap);
R<List<String>> r = remoteSapService.SapCreateOrder(sapList); R<List<String>> r = remoteSapService.SapCreateOrder(sapList);
logger.info("sap工单回传："+r.getMsg()); logger.info("sap工单回传：" + r.getMsg());
if(500==r.getCode()){ if (500 == r.getCode()) {
logger.error("sap工单回传："+r.getMsg()); logger.error("sap工单回传：" + r.getMsg());
return 0; return 0;
} }
List<String> returnCodes = r.getData(); List<String> returnCodes = r.getData();
if(!CollectionUtils.isEmpty(returnCodes)){ if (!CollectionUtils.isEmpty(returnCodes)) {
for(String sapCode:returnCodes){ for (String sapCode : returnCodes) {
ProOrderWorkorder oworkSap = new ProOrderWorkorder(); ProOrderWorkorder oworkSap = new ProOrderWorkorder();
oworkSap.setWorkorderCodeSap(sapCode); oworkSap.setWorkorderCodeSap(sapCode);
oworkSap.setWorkorderId(workorderId);//工单编码 oworkSap.setWorkorderId(workorderId);//工单编码
@ -282,7 +284,7 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
oworkSapParent.setUpdateTime(DateUtils.getNowDate()); oworkSapParent.setUpdateTime(DateUtils.getNowDate());
proOrderWorkorderMapper.updateWorkOrderCodeSap(oworkSapParent); proOrderWorkorderMapper.updateWorkOrderCodeSap(oworkSapParent);
logger.info("sap工单回传sap虚拟工单号："+sapCode); logger.info("sap工单回传sap虚拟工单号：" + sapCode);
} }
} }
@ -294,7 +296,7 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
return 1; return 1;
} }
// //获取最低级材料 // //获取最低级材料
// private void getLastChildren(List<BaseBomComponentDTO> all, List<BaseBomComponentDTO> allChildren , BaseBomComponentDTO bc) { // private void getLastChildren(List<BaseBomComponentDTO> all, List<BaseBomComponentDTO> allChildren , BaseBomComponentDTO bc) {
// List<BaseBomComponentDTO> cList = all.stream().filter(item -> item.getCumc().equals(bc.getComponent())) // List<BaseBomComponentDTO> cList = all.stream().filter(item -> item.getCumc().equals(bc.getComponent()))
// .collect(Collectors.toList()); // .collect(Collectors.toList());
@ -334,10 +336,10 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
// return bomdtos; // return bomdtos;
// } // }
//根据工单子单编码获取最顶级订单的母单 //根据工单子单编码获取最顶级订单的母单
private ProOrder getTopOrder(String workorderId){ private ProOrder getTopOrder(String workorderId) {
//pro_order_workorder //pro_order_workorder
ProOrder topOrder = proOrderWorkorderMapper.getOrderCodeById(workorderId); ProOrder topOrder = proOrderWorkorderMapper.getOrderCodeById(workorderId);
while(!"0".equals(topOrder.getParentOrder())&& StringUtils.isNotEmpty(topOrder.getParentOrder())){ while (!"0".equals(topOrder.getParentOrder()) && StringUtils.isNotEmpty(topOrder.getParentOrder())) {
//pro_order_workorder //pro_order_workorder
topOrder = proOrderWorkorderMapper.getOrderCodeById(topOrder.getParentOrder()); topOrder = proOrderWorkorderMapper.getOrderCodeById(topOrder.getParentOrder());
} }
@ -358,15 +360,15 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
while (run) { while (run) {
ProOrderWorkorder fatherWorkOrder = proOrderWorkorderMapper.selectWorkOrderByCode(proOrderWorkorder.getParentOrder()); ProOrderWorkorder fatherWorkOrder = proOrderWorkorderMapper.selectWorkOrderByCode(proOrderWorkorder.getParentOrder());
// 如果存在父工单 // 如果存在父工单
if (fatherWorkOrder != null ){ if (fatherWorkOrder != null) {
BeanUtils.copyProperties(fatherWorkOrder,proOrderWorkorder); BeanUtils.copyProperties(fatherWorkOrder, proOrderWorkorder);
}else { } else {
run = false; run = false;
} }
} }
// 通过母订单id查询母订单详情 // 通过母订单id查询母订单详情
ProOrder proOrder = proOrderMapper.selectProOrderById(proOrderWorkorder.getOrderId()); ProOrder proOrder = proOrderMapper.selectProOrderById(proOrderWorkorder.getOrderId());
if(proOrder != null){ if (proOrder != null) {
// 递归查询子订单 // 递归查询子订单
recursiveQueryChildOrder(proOrder); recursiveQueryChildOrder(proOrder);
} }
@ -374,8 +376,8 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
formatProOrderWorkorder(proOrderWorkorder); formatProOrderWorkorder(proOrderWorkorder);
Map orderAndWork = new HashMap(); Map orderAndWork = new HashMap();
orderAndWork.put("order",proOrder); orderAndWork.put("order", proOrder);
orderAndWork.put("workOrder",proOrderWorkorder); orderAndWork.put("workOrder", proOrderWorkorder);
return success(orderAndWork); return success(orderAndWork);
} }
@ -390,12 +392,12 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
@DS("#header.poolName") @DS("#header.poolName")
public AjaxResult getWorkBatchList(ProOrderWorkorder proOrderWorkorder) { public AjaxResult getWorkBatchList(ProOrderWorkorder proOrderWorkorder) {
boolean run = true; boolean run = true;
while (run){ while (run) {
ProOrderWorkorder fatherWorkOrder = proOrderWorkorderMapper.selectWorkOrderByCode(proOrderWorkorder.getParentOrder()); ProOrderWorkorder fatherWorkOrder = proOrderWorkorderMapper.selectWorkOrderByCode(proOrderWorkorder.getParentOrder());
// 如果存在父工单 // 如果存在父工单
if (fatherWorkOrder != null){ if (fatherWorkOrder != null) {
BeanUtils.copyProperties(fatherWorkOrder,proOrderWorkorder); BeanUtils.copyProperties(fatherWorkOrder, proOrderWorkorder);
}else { } else {
run = false; run = false;
} }
} }
@ -428,19 +430,19 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
// 用于循环 // 用于循环
ProOrderWorkorder childWorkOrder = new ProOrderWorkorder(); ProOrderWorkorder childWorkOrder = new ProOrderWorkorder();
BeanUtils.copyProperties(proWorkOrder,childWorkOrder); BeanUtils.copyProperties(proWorkOrder, childWorkOrder);
while (getworkOrder) { while (getworkOrder) {
// 通过parentOrder查询父工单信息 // 通过parentOrder查询父工单信息
ProOrderWorkorder fatherWorkOrder = proOrderWorkorderMapper.selectWorkOrderByCode(childWorkOrder.getParentOrder()); ProOrderWorkorder fatherWorkOrder = proOrderWorkorderMapper.selectWorkOrderByCode(childWorkOrder.getParentOrder());
if (fatherWorkOrder != null){ if (fatherWorkOrder != null) {
// 将重置对象 // 将重置对象
BeanUtils.copyProperties(fatherWorkOrder,childWorkOrder); BeanUtils.copyProperties(fatherWorkOrder, childWorkOrder);
// 将工单放入list // 将工单放入list
workOrderList.add(fatherWorkOrder); workOrderList.add(fatherWorkOrder);
// 将id放入 // 将id放入
ids.add(fatherWorkOrder.getWorkorderId()); ids.add(fatherWorkOrder.getWorkorderId());
}else { } else {
// 终止循环 // 终止循环
getworkOrder = false; getworkOrder = false;
} }
@ -459,22 +461,22 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
} }
} }
//校验各工序设备是否已选择 //校验各工序设备是否已选择
List<CascaderDTO> processes= proOrderMapper.getRouteProcess(splitOrderDTO.getRouteCode()); List<CascaderDTO> processes = proOrderMapper.getRouteProcess(splitOrderDTO.getRouteCode());
if(splitOrderDTO.getProdLineCodeArray().length == 0){ if (splitOrderDTO.getProdLineCodeArray().length == 0) {
checkout = false; checkout = false;
return error(500, "必须选择工单生产设备!"); return error(500, "必须选择工单生产设备!");
}else{ } else {
String codeArray = JSONArray.toJSONString(splitOrderDTO.getProdLineCodeArray()); String codeArray = JSONArray.toJSONString(splitOrderDTO.getProdLineCodeArray());
for(int i=0;i<processes.size();i++){ for (int i = 0; i < processes.size(); i++) {
if(codeArray.indexOf(processes.get(i).getValue())<0){ if (codeArray.indexOf(processes.get(i).getValue()) < 0) {
checkout = false; checkout = false;
return error(500, "所有有工序节点都必须选择生产设备!"); return error(500, "所有有工序节点都必须选择生产设备!");
} }
} }
String[][] array = splitOrderDTO.getProdLineCodeArray(); String[][] array = splitOrderDTO.getProdLineCodeArray();
for(int m=0;m<array.length;m++){ for (int m = 0; m < array.length; m++) {
if(array[m].length<2){ if (array[m].length < 2) {
checkout = false; checkout = false;
return error(500, "工序没有生产设备可选择，请维护工艺!"); return error(500, "工序没有生产设备可选择，请维护工艺!");
} }
@ -483,14 +485,14 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
splitOrderDTO.setProdLineCode(codeArray); splitOrderDTO.setProdLineCode(codeArray);
} }
if (checkout){ if (checkout) {
// 删除所有工单s下的批次信息 // 删除所有工单s下的批次信息
int i = proOrderWorkorderBatchMapper.deleteProOrderWorkorderBatchByWorkorderIds(workorderIds); int i = proOrderWorkorderBatchMapper.deleteProOrderWorkorderBatchByWorkorderIds(workorderIds);
// 删除湿料计划 // 删除湿料计划
proWetMaterialPlanDetailMapper.deleteProWetMaterialPlanDetailByWorkId(proWorkOrder.getWorkorderId()); proWetMaterialPlanDetailMapper.deleteProWetMaterialPlanDetailByWorkId(proWorkOrder.getWorkorderId());
// 创建订单信息，并将信息copy进去 // 创建订单信息，并将信息copy进去
ProOrder proOrder = new ProOrder(); ProOrder proOrder = new ProOrder();
BeanUtils.copyProperties(splitOrderDTO.getProduct(),proOrder); BeanUtils.copyProperties(splitOrderDTO.getProduct(), proOrder);
// 设置换算基数，用于获得换算值 // 设置换算基数，用于获得换算值
Long quantity = proOrder.getQuantity(); Long quantity = proOrder.getQuantity();
// 创建批次表通用对象 // 创建批次表通用对象
@ -505,7 +507,7 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
// 更新订单 // 更新订单
proOrder.setUpdateBy(SecurityContextHolder.getUserName()); proOrder.setUpdateBy(SecurityContextHolder.getUserName());
proOrder.setUpdateTime(DateUtils.getNowDate()); proOrder.setUpdateTime(DateUtils.getNowDate());
proOrder.setQuantitySplit(proOrder.getQuantitySplit()+Long.valueOf(proOrder.getAtrr1())); proOrder.setQuantitySplit(proOrder.getQuantitySplit() + Long.valueOf(proOrder.getAtrr1()));
proOrderMapper.updateProOrder(proOrder); proOrderMapper.updateProOrder(proOrder);
// 设置工单信息 // 设置工单信息
proOrderWorkorder.setUpdateBy(SecurityContextHolder.getUserName()); proOrderWorkorder.setUpdateBy(SecurityContextHolder.getUserName());
@ -513,16 +515,16 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
// 拆分数量 // 拆分数量
proOrderWorkorder.setQuantitySplit(Long.valueOf(proOrder.getAtrr1())); proOrderWorkorder.setQuantitySplit(Long.valueOf(proOrder.getAtrr1()));
// 2.将工单信息更新至数据库 // 2.将工单信息更新至数据库
if (splitOrderDTO.getProdLineCode() != null){ if (splitOrderDTO.getProdLineCode() != null) {
proOrderWorkorder.setProdLineCode(splitOrderDTO.getProdLineCode()); proOrderWorkorder.setProdLineCode(splitOrderDTO.getProdLineCode());
} }
if (splitOrderDTO.getProductDate() != null){ if (splitOrderDTO.getProductDate() != null) {
proOrderWorkorder.setProductDate(splitOrderDTO.getProductDate()); proOrderWorkorder.setProductDate(splitOrderDTO.getProductDate());
} }
if (splitOrderDTO.getShiftId() != null){ if (splitOrderDTO.getShiftId() != null) {
proOrderWorkorder.setShiftId(splitOrderDTO.getShiftId()); proOrderWorkorder.setShiftId(splitOrderDTO.getShiftId());
} }
if (splitOrderDTO.getRouteCode() != null){ if (splitOrderDTO.getRouteCode() != null) {
proOrderWorkorder.setRouteCode(splitOrderDTO.getRouteCode()); proOrderWorkorder.setRouteCode(splitOrderDTO.getRouteCode());
} }
// 白坯工单返修-车数 // 白坯工单返修-车数
@ -545,7 +547,7 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
// 生成批次号 // 生成批次号
workBatch.setBatchCode(batch.getBatchCode()); workBatch.setBatchCode(batch.getBatchCode());
// 生成批次数量 // 生成批次数量
workBatch.setBatchQuantity(batch.getBatchQuantity()*conver); workBatch.setBatchQuantity(batch.getBatchQuantity() * conver);
// 更新至数据库 // 更新至数据库
proOrderWorkorderBatchMapper.insertProOrderWorkorderBatch(workBatch); proOrderWorkorderBatchMapper.insertProOrderWorkorderBatch(workBatch);
@ -555,7 +557,7 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
} }
// 如果存在子节点 // 如果存在子节点
if (proOrder.getChildren().size()>0){ if (proOrder.getChildren().size() > 0) {
ProOrderDTO newProOrder = (ProOrderDTO) proOrder.getChildren().get(0); ProOrderDTO newProOrder = (ProOrderDTO) proOrder.getChildren().get(0);
// 更新换算值 // 更新换算值
conver = (newProOrder.getQuantity() / quantity); conver = (newProOrder.getQuantity() / quantity);
@ -584,11 +586,8 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
public AjaxResult checkWorkOrder(String id) { public AjaxResult checkWorkOrder(String id) {
// 判断工单状态1.活动不可以2.已报工不可以 // 判断工单状态1.活动不可以2.已报工不可以
ProOrderWorkorder proOrderWorkorder = proOrderWorkorderMapper.selectProOrderWorkorderByWorkorderId(id); ProOrderWorkorder proOrderWorkorder = proOrderWorkorderMapper.selectProOrderWorkorderByWorkorderId(id);
if (proOrderWorkorder.getStatus().equals("w2")) { if (!(proOrderWorkorder.getStatus().equals("w0") ||proOrderWorkorder.getStatus().equals("w1"))) {
return error("工单处于活动状态！不可更改！"); return error("工单已生产，不可变更！");
}
if (proOrderWorkorder.getStatus().equals("w3")) {
return error("工单处于报工状态！不可更改！");
} }
return success(); return success();
} }
@ -596,6 +595,7 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
/** /**
* 根据workerIds查询ProOrderWorkorder * 根据workerIds查询ProOrderWorkorder
*
* @param workerIds * @param workerIds
* @return * @return
*/ */
@ -607,6 +607,7 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
/** /**
* 通过子工单code查询并返回所有级联工单 * 通过子工单code查询并返回所有级联工单
*
* @param code * @param code
* @return * @return
*/ */
@ -637,7 +638,7 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
// 反转list // 反转list
List<ProOrderWorkorder> reversalWorkOrderList = new ArrayList<>(); List<ProOrderWorkorder> reversalWorkOrderList = new ArrayList<>();
for (int i = proOrderWorkorderList.size()-1; i >= 0; i--) { for (int i = proOrderWorkorderList.size() - 1; i >= 0; i--) {
reversalWorkOrderList.add(proOrderWorkorderList.get(i)); reversalWorkOrderList.add(proOrderWorkorderList.get(i));
} }
@ -655,22 +656,22 @@ public class ProOrderWorkorderServiceImpl implements IProOrderWorkorderService {
JSONArray codeArray = JSONArray.parseArray(proOrderWorkorder.getProdLineCode()); JSONArray codeArray = JSONArray.parseArray(proOrderWorkorder.getProdLineCode());
String[][] array = new String[codeArray.size()][2]; String[][] array = new String[codeArray.size()][2];
for(int c1=0;c1<codeArray.size();c1++){ for (int c1 = 0; c1 < codeArray.size(); c1++) {
for(int c2=0;c2<2;c2++){ for (int c2 = 0; c2 < 2; c2++) {
array[c1][c2] = codeArray.getJSONArray(c1).getString(c2); array[c1][c2] = codeArray.getJSONArray(c1).getString(c2);
} }
} }
proOrderWorkorder.setProdLineCodeArray(array); proOrderWorkorder.setProdLineCodeArray(array);
String prodLineName = ""; String prodLineName = "";
String equipCods = "'"; String equipCods = "'";
for(int c=0;c<codeArray.size();c++){ for (int c = 0; c < codeArray.size(); c++) {
equipCods += codeArray.getJSONArray(c).getString(1)+"','"; equipCods += codeArray.getJSONArray(c).getString(1) + "','";
} }
Map<String, CascaderDTO> equipMap = proOrderMapper.getEquipInfoByCodes(equipCods.substring(1));//设备字典 Map<String, CascaderDTO> equipMap = proOrderMapper.getEquipInfoByCodes(equipCods.substring(1));//设备字典
Set<String> keys = equipMap.keySet(); Set<String> keys = equipMap.keySet();
for (String key : keys) { for (String key : keys) {
prodLineName += equipMap.get(key).getLabel()+","; prodLineName += equipMap.get(key).getLabel() + ",";
} }
proOrderWorkorder.setProdLineCode(prodLineName); proOrderWorkorder.setProdLineCode(prodLineName);

1
op-modules/op-plan/src/main/resources/mapper/plan/ProOrderMapper.xml
Unescape Escape View File

@ -64,6 +64,7 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
<if test="planDateStart != null "> and CONVERT(varchar(10),plan_pro_date, 120) >= '${planDateStart}'</if> <if test="planDateStart != null "> and CONVERT(varchar(10),plan_pro_date, 120) >= '${planDateStart}'</if>
<if test="planDateEnd != null "> and '${planDateEnd}%' >= CONVERT(varchar(10),plan_pro_date, 120)</if> <if test="planDateEnd != null "> and '${planDateEnd}%' >= CONVERT(varchar(10),plan_pro_date, 120)</if>
</where> </where>
and prod_type != 'white'
ORDER BY plan_pro_date DESC ORDER BY plan_pro_date DESC
</select> </select>

Write Preview
Loading…
Cancel
Save