1.排产临时提交

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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