段长比对优先级

src/main/java/com/jeeplus/modules/sg/balancedlibrary/liKuResourcePool/entity/LiKuResourcePool.java

@@ -68,7 +68,7 @@ public class LiKuResourcePool extends DataEntity<LiKuResourcePool> {
     /**
      * 线缆段长
      * */
-    private String lengthOfCable;
+    private Double lengthOfCable;
     /**
      * 环网箱尺寸
      * */
@@ -122,6 +122,11 @@ public class LiKuResourcePool extends DataEntity<LiKuResourcePool> {
      */
     private Integer completeLiKu;
 
+    /**
+     * 线缆段长计算
+     */
+    private String meterNumber;
+
     @ExcelField(title = "序号", align = 2, sort = 1)
     public String getSerialNumber() {
         return serialNumber;
@@ -251,11 +256,11 @@ public class LiKuResourcePool extends DataEntity<LiKuResourcePool> {
     }
 
     @ExcelField(title = "线缆段长", align = 2, sort = 15)
-    public String getLengthOfCable() {
+    public Double getLengthOfCable() {
         return lengthOfCable;
     }
 
-    public void setLengthOfCable(String lengthOfCable) {
+    public void setLengthOfCable(Double lengthOfCable) {
         this.lengthOfCable = lengthOfCable;
     }
 
@@ -374,4 +379,12 @@ public class LiKuResourcePool extends DataEntity<LiKuResourcePool> {
     public void setCompleteLiKu(Integer completeLiKu) {
         this.completeLiKu = completeLiKu;
     }
+
+    public String getMeterNumber() {
+        return meterNumber;
+    }
+
+    public void setMeterNumber(String meterNumber) {
+        this.meterNumber = meterNumber;
+    }
 }

src/main/java/com/jeeplus/modules/sg/balancedlibrary/liKuResourcePool/web/LiKuResourcePoolController.java

@@ -196,7 +196,7 @@ public class LiKuResourcePoolController extends BaseController {
 				pool.setSpecialStock(String.valueOf(row.getCell(11)));
 				pool.setExtendedCoding(String.valueOf(row.getCell(12)));
 				pool.setExtendedDescription(String.valueOf(row.getCell(13)));
-				pool.setLengthOfCable(String.valueOf(row.getCell(14)));
+				pool.setMeterNumber(String.valueOf(row.getCell(14)));
 				pool.setRingCage(String.valueOf(row.getCell(15)));
 				pool.setTerminalWarranty(String.valueOf(row.getCell(16)));
 				pool.setSpecialParameters(String.valueOf(row.getCell(17)));
@@ -219,7 +219,7 @@ public class LiKuResourcePoolController extends BaseController {
 						list) {
 					Integer isSectionLength = pool.getIsSectionLength();
 					if (isSectionLength.compareTo(LiKuUtils.YES) == 0) {
-						String lengthOfCable = pool.getLengthOfCable();
+						String lengthOfCable = pool.getMeterNumber();
 						if (null != lengthOfCable && !"".equals(lengthOfCable)) {
 							String[] split = lengthOfCable.split(";");
 							for (int i = 0; i < split.length; i++) {
@@ -230,7 +230,7 @@ public class LiKuResourcePoolController extends BaseController {
 								liKu.setMaterialCode(pool.getMaterialCode());
 								liKu.setMaterialDescription(pool.getMaterialDescription());
 								liKu.setUnitOfMeasurement(pool.getUnitOfMeasurement());
-								liKu.setInventoryAmount(Double.valueOf(split[i]));
+								liKu.setInventoryAmount(pool.getInventoryAmount());
 								liKu.setInventoryLocation(pool.getInventoryLocation());
 								liKu.setInvLocation(pool.getInvLocation());
 								liKu.setInvLocationDes(pool.getInvLocationDes());
@@ -238,7 +238,7 @@ public class LiKuResourcePoolController extends BaseController {
 								liKu.setSpecialStock(pool.getSpecialStock());
 								liKu.setExtendedCoding(pool.getExtendedCoding());
 								liKu.setExtendedDescription(pool.getExtendedDescription());
-								liKu.setLengthOfCable(pool.getLengthOfCable());
+								liKu.setLengthOfCable(Double.valueOf(split[i]));
 								liKu.setRingCage(pool.getRingCage());
 								liKu.setTerminalWarranty(pool.getTerminalWarranty());
 								liKu.setSpecialParameters(pool.getSpecialParameters());
@@ -255,6 +255,7 @@ public class LiKuResourcePoolController extends BaseController {
 							}
 						} else {
 							pool.setSegBelongs(1);
+							pool.setLengthOfCable(pool.getInventoryAmount());
 							insertList.add(pool);
 						}
 					}else {

src/main/java/com/jeeplus/modules/sg/balancedlibrary/materialReportDetails/web/MaterialReportDetailsController.java

@@ -3406,14 +3406,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(bBSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3451,14 +3451,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(yZSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3496,14 +3496,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(dYSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3541,14 +3541,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(jRSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3587,14 +3587,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(yZSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3632,14 +3632,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(dYSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3677,14 +3677,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(jRSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3723,14 +3723,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(bBSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3768,14 +3768,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(dYSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3813,14 +3813,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(jRSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3859,14 +3859,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(bBSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3904,14 +3904,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(yZSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3949,14 +3949,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(jRSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -3996,14 +3996,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(bBSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4041,14 +4041,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(yZSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4086,14 +4086,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(dYSegmentList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4147,14 +4147,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(fourAreaList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4192,14 +4192,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(fourAreaList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4237,14 +4237,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(fourAreaList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4282,14 +4282,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = Calculation(fourAreaList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4386,14 +4386,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(bBList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4431,14 +4431,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(yZList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4476,14 +4476,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(dYList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4521,14 +4521,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(jRList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4567,14 +4567,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(yZList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4612,14 +4612,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(dYList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4657,14 +4657,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(jRList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4703,14 +4703,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(bBList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4748,14 +4748,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(dYList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4793,14 +4793,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(jRList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4839,14 +4839,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(bBList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4884,14 +4884,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(yZList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4929,14 +4929,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(jRList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -4975,14 +4975,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(bBList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -5020,14 +5020,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(yZList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -5065,14 +5065,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(dYList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -5125,14 +5125,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(fourRepList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -5170,14 +5170,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(fourRepList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -5215,14 +5215,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(fourRepList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -5260,14 +5260,14 @@ public class MaterialReportDetailsController extends BaseController {
                     //利库数量
                     BigDecimal niches = BigDecimal.valueOf(pool.getNumberOfNiches());
                     //库存总量
-                    BigDecimal amount = BigDecimal.valueOf(pool.getInventoryAmount());
+                    BigDecimal amount = BigDecimal.valueOf(pool.getLengthOfCable());
                     if (amount.compareTo(niches) == 0) {
                         continue;
                     }
                     //通过物料编码，扩展编码，是否完成利库，获取符合当前利库线段数据的项目集合数据
                     calculation = CalculationRep(fourRepList, poolCode, poExCode);
                     //返回最优解
-                    bestChose = optimalUtil.getOptimal(pool.getInventoryAmount(),calculation);;;
+                    bestChose = optimalUtil.getOptimal(pool.getLengthOfCable(),calculation);;;
                     //计算最优解
                     if (bestChose.size() > 0) {
                         for (MaterialReportDetails a :
@@ -5666,7 +5666,7 @@ public class MaterialReportDetailsController extends BaseController {
         Comparator<LiKuResourcePool> reversed = Comparator.comparing(LiKuResourcePool::getDaysStorage).reversed();
         Comparator<LiKuResourcePool> comparator = Comparator.comparing(LiKuResourcePool::getInventoryAmount).reversed();
         Comparator<LiKuResourcePool> poolComparator = Comparator.comparing(LiKuResourcePool::getBatch);
-        Comparator<LiKuResourcePool> beComparator = Comparator.comparing(LiKuResourcePool::getSegBelongs);
+        Comparator<LiKuResourcePool> beComparator = Comparator.comparing(LiKuResourcePool::getLengthOfCable);
         bBNonPoolList.sort(reversed.thenComparing(comparator).thenComparing(poolComparator).thenComparing(beComparator));
     }