1.排产临时提交

master
董哲奇 2 years ago
parent 039f774a9a
commit c5a65c1623

@ -14,11 +14,16 @@ public interface Constant {
.put(工序.切割, -5)
.put(工序.坡口, -3)
.put(工序.型材面板, -2)
.put(工序.曲加工, -5)
.put(工序.曲型, -5)
.put(工序.打磨, -5)
.put(工序.预配盘, 0)
.put(工序.光电结束, -3)
.put(工序.自由边处理,0)
.put(工序.号料,0)
.put(工序.倒棱,0)
.put(工序.切端头,0)
.put(工序.配送, 0)
.put(工序.NULL, 0)
.build();
@Getter
@ -32,18 +37,19 @@ public interface Constant {
龙门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),
火焰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(工序.切割,"火焰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),
火焰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(工序.坡口,"坡口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),
型材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(工序.NULL, "未知01", "", 2.0, 3.0, 1.0, 13.0, 13.0),
;
public 工序 _工序;
public String 设备编号;
@ -56,22 +62,27 @@ public interface Constant {
}
@AllArgsConstructor
enum 工序{
enum 工序 {
NULL(""),
上料("19"),
抛丸("20"),
理料("21"),
划线("01"),
切割("03,04,05,06"),
// 一跨龙门切割("03"),一跨数控切割("04"),二跨数控切割("04"),三跨数控切割("04"),三跨平铁切割("05"),手工切割("06"),
// 一跨龙门切割("03"),一跨数控切割("04"),二跨数控切割("04"),三跨数控切割("04"),三跨平铁切割("05"),手工切割("06"),
坡口("08"),
型材面板("17"),
曲加工("18"),
自由边处理("14,15"),
曲型("18"),
打磨("13,16"),
// 平铁打磨("13"),手工打磨("16"),
号料("02"),
// 平铁打磨("13"),手工打磨("16"),
倒棱("09"),
切端头("11"),
预配盘(""),
光电结束(""),
配送(""),
;
@Getter

@ -14,10 +14,8 @@ 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.设备;
import com.dsic.gj_erp.pc.dto.资源;
import com.dsic.gj_erp.pc.dto.tlt.*;
import com.dsic.gj_erp.pc.dto.*;
import com.dsic.gj_erp.service.jcsj.EmGcrlService;
import com.dsic.gj_erp.service.jcsj.EmSbcnpService;
import com.dsic.gj_erp.service.jcsj.EmSbjbbService;
@ -27,6 +25,8 @@ import com.google.common.collect.ImmutableMap;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import static com.dsic.gj_erp.pc.Constant.工序CD;
@ -35,77 +35,124 @@ import static com.dsic.gj_erp.pc.Manager.*;
public class DataFactory {
public static void 排产(){
public static void 排产2() {
套料图所占工序的资源.clear();
List<DmSygdxq> 按需求日期排序的钢料需求 = getBean(DmSygdxqService.class).getXqWithBom(from, to);
按需求日期排序的钢料需求.forEach(钢料需求 -> {
CountDownLatch latch = new CountDownLatch(钢料需求.getBomList().size());
钢料需求.getBomList().forEach(bom -> {
套料图工序 _套料图工序 = 套料图工序工厂(bom);
if (_套料图工序!=null){
_套料图工序.set需求日期(钢料需求.getXzglxq());
es.execute(() -> {
try{
_套料图工序.run();
}finally {
latch.countDown();
}
});
}else {
latch.countDown();
}
});
try {
latch.await(10, TimeUnit.SECONDS); // 指定超时时间
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
//========调试打印===========
资源池.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("工序:" + 工序);
System.out.println("工序产能:" + 工序产能.get资源占用图纸表().size());
}
});
System.out.println("====打印资源完成===");
});
//========调试打印结束===========
}
public static void 排产() {
套料图所占工序的资源.clear();
List<排产结果> list = 排产.list;
List<DmBom> 强占记录=new ArrayList<>();
List<DmBom> 强占记录 = new ArrayList<>();
list.clear();
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(钢料需求.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工序产能MAP().get(gx);
}
if (工序产能!=null&&工序产能.get资源占用图纸表().contains(bom.getTzbh())){
bom.set所在资源(it);
Optional<设备> _设备 = 工序产能.获取已占用设备(bom.getTzbh());
_设备.ifPresent(bom::set所在设备);
}else{
工序产能 = it.get工序产能MAP().get(gx);
Optional<设备> _设备 = 工序产能.获取可占用设备(需求数量);
工序产能 final工序产能 = 工序产能;
_设备.ifPresent(tmp->{
bom.set所在设备(tmp);
tmp.占用设备(bom.getTzbh(),需求数量);
按需求日期排序的钢料需求.forEach(钢料需求 -> {
钢料需求.getBomList().forEach(bom -> {
Arrays.stream(Constant.工序.values()).forEach(gx -> {
if (StrUtil.isEmpty(gx.getCode())) return;
//todo 由于工序code存在多个值的情况,这里需要抽象套料图工序,修改后同时可支持多线程运算
Optional<String> first = 套料图工序对应关系.keySet().stream()
.filter(it -> it.startsWith(bom.getKw() + bom.getZl()))
.filter(it -> gx.getCode().contains(it.split("_")[1])).findFirst();
first.ifPresent(_code -> {
if (ObjUtil.isNotEmpty(套料图工序对应关系.get(_code))) {
Integer cd = 工序CD.get(gx);
DateTime parse = DateUtil.parse(钢料需求.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工序产能MAP().get(gx);
}
if (工序产能 != null && 工序产能.get资源占用图纸表().contains(bom.getTzbh())) {
bom.set所在资源(it);
final工序产能.占用资源(bom.getTzbh(), 需求数量);
套料图所占工序的资源.put(bom.getTzbh(),it);
Optional<设备> _设备 = 工序产能.获取已占用设备(bom.getTzbh());
_设备.ifPresent(bom::set所在设备);
} else {
工序产能 = it.get工序产能MAP().get(gx);
Optional<设备> _设备 = 工序产能.获取可占用设备(需求数量);
工序产能 final工序产能 = 工序产能;
_设备.ifPresent(tmp -> {
bom.set所在设备(tmp);
tmp.占用设备(bom.getTzbh(), 需求数量);
bom.set所在资源(it);
final工序产能.占用资源(bom.getTzbh(), 需求数量);
套料图所占工序的资源.put(bom.getTzbh(), it);
});
}
});
//没有可用资源是全局搜索可用资源,进行排产
if (bom.get所在设备() == null) {
Optional<资源> 可用资源 = 搜索可用资源(gx, DateUtil.parse(from, "yyyy/MM/dd"), parse, 需求数量);
可用资源.ifPresent(tmp资源 -> {
工序产能 _工序产能 = tmp资源.get工序产能MAP().get(gx);
Optional<设备> _设备 = _工序产能.获取可占用设备(0);
_设备.ifPresent(tmp -> {
tmp.占用设备(bom.getTzbh(), 需求数量);
bom.set所在设备(tmp);
_工序产能.占用资源(bom.getTzbh(), 需求数量);
bom.set所在资源(tmp资源);
套料图所占工序的资源.put(bom.getTzbh(), tmp资源);
});
});
}
});
//没有可用资源是全局搜索可用资源,进行排产
if (bom.get所在设备()==null){
Optional<资源> 可用资源 = 搜索可用资源(gx, DateUtil.parse(from,"yyyy/MM/dd"), parse,需求数量);
可用资源.ifPresent(tmp资源->{
//没有可用资源放入月末(强占),待手工调整
if (bom.get所在设备() == null) {
强占记录.add(bom);
资源 tmp资源 = 提取资源(DateUtil.endOfMonth(DateUtil.parse(钢料需求.getXzglxq(), "yyyy/MM/dd")));
工序产能 _工序产能 = tmp资源.get工序产能MAP().get(gx);
Optional<设备> _设备 = _工序产能.获取可占用设备(0);
_设备.ifPresent(tmp->{
tmp.占用设备(bom.getTzbh(),需求数量);
bom.set所在设备(tmp);
_工序产能.占用资源(bom.getTzbh(), 需求数量);
bom.set所在资源(tmp资源);
套料图所占工序的资源.put(bom.getTzbh(),tmp资源);
});
});
}
//没有可用资源放入月末(强占),待手工调整
if (bom.get所在设备()==null){
强占记录.add(bom);
资源 tmp资源 = 提取资源(DateUtil.endOfMonth(DateUtil.parse(钢料需求.getXzglxq(), "yyyy/MM/dd")));
工序产能 _工序产能 = tmp资源.get工序产能MAP().get(gx);
Optional<设备> _设备 = _工序产能.get设备().values().stream().findAny();
bom.set所在设备(_设备.get());
bom.set所在资源(tmp资源);
_工序产能.占用资源(bom.getTzbh(),0);
套料图所占工序的资源.put(bom.getTzbh(),tmp资源);
Optional<设备> _设备 = _工序产能.get设备().values().stream().findAny();
bom.set所在设备(_设备.get());
bom.set所在资源(tmp资源);
_工序产能.占用资源(bom.getTzbh(), 0);
套料图所占工序的资源.put(bom.getTzbh(), tmp资源);
}
}
}
});
});
});
});
@ -148,23 +195,85 @@ public class DataFactory {
public static void 创建产能资源池(){
资源池.clear();
工厂日历.stream().filter(item -> "1".equals(item.getXxr()))
.forEach(item -> {
Map<Constant.工序, 工序产能> map=new HashMap<>();
Arrays.stream(Constant.工序.values()).forEach(_item->{
if (StrUtil.isNotEmpty(_item.getCode())){
map.put(_item,工序产能工厂(_item));
.forEach(item -> {
Map<Constant.工序, 工序产能> map = new HashMap<>();
Arrays.stream(Constant.工序.values()).forEach(_item -> {
if (StrUtil.isNotEmpty(_item.getCode())) {
工序产能 工序产能 = 工序产能工厂(_item);
if (工序产能!=null){
map.put(_item, 工序产能);
}
});
资源池.put(item.getGl(),资源.of(item.getGl(), map));
}
});
资源池.put(item.getGl(), 资源.of(item.getGl(), map));
});
}
public static 套料图工序 套料图工序工厂(DmBom bom) {
switch (bom.getKw() + bom.getZl()) {
case "51010":
return new 二跨T型材面板().小组(bom);
case "51110":
return new 二跨T型材面板().大组(bom);
case "61010":
return new 三跨平铁().小组(bom);
case "61110":
return new 三跨平铁().大组(bom);
case "64230":
return new 三跨平铁().焊接机器人肘板(bom);
case "71010":
return new 一跨平直大板().小组(bom);
case "71110":
return new 一跨平直大板().大组(bom);
case "81110":
return new 一跨进线板().大组(bom);
case "91010":
return new 二跨超长超宽板().小组(bom);
case "91110":
return new 二跨超长超宽板().大组(bom);
case "101010":
return new 二跨超长超宽曲板().小组(bom);
case "101110":
return new 二跨超长超宽曲板().大组(bom);
case "111010":
return new 二跨T型材腹板().小组(bom);
case "111110":
return new 二跨T型材腹板().大组(bom);
case "121010":
return new 二跨激光切割板().小组(bom);
case "121110":
return new 二跨激光切割板().大组(bom);
case "131010":
return new 三跨曲板().小组(bom);
case "131110":
return new 三跨曲板().大组(bom);
case "141010":
return new 三跨厚板().小组(bom);
case "141110":
return new 三跨厚板().大组(bom);
case "151010":
return new 四跨普通板().小组(bom);
case "151110":
return new 四跨普通板().大组(bom);
case "154230":
return new 四跨普通板().焊接机器人肘板(bom);
case "161010":
return new 七跨型板().小组(bom);
case "161110":
return new 七跨型板().大组(bom);
case "171010":
return new 光电().小组(bom);
default:
return null;
}
}
public static 工序产能 工序产能工厂(Constant.工序 _工序){
Map<String,设备> _设备=null;
switch (_工序){
public static 工序产能 工序产能工厂(Constant.工序 _工序) {
Map<String, 设备> _设备 = null;
switch (_工序) {
case 上料:
_设备= ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.上料01.设备编号,new 设备01上料(Constant.设备产能.上料01))
_设备 = ImmutableMap.<String, 设备>builder()
.put(Constant.设备产能.上料01.设备编号, new 设备01上料(Constant.设备产能.上料01))
.build();
return new 工序01上料(_设备);
case 抛丸:
@ -205,14 +314,14 @@ public class DataFactory {
.put(Constant.设备产能.型材01.设备编号,new 设备10型材(Constant.设备产能.型材01))
.build();
return new 工序10型材(_设备);
case 曲加工:
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))
.put(Constant.设备产能.打磨01.设备编号, new 设备09打磨(Constant.设备产能.打磨01))
.build();
return new 工序09打磨(_设备);
// case 预配盘:
@ -222,7 +331,7 @@ public class DataFactory {
// case 配送:
// return new 工序01上料(_工序,_设备);
default:
return new 工序99未知(Constant.工序.NULL,_设备);
return null;
}
}

@ -9,7 +9,7 @@ import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.*;
public class Manager {
public static String from;
@ -21,8 +21,15 @@ public class Manager {
public static final Map<String,资源> 套料图所占工序的资源= new ConcurrentHashMap<>();
public static final Map<String, Constant.工序> 套料图工序对应关系 = new ConcurrentHashMap<>();
public static final List<EmSbjbb> 设备列表= new ArrayList<>();
//实时加载
public static Map<Constant.工序, Map<String, 设备>> 工序设备对应关系;
public static final ExecutorService es;
static {
int poolSize =Runtime.getRuntime().availableProcessors() * 2;
// BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(512);
// RejectedExecutionHandler policy = new ThreadPoolExecutor.DiscardPolicy();
es=new ThreadPoolExecutor(poolSize, poolSize, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
}
private Manager(){}
}

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

@ -0,0 +1,39 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 一跨平直大板 extends 套料图工序 {
public 一跨平直大板 小组(DmBom bom) {
this.kw = "7";
this.zl = "1010";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.划线)
.add(Constant.工序.切割)
.build();
return this;
}
public 一跨平直大板 大组(DmBom bom) {
this.kw = "7";
this.zl = "1110";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.划线)
.add(Constant.工序.切割)
.add(Constant.工序.曲型)
.build();
return this;
}
}

@ -0,0 +1,28 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 一跨进线板 extends 套料图工序 {
public 一跨进线板 小组(DmBom bom) {
return null;
}
public 一跨进线板 大组(DmBom bom) {
this.kw = "8";
this.zl = "1110";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.切割)
.add(Constant.工序.坡口)
.build();
return this;
}
}

@ -0,0 +1,44 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 七跨型板 extends 套料图工序 {
public 七跨型板 小组(DmBom bom) {
this.kw = "16";
this.zl = "1010";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.号料)
.add(Constant.工序.切割)
.add(Constant.工序.打磨)
.add(Constant.工序.自由边处理)
.add(Constant.工序.曲型)
.build();
return this;
}
public 七跨型板 大组(DmBom bom) {
this.kw = "16";
this.zl = "1110";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.号料)
.add(Constant.工序.切割)
.add(Constant.工序.打磨)
.add(Constant.工序.自由边处理)
.add(Constant.工序.曲型)
.build();
return this;
}
}

@ -0,0 +1,38 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 三跨厚板 extends 套料图工序 {
public 三跨厚板 小组(DmBom bom) {
this.kw = "14";
this.zl = "1010";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.切割)
.add(Constant.工序.坡口)
.build();
return this;
}
public 三跨厚板 大组(DmBom bom) {
this.kw = "14";
this.zl = "1110";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.切割)
.add(Constant.工序.坡口)
.build();
return this;
}
}

@ -0,0 +1,58 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 三跨平铁 extends 套料图工序 {
public 三跨平铁 小组(DmBom bom) {
this.kw = "6";
this.zl = "1010";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.划线)
.add(Constant.工序.切割)
.add(Constant.工序.切割)
.add(Constant.工序.打磨)
.add(Constant.工序.曲型)
.build();
return this;
}
public 三跨平铁 大组(DmBom bom) {
this.kw = "6";
this.zl = "1110";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.划线)
.add(Constant.工序.切割)
.add(Constant.工序.切割)
.add(Constant.工序.打磨)
.add(Constant.工序.曲型)
.build();
return this;
}
public 三跨平铁 焊接机器人肘板(DmBom bom) {
this.kw = "6";
this.zl = "4230";
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.划线)
.add(Constant.工序.切割)
.add(Constant.工序.切割)
.add(Constant.工序.打磨)
.build();
return this;
}
}

@ -0,0 +1,35 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 三跨曲板 extends 套料图工序 {
public 三跨曲板 小组(DmBom bom) {
this.kw = "13";
this.zl = "1010";
this.bom = bom;
this.设置工序();
return this;
}
public 三跨曲板 大组(DmBom bom) {
this.kw = "13";
this.zl = "1110";
this.bom = bom;
this.设置工序();
return this;
}
private void 设置工序() {
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.切割)
.add(Constant.工序.曲型)
.build();
}
}

@ -0,0 +1,36 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 二跨T型材腹板 extends 套料图工序 {
public 二跨T型材腹板 小组(DmBom bom) {
this.kw = "11";
this.zl = "1010";
this.bom = bom;
this.设置工序();
return this;
}
public 二跨T型材腹板 大组(DmBom bom) {
this.kw = "11";
this.zl = "1110";
this.bom = bom;
this.设置工序();
return this;
}
private void 设置工序() {
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.划线)
.add(Constant.工序.切割)
.add(Constant.工序.型材面板)
.build();
}
}

