1.排产结果显示到页面

2.优化排产数据查询结果集结构

src/main/java/com/dsic/gj_erp/controller/jhgk/DmSygdMxController.java

@@ -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.*;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
 
 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 ){

src/main/java/com/dsic/gj_erp/pc/Constant.java

@@ -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, 10.0, 13.0, 13.0),
-        曲加工01(工序.曲型, "曲加工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, 1.0, 13.0, 13.0),
+        打磨01(工序.打磨, "打磨01", "", 2.0, 3.0, 10.0, 13.0, 13.0),
-        未知01(工序.NULL, "未知01", "", 2.0, 3.0, 1.0, 13.0, 13.0),
+        未知01(工序.NULL, "未知01", "", 2.0, 3.0, 10.0, 13.0, 13.0),
         ;
         public 工序 _工序;
         public String 设备编号;

src/main/java/com/dsic/gj_erp/pc/DataFactory.java

@@ -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);
+        List<钢料需求> list=读取钢料需求();
-        按需求日期排序的钢料需求.forEach(钢料需求 -> {
+
+        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) -> {
+        list.forEach(钢料需求->{
-            System.out.println("====打印资源===");
+            钢料需求.getBomList().forEach(bom -> {
-            System.out.println(day);
+                if (bom.get所在设备()!=null){
-            Map<Constant.工序, 工序产能> 工序产能MAP = item.get工序产能MAP();
+                    bom.set所在设备(null);
-            工序产能MAP.forEach((工序, 工序产能) -> {
+                }
-                if (工序产能.get资源占用图纸表().size() > 0) {
+                if (bom.get所在资源()!=null){
-                    System.out.println("工序:" + 工序);
+                    bom.set所在资源(null);
-                    System.out.println("工序产能:" + 工序产能.get资源占用图纸表().size());
                 }
             });
-            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);

src/main/java/com/dsic/gj_erp/pc/Manager.java

@@ -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);

src/main/java/com/dsic/gj_erp/pc/dto/data/Bom.java

@@ -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;
+    }
+}

src/main/java/com/dsic/gj_erp/pc/dto/data/钢料需求.java

@@ -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 _钢料需求;
+    }
+}

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

@@ -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;

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

@@ -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;

src/main/java/com/dsic/gj_erp/pc/dto/tlt/七跨型板.java

@@ -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;

src/main/java/com/dsic/gj_erp/pc/dto/tlt/三跨厚板.java

@@ -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;

src/main/java/com/dsic/gj_erp/pc/dto/tlt/三跨平铁.java

@@ -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()

src/main/java/com/dsic/gj_erp/pc/dto/tlt/三跨曲板.java

@@ -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;

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

@@ -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;

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

@@ -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;

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

@@ -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;

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

@@ -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";

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

@@ -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;

src/main/java/com/dsic/gj_erp/pc/dto/tlt/光电.java

@@ -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;
     }
 

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

@@ -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;

src/main/java/com/dsic/gj_erp/pc/dto/套料图工序.java

@@ -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资源 -> {
+                    可用资源.ifPresent(_资源 -> {
-                        工序产能 _工序产能 = tmp资源.get工序产能MAP().get(_工序);
+                        _资源.占用资源(_工序,this.bom,需求数量);
-                        Optional<设备> _设备 = _工序产能.获取可占用设备(0);
-                        _设备.ifPresent(tmp -> {
-                            this.占用设备(tmp资源,_工序产能,tmp,需求数量);
-                        });
                     });
                 }
 
                 //没有可用资源放入月末(强占),待手工调整
-                if (bom.get所在设备() == null) {
+                if (bom.get所在资源() == null) {
-                    资源 tmp资源 = 提取资源(DateUtil.endOfMonth(DateUtil.parse(this.需求日期, "yyyy/MM/dd")));
+                    资源 _资源 = 提取资源(DateUtil.endOfMonth(DateUtil.parse(this.需求日期, "yyyy/MM/dd")));
-                    工序产能 _工序产能 = tmp资源.get工序产能MAP().get(_工序);
+                    _资源.强占资源(_工序,this.bom,需求数量);
-                    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<设备> _设备 = 工序产能.获取可占用设备(需求数量);
+            _资源.占用资源(_工序,this.bom,需求数量);
-            _设备.ifPresent(tmp -> {
+            this.bom.set所在资源(_资源);
-                this.占用设备(_资源,工序产能,tmp,需求数量);
             占用成功.set(true);
-            });
         }catch (Exception e){
 
         }
@@ -108,4 +93,9 @@ public abstract class 套料图工序 implements 套料图工序接口 {
         return 套料图所占工序的资源.get(this.bom.getTzbh());
     }
 
+    @Override
+    public 套料图工序 钢料需求(钢料需求 _钢料需求) {
+        this._钢料需求=_钢料需求;
+        return this;
+    }
 }

src/main/java/com/dsic/gj_erp/pc/dto/工序产能.java

@@ -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);
+        });
+    }
+
 }

src/main/java/com/dsic/gj_erp/pc/dto/设备.java

@@ -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.concurrent.ConcurrentLinkedDeque;
-import java.util.List;
 
 @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<>();
     }
 }

src/main/java/com/dsic/gj_erp/pc/dto/资源.java

@@ -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;

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

@@ -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);
 }

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

@@ -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);
 }

src/main/java/com/dsic/gj_erp/pc/service/设备接口.java

@@ -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);
 }

src/main/java/com/dsic/gj_erp/pc/排产.java

@@ -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();
         }
     }