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

1.排产临时提交

Browse Source
master
董哲奇 1 year ago
parent cb15bc0cb3
commit 65b67912b7
26 changed files with 333 additions and 120 deletions
Show Stats Download Patch File Download Diff File

4
src/main/java/com/dsic/gj_erp/bean/jcsj/DmBom.java
Unescape View File

@ -3,6 +3,7 @@ package com.dsic.gj_erp.bean.jcsj;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.dsic.gj_erp.pc.dto.设备;
import com.dsic.gj_erp.pc.dto.资源;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
@ -222,4 +223,7 @@ public class DmBom implements Serializable {
@TableField(exist = false)
private 资源 所在资源;
@TableField(exist = false)
private 设备 所在设备;
}

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

@ -1,8 +1,8 @@
package com.dsic.gj_erp.pc;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
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;
@ -12,27 +12,27 @@ 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<工序, 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()
@ -40,19 +40,11 @@ public interface Constant {
.put(工序.抛丸, -8)
.put(工序.理料, -8)
.put(工序.划线, -5)
.put(工序.一跨龙门切割, -5)
.put(工序.一跨数控切割, -5)
.put(工序.二跨数控切割, -5)
.put(工序.三跨数控切割, -5)
.put(工序.三跨平铁切割, -5)
.put(工序.手工切割, -5)
.put(工序.切割, -5)
.put(工序.坡口, -3)
.put(工序.型材面板, -2)
.put(工序.曲加工, -5)
.put(工序.平铁打磨, -5)
.put(工序.手工打磨, -5)
.put(工序.打磨, -5)
.put(工序.预配盘, 0)
.put(工序.光电结束, -3)
.put(工序.配送, 0)
@ -81,38 +73,64 @@ public interface Constant {
ImmutableMap<工序, Map<String, 设备>> 工序设备对应关系 = ImmutableMap.<工序, Map<String, 设备>>builder()
//二跨超长超宽曲板小组
.put(工序.上料, ImmutableMap.<String, 设备>builder()
.put("",new 设备01上料())
.put(设备产能.上料01.设备编号,new 设备01上料(设备产能.上料01))
.build())
.put(工序.抛丸, ImmutableMap.<String, 设备>builder()
.put("",new 设备02抛丸())
.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())
// .put(工序.抛丸, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.理料, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.划线, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
//
// .put(工序.一跨龙门切割, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.一跨数控切割, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.二跨数控切割, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.三跨数控切割, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.三跨平铁切割, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
//
// .put(工序.坡口, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.型材面板, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.曲加工, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.平铁打磨, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.手工打磨, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.预配盘, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.光电结束, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
// .put(工序.配送, new EmSbjbb[]{new EmSbjbb(), new EmSbjbb()})
.build();
@Getter
@AllArgsConstructor
enum 设备产能{
SLSB01(工序.上料,"","",0,0,200.0,200.0,400),
PWSB01(工序.抛丸,"","",0,0,240.0,286.0,526.0),
LM01(工序.一跨龙门切割,"","",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,25.5),
上料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(工序.切割,"","",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),
火焰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),
坡口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),
;
public 工序 _工序;
public String 设备编号;
@ -131,11 +149,13 @@ public interface Constant {
抛丸("20"),
理料("21"),
划线("01"),
一跨龙门切割("03"),一跨数控切割("04"),二跨数控切割("04"),三跨数控切割("04"),三跨平铁切割("05"),手工切割("06"),
切割("03,04,05,06"),
// 一跨龙门切割("03"),一跨数控切割("04"),二跨数控切割("04"),三跨数控切割("04"),三跨平铁切割("05"),手工切割("06"),
坡口("08"),
型材面板("17"),
曲加工("18"),
平铁打磨("13"),手工打磨("16"),
打磨("13,16"),
// 平铁打磨("13"),手工打磨("16"),
预配盘(""),
光电结束(""),
配送(""),

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

@ -24,7 +24,6 @@ import com.dsic.gj_erp.service.jhgk.DmSygdxqService;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
import static com.dsic.gj_erp.pc.Constant.工序CD;
@ -46,22 +45,59 @@ public class DataFactory {
DateTime parse = DateUtil.parse(xq.getXzglxq(), "yyyy/MM/dd");
DateTime dateTime = DateUtil.offsetDay(parse, cd);
资源 _资源 = 提取资源(dateTime);
//除切割工序外默认需求数量都是1
//todo 如果是切割工序需要获取切割长度
double 需求数量=bom.getTlsl().doubleValue();
Optional.of(_资源).ifPresent(it->{
工序产能 工序产能=null;
资源 资源 = 套料图所占工序的资源.get(bom.getTzbh());
if (资源!=null){
工序产能 = 套料图所占工序的资源.get(bom.getTzbh()).get工序产能MAP().get(gx);
工序产能 = 资源.get工序产能MAP().get(gx);
}
if (工序产能!=null&&工序产能.get资源占用图纸表().contains(bom.getTzbh())){
bom.set所在资源(_资源);
bom.set所在资源(it);
Optional<设备> _设备 = 工序产能.获取已占用设备(bom.getTzbh());
_设备.ifPresent(bom::set所在设备);
}else{
工序产能 = it.get工序产能MAP().get(gx);
//直接占用资源
工序产能.占用资源(bom.getTzbh(), bom.getTlsl().doubleValue());
bom.set所在资源(_资源);
套料图所占工序的资源.put(bom.getTzbh(),_资源);
Optional<设备> _设备 = 工序产能.获取可占用设备(需求数量);
工序产能 final工序产能 = 工序产能;
_设备.ifPresent(tmp->{
bom.set所在设备(tmp);
tmp.占用设备(bom.getTzbh(),需求数量);
final工序产能.占用资源(bom.getTzbh(), 需求数量);
bom.set所在资源(it);
套料图所占工序的资源.put(bom.getTzbh(),it);
});
}
});
//没有可用资源是全局搜索可用资源,进行排产
if (bom.get所在设备()==null){
Optional<资源> 可用资源 = 搜索可用资源(gx, 需求数量);
可用资源.ifPresent(tmp资源->{
工序产能 _工序产能 = tmp资源.get工序产能MAP().get(gx);
Optional<设备> _设备 = _工序产能.获取可占用设备(0);
_设备.ifPresent(tmp->{
bom.set所在设备(tmp);
tmp.占用设备(bom.getTzbh(),需求数量);
_工序产能.占用资源(bom.getTzbh(), 需求数量);
bom.set所在资源(tmp资源);
套料图所占工序的资源.put(bom.getTzbh(),tmp资源);
});
});
}
//没有可用资源放入月末,待手工调整
if (bom.get所在设备()==null){
资源 tmp资源 = 提取资源(DateUtil.endOfMonth(DateUtil.parse(xq.getXzglxq(), "yyyy/MM/dd")));
工序产能 _工序产能 = tmp资源.get工序产能MAP().get(gx);
Optional<设备> _设备 = _工序产能.获取可占用设备(0);
bom.set所在设备(_设备.get());
bom.set所在资源(tmp资源);
_工序产能.占用资源(bom.getTzbh(),0);
套料图所占工序的资源.put(bom.getTzbh(),tmp资源);
}
}
});
});
@ -69,6 +105,13 @@ public class DataFactory {
System.out.println(111);
}
public static Optional<资源> 搜索可用资源(Constant.工序 工序, double 需求数量){
return 资源池.values().stream().filter(资源->{
工序产能 工序产能 = 资源.get工序产能MAP().get(工序);
return 工序产能.判断是否可以占用(需求数量);
}).findFirst();
}
public static 资源 提取资源(Date date){
资源 资源 = 资源池.get(DateUtil.format(date, "yyyy/MM/dd"));
if (资源==null){
@ -94,29 +137,23 @@ public class DataFactory {
Map<String, 设备> _设备 = Constant.工序设备对应关系.get(_工序);
switch (_工序){
case 上料:
return new 工序01上料(_工序,_设备);
return new 工序01上料(_设备);
case 抛丸:
return new 工序02抛丸(_工序,_设备);
return new 工序02抛丸(_设备);
case 理料:
return new 工序03理料(_工序,_设备);
return new 工序03理料(_设备);
case 划线:
return new 工序04划线(_工序,_设备);
case 一跨龙门切割:
case 一跨数控切割:
case 二跨数控切割:
case 三跨数控切割:
case 三跨平铁切割:
case 手工切割:
return new 工序05切割(_工序,_设备);
return new 工序04划线(_设备);
case 切割:
return new 工序05切割(_设备);
case 坡口:
return new 工序07坡口(_工序,_设备);
return new 工序07坡口(_设备);
case 型材面板:
return new 工序10型材(_工序,_设备);
return new 工序10型材(_设备);
case 曲加工:
return new 工序08曲面(_工序,_设备);
case 平铁打磨:
case 手工打磨:
return new 工序09打磨(_工序,_设备);
return new 工序08曲面(_设备);
case 打磨:
return new 工序09打磨(_设备);
// case 预配盘:
// return new 工序01上料(_工序,_设备);
// case 光电结束:
@ -124,7 +161,7 @@ public class DataFactory {
// case 配送:
// return new 工序01上料(_工序,_设备);
default:
return new 工序99未知(_工序,_设备);
return new 工序99未知(Constant.工序.NULL,_设备);
}
}

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

@ -11,8 +11,9 @@ import java.util.Map;
@Getter
@Setter
public class 工序01上料 extends 工序产能 {
public 工序01上料(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
public 工序01上料(Map<String, 设备> _设备) {
super(Constant.工序.上料,_设备);
}
@Override

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

@ -11,8 +11,8 @@ import java.util.Map;
@Getter
@Setter
public class 工序02抛丸 extends 工序产能 {
public 工序02抛丸(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
public 工序02抛丸(Map<String, 设备> _设备) {
super(Constant.工序.抛丸,_设备);
}
@Override

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

@ -11,8 +11,8 @@ import java.util.Map;
@Getter
@Setter
public class 工序03理料 extends 工序产能 {
public 工序03理料(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
public 工序03理料(Map<String, 设备> _设备) {
super(Constant.工序.理料,_设备);
}
@Override

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

@ -12,8 +12,9 @@ import java.util.Map;
@Getter
@Setter
public class 工序04划线 extends 工序产能 {
public 工序04划线(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
public 工序04划线(Map<String, 设备> _设备) {
super(Constant.工序.划线,_设备);
}
@Override

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

@ -12,8 +12,8 @@ import java.util.Map;
@Getter
@Setter
public class 工序05切割 extends 工序产能 {
public 工序05切割(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
public 工序05切割(Map<String, 设备> _设备) {
super(Constant.工序.切割,_设备);
}
@Override

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

@ -12,8 +12,8 @@ import java.util.Map;
@Getter
@Setter
public class 工序07坡口 extends 工序产能 {
public 工序07坡口(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
public 工序07坡口(Map<String, 设备> _设备) {
super(Constant.工序.坡口,_设备);
}
@Override

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

@ -12,8 +12,8 @@ import java.util.Map;
@Getter
@Setter
public class 工序08曲面 extends 工序产能 {
public 工序08曲面(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
public 工序08曲面(Map<String, 设备> _设备) {
super(Constant.工序.曲加工,_设备);
}
@Override

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

@ -12,8 +12,8 @@ import java.util.Map;
@Getter
@Setter
public class 工序09打磨 extends 工序产能 {
public 工序09打磨(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
public 工序09打磨(Map<String, 设备> _设备) {
super(Constant.工序.打磨,_设备);
}
@Override

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

@ -12,8 +12,8 @@ import java.util.Map;
@Getter
@Setter
public class 工序10型材 extends 工序产能 {
public 工序10型材(Constant.工序 工序, Map<String, 设备> _设备) {
super(工序,_设备);
public 工序10型材(Map<String, 设备> _设备) {
super(Constant.工序.打磨,_设备);
}
@Override

5
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备01上料.java
Unescape View File

@ -1,8 +1,11 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.bean.jcsj.EmSbjbb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备01上料 extends 设备 {
public 设备01上料(Constant.设备产能 _设备产能) {
super(_设备产能);
}
}

4
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备02抛丸.java
Unescape View File

@ -1,7 +1,11 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备02抛丸 extends 设备 {
public 设备02抛丸(Constant.设备产能 _设备产能) {
super(_设备产能);
}
}

11
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备03理料.java
Unescape View File

@ -0,0 +1,11 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备03理料 extends 设备 {
public 设备03理料(Constant.设备产能 _设备产能) {
super(_设备产能);
}
}

11
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备04划线.java
Unescape View File

@ -0,0 +1,11 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备04划线 extends 设备 {
public 设备04划线(Constant.设备产能 _设备产能) {
super(_设备产能);
}
}

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

@ -0,0 +1,30 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.设备;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class 设备05切割 extends 设备 {
private String 所在跨;
protected double 白班时长=7.0;
protected double 二班时长;
public 设备05切割(Constant.设备产能 _设备产能) {
super(_设备产能);
}
@Override
public void 修正工作量(double 白班时长, double 二班时长) {
this.白班时长=白班时长;
this.二班时长=二班时长;
this.修正产能();
}
public void 修正产能(){
this.产能=this.白班设备产能*this.白班时长+this.二班设备产能*this.二班时长;
}
}

11
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备07坡口.java
Unescape View File

@ -0,0 +1,11 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备07坡口 extends 设备 {
public 设备07坡口(Constant.设备产能 _设备产能) {
super(_设备产能);
}
}

11
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备08曲面.java
Unescape View File

@ -0,0 +1,11 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备08曲面 extends 设备 {
public 设备08曲面(Constant.设备产能 _设备产能) {
super(_设备产能);
}
}

11
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备09打磨.java
Unescape View File

@ -0,0 +1,11 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备09打磨 extends 设备 {
public 设备09打磨(Constant.设备产能 _设备产能) {
super(_设备产能);
}
}

11
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备10型材.java
Unescape View File

@ -0,0 +1,11 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备10型材 extends 设备 {
public 设备10型材(Constant.设备产能 _设备产能) {
super(_设备产能);
}
}

11
src/main/java/com/dsic/gj_erp/pc/dto/sb/设备99未知.java
Unescape View File

@ -0,0 +1,11 @@
package com.dsic.gj_erp.pc.dto.sb;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.设备;
public class 设备99未知 extends 设备 {
public 设备99未知(Constant.设备产能 _设备产能) {
super(_设备产能);
}
}

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

@ -9,7 +9,6 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
@Getter
@Setter
@ -35,7 +34,6 @@ public abstract class 工序产能 implements 工序排产处理接口 {
设备.values().forEach(item->{
this.产能+=item.白班设备产能*this.白班时长+item.二班设备产能*this.二班时长;
});
this.产能=Constant.工序产能.get(工序);
this.cd=Constant.工序CD.get(工序);
资源占用图纸表=new ArrayList<>();
}
@ -53,9 +51,24 @@ public abstract class 工序产能 implements 工序排产处理接口 {
资源占用图纸表=new ArrayList<>();
}
public 设备 获取可占用设备(double 所需产能){
public void 修正工作量(double 白班时长,double 二班时长){
this.白班时长=白班时长;
this.二班时长=二班时长;
设备.values().forEach(item->{
item.修正工作量(白班时长,二班时长);
this.产能+=item.产能;
});
}
public Optional<设备> 获取已占用设备(String 占用源){
return this.设备.values().stream()
.filter(item -> this.判断设备是否可以占用(item.设备编号, 所需产能)).findFirst().orElse(null);
.filter(item -> item.get资源占用图纸表().contains(占用源))
.findFirst();
}
public Optional<设备> 获取可占用设备(double 所需产能){
return this.设备.values().stream()
.filter(item -> this.判断设备是否可以占用(item.设备编号, 所需产能)).findFirst();
}
public boolean 判断设备是否可以占用(String 设备编号,double 所需产能){
@ -75,9 +88,4 @@ public abstract class 工序产能 implements 工序排产处理接口 {
this.资源占用图纸表.add(占用源);
}
@Override
public void 占用设备(String 设备编号,String 占用源) {
设备 _设备 = 设备.get(设备编号);
_设备.资源占用图纸表.add(占用源);
}
}

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

@ -1,6 +1,7 @@
package com.dsic.gj_erp.pc.dto;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.service.设备接口;
import lombok.Getter;
import lombok.Setter;
@ -8,7 +9,7 @@ import java.util.List;
@Getter
@Setter
public abstract class 设备 {
public abstract class 设备 implements 设备接口 {
protected String 设备编号;
protected String 设备名称;
protected double 白班设备产能;
@ -17,7 +18,25 @@ public abstract class 设备 {
protected double 占用=0.0;
protected List<String> 资源占用图纸表;
public 设备(Constant.设备产能 _设备产能){
@Override
public void 占用设备(double 所需产能) {
this.占用+=所需产能;
}
@Override
public void 占用设备(String 占用源) {
this.资源占用图纸表.add(占用源);
}
@Override
public void 修正工作量(double 白班时长, double 二班时长) {
}
public 设备(Constant.设备产能 _设备产能){
this.设备编号= _设备产能.设备编号;
this.设备名称= _设备产能.设备名称;
this.白班设备产能= _设备产能.白班设备产能;
this.二班设备产能= _设备产能.二班设备产能;
}
}

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

@ -1,19 +1,14 @@
package com.dsic.gj_erp.pc.service;
public interface 工序排产处理接口 {
void 修正工作量(double 白班时长,double 二班时长);
default void 占用资源(String 设备编号,String 图纸,double 所需产能){
占用资源(图纸,所需产能);
占用设备(设备编号,图纸);
}
default void 占用资源(String 图纸,double 所需产能){
占用资源(所需产能);
占用资源(图纸);
}
void 占用设备(String 设备编号,String 占用源);
void 占用资源(double 所需产能);
void 占用资源(String 占用源);

14
src/main/java/com/dsic/gj_erp/pc/service/设备接口.java
Unescape View File

@ -0,0 +1,14 @@
package com.dsic.gj_erp.pc.service;
public interface 设备接口 {
void 修正工作量(double 白班时长,double 二班时长);
default void 占用设备(String 图纸,double 所需产能){
占用设备(所需产能);
占用设备(图纸);
}
void 占用设备(double 所需产能);
void 占用设备(String 占用源);
}
Write Preview
Loading…
Cancel
Save