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

1.排产结果显示到页面

Browse Source 
2.优化排产数据查询结果集结构
master
董哲奇 1 year ago
parent c5a65c1623
commit 6ba6bed2be
27 changed files with 300 additions and 108 deletions
Show Stats Download Patch File Download Diff File

51
src/main/java/com/dsic/gj_erp/controller/jhgk/DmSygdMxController.java
Unescape View File

@ -16,19 +16,19 @@ import com.dsic.gj_erp.bean.jhgk.DmSygd;
import com.dsic.gj_erp.bean.jhgk.DmSygdMx;
import com.dsic.gj_erp.bean.jhgk.DmYdjhxf;
import com.dsic.gj_erp.handler.ComputePlan;
import com.dsic.gj_erp.pc.Manager;
import com.dsic.gj_erp.pc.排产;
import com.dsic.gj_erp.service.jcsj.EmGcrlService;
import com.dsic.gj_erp.service.jcsj.EmSbcnpService;
import com.dsic.gj_erp.service.jhgk.DmSygdMxService;
import com.dsic.gj_erp.service.sy.SYService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.concurrent.Semaphore;
import java.util.stream.Collectors;
/**
@ -126,6 +126,49 @@ public class DmSygdMxController {
return service.sygdPC();
}
private static Semaphore semaphore = new Semaphore(1);
@GetMapping("pc")
public ResultBean<?> pc(String from, String to){
try {
semaphore.acquire();
排产.execute(from,to);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
semaphore.release();
}
return new ResultBean<>();
}
@GetMapping("sygdjh")
public ResultBean<?> 获取三月滚动计划(String from, String to) throws InterruptedException {
semaphore.acquire();
if (!StrUtil.isAllNotEmpty(from,to)){
semaphore.release();
return new ResultBean<>();
}
HashMap<Object, Object> map = new HashMap<>();
if (from.equals(Manager.from)&&to.equals(Manager.to)){
semaphore.release();
map.put("result",Manager.排产结果);
map.put("zy",Manager.资源池);
return new ResultBean<>(map);
}
try {
排产.execute(from,to);
}finally {
semaphore.release();
}
map.put("result",Manager.排产结果);
map.put("zy",Manager.资源池);
return new ResultBean<>(map);
}
@RequestMapping("/saveList")
@AuthFunction
public ResultBean saveList( @RequestBody List<DmSygdMx> list ){

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

@ -43,13 +43,13 @@ public interface Constant {
火焰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", "", 2.0, 3.0, 10.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),
型材01(工序.型材面板, "型材01", "", 2.0, 3.0, 10.0, 13.0, 13.0),
曲加工01(工序.曲型, "曲加工01", "", 2.0, 3.0, 10.0, 13.0, 13.0),
打磨01(工序.打磨, "打磨01", "", 2.0, 3.0, 10.0, 13.0, 13.0),
未知01(工序.NULL, "未知01", "", 2.0, 3.0, 10.0, 13.0, 13.0),
;
public 工序 _工序;
public String 设备编号;

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

@ -12,9 +12,12 @@ 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.data.Bom;
import com.dsic.gj_erp.pc.dto.data.钢料需求;
import com.dsic.gj_erp.pc.dto.gx.*;
import com.dsic.gj_erp.pc.dto.sb.*;
import com.dsic.gj_erp.pc.dto.tlt.*;
import com.dsic.gj_erp.pc.dto.排产结果;
import com.dsic.gj_erp.pc.dto.*;
import com.dsic.gj_erp.service.jcsj.EmGcrlService;
import com.dsic.gj_erp.service.jcsj.EmSbcnpService;
@ -37,8 +40,9 @@ public class DataFactory {
public static void 排产2() {
套料图所占工序的资源.clear();
List<DmSygdxq> 按需求日期排序的钢料需求 = getBean(DmSygdxqService.class).getXqWithBom(from, to);
按需求日期排序的钢料需求.forEach(钢料需求 -> {
List<钢料需求> list=读取钢料需求();
list.forEach(钢料需求 -> {
CountDownLatch latch = new CountDownLatch(钢料需求.getBomList().size());
钢料需求.getBomList().forEach(bom -> {
套料图工序 _套料图工序 = 套料图工序工厂(bom);
@ -56,25 +60,29 @@ public class DataFactory {
}
});
try {
latch.await(10, TimeUnit.SECONDS); // 指定超时时间
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());
//清理冗余数据
list.forEach(钢料需求->{
钢料需求.getBomList().forEach(bom -> {
if (bom.get所在设备()!=null){
bom.set所在设备(null);
}
if (bom.get所在资源()!=null){
bom.set所在资源(null);
}
});
System.out.println("====打印资源完成===");
});
//========调试打印结束===========
}
public static List<钢料需求> 读取钢料需求(){
List<钢料需求> list=new ArrayList<>();
List<DmSygdxq> 按需求日期排序的钢料需求 = getBean(DmSygdxqService.class).getXqWithBom(from, to);
按需求日期排序的钢料需求.forEach(item-> list.add(钢料需求.of(item)));
return list;
}
public static void 排产() {
@ -83,6 +91,7 @@ public class DataFactory {
List<DmBom> 强占记录 = new ArrayList<>();
list.clear();
List<DmSygdxq> 按需求日期排序的钢料需求 = getBean(DmSygdxqService.class).getXqWithBom(from, to);
按需求日期排序的钢料需求.forEach(钢料需求 -> {
钢料需求.getBomList().forEach(bom -> {
Arrays.stream(Constant.工序.values()).forEach(gx -> {
@ -156,6 +165,7 @@ public class DataFactory {
});
});
});
// Manager.排产结果=按需求日期排序的钢料需求;
//========调试打印===========
资源池.forEach((day,item)->{
System.out.println("====打印资源===");
@ -209,7 +219,7 @@ public class DataFactory {
});
}
public static 套料图工序 套料图工序工厂(DmBom bom) {
public static 套料图工序 套料图工序工厂(Bom bom) {
switch (bom.getKw() + bom.getZl()) {
case "51010":
return new 二跨T型材面板().小组(bom);

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

@ -2,7 +2,7 @@ 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.data.钢料需求;
import com.dsic.gj_erp.pc.dto.资源;
import java.util.ArrayList;
@ -24,6 +24,8 @@ public class Manager {
public static final ExecutorService es;
public static List<钢料需求> 排产结果;
static {
int poolSize =Runtime.getRuntime().availableProcessors() * 2;
// BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(512);

39
src/main/java/com/dsic/gj_erp/pc/dto/data/Bom.java
Unescape View File

@ -0,0 +1,39 @@
package com.dsic.gj_erp.pc.dto.data;
import cn.hutool.core.bean.BeanUtil;
import com.dsic.gj_erp.bean.jcsj.DmBom;
import com.dsic.gj_erp.pc.dto.设备;
import com.dsic.gj_erp.pc.dto.资源;
import lombok.Getter;
import lombok.Setter;
import java.util.Map;
@Getter
@Setter
public class Bom {
private String dcch;
private String pl;
private String fd;
private String xzglxq;
private String dzglxq;
private String zl;
private String kw;
private String tzbh;
private String wpgg;
private String wpcz;
private String ljsl;
private Map<String,String> degs;
private 设备 所在设备;
private 资源 所在资源;
public static Bom of(String xzxq, String dzxq, DmBom bom){
Bom _bom = new Bom();
BeanUtil.copyProperties(bom,_bom);
_bom.xzglxq=xzxq;
_bom.dzglxq=dzxq;
return _bom;
}
}

27
src/main/java/com/dsic/gj_erp/pc/dto/data/钢料需求.java
Unescape View File

@ -0,0 +1,27 @@
package com.dsic.gj_erp.pc.dto.data;
import cn.hutool.core.bean.BeanUtil;
import com.dsic.gj_erp.bean.jhgk.DmSygdxq;
import lombok.Getter;
import lombok.Setter;
import java.util.List;
import java.util.stream.Collectors;
@Getter
@Setter
public class 钢料需求 {
private String dcCh;
private String dcPl;
private String dcFd;
private String xzglxq;
private String dzglxq;
private List<Bom> bomList;
public static 钢料需求 of(DmSygdxq qfxq){
钢料需求 _钢料需求 = new 钢料需求();
BeanUtil.copyProperties(qfxq,_钢料需求,"bomList");
_钢料需求.bomList=qfxq.getBomList().stream().map(item->Bom.of(_钢料需求.getXzglxq(),_钢料需求.getDzglxq(),item)).collect(Collectors.toList());
return _钢料需求;
}
}

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/一跨平直大板.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 一跨平直大板 extends 套料图工序 {
public 一跨平直大板 小组(DmBom bom) {
public 一跨平直大板 小组(Bom bom) {
this.kw = "7";
this.zl = "1010";
this.bom = bom;
@ -21,7 +21,7 @@ public class 一跨平直大板 extends 套料图工序 {
return this;
}
public 一跨平直大板 大组(DmBom bom) {
public 一跨平直大板 大组(Bom bom) {
this.kw = "7";
this.zl = "1110";
this.bom = bom;

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/一跨进线板.java
Unescape View File

@ -1,17 +1,17 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 一跨进线板 extends 套料图工序 {
public 一跨进线板 小组(DmBom bom) {
public 一跨进线板 小组(Bom bom) {
return null;
}
public 一跨进线板 大组(DmBom bom) {
public 一跨进线板 大组(Bom bom) {
this.kw = "8";
this.zl = "1110";
this.bom = bom;

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/七跨型板.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 七跨型板 extends 套料图工序 {
public 七跨型板 小组(DmBom bom) {
public 七跨型板 小组(Bom bom) {
this.kw = "16";
this.zl = "1010";
this.bom = bom;
@ -24,7 +24,7 @@ public class 七跨型板 extends 套料图工序 {
return this;
}
public 七跨型板 大组(DmBom bom) {
public 七跨型板 大组(Bom bom) {
this.kw = "16";
this.zl = "1110";
this.bom = bom;

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/三跨厚板.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 三跨厚板 extends 套料图工序 {
public 三跨厚板 小组(DmBom bom) {
public 三跨厚板 小组(Bom bom) {
this.kw = "14";
this.zl = "1010";
this.bom = bom;
@ -21,7 +21,7 @@ public class 三跨厚板 extends 套料图工序 {
return this;
}
public 三跨厚板 大组(DmBom bom) {
public 三跨厚板 大组(Bom bom) {
this.kw = "14";
this.zl = "1110";
this.bom = bom;

8
src/main/java/com/dsic/gj_erp/pc/dto/tlt/三跨平铁.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 三跨平铁 extends 套料图工序 {
public 三跨平铁 小组(DmBom bom) {
public 三跨平铁 小组(Bom bom) {
this.kw = "6";
this.zl = "1010";
this.bom = bom;
@ -24,7 +24,7 @@ public class 三跨平铁 extends 套料图工序 {
return this;
}
public 三跨平铁 大组(DmBom bom) {
public 三跨平铁 大组(Bom bom) {
this.kw = "6";
this.zl = "1110";
this.bom = bom;
@ -41,7 +41,7 @@ public class 三跨平铁 extends 套料图工序 {
return this;
}
public 三跨平铁 焊接机器人肘板(DmBom bom) {
public 三跨平铁 焊接机器人肘板(Bom bom) {
this.kw = "6";
this.zl = "4230";
this.工序 = ImmutableList.<Constant.工序>builder()

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/三跨曲板.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 三跨曲板 extends 套料图工序 {
public 三跨曲板 小组(DmBom bom) {
public 三跨曲板 小组(Bom bom) {
this.kw = "13";
this.zl = "1010";
this.bom = bom;
@ -15,7 +15,7 @@ public class 三跨曲板 extends 套料图工序 {
return this;
}
public 三跨曲板 大组(DmBom bom) {
public 三跨曲板 大组(Bom bom) {
this.kw = "13";
this.zl = "1110";
this.bom = bom;

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/二跨T型材腹板.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 二跨T型材腹板 extends 套料图工序 {
public 二跨T型材腹板 小组(DmBom bom) {
public 二跨T型材腹板 小组(Bom bom) {
this.kw = "11";
this.zl = "1010";
this.bom = bom;
@ -15,7 +15,7 @@ public class 二跨T型材腹板 extends 套料图工序 {
return this;
}
public 二跨T型材腹板 大组(DmBom bom) {
public 二跨T型材腹板 大组(Bom bom) {
this.kw = "11";
this.zl = "1110";
this.bom = bom;

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/二跨T型材面板.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 二跨T型材面板 extends 套料图工序 {
public 二跨T型材面板 小组(DmBom bom) {
public 二跨T型材面板 小组(Bom bom) {
this.kw = "5";
this.zl = "1010";
this.bom = bom;
@ -15,7 +15,7 @@ public class 二跨T型材面板 extends 套料图工序 {
return this;
}
public 二跨T型材面板 大组(DmBom bom) {
public 二跨T型材面板 大组(Bom bom) {
this.kw = "5";
this.zl = "1110";
this.bom = bom;

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/二跨激光切割板.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 二跨激光切割板 extends 套料图工序 {
public 二跨激光切割板 小组(DmBom bom) {
public 二跨激光切割板 小组(Bom bom) {
this.kw = "12";
this.zl = "1010";
this.bom = bom;
@ -21,7 +21,7 @@ public class 二跨激光切割板 extends 套料图工序 {
return this;
}
public 二跨激光切割板 大组(DmBom bom) {
public 二跨激光切割板 大组(Bom bom) {
this.kw = "12";
this.zl = "1110";
this.bom = bom;

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/二跨超长超宽曲板.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 二跨超长超宽曲板 extends 套料图工序 {
public 二跨超长超宽曲板 小组(DmBom bom) {
public 二跨超长超宽曲板 小组(Bom bom) {
this.kw = "10";
this.zl = "1010";
this.bom = bom;
@ -22,7 +22,7 @@ public class 二跨超长超宽曲板 extends 套料图工序 {
return this;
}
public 二跨超长超宽曲板 大组(DmBom bom) {
public 二跨超长超宽曲板 大组(Bom bom) {
二跨超长超宽曲板 _二跨超长超宽曲板 = new 二跨超长超宽曲板();
_二跨超长超宽曲板.kw = "10";
_二跨超长超宽曲板.zl = "1110";

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/二跨超长超宽板.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 二跨超长超宽板 extends 套料图工序 {
public 二跨超长超宽板 小组(DmBom bom) {
public 二跨超长超宽板 小组(Bom bom) {
this.kw = "9";
this.zl = "1010";
this.bom = bom;
@ -15,7 +15,7 @@ public class 二跨超长超宽板 extends 套料图工序 {
return this;
}
public 二跨超长超宽板 大组(DmBom bom) {
public 二跨超长超宽板 大组(Bom bom) {
this.kw = "9";
this.zl = "1110";
this.bom = bom;

6
src/main/java/com/dsic/gj_erp/pc/dto/tlt/光电.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 光电 extends 套料图工序 {
public 光电 小组(DmBom bom) {
public 光电 小组(Bom bom) {
this.kw = "17";
this.zl = "1120";
this.bom = bom;
@ -22,7 +22,7 @@ public class 光电 extends 套料图工序 {
return this;
}
public 光电 大组(DmBom bom) {
public 光电 大组(Bom bom) {
return null;
}

8
src/main/java/com/dsic/gj_erp/pc/dto/tlt/四跨普通板.java
Unescape View File

@ -1,13 +1,13 @@
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.data.Bom;
import com.dsic.gj_erp.pc.dto.套料图工序;
import com.google.common.collect.ImmutableList;
public class 四跨普通板 extends 套料图工序 {
public 四跨普通板 小组(DmBom bom) {
public 四跨普通板 小组(Bom bom) {
this.kw = "15";
this.zl = "1010";
this.bom = bom;
@ -15,7 +15,7 @@ public class 四跨普通板 extends 套料图工序 {
return this;
}
public 四跨普通板 大组(DmBom bom) {
public 四跨普通板 大组(Bom bom) {
this.kw = "15";
this.zl = "1110";
this.bom = bom;
@ -23,7 +23,7 @@ public class 四跨普通板 extends 套料图工序 {
return this;
}
public 四跨普通板 焊接机器人肘板(DmBom bom) {
public 四跨普通板 焊接机器人肘板(Bom bom) {
this.kw = "15";
this.zl = "4230";
this.bom = bom;

46
src/main/java/com/dsic/gj_erp/pc/dto/套料图工序.java
Unescape View File

@ -4,8 +4,9 @@ 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.dto.data.Bom;
import com.dsic.gj_erp.pc.dto.data.钢料需求;
import com.dsic.gj_erp.pc.service.套料图工序接口;
import lombok.Getter;
import lombok.Setter;
@ -26,7 +27,8 @@ import static com.dsic.gj_erp.pc.Manager.套料图所占工序的资源;
public abstract class 套料图工序 implements 套料图工序接口 {
protected String kw;
protected String zl;
protected DmBom bom;
protected 钢料需求 _钢料需求;
protected Bom bom;
protected String 需求日期;
protected Date _需求日期;
protected List<Constant.工序> 工序;
@ -40,48 +42,31 @@ public abstract class 套料图工序 implements 套料图工序接口 {
double 需求数量 = 1;
this.工序.forEach(_工序 -> {
if (!this.已占资源(_工序)&&!this.占用资源(_工序,需求数量)){
if (bom.get所在设备() == null) {
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,需求数量);
});
可用资源.ifPresent(_资源 -> {
_资源.占用资源(_工序,this.bom,需求数量);
});
}
//没有可用资源放入月末(强占),待手工调整
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(),需求数量);
if (bom.get所在资源() == null) {
资源 _资源 = 提取资源(DateUtil.endOfMonth(DateUtil.parse(this.需求日期, "yyyy/MM/dd")));
_资源.强占资源(_工序,this.bom,需求数量);
}
}
});
}
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);
});
_资源.占用资源(_工序,this.bom,需求数量);
this.bom.set所在资源(_资源);
占用成功.set(true);
}catch (Exception e){
}
@ -108,4 +93,9 @@ public abstract class 套料图工序 implements 套料图工序接口 {
return 套料图所占工序的资源.get(this.bom.getTzbh());
}
@Override
public 套料图工序 钢料需求(钢料需求 _钢料需求) {
this._钢料需求=_钢料需求;
return this;
}
}

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.dto.data.Bom;
import com.dsic.gj_erp.pc.service.工序排产处理接口;
import lombok.Getter;
import lombok.Setter;
@ -9,6 +10,7 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentLinkedDeque;
@Getter
@Setter
@ -21,7 +23,7 @@ public abstract class 工序产能 implements 工序排产处理接口 {
protected int cd;
protected Constant.工序 CD所对应的工序;//需要根据对应工序进行计算cd
protected Map<String,设备> 设备;
protected List<String> 资源占用图纸表;
protected ConcurrentLinkedDeque<String> 资源占用图纸表;
/**
* 默认构造
@ -34,7 +36,7 @@ public abstract class 工序产能 implements 工序排产处理接口 {
this.产能=0;
this.计算产能();
this.cd=Constant.工序CD.get(工序);
资源占用图纸表=new ArrayList<>();
资源占用图纸表=new ConcurrentLinkedDeque<>();
}
public 工序产能(Constant.工序 工序, Map<String,设备> 设备,double 白班时长,double 二班时长){
@ -45,7 +47,7 @@ public abstract class 工序产能 implements 工序排产处理接口 {
this.产能=0;
this.计算产能();
this.cd=Constant.工序CD.get(工序);
资源占用图纸表=new ArrayList<>();
this.资源占用图纸表=new ConcurrentLinkedDeque<>();
}
private void 计算产能(){
@ -89,4 +91,19 @@ public abstract class 工序产能 implements 工序排产处理接口 {
this.资源占用图纸表.add(占用源);
}
public void 占用设备(String 占用源,double 所需产能, Bom bom){
Optional<设备> 可占用设备 = this.获取可占用设备(所需产能);
可占用设备.ifPresent(it->{
it.占用设备(所需产能);
it.占用设备(bom);
});
}
public void 强占设备(String 占用源,double 所需产能, Bom bom){
Optional<设备> _设备 = this.设备.values().stream().findAny();
_设备.ifPresent(it->{
it.占用设备(所需产能);
it.占用设备(bom);
});
}
}

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

@ -1,12 +1,12 @@
package com.dsic.gj_erp.pc.dto;
import com.dsic.gj_erp.pc.Constant;
import com.dsic.gj_erp.pc.dto.data.Bom;
import com.dsic.gj_erp.pc.service.设备接口;
import lombok.Getter;
import lombok.Setter;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedDeque;
@Getter
@Setter
@ -17,7 +17,8 @@ public abstract class 设备 implements 设备接口 {
protected double 二班设备产能;
protected double 产能;
protected volatile double 占用=0.0;
protected List<String> 资源占用图纸表;
protected ConcurrentLinkedDeque<String> 资源占用图纸表;
protected ConcurrentLinkedDeque<Bom> 资源占用图表;
@Override
public void 修正工作量(double 白班时长, double 二班时长) {
@ -39,12 +40,19 @@ public abstract class 设备 implements 设备接口 {
this.资源占用图纸表.add(占用源);
}
@Override
public void 占用设备(Bom bom) {
this.资源占用图纸表.add(bom.getTzbh());
this.资源占用图表.add(bom);
}
public 设备(Constant.设备产能 _设备产能){
this.设备编号= _设备产能.设备编号;
this.设备名称= _设备产能.设备名称;
this.白班设备产能= _设备产能.白班设备产能;
this.二班设备产能= _设备产能.二班设备产能;
this.资源占用图纸表=new ArrayList<>();
this.资源占用图纸表=new ConcurrentLinkedDeque<>();
this.资源占用图表=new ConcurrentLinkedDeque<>();
}
}

24
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.dto.data.Bom;
import lombok.Getter;
import lombok.Setter;
@ -18,10 +19,33 @@ public class 资源 {
Optional.of(工序产能).ifPresent(it->{
if (it.判断是否可以占用(产能消耗)){
it.占用资源(套料图号,产能消耗);
设置套料图所在资源(套料图号);
}
});
}
public void 占用资源(Constant.工序 工序, Bom bom, double 产能消耗){
工序产能 工序产能 = 工序产能MAP.get(工序);
Optional.of(工序产能).ifPresent(it->{
if (it.判断是否可以占用(产能消耗)){
it.占用资源(产能消耗,bom);
设置套料图所在资源(bom.getTzbh());
}
});
}
public void 强占资源(Constant.工序 工序,Bom bom,double 产能消耗){
工序产能 工序产能 = 工序产能MAP.get(工序);
Optional.of(工序产能).ifPresent(it->{
it.强占资源(产能消耗,bom);
设置套料图所在资源(bom.getTzbh());
});
}
protected void 设置套料图所在资源(String 套料图号) {
//套料图所占工序的资源.put(套料图号,this);
}
public static 资源 of(String date,Map<Constant.工序,工序产能> 工序产能MAP){
资源 资源 = new 资源();
资源.date=date;

10
src/main/java/com/dsic/gj_erp/pc/service/套料图工序接口.java
Unescape View File

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

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

@ -1,5 +1,7 @@
package com.dsic.gj_erp.pc.service;
import com.dsic.gj_erp.pc.dto.data.Bom;
public interface 工序排产处理接口 {
void 修正工作量(double 白班时长,double 二班时长);
@ -9,9 +11,30 @@ public interface 工序排产处理接口 {
占用资源(图纸);
}
default void 占用资源(String 图纸,double 所需产能, Bom bom){
占用资源(所需产能);
占用资源(图纸);
占用设备(图纸,所需产能,bom);
}
default void 占用资源(double 所需产能, Bom bom){
占用资源(所需产能);
占用资源(bom.getTzbh());
占用设备(bom.getTzbh(),所需产能,bom);
}
default void 强占资源(double 所需产能, Bom bom){
占用资源(所需产能);
占用资源(bom.getTzbh());
强占设备(bom.getTzbh(),所需产能,bom);
}
void 计算工作量();
void 占用资源(double 所需产能);
void 占用资源(String 占用源);
void 占用设备(String 占用源, double 所需产能, Bom bom);
void 强占设备(String 占用源,double 所需产能, Bom bom);
}

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

@ -1,5 +1,7 @@
package com.dsic.gj_erp.pc.service;
import com.dsic.gj_erp.pc.dto.data.Bom;
public interface 设备接口 {
void 修正工作量(double 白班时长,double 二班时长);
@ -8,7 +10,14 @@ public interface 设备接口 {
占用设备(图纸);
}
default void 占用设备(Bom bom, double 所需产能){
占用设备(所需产能);
占用设备(bom);
}
void 占用设备(double 所需产能);
void 占用设备(String 占用源);
void 占用设备(Bom bom);
}

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

@ -7,7 +7,6 @@ import lombok.Setter;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;
@Getter
@Setter
@ -16,12 +15,10 @@ public class 排产 {
private String to;
private boolean complete;
List<排产结果> list;
private static Semaphore semaphore = new Semaphore(1);
public static void execute(@NotNull String from, @NotNull String to) {
排产 _排产=null;
try {
semaphore.acquire();
_排产 = 排产.of(from,to);
DataFactory.排产2();
}catch (Exception e){
@ -30,7 +27,6 @@ public class 排产 {
if (_排产!=null){
_排产.complete = true;
}
semaphore.release();
}
}

Write Preview
Loading…
Cancel
Save