xiaoning
/
gj_erp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1.排产临时提交

Browse Source
master
董哲奇 1 year ago
parent 65b67912b7
commit 039f774a9a
17 changed files with 243 additions and 175 deletions
Show Stats Download Patch File Download Diff File

123
src/main/java/com/dsic/gj_erp/pc/Constant.java
Unescape View File

@ -1,39 +1,10 @@
package com.dsic.gj_erp.pc;
import com.dsic.gj_erp.pc.dto.sb.设备01上料;
import com.dsic.gj_erp.pc.dto.sb.设备02抛丸;
import com.dsic.gj_erp.pc.dto.sb.设备05切割;
import com.dsic.gj_erp.pc.dto.设备;
import com.google.common.collect.ImmutableMap;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.Map;
public interface Constant {
//手动配置,后期可根据设备进行计算(计算方式根据所有设备的产能合并后的结果,设备维护时不计入产能,休息日产能默认为0)
// ImmutableMap<工序, Double> 工序产能 = ImmutableMap.<工序, Double>builder()
// .put(工序.上料, 200.0)
// .put(工序.抛丸, 200.0)
// .put(工序.理料, 200.0)
// .put(工序.划线, 200.0)
//
// .put(工序.一跨龙门切割, 200.0)
// .put(工序.一跨数控切割, 200.0)
// .put(工序.二跨数控切割, 200.0)
// .put(工序.三跨数控切割, 200.0)
// .put(工序.三跨平铁切割, 200.0)
// .put(工序.手工切割, 200.0)
//
// .put(工序.坡口, 200.0)
// .put(工序.型材面板, 200.0)
// .put(工序.曲加工, 200.0)
// .put(工序.平铁打磨, 200.0)
// .put(工序.手工打磨, 200.0)
// .put(工序.预配盘, 200.0)
// .put(工序.光电结束, 200.0)
// .build();
//相对于钢料需求期
ImmutableMap<工序, Integer> 工序CD = ImmutableMap.<工序, Integer>builder()
.put(工序.上料, -10)
@ -50,87 +21,29 @@ public interface Constant {
.put(工序.配送, 0)
.build();
//来源数据库
// ImmutableMap<String, 工序> 套料图工序对应关系 = ImmutableMap.of();
// .<String, 工序>builder()
//二跨超长超宽曲板小组
// .put("10101019", 工序.上料)
// .put("10101020", 工序.抛丸)
// .put("10101021", 工序.理料)
// .put("10101004", 工序.二跨数控切割)
// .put("10101008", 工序.坡口)
// .put("10101018", 工序.曲加工)
//二跨超长超宽曲板中大组
// .put("10111019", 工序.上料)
// .put("10111020", 工序.抛丸)
// .put("10111021", 工序.理料)
// .put("10111004", 工序.二跨数控切割)
// .put("10111008", 工序.坡口)
// .put("10111018", 工序.曲加工)
// .build();
//来源数据库
ImmutableMap<工序, Map<String, 设备>> 工序设备对应关系 = ImmutableMap.<工序, Map<String, 设备>>builder()
//二跨超长超宽曲板小组
.put(工序.上料, ImmutableMap.<String, 设备>builder()
.put(设备产能.上料01.设备编号,new 设备01上料(设备产能.上料01))
.build())
.put(工序.抛丸, ImmutableMap.<String, 设备>builder()
.put(设备产能.抛丸01.设备编号,new 设备02抛丸(设备产能.抛丸01))
.build())
.put(工序.理料, ImmutableMap.<String, 设备>builder()
.put(设备产能.抛丸01.设备编号,new 设备02抛丸(设备产能.抛丸01))
.build())
.put(工序.划线, ImmutableMap.<String, 设备>builder()
.put(设备产能.划线01.设备编号,new 设备02抛丸(设备产能.划线01))
.build())
.put(工序.切割, ImmutableMap.<String, 设备>builder()
.put(设备产能.龙门01.设备编号,new 设备05切割(设备产能.龙门01))
.put(设备产能.火焰01.设备编号,new 设备05切割(设备产能.火焰01))
.put(设备产能.数控01.设备编号,new 设备05切割(设备产能.数控01))
.put(设备产能.火焰03.设备编号,new 设备05切割(设备产能.火焰03))
.put(设备产能.数控03.设备编号,new 设备05切割(设备产能.数控03))
.put(设备产能.龙门03.设备编号,new 设备05切割(设备产能.龙门03))
.put(设备产能.火焰02.设备编号,new 设备05切割(设备产能.火焰02))
.put(设备产能.数控02.设备编号,new 设备05切割(设备产能.数控02))
.put(设备产能.龙门02.设备编号,new 设备05切割(设备产能.龙门02))
.build())
.put(工序.坡口, ImmutableMap.<String, 设备>builder()
.put("",new 设备02抛丸(设备产能.坡口01))
.build())
.put(工序.型材面板, ImmutableMap.<String, 设备>builder()
.put("",new 设备02抛丸(设备产能.型材01))
.build())
.put(工序.曲加工, ImmutableMap.<String, 设备>builder()
.put("",new 设备02抛丸(设备产能.曲加工01))
.build())
.put(工序.打磨, ImmutableMap.<String, 设备>builder()
.put("",new 设备02抛丸(设备产能.打磨01))
.build())
.build();
@Getter
@AllArgsConstructor
enum 设备产能{
上料01(工序.上料,"","",0,0,200.0,200.0,400),
抛丸01(工序.抛丸,"","",0,0,240.0,286.0,526.0),
理料01(工序.理料,"","",0,0,240.0,286.0,526.0),
划线01(工序.划线,"","",0,0,240.0,286.0,526.0),
上料01(工序.上料,"上料01","",0,0,200.0,200.0,400),
抛丸01(工序.抛丸,"抛丸01","",0,0,240.0,286.0,526.0),
理料01(工序.理料,"理料01","",0,0,240.0,286.0,526.0),
划线01(工序.划线,"划线01","",0,0,240.0,286.0,526.0),
龙门01(工序.切割,"","",2.4,3.6,9.6,15.6,25.2),
火焰01(工序.切割,"","",0.3,11.5,2.0,0,2.0),
数控01(工序.切割,"","",1.5,3.0,0,8.5,8.5),
火焰03(工序.切割,"","",0.3,11.5,2.0,0,2.0),
数控03(工序.切割,"","",2.0,4.2,0,14.0,14.0),
龙门03(工序.切割,"","",1.6,3.2,7.2,11.2,18.4),
龙门01(工序.切割,"龙门01","",2.4,3.6,9.6,15.6,25.2),
火焰01(工序.切割,"火焰01","",0.3,11.5,2.0,0,2.0),
数控01(工序.切割,"数控01","",1.5,3.0,0,8.5,8.5),
火焰03(工序.切割,"火焰03","",0.3,11.5,2.0,0,2.0),
数控03(工序.切割,"数控03","",2.0,4.2,0,14.0,14.0),
龙门03(工序.切割,"龙门03","",1.6,3.2,7.2,11.2,18.4),
火焰02(工序.切割,"","",0.3,11.5,3.9,0,3.9),
数控02(工序.切割,"","",1.4,3.0,0,18.2,18.2),
龙门02(工序.切割,"","",2.0,3.0,1.0,13.0,13.0),
火焰02(工序.切割,"火焰02","",0.3,11.5,3.9,0,3.9),
数控02(工序.切割,"数控02","",1.4,3.0,0,18.2,18.2),
龙门02(工序.切割,"龙门02","",2.0,3.0,1.0,13.0,13.0),
坡口01(工序.坡口,"","",2.0,3.0,1.0,13.0,13.0),
型材01(工序.型材面板,"","",2.0,3.0,1.0,13.0,13.0),
曲加工01(工序.曲加工,"","",2.0,3.0,1.0,13.0,13.0),
打磨01(工序.打磨,"","",2.0,3.0,1.0,13.0,13.0),
坡口01(工序.坡口,"坡口01","",2.0,3.0,1.0,13.0,13.0),
型材01(工序.型材面板,"型材01","",2.0,3.0,1.0,13.0,13.0),
曲加工01(工序.曲加工,"曲加工01","",2.0,3.0,1.0,13.0,13.0),
打磨01(工序.打磨,"打磨01","",2.0,3.0,1.0,13.0,13.0),
;
public 工序 _工序;
public String 设备编号;
@ -167,7 +80,7 @@ public interface Constant {
//通过code获取工序
public static 工序 getGxByCode(String code) {
for (工序 gx : 工序.values()) {
if (gx.getCode().equals(code)) {
if (gx.getCode().contains(code)) {
return gx;
}
}

114
src/main/java/com/dsic/gj_erp/pc/DataFactory.java
Unescape View File

@ -7,11 +7,13 @@ import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.dsic.gj_erp.bean.SpringContextHolder;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.bean.jcsj.EmGcrl;
import com.dsic.gj_erp.bean.jcsj.EmSbcnp;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.bean.jhgk.DmSygdxq;
import com.dsic.gj_erp.pc.dto.gx.*;
import com.dsic.gj_erp.pc.dto.sb.*;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.排产结果;
import com.dsic.gj_erp.pc.dto.设备;
@ -20,6 +22,7 @@ import com.dsic.gj_erp.service.jcsj.EmGcrlService;
import com.dsic.gj_erp.service.jcsj.EmSbcnpService;
import com.dsic.gj_erp.service.jcsj.EmSbjbbService;
import com.dsic.gj_erp.service.jhgk.DmSygdxqService;
import com.google.common.collect.ImmutableMap;
import java.io.FileOutputStream;
import java.io.OutputStream;
@ -27,6 +30,7 @@ import java.util.*;
import java.util.stream.Collectors;
import static com.dsic.gj_erp.pc.Constant.工序CD;
import static com.dsic.gj_erp.pc.Manager.排产;
import static com.dsic.gj_erp.pc.Manager.*;
public class DataFactory {
@ -34,15 +38,17 @@ public class DataFactory {
public static void 排产(){
套料图所占工序的资源.clear();
List<排产结果> list = 排产.list;
List<DmBom> 强占记录=new ArrayList<>();
list.clear();
List<DmSygdxq> xqWithBom = getBean(DmSygdxqService.class).getXqWithBom(from, to);
xqWithBom.forEach(xq->{
xq.getBomList().forEach(bom->{
List<DmSygdxq> 按需求日期排序的钢料需求 = getBean(DmSygdxqService.class).getXqWithBom(from, to);
按需求日期排序的钢料需求.forEach(钢料需求->{
钢料需求.getBomList().forEach(bom->{
Arrays.stream(Constant.工序.values()).forEach(gx->{
if (StrUtil.isEmpty(gx.getCode()))return;
//todo 由于工序code存在多个值的情况,这里需要抽象套料图工序,修改后可支持多线程运算
if (ObjUtil.isNotEmpty(套料图工序对应关系.get(bom.getKw()+bom.getZl()+"_"+gx.getCode()))){
Integer cd = 工序CD.get(gx);
DateTime parse = DateUtil.parse(xq.getXzglxq(), "yyyy/MM/dd");
DateTime parse = DateUtil.parse(钢料需求.getXzglxq(), "yyyy/MM/dd");
DateTime dateTime = DateUtil.offsetDay(parse, cd);
资源 _资源 = 提取资源(dateTime);
//除切割工序外默认需求数量都是1
@ -65,8 +71,8 @@ public class DataFactory {
_设备.ifPresent(tmp->{
bom.set所在设备(tmp);
tmp.占用设备(bom.getTzbh(),需求数量);
final工序产能.占用资源(bom.getTzbh(), 需求数量);
bom.set所在资源(it);
final工序产能.占用资源(bom.getTzbh(), 需求数量);
套料图所占工序的资源.put(bom.getTzbh(),it);
});
}
@ -74,13 +80,13 @@ public class DataFactory {
//没有可用资源是全局搜索可用资源,进行排产
if (bom.get所在设备()==null){
Optional<资源> 可用资源 = 搜索可用资源(gx, 需求数量);
Optional<资源> 可用资源 = 搜索可用资源(gx, DateUtil.parse(from,"yyyy/MM/dd"), parse,需求数量);
可用资源.ifPresent(tmp资源->{
工序产能 _工序产能 = tmp资源.get工序产能MAP().get(gx);
Optional<设备> _设备 = _工序产能.获取可占用设备(0);
_设备.ifPresent(tmp->{
bom.set所在设备(tmp);
tmp.占用设备(bom.getTzbh(),需求数量);
bom.set所在设备(tmp);
_工序产能.占用资源(bom.getTzbh(), 需求数量);
bom.set所在资源(tmp资源);
套料图所占工序的资源.put(bom.getTzbh(),tmp资源);
@ -88,11 +94,12 @@ public class DataFactory {
});
}
//没有可用资源放入月末,待手工调整
//没有可用资源放入月末(强占),待手工调整
if (bom.get所在设备()==null){
资源 tmp资源 = 提取资源(DateUtil.endOfMonth(DateUtil.parse(xq.getXzglxq(), "yyyy/MM/dd")));
强占记录.add(bom);
资源 tmp资源 = 提取资源(DateUtil.endOfMonth(DateUtil.parse(钢料需求.getXzglxq(), "yyyy/MM/dd")));
工序产能 _工序产能 = tmp资源.get工序产能MAP().get(gx);
Optional<设备> _设备 = _工序产能.获取可占用设备(0);
Optional<设备> _设备 = _工序产能.get设备().values().stream().findAny();
bom.set所在设备(_设备.get());
bom.set所在资源(tmp资源);
_工序产能.占用资源(bom.getTzbh(),0);
@ -102,13 +109,31 @@ public class DataFactory {
});
});
});
System.out.println(111);
//========调试打印===========
资源池.forEach((day,item)->{
System.out.println("====打印资源===");
System.out.println(day);
Map<Constant.工序, 工序产能> 工序产能MAP = item.get工序产能MAP();
工序产能MAP.forEach((工序,工序产能)->{
if (工序产能.get资源占用图纸表().size()>0){
System.out.println("工序:"+工序);
if ("2024/06/03".equals(day)){
System.out.println(工序产能.get资源占用图纸表());
}
System.out.println("工序产能:"+工序产能.get资源占用图纸表().size());
}
});
System.out.println("====打印资源完成===");
});
System.out.println(强占记录.size());
//========调试打印结束===========
}
public static Optional<资源> 搜索可用资源(Constant.工序 工序, double 需求数量){
public static Optional<资源> 搜索可用资源(Constant.工序 工序,Date 搜索起始日期,Date 搜索截止日期, double 需求数量){
return 资源池.values().stream().filter(资源->{
工序产能 工序产能 = 资源.get工序产能MAP().get(工序);
return 工序产能.判断是否可以占用(需求数量);
Date 资源日期=DateUtil.parse(资源.getDate(),"yyyy/MM/dd");
return 工序产能.判断是否可以占用(需求数量)&&资源日期.after(搜索起始日期)&&资源日期.before(搜索截止日期);
}).findFirst();
}
@ -122,37 +147,73 @@ public class DataFactory {
public static void 创建产能资源池(){
资源池.clear();
Map<Constant.工序, 工序产能> map=new HashMap<>();
Arrays.stream(Constant.工序.values()).forEach(item->{
if (StrUtil.isNotEmpty(item.getCode())){
map.put(item,工序产能工厂(item));
}
});
工厂日历.stream().filter(item -> "1".equals(item.getXxr()))
.forEach(item -> 资源池.put(item.getGl(),资源.of(item.getGl(), map)));
.forEach(item -> {
Map<Constant.工序, 工序产能> map=new HashMap<>();
Arrays.stream(Constant.工序.values()).forEach(_item->{
if (StrUtil.isNotEmpty(_item.getCode())){
map.put(_item,工序产能工厂(_item));
}
});
资源池.put(item.getGl(),资源.of(item.getGl(), map));
});
}
public static 工序产能 工序产能工厂(Constant.工序 _工序){
Map<String, 设备> _设备 = Constant.工序设备对应关系.get(_工序);
Map<String,设备> _设备=null;
switch (_工序){
case 上料:
_设备= ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.上料01.设备编号,new 设备01上料(Constant.设备产能.上料01))
.build();
return new 工序01上料(_设备);
case 抛丸:
_设备=ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.抛丸01.设备编号,new 设备02抛丸(Constant.设备产能.抛丸01))
.build();
return new 工序02抛丸(_设备);
case 理料:
_设备=ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.理料01.设备编号,new 设备03理料(Constant.设备产能.理料01))
.build();
return new 工序03理料(_设备);
case 划线:
_设备=ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.划线01.设备编号,new 设备04划线(Constant.设备产能.划线01))
.build();
return new 工序04划线(_设备);
case 切割:
_设备=ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.龙门01.设备编号,new 设备05切割(Constant.设备产能.龙门01))
.put(Constant.设备产能.火焰01.设备编号,new 设备05切割(Constant.设备产能.火焰01))
.put(Constant.设备产能.数控01.设备编号,new 设备05切割(Constant.设备产能.数控01))
.put(Constant.设备产能.火焰03.设备编号,new 设备05切割(Constant.设备产能.火焰03))
.put(Constant.设备产能.数控03.设备编号,new 设备05切割(Constant.设备产能.数控03))
.put(Constant.设备产能.龙门03.设备编号,new 设备05切割(Constant.设备产能.龙门03))
.put(Constant.设备产能.火焰02.设备编号,new 设备05切割(Constant.设备产能.火焰02))
.put(Constant.设备产能.数控02.设备编号,new 设备05切割(Constant.设备产能.数控02))
.put(Constant.设备产能.龙门02.设备编号,new 设备05切割(Constant.设备产能.龙门02))
.build();
return new 工序05切割(_设备);
case 坡口:
_设备=ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.坡口01.设备编号,new 设备07坡口(Constant.设备产能.坡口01))
.build();
return new 工序07坡口(_设备);
case 型材面板:
_设备=ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.型材01.设备编号,new 设备10型材(Constant.设备产能.型材01))
.build();
return new 工序10型材(_设备);
case 曲加工:
_设备=ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.曲加工01.设备编号,new 设备08曲面(Constant.设备产能.曲加工01))
.build();
return new 工序08曲面(_设备);
case 打磨:
_设备=ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.打磨01.设备编号,new 设备09打磨(Constant.设备产能.打磨01))
.build();
return new 工序09打磨(_设备);
// case 预配盘:
// return new 工序01上料(_工序,_设备);
@ -187,15 +248,6 @@ public class DataFactory {
设备列表.addAll(deviceList);
}
public static void 加载工序设备对应关系(){
工序设备对应关系.clear();
Arrays.stream(Constant.工序.values()).forEach(gx->{
if (StrUtil.isNotEmpty(gx.getCode())){
工序设备对应关系.putIfAbsent(gx, 设备列表.stream().filter(d->d.getGx().equals(gx.getCode())).collect(Collectors.toList()));
}
});
}
public static void 输出排产结果到EXCEL(OutputStream stream){
}

6
src/main/java/com/dsic/gj_erp/pc/Manager.java
Unescape View File

@ -2,9 +2,11 @@ package com.dsic.gj_erp.pc;
import com.dsic.gj_erp.bean.jcsj.EmGcrl;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.dto.设备;
import com.dsic.gj_erp.pc.dto.资源;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@ -14,13 +16,13 @@ public class Manager {
public static String to;
public static 排产 排产;
public static final List<EmGcrl> 工厂日历=new ArrayList<>();
public static final Map<String,资源> 资源池= new ConcurrentHashMap<>();
public static final Map<String,资源> 资源池= new LinkedHashMap<>();
//key=tlth+"_"+工序名称
public static final Map<String,资源> 套料图所占工序的资源= new ConcurrentHashMap<>();
public static final Map<String, Constant.工序> 套料图工序对应关系 = new ConcurrentHashMap<>();
public static final List<EmSbjbb> 设备列表= new ArrayList<>();
//实时加载
public static final Map<Constant.工序, List<EmSbjbb>> 工序设备对应关系 = new ConcurrentHashMap<>();
public static Map<Constant.工序, Map<String, 设备>> 工序设备对应关系;
private Manager(){}
}

11
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序01上料.java
Unescape View File

@ -16,6 +16,17 @@ public class 工序01上料 extends 工序产能 {
super(Constant.工序.上料,_设备);
}
@Override
public void 计算工作量() {
this.产能=0;
if (this.白班时长>0){
this.产能+=this.白班时长*Constant.设备产能.上料01.get白班设备产能()/7.0;
}
if (this.二班时长>0){
this.产能+=this.二班时长*Constant.设备产能.上料01.get二班设备产能()/7.0;
}
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(1.0);

11
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序02抛丸.java
Unescape View File

@ -15,6 +15,17 @@ public class 工序02抛丸 extends 工序产能 {
super(Constant.工序.抛丸,_设备);
}
@Override
public void 计算工作量() {
this.产能=0;
if (this.白班时长>0){
this.产能+=this.白班时长*Constant.设备产能.抛丸01.get白班设备产能()/7.0;
}
if (this.二班时长>0){
this.产能+=this.二班时长*Constant.设备产能.抛丸01.get二班设备产能()/7.0;
}
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(1.0);

11
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序03理料.java
Unescape View File

@ -15,6 +15,17 @@ public class 工序03理料 extends 工序产能 {
super(Constant.工序.理料,_设备);
}
@Override
public void 计算工作量() {
this.产能=0;
if (this.白班时长>0){
this.产能+=this.白班时长*Constant.设备产能.理料01.get白班设备产能()/7.0;
}
if (this.二班时长>0){
this.产能+=this.二班时长*Constant.设备产能.理料01.get二班设备产能()/7.0;
}
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);

12
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序04划线.java
Unescape View File

@ -1,6 +1,5 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
@ -17,6 +16,17 @@ public class 工序04划线 extends 工序产能 {
super(Constant.工序.划线,_设备);
}
@Override
public void 计算工作量() {
this.产能=0;
if (this.白班时长>0){
this.产能+=this.白班时长*Constant.设备产能.划线01.get白班设备产能()/7.0;
}
if (this.二班时长>0){
this.产能+=this.二班时长*Constant.设备产能.划线01.get二班设备产能()/7.0;
}
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);

10
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序05切割.java
Unescape View File

@ -1,6 +1,5 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
@ -16,6 +15,15 @@ public class 工序05切割 extends 工序产能 {
super(Constant.工序.切割,_设备);
}
@Override
public void 计算工作量() {
this.产能=0;
this.设备.values().forEach(设备->{
设备.修正工作量(this.白班时长,this.二班时长);
this.产能+=设备.get产能();
});
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);

12
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序07坡口.java
Unescape View File

@ -1,6 +1,5 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
@ -16,6 +15,17 @@ public class 工序07坡口 extends 工序产能 {
super(Constant.工序.坡口,_设备);
}
@Override
public void 计算工作量() {
this.产能=0;
if (this.白班时长>0){
this.产能+=this.白班时长*Constant.设备产能.坡口01.get白班设备产能()/7.0;
}
if (this.二班时长>0){
this.产能+=this.二班时长*Constant.设备产能.坡口01.get二班设备产能()/7.0;
}
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);

12
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序08曲面.java
Unescape View File

@ -1,6 +1,5 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
@ -16,6 +15,17 @@ public class 工序08曲面 extends 工序产能 {
super(Constant.工序.曲加工,_设备);
}
@Override
public void 计算工作量() {
this.产能=0;
if (this.白班时长>0){
this.产能+=this.白班时长*Constant.设备产能.曲加工01.get白班设备产能()/7.0;
}
if (this.二班时长>0){
this.产能+=this.二班时长*Constant.设备产能.曲加工01.get二班设备产能()/7.0;
}
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);

12
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序09打磨.java
Unescape View File

@ -1,6 +1,5 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
@ -16,6 +15,17 @@ public class 工序09打磨 extends 工序产能 {
super(Constant.工序.打磨,_设备);
}
@Override
public void 计算工作量() {
this.产能=0;
if (this.白班时长>0){
this.产能+=this.白班时长*Constant.设备产能.打磨01.get白班设备产能()/7.0;
}
if (this.二班时长>0){
this.产能+=this.二班时长*Constant.设备产能.打磨01.get二班设备产能()/7.0;
}
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);

12
src/main/java/com/dsic/gj_erp/pc/dto/gx/工序10型材.java
Unescape View File

@ -1,6 +1,5 @@
package com.dsic.gj_erp.pc.dto.gx;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.工序产能;
import com.dsic.gj_erp.pc.dto.设备;
@ -16,6 +15,17 @@ public class 工序10型材 extends 工序产能 {
super(Constant.工序.打磨,_设备);
}
@Override
public void 计算工作量() {
this.产能=0;
if (this.白班时长>0){
this.产能+=this.白班时长*Constant.设备产能.型材01.get白班设备产能()/7.0;
}
if (this.二班时长>0){
this.产能+=this.二班时长*Constant.设备产能.型材01.get二班设备产能()/7.0;
}
}
@Override
public void 占用资源(double 所需产能) {
super.占用资源(所需产能);

20
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备05切割.java
Unescape View File

@ -17,14 +17,14 @@ public class 设备05切割 extends 设备 {
super(_设备产能);
}
@Override
public void 修正工作量(double 白班时长, double 二班时长) {
this.白班时长=白班时长;
this.二班时长=二班时长;
this.修正产能();
}
public void 修正产能(){
this.产能=this.白班设备产能*this.白班时长+this.二班设备产能*this.二班时长;
}
// @Override
// public void 修正工作量(double 白班时长, double 二班时长) {
// this.白班时长=白班时长;
// this.二班时长=二班时长;
// this.修正产能();
// }
//
// public void 修正产能(){
// this.产能=this.白班设备产能*this.白班时长+this.二班设备产能*this.二班时长;
// }
}

31
src/main/java/com/dsic/gj_erp/pc/dto/工序产能.java
Unescape View File

@ -17,7 +17,7 @@ public abstract class 工序产能 implements 工序排产处理接口 {
protected double 白班时长;
protected double 二班时长;
protected double 产能;
protected double 占用=0.0;
protected volatile double 占用=0.0;
protected int cd;
protected Constant.工序 CD所对应的工序;//需要根据对应工序进行计算cd
protected Map<String,设备> 设备;
@ -30,10 +30,9 @@ public abstract class 工序产能 implements 工序排产处理接口 {
this.工序=工序;
this.设备=设备;
this.白班时长=7;
this.二班时长=0;
this.产能=0;
设备.values().forEach(item->{
this.产能+=item.白班设备产能*this.白班时长+item.二班设备产能*this.二班时长;
});
this.计算产能();
this.cd=Constant.工序CD.get(工序);
资源占用图纸表=new ArrayList<>();
}
@ -44,22 +43,24 @@ public abstract class 工序产能 implements 工序排产处理接口 {
this.白班时长=白班时长;
this.二班时长=二班时长;
this.产能=0;
设备.values().forEach(item->{
this.产能+=item.白班设备产能*this.白班时长+item.二班设备产能*this.二班时长;
});
this.计算产能();
this.cd=Constant.工序CD.get(工序);
资源占用图纸表=new ArrayList<>();
}
public void 修正工作量(double 白班时长,double 二班时长){
this.白班时长=白班时长;
this.二班时长=二班时长;
设备.values().forEach(item->{
item.修正工作量(白班时长,二班时长);
this.产能+=item.产能;
});
private void 计算产能(){
this.计算工作量();
this.计算设备工作量();
}
public void 计算工作量(){}
private void 计算设备工作量(){
this.设备.values().forEach(_设备-> _设备.修正工作量(this.白班时长,this.二班时长));
}
public void 修正工作量(double 白班时长,double 二班时长){}
public Optional<设备> 获取已占用设备(String 占用源){
return this.设备.values().stream()
.filter(item -> item.get资源占用图纸表().contains(占用源))
@ -72,7 +73,7 @@ public abstract class 工序产能 implements 工序排产处理接口 {
}
public boolean 判断设备是否可以占用(String 设备编号,double 所需产能){
设备 _设备 = 设备.get(设备编号);
设备 _设备 = this.设备.get(设备编号);
return _设备.占用+所需产能<=_设备.产能;
}

18
src/main/java/com/dsic/gj_erp/pc/dto/设备.java
Unescape View File

@ -5,6 +5,7 @@ import com.dsic.gj_erp.pc.service.设备接口;
import lombok.Getter;
import lombok.Setter;
import java.util.ArrayList;
import java.util.List;
@Getter
@ -15,9 +16,19 @@ public abstract class 设备 implements 设备接口 {
protected double 白班设备产能;
protected double 二班设备产能;
protected double 产能;
protected double 占用=0.0;
protected volatile double 占用=0.0;
protected List<String> 资源占用图纸表;
@Override
public void 修正工作量(double 白班时长, double 二班时长) {
this.产能=0;
if (白班时长>0){
this.产能+=白班时长*白班设备产能/7.0;
}
if (二班时长>0){
this.产能+=二班时长*二班设备产能/7.0;
}
}
@Override
public void 占用设备(double 所需产能) {
this.占用+=所需产能;
@ -28,15 +39,12 @@ public abstract class 设备 implements 设备接口 {
this.资源占用图纸表.add(占用源);
}
@Override
public void 修正工作量(double 白班时长, double 二班时长) {
}
public 设备(Constant.设备产能 _设备产能){
this.设备编号= _设备产能.设备编号;
this.设备名称= _设备产能.设备名称;
this.白班设备产能= _设备产能.白班设备产能;
this.二班设备产能= _设备产能.二班设备产能;
this.资源占用图纸表=new ArrayList<>();
}
}

2
src/main/java/com/dsic/gj_erp/pc/service/工序排产处理接口.java
Unescape View File

@ -9,6 +9,8 @@ public interface 工序排产处理接口 {
占用资源(图纸);
}
void 计算工作量();
void 占用资源(double 所需产能);
void 占用资源(String 占用源);

1
src/main/java/com/dsic/gj_erp/pc/排产.java
Unescape View File

@ -48,7 +48,6 @@ public class 排产 {
DataFactory.加载工厂日历();
DataFactory.加载套料图工序对应关系();
DataFactory.加载设备信息();
DataFactory.加载工序设备对应关系();
DataFactory.创建产能资源池();
}
return Manager.排产;

Write Preview
Loading…
Cancel
Save