将入库相关处理抽离

src/main/java/com/dreamchaser/depository_manage/controller/DepositoryRecordController.java

@@ -192,6 +192,9 @@ public class DepositoryRecordController {
         List<Integer> recordIds = new ArrayList<>();
 
         if (params.size() < 1 && map.size() > 3) {
+
+
+
             String unit = (String) (map.get("unit"));
             if (!"-1".equals(unit)) {
                 map.put("type", "in");
@@ -310,7 +313,7 @@ public class DepositoryRecordController {
             result.put("err", errMsg);
             result.put("success", successMsg);
         }
-
+        System.out.println("列表list"+recordIds);
         if (integer != 0 && params.size() < 1 && integer != -1) {
             return CrudUtil.postHandle(integer, 1);
         } else if (integer != 0 && params.size() > 0) {

src/main/java/com/dreamchaser/depository_manage/mapper/RoleMapper.java

@@ -59,6 +59,13 @@ public interface RoleMapper {
     List<RoleAndDepository> findRoleAndDepositoryByCondition(Map<String,Object> map);
 
 
+    /**
+     * 判断当前仓库是否需要入库审批
+     * @return
+     */
+    List<RoleAndDepository> findRoleAndDepositoryByDepositoryIdForIn(Integer depositoryId);
+
+
 
     /**
      * 根据id获取权限

src/main/java/com/dreamchaser/depository_manage/mapper/RoleMapper.xml

@@ -113,6 +113,18 @@
     </select>
 
 
+    <select id="findRoleAndDepositoryByDepositoryIdForIn" parameterType="int" resultMap="depositoryAndrole">
+        select
+        <include refid="roleNameAnddepositoryName"/>
+        from userroleanddepository
+        where 1 = 1
+        <if test="depositoryId != null and depositoryId != ''">
+            and did = #{depositoryId}
+        </if>
+       and classes in (3,4)
+    </select>
+
+
     <select id="findRoleAndDepositoryById" parameterType="int" resultMap="depositoryAndrole">
         select
         <include refid="roleNameAnddepositoryName"/>

src/main/java/com/dreamchaser/depository_manage/service/RoleService.java

@@ -81,4 +81,11 @@ public interface RoleService {
      */
     List<RoleAndDepository> findRoleAndDepositoryByDid(Integer did);
 
+
+    /**
+     * 判断当前仓库是否需要入库审批
+     * @return
+     */
+    List<RoleAndDepository> findRoleAndDepositoryByDepositoryIdForIn(Integer depositoryId);
+
 }

src/main/java/com/dreamchaser/depository_manage/service/SplitUnitService.java

@@ -29,6 +29,9 @@ public interface SplitUnitService {
     Integer addSplitInventory(Map<String,Object> map);
 
 
+//    Integer reviewForInventory()
+
+
     /**
      * 根据条件查询对应拆单详细信息
      * @param map 查询条件

src/main/java/com/dreamchaser/depository_manage/service/impl/DepositoryRecordServiceImpl.java

@@ -106,6 +106,8 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
     @Override
     @Transactional(rollbackFor = Exception.class)
     public Integer applicationIn(Map<String, Object> map) {
+        Boolean flagForApproval = ObjectFormatUtil.toBoolean(map.get("flagForApproval"));
+
         Integer depositoryId = ObjectFormatUtil.toInteger(map.get("depositoryId"));
         Depository depositoryRecordById = depositoryMapper.findDepositoryById(depositoryId);
         Map<String, Object> temp = new HashMap<>();
@@ -115,7 +117,7 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
         Integer Inventory = depositoryMapper.getToDayInventoryByDName(temp);
         //构造单号
         String code = createCode(depositoryRecordById.getDname(), "InOrderNumber", "in", "");
-        Double quantity = Double.parseDouble((String) map.get("quantity"));
+        double quantity = Double.parseDouble((String) map.get("quantity"));
         Integer mid = ObjectFormatUtil.toInteger(map.get("mid"));
         // 根据物料id查询物料
         Material material = materialMapper.findMaterialById(mid);
@@ -145,6 +147,39 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
         map.put("code", code);
         // 获取当前物料
 
+        // 获取当前入库物料id
+        Integer newMid = 0;
+        if(!flagForApproval){
+            newMid = updateOrInsertInventory(map,materialByCondition,quantity,mid,depositoryId,producedDate);
+        }
+
+        // 将新入库的物料id记录下来
+        map.put("newInMid", newMid);
+
+        // 如果包含realQuantity则代表是入库的拆单单位
+        if (map.containsKey("realQuantity")) {
+            // 将入库数量修改为realQuantity
+            map.put("quantity", map.get("realQuantity"));
+        }
+        if (!map.containsKey("flagForGroup")) {
+            // 如果不包含标志位.
+            map.put("flagForGroup", 1);
+        }
+        return depositoryRecordMapper.insertApplicationInRecord(map);
+    }
+
+
+    /**
+     * 用于入库申请时，更新物料库存计量
+     * @param map 入库数据
+     * @param materialByCondition 当前仓库是否存在该物料
+     * @param quantity 入库数量
+     * @param mid 入库物料id
+     * @param depositoryId 入库位置
+     * @param producedDate 生产日期
+     * @return
+     */
+    Integer updateOrInsertInventory(Map<String,Object> map,List<Inventory> materialByCondition,Double quantity,Integer mid,Integer depositoryId,long producedDate){
         // 获取当前入库物料id
         Integer newMid = 0;
         if (materialByCondition.size() > 0) { // 如果当前存在
@@ -154,7 +189,8 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
             mt.setProducedDate(producedDate);
             materialMapper.updateInventory(mt);
             newMid = mt.getId();
-        } else {
+        }
+        else {
             Map<String, Object> insert = new HashMap<>();
             Material materialById = materialMapper.findMaterialById(mid);
             insert.put("depositoryId", depositoryId);
@@ -165,19 +201,7 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
             materialMapper.insertInventory(insert);
             newMid = ObjectFormatUtil.toInteger(insert.get("id"));
         }
-        // 将新入库的物料id记录下来
-        map.put("newInMid", newMid);
-
-        // 如果包含realQuantity则代表是入库的拆单单位
-        if (map.containsKey("realQuantity")) {
-            // 将入库数量修改为realQuantity
-            map.put("quantity", map.get("realQuantity"));
-        }
-        if (!map.containsKey("flagForGroup")) {
-            // 如果不包含标志位.
-            map.put("flagForGroup", 1);
-        }
-        return depositoryRecordMapper.insertApplicationInRecord(map);
+        return newMid;
     }
 
 
@@ -620,6 +644,15 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
         if ("-1".equals(unit)) {
             map.put("unit", materialById.getUnit());
         }
+
+        // 获取当前仓库是否需要审批
+        List<RoleAndDepository> depositoryListForIn = roleService.findRoleAndDepositoryByDepositoryIdForIn(ObjectFormatUtil.toInteger(map.get("depositoryId")));
+        boolean flagForApproval = false; // 默认不需要审批
+        if(depositoryListForIn.size() > 0){
+            flagForApproval = true;
+        }
+        map.put("flagForApproval",flagForApproval);
+
         if (placeById.getMax() - placeById.getQuantity() > quantity) {
             // 如果当前库位还能存放
             // 入库
@@ -627,77 +660,100 @@ public class DepositoryRecordServiceImpl implements DepositoryRecordService {
             if (integer != 1) {
                 return -1;
             }
-            // 获取当前入库的物料id
-            Integer newInMid = ObjectFormatUtil.toInteger(map.get("newInMid"));
-            // 获取当前入库记录id
-            Integer InId = ObjectFormatUtil.toInteger(map.get("id"));
-            map.put("applicationInId",map.get("id"));
-            Map<String, Object> insertProducedDate = new HashMap<>();
-            insertProducedDate.put("inid", InId);
-            insertProducedDate.put("mid", newInMid);
-            if (map.containsKey("producedDate")) {
-                long producedDate = 0L;
-                Object s = map.get("producedDate");
-                if (s == null || "".equals(s.toString())) {
-                    producedDate = 0L;
-                } else {
-                    producedDate = DateUtil.DateTimeByDayToTimeStamp(s.toString());
-                    insertProducedDate.put("producedDate", producedDate);
-                }
-            }
-            // 查找当前物料id与生产日期的对应关系
-
-            MaterialAndProducedDate materialAndProducedDateByMidAndProducedDate = materialMapper.findMaterialAndProducedDateByMidAndProducedDate(insertProducedDate);
-            if (materialAndProducedDateByMidAndProducedDate != null) {
-                // 增加当前数量
-                materialAndProducedDateByMidAndProducedDate.setQuantity(materialAndProducedDateByMidAndProducedDate.getQuantity() + quantity);
-                materialAndProducedDateByMidAndProducedDate.setInventory(materialAndProducedDateByMidAndProducedDate.getInventory() + quantity);
-                // 修改
-                materialMapper.updateMaterialAndProducedDate(materialAndProducedDateByMidAndProducedDate);
-            } else {
-                insertProducedDate.put("quantity", quantity);
-                insertProducedDate.put("inventory", quantity);
-                insertProducedDate.put("expendnum", 0);
-                insertProducedDate.put("barCode", map.get("barCode"));
-                insertProducedDate.put("qrCode", map.get("qrCode"));
-                // 插入一条新记录
-                materialMapper.addMaterialAndProducedDate(insertProducedDate);
 
+            if(!flagForApproval){
+                // 如果不需要审批
+                Integer result = updateInventoryInfoForApproval(map, quantity, materialById, placeById);
+                map.remove("applicationInId");
+                return result;
             }
-            // 获取当前库存记录
-            Map<String, Object> param = new HashMap<>();
-            param.put("mcode", materialById.getCode());
-            param.put("mname", materialById.getMname());
-            if (placeId == 0) {
-                param.put("depositoryId", map.get("depositoryId"));
-            } else {
-                param.put("depositoryId", placeById.getDid());
-            }
-            List<Inventory> inventory = materialMapper.findInventory(param);
-            // 获取当前库存
-            Inventory material = inventory.get(0);
+            return integer;
+        } else {
+            return -1;
+        }
+    }
 
-            Map<String, Object> insert = new HashMap<>();
-            insert.put("mid", material.getId());
-            insert.put("pid", placeById.getId());
 
-            MaterialAndPlace placeAndMaterialByMidAndPid = placeMapper.findPlaceAndMaterialByMidAndPid(insert);
-            if (placeAndMaterialByMidAndPid == null) {
-                // 如果没有当前记录
-                insert.put("quantity", quantity);
-                // 插入记录
-                placeMapper.addMaterialOnPlace(insert);
+    /**
+     * 用于入库后修改相关数据信息
+     * @param map 入库数据
+     * @param quantity 数量
+     * @param materialById 入库物料
+     * @param placeById 入库库位
+     * @return
+     */
+    Integer updateInventoryInfoForApproval(Map<String,Object> map,Integer quantity,Material materialById,Place placeById){
+        // 获取当前入库的物料id
+        Integer newInMid = ObjectFormatUtil.toInteger(map.get("newInMid"));
+        // 获取当前入库记录id
+        Integer InId = ObjectFormatUtil.toInteger(map.get("id"));
+        map.put("applicationInId",map.get("id"));
+        Map<String, Object> insertProducedDate = new HashMap<>();
+        insertProducedDate.put("inid", InId);
+        insertProducedDate.put("mid", newInMid);
+        if (map.containsKey("producedDate")) {
+            long producedDate = 0L;
+            Object s = map.get("producedDate");
+            if (s == null || "".equals(s.toString())) {
+                producedDate = 0L;
             } else {
-                placeAndMaterialByMidAndPid.setQuantity(placeAndMaterialByMidAndPid.getQuantity() + quantity);
-                // 修改数量
-                placeMapper.updateMaterialAndPlace(placeAndMaterialByMidAndPid);
+                producedDate = DateUtil.DateTimeByDayToTimeStamp(s.toString());
+                insertProducedDate.put("producedDate", producedDate);
             }
-            // 修改当前库位数量
-            placeById.setQuantity(placeById.getQuantity() + quantity);
-            return placeMapper.UpdatePlace(placeById);
-        } else {
-            return -1;
         }
+        // 查找当前物料id与生产日期的对应关系
+
+        MaterialAndProducedDate materialAndProducedDateByMidAndProducedDate = materialMapper.findMaterialAndProducedDateByMidAndProducedDate(insertProducedDate);
+        if (materialAndProducedDateByMidAndProducedDate != null) {
+            // 增加当前数量
+            materialAndProducedDateByMidAndProducedDate.setQuantity(materialAndProducedDateByMidAndProducedDate.getQuantity() + quantity);
+            materialAndProducedDateByMidAndProducedDate.setInventory(materialAndProducedDateByMidAndProducedDate.getInventory() + quantity);
+            // 修改
+            materialMapper.updateMaterialAndProducedDate(materialAndProducedDateByMidAndProducedDate);
+        }
+        else {
+            insertProducedDate.put("quantity", quantity);
+            insertProducedDate.put("inventory", quantity);
+            insertProducedDate.put("expendnum", 0);
+            insertProducedDate.put("barCode", map.get("barCode"));
+            insertProducedDate.put("qrCode", map.get("qrCode"));
+            // 插入一条新记录
+            materialMapper.addMaterialAndProducedDate(insertProducedDate);
+
+        }
+        // 获取当前库存记录
+        Map<String, Object> param = new HashMap<>();
+        param.put("mcode", materialById.getCode());
+        param.put("mname", materialById.getMname());
+        if (Integer.compare(placeById.getId(),0) == 0) {
+            param.put("depositoryId", map.get("depositoryId"));
+        }
+        else {
+            param.put("depositoryId", placeById.getDid());
+        }
+        List<Inventory> inventory = materialMapper.findInventory(param);
+        // 获取当前库存
+        Inventory material = inventory.get(0);
+
+        Map<String, Object> insert = new HashMap<>();
+        insert.put("mid", material.getId());
+        insert.put("pid", placeById.getId());
+
+        MaterialAndPlace placeAndMaterialByMidAndPid = placeMapper.findPlaceAndMaterialByMidAndPid(insert);
+        if (placeAndMaterialByMidAndPid == null) {
+            // 如果没有当前记录
+            insert.put("quantity", quantity);
+            // 插入记录
+            placeMapper.addMaterialOnPlace(insert);
+        }
+        else {
+            placeAndMaterialByMidAndPid.setQuantity(placeAndMaterialByMidAndPid.getQuantity() + quantity);
+            // 修改数量
+            placeMapper.updateMaterialAndPlace(placeAndMaterialByMidAndPid);
+        }
+        // 修改当前库位数量
+        placeById.setQuantity(placeById.getQuantity() + quantity);
+        return placeMapper.UpdatePlace(placeById);
     }
 
     /**

src/main/java/com/dreamchaser/depository_manage/service/impl/RoleServiceImpl.java

@@ -111,4 +111,12 @@ public class RoleServiceImpl implements RoleService {
         map.put("depositoryId",did);
         return roleMapper.findRoleAndDepositoryByCondition(map);
     }
+    /**
+     * 判断当前仓库是否需要入库审批
+     * @return
+     */
+    @Override
+    public List<RoleAndDepository> findRoleAndDepositoryByDepositoryIdForIn(Integer depositoryId) {
+        return roleMapper.findRoleAndDepositoryByDepositoryIdForIn(depositoryId);
+    }
 }

src/main/java/com/dreamchaser/depository_manage/service/impl/SplitUnitServiceImpl.java

@@ -2,6 +2,7 @@ package com.dreamchaser.depository_manage.service.impl;
 
 import com.dreamchaser.depository_manage.entity.*;
 import com.dreamchaser.depository_manage.mapper.*;
+import com.dreamchaser.depository_manage.pojo.RoleAndDepository;
 import com.dreamchaser.depository_manage.pojo.SplitInfoP;
 import com.dreamchaser.depository_manage.service.DepositoryRecordService;
 import com.dreamchaser.depository_manage.service.SplitUnitService;
@@ -39,6 +40,10 @@ public class SplitUnitServiceImpl implements SplitUnitService {
     DepositoryRecordMapper depositoryRecordMapper;
 
 
+    @Autowired
+    RoleMapper roleMapper;
+
+
     /**
      * 用于添加一条拆单记录
      *
@@ -83,6 +88,15 @@ public class SplitUnitServiceImpl implements SplitUnitService {
         SplitInfo splitInfoForUnit = splitUnitMapper.findSplitInfoByMidAndUnit(paramForSplitInfo);
 
 
+        // 获取当前仓库是否有用户进行管理入库审批
+        List<RoleAndDepository> roleAndDepositoryByCondition = roleMapper.findRoleAndDepositoryByDepositoryIdForIn(ObjectFormatUtil.toInteger(map.get("depositoryId")));
+        // 用于标志该仓库是否需要进行审批
+        boolean flagForApproval = false; // 默认不需要
+        if (roleAndDepositoryByCondition.size() > 0) {
+            flagForApproval = true;
+        }
+
+
         // 用于存储最终计算结果
         Integer result = 0;
 
@@ -148,167 +162,187 @@ public class SplitUnitServiceImpl implements SplitUnitService {
 
             // 获取要操作的数量
             Double quantity = ObjectFormatUtil.toDouble(map.get("quantity"));
-            if ("in".equals(type)) {
-                // 如果是入库操作
+            if ("in".equals(type) && !flagForApproval) {
+                // 如果是入库并且不需要审批
+                result = realInInventoryToDepository(quantity, splitInventory, map, splitInfoForUnit, placeAndMaterialByMidAndPid);
+                map.remove("applicationInId");
+            }else if("in".equals(type)){
+                // 如果是入库且需要审批
+                result = depositoryRecordService.applicationIn(map);
+                map.put("applicationInId",map.get("id"));
+                map.remove("id");
 
-                // 计算处理数量(下取整)
-                int disposeQuantity = (int) Math.round(Math.floor(quantity / scale));
+            }
 
-                // 最终存储到拆单处理的数量
-                double saveQuantity = quantity - disposeQuantity * scale;
+        }
 
-                if (splitInventory != null) {
-                    // 如果有过记录
+        return result;
 
-                    // 最终存储数量
-                    int realQuantity = (int) Math.round(saveQuantity) + splitInventory.getSaveQuantity();
-                    if (realQuantity >= scale) {
-                        // 如果当前入库的数量大于拆单规定的进制数量
+    }
 
-                        // 计算要进的数目
-                        int quantity_in = (realQuantity / scale);
-                        // 更新处理数量
-                        disposeQuantity += quantity_in;
-                        // 拆单库存实际入库的数量
-                        realQuantity = realQuantity - quantity_in * scale;
-                    }
-                    // 设置当前计量单位的库存
-                    splitInventory.setSaveQuantity(realQuantity);
-                    // 设置当前计量单位的入库数目
-                    if (splitInventory.getInQuantity() != null) {
-                        // 如果当前库存不为空
-                        splitInventory.setInQuantity((int) Math.round(splitInventory.getInQuantity() + quantity));
-                    } else {
-                        splitInventory.setInQuantity((int) Math.round(quantity));
 
-                    }
-                    result += splitUnitMapper.updateSplitInventory(splitInventory);
+    Integer realInInventoryToDepository(Double quantity, SplitInventory splitInventory, Map<String, Object> map, SplitInfo splitInfoForUnit, MaterialAndPlace placeAndMaterialByMidAndPid) {
+        Integer result = 0;
 
-                    if (disposeQuantity != 0) {
-                        // 用于更改库存的数量
-                        map.put("quantity", String.valueOf(disposeQuantity));
+        // 获取当前进制
+        Integer scale = splitInfoForUnit.getQuantity();
 
-                    } else {
-                        map.put("quantity", "0");
-                    }
-                    // 实际入库数量
-                    map.put("realQuantity", quantity.toString());
-                    if (splitInfoForUnit.getParentId() != null) {
-                        SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(splitInfoForUnit.getParentId());
-                        updateSplitInfoSaveQuantity(parentSplitInfo, disposeQuantity, placeAndMaterialByMidAndPid.getId(), map, quantity.intValue(), splitInfoForUnit);
+        // 用于存储拆单库存处理操作的数据
+        Map<String, Object> paramForInsertSplitInventory = new HashMap<>();
+        paramForInsertSplitInventory.put("sid", splitInfoForUnit.getId());
+
+        // 如果是入库操作
+
+        // 计算处理数量(下取整)
+        int disposeQuantity = (int) Math.round(Math.floor(quantity / scale));
+
+        // 最终存储到拆单处理的数量
+        double saveQuantity = quantity - disposeQuantity * scale;
+
+        if (splitInventory != null) {
+            // 如果有过记录
+
+            // 最终存储数量
+            int realQuantity = (int) Math.round(saveQuantity) + splitInventory.getSaveQuantity();
+            if (realQuantity >= scale) {
+                // 如果当前入库的数量大于拆单规定的进制数量
+
+                // 计算要进的数目
+                int quantity_in = (realQuantity / scale);
+                // 更新处理数量
+                disposeQuantity += quantity_in;
+                // 拆单库存实际入库的数量
+                realQuantity = realQuantity - quantity_in * scale;
+            }
+            // 设置当前计量单位的库存
+            splitInventory.setSaveQuantity(realQuantity);
+            // 设置当前计量单位的入库数目
+            if (splitInventory.getInQuantity() != null) {
+                // 如果当前库存不为空
+                splitInventory.setInQuantity((int) Math.round(splitInventory.getInQuantity() + quantity));
+            } else {
+                splitInventory.setInQuantity((int) Math.round(quantity));
+
+            }
+            result += splitUnitMapper.updateSplitInventory(splitInventory);
+
+            if (disposeQuantity != 0) {
+                // 用于更改库存的数量
+                map.put("quantity", String.valueOf(disposeQuantity));
+
+            } else {
+                map.put("quantity", "0");
+            }
+            // 实际入库数量
+            map.put("realQuantity", quantity.toString());
+            if (splitInfoForUnit.getParentId() != null) {
+                SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(splitInfoForUnit.getParentId());
+                updateSplitInfoSaveQuantity(parentSplitInfo, disposeQuantity, placeAndMaterialByMidAndPid.getId(), map, quantity.intValue(), splitInfoForUnit);
+            } else {
+                map.put("price", Double.toString(0));
+                depositoryRecordService.applicationInPlace(map);
+                map.put("applicationInId", map.get("id"));
+                map.remove("id");
+            }
+
+
+        } else {
+            // 如果没有记录
+
+            // 获取当前拆单记录的父级
+            Integer parentId = splitInfoForUnit.getParentId();
+
+            if (disposeQuantity != 0) {
+                // 用于更改库存的数量
+                map.put("quantity", String.valueOf(disposeQuantity));
+            } else {
+                map.put("quantity", "0");
+            }
+
+            // 实际入库数量
+            map.put("realQuantity", quantity.toString());
+
+            if (disposeQuantity > splitInfoForUnit.getQuantity()) {
+                //如果当前处理数量大于设置的进制数量
+
+
+                if (parentId != null) {
+                    // 如果该记录有父级拆单
+
+                    SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(parentId);
+                    if (placeAndMaterialByMidAndPid != null) {
+                        updateSplitInfoSaveQuantity(parentSplitInfo, ObjectFormatUtil.toInteger(String.valueOf(saveQuantity)), placeAndMaterialByMidAndPid.getId(), map, quantity.intValue(), splitInfoForUnit);
                     } else {
                         map.put("price", Double.toString(0));
-                        depositoryRecordService.applicationInPlace(map);
-                        map.put("applicationInId",map.get("id"));
+                        result += depositoryRecordService.applicationInPlace(map);
+                        map.put("applicationInId", map.get("id"));
                         map.remove("id");
+                        Map<String, Object> paramForInventoryToPlace = new HashMap<>();
+                        paramForInventoryToPlace.put("mid", map.get("newInMid"));
+                        paramForInventoryToPlace.put("pid", map.get("placeId"));
+                        placeAndMaterialByMidAndPid = placeMapper.findPlaceAndMaterialByMidAndPid(paramForInventoryToPlace);
+                        updateSplitInfoSaveQuantity(parentSplitInfo, ObjectFormatUtil.toInteger(String.valueOf(saveQuantity)), placeAndMaterialByMidAndPid.getId(), map, quantity.intValue(), splitInfoForUnit);
                     }
+                } else {
+                    map.put("price", Double.toString(0));
+                    result += depositoryRecordService.applicationInPlace(map);
+                    map.put("applicationInId", map.get("id"));
+                    map.remove("id");
+                }
+            } else {
+                // 如果不大于设置的进制数量
 
+                paramForInsertSplitInventory.put("inQuantity", quantity);
+                paramForInsertSplitInventory.put("outQuantity", 0);
+                paramForInsertSplitInventory.put("saveQuantity", saveQuantity);
 
-                }
-                else {
-                    // 如果没有记录
+                if (placeAndMaterialByMidAndPid != null) {
+                    // 如果有库存记录
+                    paramForInsertSplitInventory.put("iid", placeAndMaterialByMidAndPid.getId());
+                } else {
+                    // 如果没有库存记录
 
-                    // 获取当前拆单记录的父级
-                    Integer parentId = splitInfoForUnit.getParentId();
+                    // 插入一条库存记录
+                    map.put("price", Double.toString(0));
 
-                    if (disposeQuantity != 0) {
-                        // 用于更改库存的数量
-                        map.put("quantity", String.valueOf(disposeQuantity));
-                    } else {
+
+                    if (parentId != null) {
+                        // 如果有父级
+
+                        // 先插入一条库存记录用于后续操作
                         map.put("quantity", "0");
-                    }
+                        depositoryRecordService.applicationInPlace(map);
+                        map.put("applicationInId", map.get("id"));
+                        depositoryRecordMapper.deleteApplicationInRecordById(ObjectFormatUtil.toInteger(map.get("id")));
+                        map.remove("id");
 
-                    // 实际入库数量
-                    map.put("realQuantity", quantity.toString());
-
-                    if (disposeQuantity > splitInfoForUnit.getQuantity()) {
-                        //如果当前处理数量大于设置的进制数量
-
-
-                        if (parentId != null) {
-                            // 如果该记录有父级拆单
-
-                            SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(parentId);
-                            if (placeAndMaterialByMidAndPid != null) {
-                                updateSplitInfoSaveQuantity(parentSplitInfo, ObjectFormatUtil.toInteger(String.valueOf(saveQuantity)), placeAndMaterialByMidAndPid.getId(), map, quantity.intValue(), splitInfoForUnit);
-                            } else {
-                                map.put("price", Double.toString(0));
-                                result += depositoryRecordService.applicationInPlace(map);
-                                map.put("applicationInId",map.get("id"));
-                                map.remove("id");
-                                Map<String, Object> paramForInventoryToPlace = new HashMap<>();
-                                paramForInventoryToPlace.put("mid", map.get("newInMid"));
-                                paramForInventoryToPlace.put("pid", map.get("placeId"));
-                                placeAndMaterialByMidAndPid = placeMapper.findPlaceAndMaterialByMidAndPid(paramForInventoryToPlace);
-                                updateSplitInfoSaveQuantity(parentSplitInfo, ObjectFormatUtil.toInteger(String.valueOf(saveQuantity)), placeAndMaterialByMidAndPid.getId(), map, quantity.intValue(), splitInfoForUnit);
-                            }
-                        } else {
-                            map.put("price", Double.toString(0));
-                            result += depositoryRecordService.applicationInPlace(map);
-                            map.put("applicationInId",map.get("id"));
-                            map.remove("id");
-                        }
-                    }
-                    else {
-                        // 如果不大于设置的进制数量
-
-                        paramForInsertSplitInventory.put("inQuantity", quantity);
-                        paramForInsertSplitInventory.put("outQuantity", 0);
-                        paramForInsertSplitInventory.put("saveQuantity", saveQuantity);
-
-                        if (placeAndMaterialByMidAndPid != null) {
-                            // 如果有库存记录
-                            paramForInsertSplitInventory.put("iid", placeAndMaterialByMidAndPid.getId());
-                        } else {
-                            // 如果没有库存记录
-
-                            // 插入一条库存记录
-                            map.put("price", Double.toString(0));
-
-
-                            if (parentId != null) {
-                                // 如果有父级
-
-                                // 先插入一条库存记录用于后续操作
-                                map.put("quantity", "0");
-                                depositoryRecordService.applicationInPlace(map);
-                                map.put("applicationInId",map.get("id"));
-                                depositoryRecordMapper.deleteApplicationInRecordById(ObjectFormatUtil.toInteger(map.get("id")));
-                                map.remove("id");
-
-                            } else {
-                                // 如果没有父级
-                                depositoryRecordService.applicationInPlace(map);
-                                map.put("applicationInId",map.get("id"));
-                                map.remove("id");
-                            }
-                            Map<String, Object> paramForInventoryToPlace = new HashMap<>();
-                            paramForInventoryToPlace.put("mid", map.get("newInMid"));
-                            paramForInventoryToPlace.put("pid", map.get("placeId"));
-                            placeAndMaterialByMidAndPid = placeMapper.findPlaceAndMaterialByMidAndPid(paramForInventoryToPlace);
-                            paramForInsertSplitInventory.put("iid", placeAndMaterialByMidAndPid.getId());
-                        }
-
-                        result += splitUnitMapper.addSplitInventory(paramForInsertSplitInventory);
-                        if (parentId != null) {
-                            // 获取父级
-                            SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(splitInfoForUnit.getParentId());
-                            updateSplitInfoSaveQuantity(parentSplitInfo, disposeQuantity, placeAndMaterialByMidAndPid.getId(), map, quantity.intValue(), splitInfoForUnit);
-                        }
+                    } else {
+                        // 如果没有父级
+                        depositoryRecordService.applicationInPlace(map);
+                        map.put("applicationInId", map.get("id"));
+                        map.remove("id");
                     }
+                    Map<String, Object> paramForInventoryToPlace = new HashMap<>();
+                    paramForInventoryToPlace.put("mid", map.get("newInMid"));
+                    paramForInventoryToPlace.put("pid", map.get("placeId"));
+                    placeAndMaterialByMidAndPid = placeMapper.findPlaceAndMaterialByMidAndPid(paramForInventoryToPlace);
+                    paramForInsertSplitInventory.put("iid", placeAndMaterialByMidAndPid.getId());
+                }
 
-
+                result += splitUnitMapper.addSplitInventory(paramForInsertSplitInventory);
+                if (parentId != null) {
+                    // 获取父级
+                    SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(splitInfoForUnit.getParentId());
+                    updateSplitInfoSaveQuantity(parentSplitInfo, disposeQuantity, placeAndMaterialByMidAndPid.getId(), map, quantity.intValue(), splitInfoForUnit);
                 }
             }
-        }
 
-        return result;
 
+        }
+        return result;
     }
 
 
-
-
     /**
      * 用于计算当前拆单单位与目标拆单单位之间的进率
      *
@@ -344,14 +378,14 @@ public class SplitUnitServiceImpl implements SplitUnitService {
     /**
      * 获取当前拆单与基础拆单之间的库存总额(当前拆单记录为-1是全部库存是使用)
      *
-     * @param splitInfoId     当前拆单记录Id
-     * @param materialAndPlace       库存记录
-     * @param baseSplitInfoId 基础拆单记录Id
-     * @param saveQuantity    最终返回值
-     * @param allQuantityFlag 用于标志是否获取全部库存
+     * @param splitInfoId      当前拆单记录Id
+     * @param materialAndPlace 库存记录
+     * @param baseSplitInfoId  基础拆单记录Id
+     * @param saveQuantity     最终返回值
+     * @param allQuantityFlag  用于标志是否获取全部库存
      * @return
      */
-    public int findAllInventoryForSplitInfo(Integer splitInfoId, MaterialAndPlace  materialAndPlace, Integer baseSplitInfoId, int saveQuantity, boolean allQuantityFlag) {
+    public int findAllInventoryForSplitInfo(Integer splitInfoId, MaterialAndPlace materialAndPlace, Integer baseSplitInfoId, int saveQuantity, boolean allQuantityFlag) {
         if (allQuantityFlag) {
 
             // 用于标志是否第一次计算
@@ -417,8 +451,7 @@ public class SplitUnitServiceImpl implements SplitUnitService {
             }
 
 
-        }
-        else {
+        } else {
             // 如果不是获取所有库存
             // 获取当前基础单位
             SplitInfo baseSplitInfo = splitUnitMapper.findSplitInfoById(baseSplitInfoId);
@@ -487,6 +520,7 @@ public class SplitUnitServiceImpl implements SplitUnitService {
 
     /**
      * 用于查找当前拆单是否正在使用
+     *
      * @param sid 待查询id
      * @return
      */
@@ -507,10 +541,10 @@ public class SplitUnitServiceImpl implements SplitUnitService {
     /**
      * 用于拆单库存处理记录的修改
      *
-     * @param splitInfo  对应拆单记录
-     * @param quantity   修改数目
-     * @param map        入库条件
-     * @param inQuantity 最终入库数量
+     * @param splitInfo     对应拆单记录
+     * @param quantity      修改数目
+     * @param map           入库条件
+     * @param inQuantity    最终入库数量
      * @param baseSplitInfo 基础拆单记录
      */
     public void updateSplitInfoSaveQuantity(SplitInfo splitInfo, int quantity, int iid, Map<String, Object> map, int inQuantity, SplitInfo baseSplitInfo) {
@@ -570,11 +604,10 @@ public class SplitUnitServiceImpl implements SplitUnitService {
                     depositoryRecordService.applicationInPlace(map);
                     // 删除入库订单
 //                    depositoryRecordMapper.deleteApplicationInRecordById(ObjectFormatUtil.toInteger(map.get("id")));
-                    map.put("applicationInId",map.get("id"));
+                    map.put("applicationInId", map.get("id"));
                     map.remove("id");
                 }
-            }
-            else {
+            } else {
                 // 当前库存拆单记录与新入库的数目不大于预设的进制
                 splitInventory.setSaveQuantity(splitInventory.getSaveQuantity() + (int) saveQuantity);
                 splitInventory.setInQuantity(splitInventory.getInQuantity() + (int) saveQuantity);
@@ -587,11 +620,10 @@ public class SplitUnitServiceImpl implements SplitUnitService {
                 depositoryRecordService.applicationInPlace(map);
                 // 删除入库订单
 //                depositoryRecordMapper.deleteApplicationInRecordById(ObjectFormatUtil.toInteger(map.get("id")));
-                map.put("applicationInId",map.get("id"));
+                map.put("applicationInId", map.get("id"));
                 map.remove("id");
             }
-        }
-        else {
+        } else {
 
             // 如果为空
             Map<String, Object> paramForInsertSplitInventory = new HashMap<>();
@@ -617,15 +649,14 @@ public class SplitUnitServiceImpl implements SplitUnitService {
                     SplitInfo parentSplitInfo = splitUnitMapper.findSplitInfoById(parentId);
 
                     updateSplitInfoSaveQuantity(parentSplitInfo, quantity_scale, iid, map, inQuantity, baseSplitInfo);
-                }
-                else {
+                } else {
                     map.put("price", Double.toString(0));
                     map.put("quantity", String.valueOf(quantity_scale));
                     map.put("realQuantity", String.valueOf(inQuantity));
                     depositoryRecordService.applicationInPlace(map);
                     // 删除入库订单
 //                    depositoryRecordMapper.deleteApplicationInRecordById(ObjectFormatUtil.toInteger(map.get("id")));
-                    map.put("applicationInId",map.get("id"));
+                    map.put("applicationInId", map.get("id"));
                     map.remove("id");
                 }
             } else {
@@ -638,7 +669,7 @@ public class SplitUnitServiceImpl implements SplitUnitService {
                 depositoryRecordService.applicationInPlace(map);
                 // 删除入库订单
 //                depositoryRecordMapper.deleteApplicationInRecordById(ObjectFormatUtil.toInteger(map.get("id")));
-                map.put("applicationInId",map.get("id"));
+                map.put("applicationInId", map.get("id"));
                 map.remove("id");
 
             }

src/main/java/com/dreamchaser/depository_manage/utils/ObjectFormatUtil.java

@@ -22,7 +22,7 @@ public class ObjectFormatUtil {
     }
 
     public static Boolean toBoolean(Object o){
-        return  (o==null)?null:Boolean.getBoolean(o.toString());
+        return  (o==null)?null:Boolean.parseBoolean(o.toString());
     }
 
     public static Double toDouble(Object o){return (o == null)?null:Double.parseDouble(o.toString());}

src/main/resources/templates/pages/user/userRole.html

@@ -183,7 +183,7 @@
                                     });
                                     //执行搜索重载
                                     table.reload('demo', {
-                                        url: '/findUserRole?userId=' + userId,
+                                        url: '/findUserRole?userId=' + userId+'&classes=1',
                                         page: {
                                             curr: 1
                                         }

src/main/resources/templates/pages/user/userRoleForIn.html

@@ -183,7 +183,7 @@
                                     });
                                     //执行搜索重载
                                     table.reload('demo', {
-                                        url: '/findUserRole?userId=' + userId,
+                                        url: 'findUserRole?userId=' + userId+'&classes=3',
                                         page: {
                                             curr: 1
                                         }

src/test/java/com/dreamchaser/depository_manage/TestOther.java

@@ -1,6 +1,7 @@
 package com.dreamchaser.depository_manage;
 
 
+import com.dreamchaser.depository_manage.utils.ObjectFormatUtil;
 import com.google.zxing.BarcodeFormat;
 import com.google.zxing.EncodeHintType;
 import com.google.zxing.WriterException;
@@ -26,131 +27,14 @@ import java.util.Map;
 @RunWith(SpringRunner.class)
 public class TestOther {
 
-    /**
-     * 条形码宽度
-     */
-    public static final int WIDTH = 300;
-    /**
-     * 条形码高度
-     */
-    public static final int HEIGHT = 52;
-    /**
-     * 加文字 条形码
-     */
-    public static final int WORD_HEIGHT = 120;
 
-    /**
-     * 设置 条形码参数
-     */
-    public Map<EncodeHintType, Object> hints = new HashMap<EncodeHintType, Object>() {
-        public static final long serialVersionUID = 1L;
-
-        {
-            // 设置编码方式
-            put(EncodeHintType.CHARACTER_SET, "utf-8");
-            // 容错级别 这里选择最高H级别
-            put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
-            put(EncodeHintType.MARGIN, 1);
-        }
-    };
 
     @Test
     public void Test() throws IOException {
-        BufferedImage image = insertWords(getBarCode("123456"), "123456");
-        ImageIO.write(image, "jpg", new File("D:/superMan.png"));
-    }
-
-    /**
-     * 生成 图片缓冲
-     *
-     * @param vaNumber VA 码
-     * @return 返回BufferedImage
-     * @author fxbin
-     */
-    public BufferedImage getBarCode(String vaNumber) {
-        try {
-            Code128Writer writer = new Code128Writer();
-            // 编码内容, 编码类型, 宽度, 高度, 设置参数
-            BitMatrix bitMatrix = writer.encode(vaNumber, BarcodeFormat.CODE_128, WIDTH, HEIGHT, hints);
-            return MatrixToImageWriter.toBufferedImage(bitMatrix);
-        } catch (WriterException e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    /**
-     * 把带logo的二维码下面加上文字
-     *
-     * @param image 条形码图片
-     * @param words 文字
-     * @return 返回BufferedImage
-     * @author fxbin
-     */
-    public BufferedImage insertWords(BufferedImage image, String words) {
-        // 新的图片，把带logo的二维码下面加上文字
-        if (StringUtils.isNotEmpty(words)) {
-            BufferedImage outImage = new BufferedImage(WIDTH, WORD_HEIGHT, BufferedImage.TYPE_INT_RGB);
-            Graphics2D g2d = outImage.createGraphics();
-            // 抗锯齿
-            setGraphics2D(g2d);
-            // 设置白色
-            setColorWhite(g2d);
-            // 画条形码到新的面板
-            g2d.drawImage(image, 0, WORD_HEIGHT / 2 -image.getHeight() / 2, image.getWidth(), image.getHeight(), null);
-            // 画文字到新的面板
-            Color color = new Color(0, 0, 0);
-            g2d.setColor(color);
-            // 字体、字型、字号
-            g2d.setFont(new Font("微软雅黑", Font.PLAIN, 16));
-            //文字长度
-            int strWidth = g2d.getFontMetrics().stringWidth(words);
-            //总长度减去文字长度的一半  （居中显示）
-            int wordStartX = (WIDTH - strWidth) / 2;
-            //height + (outImage.getHeight() - height) / 2 + 12
-            int wordStartY = WORD_HEIGHT / 2 + image.getHeight() /2 + 16;
-            // 画文字
-            g2d.drawString(words, wordStartX, wordStartY);
-            g2d.drawString(words, wordStartX, 16);
-            g2d.dispose();
-            outImage.flush();
-            return outImage;
-        }
-        return null;
-    }
-
-    /**
-     * 设置 Graphics2D 属性  （抗锯齿）
-     *
-     * @param g2d Graphics2D提供对几何形状、坐标转换、颜色管理和文本布局更为复杂的控制
-     */
-    public void setGraphics2D(Graphics2D g2d) {
-        // 消除画图锯齿
-        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-        // 消除文字锯齿
-        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-        g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_DEFAULT);
-        Stroke s = new BasicStroke(1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_MITER);
-        g2d.setStroke(s);
-    }
-
-    /**
-     * 设置背景为白色
-     *
-     * @param g2d Graphics2D提供对几何形状、坐标转换、颜色管理和文本布局更为复杂的控制
-     */
-    public void setColorWhite(Graphics2D g2d) {
-        g2d.setColor(Color.WHITE);
-        //填充整个屏幕
-        g2d.fillRect(0, 0, 302, 113);
-        //设置笔刷
-        g2d.setColor(Color.BLACK);
+        System.out.println(ObjectFormatUtil.toBoolean("true"));
     }
 
 
 
-
-
-
 }