@ -0,0 +1,38 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 二跨T型材面板 extends 套料图工序 {
public 二跨T型材面板 小组(DmBom bom) {
this.kw = "5";
this.zl = "1010";
this.bom = bom;
this.设置工序();
return this;
}
public 二跨T型材面板 大组(DmBom bom) {
this.kw = "5";
this.zl = "1110";
this.bom = bom;
this.设置工序();
return this;
}
private void 设置工序() {
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.划线)
.add(Constant.工序.切割)
.add(Constant.工序.倒棱)
.add(Constant.工序.切端头)
.add(Constant.工序.型材面板)
.build();
}
}

@ -0,0 +1,38 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 二跨激光切割板 extends 套料图工序 {
public 二跨激光切割板 小组(DmBom bom) {
this.kw = "12";
this.zl = "1010";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.切割)
.add(Constant.工序.坡口)
.build();
return this;
}
public 二跨激光切割板 大组(DmBom bom) {
this.kw = "12";
this.zl = "1110";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.切割)
.add(Constant.工序.坡口)
.build();
return this;
}
}

@ -0,0 +1,41 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 二跨超长超宽曲板 extends 套料图工序 {
public 二跨超长超宽曲板 小组(DmBom bom) {
this.kw = "10";
this.zl = "1010";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.切割)
.add(Constant.工序.坡口)
.add(Constant.工序.曲型)
.build();
return this;
}
public 二跨超长超宽曲板 大组(DmBom bom) {
二跨超长超宽曲板 _二跨超长超宽曲板 = new 二跨超长超宽曲板();
_二跨超长超宽曲板.kw = "10";
_二跨超长超宽曲板.zl = "1110";
_二跨超长超宽曲板.bom = bom;
_二跨超长超宽曲板.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.切割)
.add(Constant.工序.坡口)
.add(Constant.工序.曲型)
.build();
return _二跨超长超宽曲板;
}
}

@ -0,0 +1,35 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 二跨超长超宽板 extends 套料图工序 {
public 二跨超长超宽板 小组(DmBom bom) {
this.kw = "9";
this.zl = "1010";
this.bom = bom;
this.设置工序();
return this;
}
public 二跨超长超宽板 大组(DmBom bom) {
this.kw = "9";
this.zl = "1110";
this.bom = bom;
this.设置工序();
return this;
}
private void 设置工序() {
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.切割)
.add(Constant.工序.坡口)
.build();
}
}

@ -0,0 +1,29 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 光电 extends 套料图工序 {
public 光电 小组(DmBom bom) {
this.kw = "17";
this.zl = "1120";
this.bom = bom;
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.抛丸)
.add(Constant.工序.理料)
.add(Constant.工序.切割)
.add(Constant.工序.坡口)
.add(Constant.工序.自由边处理)
.build();
return this;
}
public 光电 大组(DmBom bom) {
return null;
}
}

@ -0,0 +1,45 @@
package com.dsic.gj_erp.pc.dto.tlt;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 四跨普通板 extends 套料图工序 {
public 四跨普通板 小组(DmBom bom) {
this.kw = "15";
this.zl = "1010";
this.bom = bom;
this.设置工序();
return this;
}
public 四跨普通板 大组(DmBom bom) {
this.kw = "15";
this.zl = "1110";
this.bom = bom;
this.设置工序();
return this;
}
public 四跨普通板 焊接机器人肘板(DmBom bom) {
this.kw = "15";
this.zl = "4230";
this.bom = bom;
this.设置工序();
return this;
}
private void 设置工序() {
this.工序 = ImmutableList.<Constant.工序>builder()
.add(Constant.工序.上料)
.add(Constant.工序.切割)
.add(Constant.工序.理料)
.add(Constant.工序.划线)
.add(Constant.工序.抛丸)
.add(Constant.工序.坡口)
.add(Constant.工序.自由边处理)
.build();
}
}

@ -0,0 +1,111 @@
package com.dsic.gj_erp.pc.dto;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjUtil;
import cn.hutool.core.util.StrUtil;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.service.套料图工序接口;
import lombok.Getter;
import lombok.Setter;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
import static com.dsic.gj_erp.pc.Constant.工序CD;
import static com.dsic.gj_erp.pc.DataFactory.提取资源;
import static com.dsic.gj_erp.pc.DataFactory.搜索可用资源;
import static com.dsic.gj_erp.pc.Manager.from;
import static com.dsic.gj_erp.pc.Manager.套料图所占工序的资源;
@Getter
@Setter
public abstract class 套料图工序 implements 套料图工序接口 {
protected String kw;
protected String zl;
protected DmBom bom;
protected String 需求日期;
protected Date _需求日期;
protected List<Constant.工序> 工序;
@Override
public void run() {
if (ObjUtil.isEmpty(this.bom)||StrUtil.isEmpty(this.bom.getTzbh())){
return;
}
this._需求日期 = DateUtil.parse(this.需求日期, "yyyy/MM/dd");
double 需求数量 = 1;
this.工序.forEach(_工序 -> {
if (!this.已占资源(_工序)&&!this.占用资源(_工序,需求数量)){
if (bom.get所在设备() == null) {
Optional<资源> 可用资源 = 搜索可用资源(_工序, DateUtil.parse(from, "yyyy/MM/dd"), this._需求日期, 需求数量);
可用资源.ifPresent(tmp资源 -> {
工序产能 _工序产能 = tmp资源.get工序产能MAP().get(_工序);
Optional<设备> _设备 = _工序产能.获取可占用设备(0);
_设备.ifPresent(tmp -> {
this.占用设备(tmp资源,_工序产能,tmp,需求数量);
});
});
}
//没有可用资源放入月末(强占),待手工调整
if (bom.get所在设备() == null) {
资源 tmp资源 = 提取资源(DateUtil.endOfMonth(DateUtil.parse(this.需求日期, "yyyy/MM/dd")));
工序产能 _工序产能 = tmp资源.get工序产能MAP().get(_工序);
Optional<设备> _设备 = _工序产能.get设备().values().stream().findAny();
this.占用设备(tmp资源,_工序产能,_设备.get(),需求数量);
}
}
});
}
protected void 占用设备(资源 _资源,工序产能 工序产能,设备 tmp,double 需求数量){
bom.set所在设备(tmp);
tmp.占用设备(bom.getTzbh(), 需求数量);
bom.set所在资源(_资源);
工序产能.占用资源(bom.getTzbh(), 需求数量);
套料图所占工序的资源.put(bom.getTzbh(), _资源);
}
protected boolean 占用资源(Constant.工序 _工序,double 需求数量){
Integer cd = 工序CD.get(_工序);
DateTime dateTime = DateUtil.offsetDay(this._需求日期, cd);
资源 _资源 = 提取资源(dateTime);
工序产能 工序产能 = _资源.get工序产能MAP().get(_工序);
AtomicBoolean 占用成功=new AtomicBoolean(false);
try {
Optional<设备> _设备 = 工序产能.获取可占用设备(需求数量);
_设备.ifPresent(tmp -> {
this.占用设备(_资源,工序产能,tmp,需求数量);
占用成功.set(true);
});
}catch (Exception e){
}
return 占用成功.get();
}
protected boolean 已占资源(Constant.工序 _工序){
资源 已占资源 = this.获取所在资源();
工序产能 工序产能 = null;
if (已占资源 != null) {
工序产能 = 已占资源.get工序产能MAP().get(_工序);
}
if (工序产能 != null && 工序产能.get资源占用图纸表().contains(bom.getTzbh())) {
bom.set所在资源(已占资源);
Optional<设备> _设备 = 工序产能.获取已占用设备(bom.getTzbh());
_设备.ifPresent(bom::set所在设备);
return true;
}
return false;
}
protected 资源 获取所在资源() {
return 套料图所占工序的资源.get(this.bom.getTzbh());
}
}

@ -0,0 +1,10 @@
package com.dsic.gj_erp.pc.service;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.dto.套料图工序;
public interface 套料图工序接口 extends Runnable {
套料图工序 小组(DmBom bom);
套料图工序 大组(DmBom bom);
}

@ -23,7 +23,7 @@ public class 排产 {
try {
semaphore.acquire();
_排产 = 排产.of(from,to);
DataFactory.排产();
DataFactory.排产2();
}catch (Exception e){
e.printStackTrace();
}finally {
@ -32,24 +32,21 @@ public class 排产 {
}
semaphore.release();
}
}
private static 排产 of(@NotNull String from, @NotNull String to){
if (!from.equals(Manager.from)||!to.equals(Manager.to)){
排产 排产 = new 排产();
排产.from=from;
排产.to=to;
排产.complete=false;
排产.list=new ArrayList<>();
Manager.排产=排产;
Manager.from = from;
Manager.to = to;
DataFactory.加载工厂日历();
DataFactory.加载套料图工序对应关系();
DataFactory.加载设备信息();
DataFactory.创建产能资源池();
}
排产 排产 = new 排产();
排产.from = from;
排产.to = to;
排产.complete = false;
排产.list = new ArrayList<>();
Manager.排产 = 排产;
Manager.from = from;
Manager.to = to;
DataFactory.加载工厂日历();
DataFactory.加载套料图工序对应关系();
DataFactory.加载设备信息();
DataFactory.创建产能资源池();
return Manager.排产;
}

Loading…
Cancel
Save