修改管理员权限设置页面

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

@@ -599,8 +599,7 @@ public class DepositoryController {
             }
 
 
-        }
+        } else {
-        else {
 
             // 获取本周至今仓库的入/出库数量
             Future<Object> futureForBarChartData = completionService.submit(new distributeTasks(depositoryAllNameAndId, type, 1, userByPort, depositoryName));
@@ -1172,12 +1171,60 @@ public class DepositoryController {
         }
     }
 
+    @PostMapping("/setManagerRole")
+    public RestResponse setManagerRole(@RequestBody Map<String, Object> map, HttpServletRequest request) {
+        if (map.containsKey("permissionType") && map.containsKey("setType")) {
+            // 获取当前登录的用户
+            String token = request.getHeader("user-token");
+            if (token == null) {
+                token = (String) request.getSession().getAttribute("userToken");
+            }
+            UserByPort userToken = AuthenticationTokenPool.getUserToken(token);
+            map.put("userId", userToken.getId());
+            map.put("uid", userToken.getId());
+            // 需要添加的数量
+            Integer count = ObjectFormatUtil.toInteger(map.get("count"));
+            // 操作时影响的行数
+            Integer integer = 0;
+            if (count == 0) {
+                // 如果要删除
+                map.put("depositoryIds", new ArrayList<>());
+                integer = roleService.delManangerForPermission(map);
+                count = integer;
+            } else {
+                // 如果不是删除
+                integer = roleService.setManagerForRole(map);
+            }
+            return CrudUtil.insertHandle(count, integer);
+        } else {
+            throw new MyException("缺少必要参数");
+        }
+    }
+
+    /**
+     * 获取当前条件下的可见仓库
+     *
+     * @param map
+     * @return
+     */
     @PostMapping("/findWarehouseVisiblePermission")
     public RestResponse findWarehouseVisiblePermission(@RequestBody Map<String, Object> map) {
         List<Integer> list = roleService.findDepositoryIdForWarehouseVisiblePermissionByCondition(map);
         return new RestResponse(list);
     }
 
+    /**
+     * 获取当前条件下用户管理的仓库
+     *
+     * @param map
+     * @return
+     */
+    @PostMapping("/findWareHouseForManager")
+    public RestResponse findWareHouseForManager(@RequestBody Map<String, Object> map) {
+        Map<String, Object> result = roleService.findWareHouseForManager(map);
+        return new RestResponse(result);
+    }
+
     /**
      * 用于获取当前仓库的所有子类
      *

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

@@ -2794,7 +2794,7 @@ public class PageController {
         }
         UserByPort userToken = AuthenticationTokenPool.getUserToken(token);
         ModelAndView mv = new ModelAndView();
-        mv.setViewName("pages/company/company-out");
+        mv.setViewName("pages/company/company-out_back");
         List<AdministrationP> administrationPList = LinkInterfaceUtil.findAllCompany(userKey, token);
         mv.addObject("administrationPList", administrationPList);
         mv.addObject("level", 3);

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

@@ -95,6 +95,7 @@ public interface RoleMapper {
 
     /**
      * 根据类型id获取userId
+     *
      * @param mtId
      * @return
      */
@@ -175,43 +176,63 @@ public interface RoleMapper {
     Integer deleteRoleAndMaterialTypeById(Integer id);
 
 
+    /**
+     * 根据条件删除用户管理的仓库
+     * @param map
+     * @return
+     */
+    Integer deleteRoleAndDepositoryByCondition(Map<String, Object> map);
+
+    /**
+     * 根据条件删除用户管理的物料类型
+     * @param map
+     * @return
+     */
+    Integer deleteRoleAndMaterialTypeByCondition(Map<String, Object> map);
+
+
     /**
      * 用于添加添加仓库可见范围
+     *
      * @param map 添加具体数据
      * @return
      */
-    Integer addWarehouseVisiblePermission(Map<String,Object> map);
+    Integer addWarehouseVisiblePermission(Map<String, Object> map);
 
 
     /**
      * 根据条件查询可见范围的数量
+     *
      * @param map 待查询数据
      * @return
      */
-    Integer findWarehouseVisiblePermissionCountByCondition(Map<String,Object> map);
+    Integer findWarehouseVisiblePermissionCountByCondition(Map<String, Object> map);
 
 
     /**
      * 根据条件删除仓库可见范围
+     *
      * @param map
      * @return
      */
-    Integer delWarehouseVisiblePermissionByCondition(Map<String,Object> map);
+    Integer delWarehouseVisiblePermissionByCondition(Map<String, Object> map);
 
 
     /**
      * 根据条件获取在可视范围内的仓库id
+     *
      * @param map
      * @return
      */
-    List<Integer> findDepositoryIdForWarehouseVisiblePermissionByCondition(Map<String,Object> map);
+    List<Integer> findDepositoryIdForWarehouseVisiblePermissionByCondition(Map<String, Object> map);
 
 
     /**
      * 根据条件获取可视范围内的仓库数量
+     *
      * @param map
      * @return
      */
-    Integer findDepositoryIDCountForWarehouseVisiblePermissionByCondition(Map<String,Object> map);
+    Integer findDepositoryIDCountForWarehouseVisiblePermissionByCondition(Map<String, Object> map);
 
 }

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

@@ -94,19 +94,16 @@
     </update>
 
     <insert id="addUserOrPostRoleAndDepository" parameterType="map">
-         INSERT INTO postoruserrole (
+        INSERT ignore INTO postoruserrole (id, classes, role, userid, did)
-            id, classes, role,userid,did
+        VALUES (#{id},
-        ) VALUES (
-            #{id},
                 #{classes},
                 #{authority},
                 #{userid},
-            #{depositoryId}
+                #{depositoryId})
-        )
     </insert>
 
     <insert id="addUserOrPostRoleAndDepositorys" parameterType="map">
-        INSERT INTO postoruserrole (
+        INSERT ignore  INTO postoruserrole (
         id, classes, role,userid,did
         )
         VALUES
@@ -121,18 +118,15 @@
     </insert>
 
     <insert id="addUserOrPostRoleAndMaterialType" parameterType="map">
-         INSERT INTO mtanduserrole (
+        INSERT ignore INTO mtanduserrole (id, classes, uid, mtid)
-            id, classes,uid,mtid
+        VALUES (#{id},
-        ) VALUES (
-            #{id},
                 #{classes},
                 #{userid},
-            #{mtid}
+                #{mtid})
-        )
     </insert>
 
     <insert id="addUserOrPostRoleAndMaterialTypes" parameterType="map">
-        INSERT INTO mtanduserrole (
+        INSERT ignore INTO mtanduserrole (
         id, classes,uid,mtid
         )
         VALUES
@@ -154,16 +148,29 @@
     </select>
 
     <select id="findRoleByUid" parameterType="int" resultType="int">
-         select role from postoruserrole where userid = #{uid} and classes = 1
+        select role
+        from postoruserrole
+        where userid = #{uid}
+          and classes = 1
     </select>
 
 
     <select id="findUserIdByDid" parameterType="int" resultType="int">
-        select userid from postoruserrole  where 1 = 1 and did = #{did}  and classes in (1,2) group by userid
+        select userid
+        from postoruserrole
+        where 1 = 1
+          and did = #{did}
+          and classes in (1, 2)
+        group by userid
     </select>
 
     <select id="findUserIdByMtId" parameterType="long" resultType="int">
-        select uid from mtanduserrole  where 1 = 1 and mtid = #{mtId}  and classes in (1,2) group by uid
+        select uid
+        from mtanduserrole
+        where 1 = 1
+          and mtid = #{mtId}
+          and classes in (1, 2)
+        group by uid
     </select>
 
     <select id="findRoleAndDepositoryByCondition" parameterType="map" resultMap="depositoryAndrole">
@@ -195,7 +202,19 @@
             and did = #{depositoryId}
         </if>
         <if test="userId != null and userId != ''">
-            and userId = #{userId}
+            and userid = #{userId}
+        </if>
+        <if test="uidList != null">
+            and userid in
+            <foreach collection="uidList" index="index" item="uid" open="(" separator="," close=")">
+                #{uid}
+            </foreach>
+        </if>
+        <if test="depositoryIdList != null and depositoryIdList !=''">
+            and did in
+            <foreach collection="depositoryIdList" index="index" item="did" open="(" separator="," close=")">
+                #{did}
+            </foreach>
         </if>
         <if test="classes != null and classes != ''">
             and classes = #{classes}
@@ -228,9 +247,21 @@
         <if test="mtid != null and mtid != ''">
             and mtid = #{mtid}
         </if>
+        <if test="mtIdList != null and mtIdList !=''">
+            and mtid in
+            <foreach collection="mtIdList" index="index" item="mtid" open="(" separator="," close=")">
+                #{mtid}
+            </foreach>
+        </if>
         <if test="uid != null and uid != ''">
             and uid = #{uid}
         </if>
+        <if test="uidList != null">
+            and uid in
+            <foreach collection="uidList" index="index" item="uid" open="(" separator="," close=")">
+                #{uid}
+            </foreach>
+        </if>
         <if test="classes != null and classes != ''">
             and classes = #{classes}
         </if>
@@ -252,11 +283,15 @@
     </select>
 
     <delete id="deleteRoleAndDepositoryById" parameterType="int">
-        delete  from postoruserrole  WHERE id = #{id}
+        delete
+        from postoruserrole
+        WHERE id = #{id}
     </delete>
 
     <delete id="deleteRoleAndMaterialTypeById" parameterType="int">
-        delete  from mtanduserrole  WHERE id = #{id}
+        delete
+        from mtanduserrole
+        WHERE id = #{id}
     </delete>
 
     <insert id="addWarehouseVisiblePermission">
@@ -323,6 +358,48 @@
     </delete>
 
 
+    <delete id="deleteRoleAndDepositoryByCondition" parameterType="map">
+        delete from postoruserrole
+        where classes = #{classes}
+        <if test="userIdList != null and userIdList !=''">
+            and userid in
+            <foreach collection="userIdList" index="index" item="userid" open="(" separator="," close=")">
+                #{userid}
+            </foreach>
+        </if>
+        <if test="userId != null and userId != ''">
+            and userid = #{userId}
+        </if>
+        <if test="depositoryIdList != null and depositoryIdList != ''">
+            and did in
+            <foreach collection="depositoryIdList" index="index" item="did" open="(" separator="," close=")">
+                #{did}
+            </foreach>
+        </if>
+    </delete>
+
+
+    <delete id="deleteRoleAndMaterialTypeByCondition" parameterType="map">
+        delete from mtanduserrole
+        where classes = #{classes}
+        <if test="userIdList != null and userIdList !=''">
+            and uid in
+            <foreach collection="userIdList" index="index" item="userid" open="(" separator="," close=")">
+                #{userid}
+            </foreach>
+        </if>
+        <if test="uid != null and uid != ''">
+            and uid = #{uid}
+        </if>
+        <if test="materialTypeIdList != null and materialTypeIdList != ''">
+            and mtid in
+            <foreach collection="materialTypeIdList" index="index" item="mtid" open="(" separator="," close=")">
+                #{mtid}
+            </foreach>
+        </if>
+    </delete>
+
+
     <select id="findDepositoryIdForWarehouseVisiblePermissionByCondition" parameterType="map" resultType="int">
         select
         did
@@ -346,6 +423,4 @@
     </select>
 
 
-
-
 </mapper>

src/main/java/com/dreamchaser/depository_manage/pojo/RoleAndMaterialType.java

@@ -15,7 +15,7 @@ public class RoleAndMaterialType {
     /**
      * 类型id
      */
-    private Integer mtid;
+    private Long mtid;
     /**
      * 类型名称
      */

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

@@ -164,20 +164,42 @@ public interface RoleService {
 
 
     /**
-     * 用于删除权限
+     * 用于添加管理权限
+     * @param map 添加具体数据
+     * @return
+     */
+    Integer setManagerForRole(Map<String,Object> map);
+
+
+    /**
+     * 用于删除开放仓库
      * @param map 待删除数据
      */
     Integer delWarehouseVisiblePermission(Map<String,Object> map);
 
+    /**
+     * 用于删除权限
+     * @param map 待删除数据
+     * @return
+     */
+    Integer delManangerForPermission(Map<String,Object> map);
+
 
     /**
-     * 根据调剂获取在可视范围内的仓库id
+     * 根据条件获取在可视范围内的仓库id
-     * @param map 待查询调剂
+     * @param map 待查询条件
      * @return
      */
     List<Integer> findDepositoryIdForWarehouseVisiblePermissionByCondition(Map<String,Object> map);
 
 
+    /**
+     * 根据条件获取管理的的仓库id
+     * @param map 待查询条件
+     * @return
+     */
+    Map<String,Object> findWareHouseForManager(Map<String,Object> map);
+
     /**
      * 用于查询当前用户所被赋予的可见仓库
      * @param userToken 待查询用户

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

@@ -265,6 +265,7 @@ public class CompanyServiceImpl implements CompanyService {
      */
     @Override
     public JSONArray BuildOrgAndPostThree(String userKey,String token) {
+
         JSONArray orgAndPostThree = LinkInterfaceUtil.getOrgAndPostThree(userKey,token);
         // 将获取到的json字符串进行修改为使用的结构
         String replace = JSONObject.toJSONString(orgAndPostThree).replace("name", "title").replace("child", "children");

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

@@ -130,7 +130,7 @@ public class MaterialServiceImpl implements MaterialService {
         if (map.containsKey("barCode")) {
             materialMapper.addBarCodeAndMcode(map);
         }
-        map.put("createTime",System.currentTimeMillis());
+        map.put("createTime", System.currentTimeMillis());
         return materialMapper.insertMaterial(map);
     }
 
@@ -183,7 +183,7 @@ public class MaterialServiceImpl implements MaterialService {
             Long producedDate = DateUtil.DateTimeByDayToTimeStamp(map.get("producedDate").toString());
             map.put("producedDate", producedDate);
         }
-        map.put("updateTime",System.currentTimeMillis());
+        map.put("updateTime", System.currentTimeMillis());
         return materialMapper.updateMaterial(map);
     }
 
@@ -683,9 +683,9 @@ public class MaterialServiceImpl implements MaterialService {
      */
     @Override
     public Integer changeStateToDeletedById(Integer id) {
-        Map<String,Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>();
-        map.put("id",id);
+        map.put("id", id);
-        map.put("updateTime",System.currentTimeMillis());
+        map.put("updateTime", System.currentTimeMillis());
         return materialMapper.changeStateToDeletedById(map);
     }
 
@@ -697,9 +697,9 @@ public class MaterialServiceImpl implements MaterialService {
      */
     @Override
     public Integer changeStateToDeletedByIds(List<Integer> ids) {
-        Map<String,Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>();
-        map.put("list",ids);
+        map.put("list", ids);
-        map.put("updateTime",System.currentTimeMillis());
+        map.put("updateTime", System.currentTimeMillis());
         return materialMapper.changeStateToDeletedByIds(map);
     }
 
@@ -731,7 +731,7 @@ public class MaterialServiceImpl implements MaterialService {
      */
     @Override
     public Integer updateStateByParam(Map<String, Object> map) {
-        map.put("updateTime",System.currentTimeMillis());
+        map.put("updateTime", System.currentTimeMillis());
         return materialMapper.updateStateByParam(map);
     }
 
@@ -743,7 +743,7 @@ public class MaterialServiceImpl implements MaterialService {
      */
     @Override
     public Integer updateStateByTypeId(Map<String, Object> map) {
-        map.put("updateTime",System.currentTimeMillis());
+        map.put("updateTime", System.currentTimeMillis());
         return materialMapper.updateStateByTypeId(map);
     }
 
@@ -870,7 +870,7 @@ public class MaterialServiceImpl implements MaterialService {
                     int scale = splitUnitService.findSplitInfoScaleQuantity(splitInfo, -1);
                     BigDecimal bigDecimal = BigDecimal.valueOf(inventory.getPrice() / scale);
                     double split_price = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
-                    amounts = ObjectFormatUtil.sum(amounts,split_price * saveQuantity);
+                    amounts = ObjectFormatUtil.sum(amounts, split_price * saveQuantity);
                     unit = splitInfo.getNewUnit();
 
                 }
@@ -2361,8 +2361,8 @@ public class MaterialServiceImpl implements MaterialService {
                 e.printStackTrace();
             }
             redisPool.getRedisTemplateByDb(15).opsForList().rightPush("wms_materialTree_result", JSON.toJSONString(result));
-            redisPool.getRedisTemplateByDb(15).expire("wms_materialTree_result", DateUtil.getSecondsNextEarlyMorning(), TimeUnit.SECONDS);
         }
+        redisPool.getRedisTemplateByDb(15).expire("wms_materialTree_result", DateUtil.getSecondsNextEarlyMorning(), TimeUnit.SECONDS);
         // 关闭线程池
         PublicConfig.closeThreadPool(exs);
     }
@@ -2643,6 +2643,7 @@ public class MaterialServiceImpl implements MaterialService {
 
     /**
      * 用于完成出库任务时获取对应的库存数据
+     *
      * @param map
      * @return
      */
@@ -2664,7 +2665,7 @@ public class MaterialServiceImpl implements MaterialService {
             }
         } else {
             // 如果不是默认库位
-            map.put("placeId",pid);
+            map.put("placeId", pid);
             List<MaterialAndPlaceForViewP> placeAndMaterialByCondition = placeService.findPlaceAndMaterialByCondition(map);
             for (MaterialAndPlaceForViewP materialAndPlaceForViewP : placeAndMaterialByCondition) {
                 midList.add(materialAndPlaceForViewP.getMid());

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

@@ -1,11 +1,14 @@
 package com.dreamchaser.depository_manage.service.impl;
 
+import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.dreamchaser.depository_manage.config.PublicConfig;
 import com.dreamchaser.depository_manage.entity.MaterialType;
 import com.dreamchaser.depository_manage.mapper.MaterialTypeMapper;
+import com.dreamchaser.depository_manage.security.pool.RedisPool;
 import com.dreamchaser.depository_manage.service.MaterialTypeService;
+import com.dreamchaser.depository_manage.utils.DateUtil;
 import com.dreamchaser.depository_manage.utils.ObjectFormatUtil;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -22,34 +25,37 @@ import java.util.concurrent.*;
 public class MaterialTypeServiceImpl implements MaterialTypeService {
     @Autowired
     MaterialTypeMapper materialTypeMapper;
+    @Autowired
+    private RedisPool redisPool;
 
     /**
      * 插入一条物料类型记录
+     *
      * @param map 参数map
      * @return 受影响的数量
      */
     @Override
-    public Integer insertMaterialType(Map<String,Object> map) {
+    public Integer insertMaterialType(Map<String, Object> map) {
-        if("".equals(map.get("materialTypeId"))){
+        if ("".equals(map.get("materialTypeId"))) {
-            map.put("parentId",0);
+            map.put("parentId", 0);
-        }else{
+        } else {
-            map.put("parentId",map.get("materialTypeId"));
+            map.put("parentId", map.get("materialTypeId"));
             map.remove("materialTypeId");
         }
         Object oldId = map.get("oldId");
-        if(oldId == null) {
+        if (oldId == null) {
-            Long parentId =Long.valueOf(map.get("parentId").toString());
+            Long parentId = Long.valueOf(map.get("parentId").toString());
             MaterialType materialTypeById = materialTypeMapper.findMaterialTypeByOldId(parentId);
             Integer size = 0;
             String firstName = "";
-            if(materialTypeById == null){
+            if (materialTypeById == null) {
                 List<MaterialType> materialTypeByParent = materialTypeMapper.findMaterialTypeByParent(Long.valueOf("0"));
                 size = materialTypeByParent.size();
-            }else{
+            } else {
                 List<MaterialType> materialTypeByParent = materialTypeMapper.findMaterialTypeByParent(materialTypeById.getOldId());
                 size = materialTypeByParent.size();
                 firstName = materialTypeById.getOldId().toString();
-                map.put("parentId",materialTypeById.getOldId());
+                map.put("parentId", materialTypeById.getOldId());
             }
             map.put("oldId", firstName + String.format("%02d", size + 1));
         }
@@ -58,45 +64,48 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 根据条件查询对应记录数目
+     *
      * @param map
      * @return 对应数目
      */
     @Override
     public Integer findMaterialTypeCountByCondition(Map<String, Object> map) {
         Object state = 1;
-        if(map.containsKey("state")){
+        if (map.containsKey("state")) {
             state = map.get("state");
         }
-        map.put("state",state);
+        map.put("state", state);
         return materialTypeMapper.findMaterialTypeCountByCondition(map);
     }
 
     /**
      * 根据条件查询物料类型
+     *
      * @param map
      * @return 符合条件的记录
      */
     @Override
     public List<MaterialType> findMaterialTypeByCondition(Map<String, Object> map) {
-        Integer size = 10,page=1;
+        Integer size = 10, page = 1;
-        if (map.containsKey("size")){
+        if (map.containsKey("size")) {
-            size= ObjectFormatUtil.toInteger(map.get("size"));
+            size = ObjectFormatUtil.toInteger(map.get("size"));
             map.put("size", size);
         }
-        if (map.containsKey("page")){
+        if (map.containsKey("page")) {
-            page=ObjectFormatUtil.toInteger(map.get("page"));
+            page = ObjectFormatUtil.toInteger(map.get("page"));
-            map.put("begin",(page-1)*size);
+            map.put("begin", (page - 1) * size);
         }
         Object state = 1;
-        if(map.containsKey("state")){
+        if (map.containsKey("state")) {
             state = map.get("state");
         }
-        map.put("state",state);
+        map.put("state", state);
         return materialTypeMapper.findMaterialTypeByCondition(map);
     }
 
     /**
      * 查询所有物料类型
+     *
      * @return 所有记录
      */
     @Override
@@ -107,6 +116,7 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 查询所有顶级类型
+     *
      * @return
      */
     @Override
@@ -116,6 +126,7 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 根据主键id完全删除记录
+     *
      * @param id
      * @return 受影响数目
      */
@@ -126,6 +137,7 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 根据多个主键id删除记录
+     *
      * @param ids
      * @return 受影响数目
      */
@@ -136,12 +148,13 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 修改物料类型
+     *
      * @param map
      * @return 受影响条数
      */
     @Override
     public Integer updateMaterialType(Map<String, Object> map) {
-        if(map.containsKey("parentId")) {
+        if (map.containsKey("parentId")) {
             String parentId = (String) map.get("parentId");
             if (parentId.isEmpty()) {
                 map.put("parentId", 0);
@@ -152,6 +165,7 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 根据主键id查询对应物料类型
+     *
      * @param id
      * @return 对应记录
      */
@@ -162,6 +176,7 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 根据类型名称查询物料类型
+     *
      * @param name
      * @return
      */
@@ -177,6 +192,7 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 根据主键id将物料类型状态修改为删除
+     *
      * @param id
      * @return 受影响条数
      */
@@ -187,6 +203,7 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 根据多个主键ids将物料类型状态修改为删除
+     *
      * @param ids
      * @return 受影响条数
      */
@@ -197,6 +214,7 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 根据条件更改类型状态
+     *
      * @param map
      * @return
      */
@@ -208,6 +226,7 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 获取当前类别下的所有类别
+     *
      * @param mtId 待查询类别Id
      * @return
      */
@@ -228,12 +247,30 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 构造树形选择框
+     *
      * @return
      */
     @Override
     public List<Object> InitTreeMenus() {
         List<Object> list = new ArrayList<>();
-        list =  buildTree_New(InitTreeMenus_New(),Long.valueOf(0));
+        List<String> wms_materialTree_result = redisPool.getRedisTemplateByDb(15).opsForList().range("wms_materialTypeTree_result", 0, -1);
+        if (wms_materialTree_result != null && wms_materialTree_result.size() != 0) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            for (String s : wms_materialTree_result) {
+                JSONObject jsonObject = JSONObject.parseObject(s);
+                list.add(jsonObject);
+            }
+            return list;
+        }
+        list = buildTree_New(InitTreeMenus_New(), 0L);
+        for (Object obj : list) {
+            redisPool.getRedisTemplateByDb(15).opsForList().rightPush("wms_materialTypeTree_result", JSON.toJSONString(obj));
+        }
+        redisPool.getRedisTemplateByDb(15).expire("wms_materialTypeTree_result", DateUtil.getSecondsNextEarlyMorning(), TimeUnit.SECONDS);
         return list;
     }
 
@@ -300,43 +337,14 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
         return list;
     }
 
-    // 用于执行测试新算法
-    class TaskTest_New implements Callable<Object> {
-
-        // 待处理的物料类型id列表
-        List<Long> materialTypeIdList;
-
-        public TaskTest_New(List<Long> materialTypeByCondition) {
-            this.materialTypeIdList = materialTypeByCondition;
-        }
-
-        @Override
-        public Object call() throws Exception {
-
-            // 定义树结构结果集
-            List<Object> list = new ArrayList<>();
-            // 查询当前物料类型id列表中的物料类型
-            List<MaterialType> materialTypeByOldIds = materialTypeMapper.findMaterialTypeByOldIds(materialTypeIdList);
-
-            for (int i = 0; i < materialTypeByOldIds.size(); i++) {
-                MaterialType mt = materialTypeByOldIds.get(i);
-                Map<String, Object> map = InitTreeMenus(mt, new ArrayList<>());
-                list.add(map);
-            }
-            return list;
-        }
-
-
-    }
-
     // 构造树形组件数据模板
     public Map<String, Object> InitTreeMenus(MaterialType mt, List<Object> children) {
         if (mt != null) {
             Map<String, Object> map = new HashMap<>();
             map.put("title", mt.getTname());
             map.put("id", mt.getOldId());
-            map.put("parentId",mt.getParentId());
+            map.put("parentId", mt.getParentId());
-            map.put("children",children);
+            map.put("children", children);
             return map;
         } else {
             return null;
@@ -345,11 +353,12 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
 
     /**
      * 用于构造树结构
+     *
      * @param list     树列表
      * @param parentId 父级id
      * @return
      */
-    public List<Object> buildTree_New(List<Object> list,Long parentId){
+    public List<Object> buildTree_New(List<Object> list, Long parentId) {
         // 定义树结构
         List<Object> result = new ArrayList<>();
         for (int i = 0; i < list.size(); i++) {
@@ -357,7 +366,7 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
             JSONObject jsonObject = new JSONObject((Map<String, Object>) list.get(i));
             // 获取当前父级id
             Long parentId1 = jsonObject.getLong("parentId");
-            if(Long.compare(parentId,parentId1) == 0){ // 如果当前类型是其父类
+            if (Long.compare(parentId, parentId1) == 0) { // 如果当前类型是其父类
                 List<Object> objectList = buildTree_New(list, jsonObject.getLong("id")); // 获取当前类型的子类
                 JSONArray children = jsonObject.getJSONArray("children");
                 children.addAll(objectList);
@@ -367,5 +376,34 @@ public class MaterialTypeServiceImpl implements MaterialTypeService {
         return result;
     }
 
+    // 用于执行测试新算法
+    class TaskTest_New implements Callable<Object> {
+
+        // 待处理的物料类型id列表
+        List<Long> materialTypeIdList;
+
+        public TaskTest_New(List<Long> materialTypeByCondition) {
+            this.materialTypeIdList = materialTypeByCondition;
+        }
+
+        @Override
+        public Object call() throws Exception {
+
+            // 定义树结构结果集
+            List<Object> list = new ArrayList<>();
+            // 查询当前物料类型id列表中的物料类型
+            List<MaterialType> materialTypeByOldIds = materialTypeMapper.findMaterialTypeByOldIds(materialTypeIdList);
+
+            for (int i = 0; i < materialTypeByOldIds.size(); i++) {
+                MaterialType mt = materialTypeByOldIds.get(i);
+                Map<String, Object> map = InitTreeMenus(mt, new ArrayList<>());
+                list.add(map);
+            }
+            return list;
+        }
+
+
+    }
+
 
 }

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

@@ -19,6 +19,7 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 @Service
 public class RoleServiceImpl implements RoleService {
@@ -284,11 +285,9 @@ public class RoleServiceImpl implements RoleService {
         // 获取当前赋值的权限类型
         String type = (String) map.get("type");
         // 定义返回结果
-        Integer result = 0;
+        int result = 0;
         // 用于插入权限列表
         Map<String, Object> paramForInsert = new HashMap<>();
-
-
         if ("person".equals(type)) {
             // 如果是对人员赋权
             paramForInsert.put("type", 1);
@@ -323,7 +322,79 @@ public class RoleServiceImpl implements RoleService {
                 result += (roleMapper.addWarehouseVisiblePermission(paramForInsert) - paramCount);
             }
         }
+        return result;
+    }
+
+    /**
+     * 用于添加管理权限
+     *
+     * @param map 添加具体数据
+     * @return
+     */
+    @Override
+    public Integer setManagerForRole(Map<String, Object> map) {
+        // 获取当前赋值的权限类型
+        String setType = (String) map.get("setType");
+        String permissionType = (String) map.get("permissionType");
+        // 定义返回结果
+        int result = 0;
+        // 用于插入权限列表
+        Map<String, Object> paramForInsert = new HashMap<>();
+        if ("person".equals(setType)) {
+            // 如果是对人员赋权
+            paramForInsert.put("classes", 1);
+        } else if ("post".equals(setType)) {
+            // 如果是对岗位赋权
+            paramForInsert.put("classes", 2);
+        } else {
+            throw new MyException("未知参数错误");
+        }
+        // 获取当前要处理的数量
+        Integer count = ObjectFormatUtil.toInteger(map.get("count"));
+        List<Object> userIds = (List<Object>) map.get("userIds");
+        paramForInsert.put("uidList", userIds);
+        if ("depository".equals(permissionType)) {
+            // 获取当前要处理用于及其仓库的数量
+            Integer countByCondition = roleMapper.findRoleAndDepositoryCountByCondition(paramForInsert);
+            if (countByCondition > count) {
+                // 当前数量小于已存在的数量，则代表权限删除
+                result = countByCondition - delManangerForPermission(map);
+            } else {
+                paramForInsert.put("depositoryIds", map.get("roleIds"));
+                // 用于查询当前可见的仓库id数量
+                Map<String, Object> paramForCount = new HashMap<>();
+                paramForCount.put("classes", paramForInsert.get("classes"));
+                for (Object userId : userIds
+                ) {
+                    paramForInsert.put("userid", userId);
+                    paramForCount.put("userId", userId);
+                    Integer paramCount = roleMapper.findRoleAndDepositoryCountByCondition(paramForCount);
+                    result += (roleMapper.addUserOrPostRoleAndDepositorys(paramForInsert) + paramCount);
+                }
+            }
+        } else if ("materialType".equals(permissionType)) {
+            // 获取当前要处理用于及其物料类型的数量
+            Integer countByCondition = roleMapper.findRoleAndMaterialTypeCountByCondition(paramForInsert);
+            if (countByCondition > count) {
+                // 当前数量小于已存在的数量，则代表权限删除
+                result = countByCondition - delManangerForPermission(map);
+            } else {
+                paramForInsert.put("mtIds", map.get("roleIds"));
+                // 用于查询当前可见的仓库id数量
+                Map<String, Object> paramForCount = new HashMap<>();
+                paramForCount.put("classes", paramForInsert.get("classes"));
+                for (Object userId : userIds
+                ) {
+                    paramForInsert.put("userid", userId);
+                    paramForCount.put("uid", userId);
+                    Integer paramCount = roleMapper.findRoleAndMaterialTypeCountByCondition(paramForCount);
+                    result += (roleMapper.addUserOrPostRoleAndMaterialTypes(paramForInsert) + paramCount);
+                }
+            }
 
+        } else {
+            throw new MyException("未知参数错误");
+        }
 
         return result;
     }
@@ -336,7 +407,6 @@ public class RoleServiceImpl implements RoleService {
     @Override
     public Integer delWarehouseVisiblePermission(Map<String, Object> map) {
         // 获取当前赋值的权限类型
-
         Map<String, Object> paramForDelete = new HashMap<>();
         Integer integer = 0;
         String type = (String) map.get("type");
@@ -363,16 +433,99 @@ public class RoleServiceImpl implements RoleService {
             ) {
                 paramForDelete.put("uid", uid);
                 // 获取当前用户所拥有的权限
-                List<Integer> depositoryIdList = roleMapper.findDepositoryIdForWarehouseVisiblePermissionByCondition(paramForDelete);
                 // 获取当前已拥有的与新拥有的差集
-                depositoryIdList.removeAll(depositoryIds);
+                List<Integer> depositoryIdList = roleMapper.findDepositoryIdForWarehouseVisiblePermissionByCondition(paramForDelete);
-                paramForDelete.put("depositoryIdList", depositoryIdList);
+                List<String> depositoryIdsString = depositoryIds.stream().map(Object::toString).collect(Collectors.toList());
+                List<String> depositoryIdListString = depositoryIdList.stream().map(Object::toString).collect(Collectors.toList());
+                depositoryIdListString.removeAll(depositoryIdsString);
+                paramForDelete.put("depositoryIdList", depositoryIdListString);
                 integer += roleMapper.delWarehouseVisiblePermissionByCondition(paramForDelete);
             }
         }
         return integer;
     }
 
+    /**
+     * 用于删除权限
+     *
+     * @param map
+     * @return
+     */
+    @Override
+    public Integer delManangerForPermission(Map<String, Object> map) {
+        // 获取当前赋值的权限类型
+        Map<String, Object> paramForDelete = new HashMap<>();
+        Integer integer = 0;
+        String setType = (String) map.get("setType");
+        String permissionType = (String) map.get("permissionType");
+        if ("person".equals(setType)) {
+            // 如果是对人员赋权
+            paramForDelete.put("classes", 1);
+        } else if ("post".equals(setType)) {
+            // 如果是对岗位赋权
+            paramForDelete.put("classes", 2);
+        } else {
+            throw new MyException("未知参数错误");
+        }
+        List<Object> userIds = (List<Object>) map.get("userIds");
+        if ("depository".equals(permissionType)) {
+            List<Object> depositoryIds = (List<Object>) map.get("roleIds");
+            if (depositoryIds.size() == 0) {
+                // 如果是要删除所有的
+                paramForDelete.put("userIdList", userIds);
+                // 删除当前所有的权限
+                integer = roleMapper.deleteRoleAndDepositoryByCondition(paramForDelete);
+            } else {
+                // 如果不是所有
+                for (Object uid : userIds
+                ) {
+                    paramForDelete.put("userId", uid);
+                    // 获取当前用户所拥有的权限
+                    List<Object> depositoryIdList = new ArrayList<>();
+                    List<RoleAndDepository> roleAndDepositoryByCondition = roleMapper.findRoleAndDepositoryByCondition(paramForDelete);
+                    for (RoleAndDepository roleAndDepository : roleAndDepositoryByCondition) {
+                        depositoryIdList.add(roleAndDepository.getDepositoryId());
+                    }
+                    // 获取当前已拥有的与新拥有的差集
+                    List<String> depositoryIdsString = depositoryIds.stream().map(Object::toString).collect(Collectors.toList());
+                    List<String> depositoryIdListString = depositoryIdList.stream().map(Object::toString).collect(Collectors.toList());
+                    depositoryIdListString.removeAll(depositoryIdsString);
+                    paramForDelete.put("depositoryIdList", depositoryIdListString);
+                    integer += roleMapper.deleteRoleAndDepositoryByCondition(paramForDelete);
+                }
+            }
+        } else if ("materialType".equals(permissionType)) {
+            List<Object> materialTypeIds = (List<Object>) map.get("roleIds");
+            if (materialTypeIds.size() == 0) {
+                // 如果是要删除所有的
+                paramForDelete.put("userIdList", userIds);
+                // 删除当前所有的权限
+                integer = roleMapper.deleteRoleAndMaterialTypeByCondition(paramForDelete);
+            } else {
+                // 如果不是所有
+                for (Object uid : userIds
+                ) {
+                    paramForDelete.put("uid", uid);
+                    // 获取当前用户所拥有的权限
+                    List<Object> materialTypeIdList = new ArrayList<>();
+                    List<RoleAndMaterialType> roleAndMaterialTypeByCondition = roleMapper.findRoleAndMaterialTypeByCondition(paramForDelete);
+                    for (RoleAndMaterialType roleAndMaterialType : roleAndMaterialTypeByCondition) {
+                        materialTypeIdList.add(roleAndMaterialType.getMtid());
+                    }
+                    // 获取当前已拥有的与新拥有的差集
+                    List<String> materialTypeIdsString = materialTypeIds.stream().map(Object::toString).collect(Collectors.toList());
+                    List<String> materialTypeIdListString = materialTypeIdList.stream().map(Object::toString).collect(Collectors.toList());
+                    materialTypeIdListString.removeAll(materialTypeIdsString);
+                    paramForDelete.put("materialTypeIdList", materialTypeIdListString);
+                    integer += roleMapper.deleteRoleAndMaterialTypeByCondition(paramForDelete);
+                }
+            }
+        } else {
+            throw new MyException("未知参数错误");
+        }
+        return integer;
+    }
+
     /**
      * 根据调剂获取在可视范围内的仓库id
      *
@@ -388,27 +541,64 @@ public class RoleServiceImpl implements RoleService {
         } else if ("post".equals(type)) {
             // 如果是对岗位赋权
             map.put("type", 2);
-        }
+        } else {
-        else {
             throw new MyException("未知参数错误");
         }
         return roleMapper.findDepositoryIdForWarehouseVisiblePermissionByCondition(map);
     }
 
+    /**
+     * 根据条件获取管理的的仓库id
+     *
+     * @param map 待查询条件
+     * @return
+     */
+    @Override
+    public Map<String, Object> findWareHouseForManager(Map<String, Object> map) {
+        String type = (String) map.get("type");
+        if ("person".equals(type)) {
+            // 如果是对人员赋权
+            map.put("classes", 1);
+        } else if ("post".equals(type)) {
+            // 如果是对岗位赋权
+            map.put("classes", 2);
+        } else {
+            throw new MyException("未知参数错误");
+        }
+        map.put("uid", map.get("userId"));
+        List<RoleAndDepository> roleAndDepositoryByCondition = roleMapper.findRoleAndDepositoryByCondition(map);
+        List<Integer> dResult = new ArrayList<>();
+        for (RoleAndDepository roleAndDepository : roleAndDepositoryByCondition) {
+            dResult.add(roleAndDepository.getDepositoryId());
+        }
+        List<RoleAndMaterialType> roleAndMaterialTypeByCondition = roleMapper.findRoleAndMaterialTypeByCondition(map);
+        List<Long> mtResult = new ArrayList<>();
+        for (RoleAndMaterialType roleAndMaterialType : roleAndMaterialTypeByCondition) {
+            mtResult.add(roleAndMaterialType.getMtid());
+        }
+        Map<String, Object> result = new HashMap<>();
+        result.put("depository", dResult);
+        result.put("materialType", mtResult);
+
+
+        return result;
+    }
+
     /**
      * 用于查询当前用户所被赋予的可见仓库
+     *
      * @param userToken 待查询用户
      * @return
      */
     @Override
     public List<Integer> findDepositoryIdForWareHouseVisiblePermissionByUser(UserByPort userToken) {
-        Map<String,Object> paramForFindDepositoryId = new HashMap<>();
+        Map<String, Object> paramForFindDepositoryId = new HashMap<>();
-        paramForFindDepositoryId.put("type",1);
+        paramForFindDepositoryId.put("type", 1);
-        paramForFindDepositoryId.put("uid",userToken.getId());
+        paramForFindDepositoryId.put("uid", userToken.getId());
         // 查询该用户是否存在单独设置的仓库
         List<Integer> depositoryIdListForPerson = roleMapper.findDepositoryIdForWarehouseVisiblePermissionByCondition(paramForFindDepositoryId);
-        paramForFindDepositoryId.put("type",2);
+        paramForFindDepositoryId.put("type", 2);
-        paramForFindDepositoryId.put("uid",userToken.getPosition());
+        paramForFindDepositoryId.put("uid", userToken.getPosition());
         // 查询该用户职位是否存在设计的仓库
         List<Integer> depositoryIdListForPost = roleMapper.findDepositoryIdForWarehouseVisiblePermissionByCondition(paramForFindDepositoryId);
         // 取并集
@@ -417,6 +607,7 @@ public class RoleServiceImpl implements RoleService {
 
     /**
      * 用于查询当前用户所拥有及所管理的仓库
+     *
      * @param userToken 待查询用户
      * @return
      */
@@ -427,13 +618,14 @@ public class RoleServiceImpl implements RoleService {
         // 获取额外的设置的仓库
         List<Integer> depositoryIdForWareHouseVisiblePermissionByUser = findDepositoryIdForWareHouseVisiblePermissionByUser(userToken);
         // 取并集
-        depositoryIdList = (List<Integer>) CollectionUtils.union(depositoryIdForWareHouseVisiblePermissionByUser,depositoryIdList);
+        depositoryIdList = (List<Integer>) CollectionUtils.union(depositoryIdForWareHouseVisiblePermissionByUser, depositoryIdList);
         return depositoryIdList;
     }
 
 
     /**
      * 用于查询当前用户部门所拥有的仓库
+     *
      * @param userToken 待查询用户
      * @return
      */
@@ -446,11 +638,11 @@ public class RoleServiceImpl implements RoleService {
         }
         // 获取当前所有的仓库
         List<Depository> depositoryAll = depositoryMapper.findDepositoryAll();
-        for (Depository depository:depositoryAll
+        for (Depository depository : depositoryAll
         ) {
             Integer parentId = depository.getParentId();
             Integer id = depository.getId();
-            if(depositoryIdList.contains(parentId) && !depositoryIdList.contains(id)){
+            if (depositoryIdList.contains(parentId) && !depositoryIdList.contains(id)) {
                 depositoryIdList.add(id);
             }
         }
@@ -466,9 +658,6 @@ public class RoleServiceImpl implements RoleService {
     }
 
 
-
-
-
     /**
      * 获取当前仓库的子仓库
      *

src/main/resources/templates/pages/company/company-out_back.html

@@ -9,37 +9,31 @@
     <link rel="stylesheet" href="/static/lib/layui-v2.6.3/css/layui.css" media="all">
     <link rel="stylesheet" href="/static/css/public.css" media="all">
     <link rel="stylesheet" href="/static/lib/font-awesome-4.7.0/css/font-awesome.min.css" media="all">
+
 </head>
 <body>
 <div class="layuimini-container">
-    <div class="layuimini-main">
+    <div class="layui-row">
-
+        <div class="layui-col-md8">
-
+            <div class="layui-tab" lay-filter="roleSet">
-        <fieldset class="table-search-fieldset">
+                <ul class="layui-tab-title">
-            <legend>搜索信息</legend>
+                    <li class="layui-this" tabType="person">人员</li>
-            <div style="margin: 10px 10px 10px 10px">
+                    <li tabType="post">岗位</li>
+                </ul>
+                <div class="layui-tab-content">
+                    <div class="layui-tab-item layui-show">
                         <form class="layui-form layui-form-pane" action="">
-                    <input id="parentId" style="display: none" th:value="${parentId}">
                             <div class="layui-form-item">
                                 <div class="layui-inline">
-                            <label class="layui-form-label">公司名称</label>
+                                    <label class="layui-form-label">人员姓名</label>
                                     <div class="layui-input-inline">
-                                <select name="cid">
+                                        <input type="text" name="name" autocomplete="off" class="layui-input">
-                                    <option value="" selected>请选择公司</option>
-                                    <option th:each="company,iterStar:${companies}" th:value="${company?.getCid()}"
-                                            th:text="${company?.getCname()}">顶级公司
-                                    </option>
-                                </select>
                                     </div>
                                 </div>
                                 <div class="layui-inline">
-                            <label class="layui-form-label">状态</label>
+                                    <label class="layui-form-label">人员工号</label>
                                     <div class="layui-input-inline">
-                                <select name="state">
+                                        <input type="text" name="number" autocomplete="off" class="layui-input">
-                                    <option value="">请选择状态</option>
-                                    <option value="1">启用</option>
-                                    <option value="2">禁用</option>
-                                </select>
                                     </div>
                                 </div>
                                 <div class="layui-inline">
@@ -49,45 +43,148 @@
                                 </div>
                             </div>
                         </form>
+                        <table class="layui-hide" id="currentTableForUser"
+                               lay-filter="currentTableFilterForUser"></table>
+                    </div>
+                    <div class="layui-tab-item">
+                        <div id="postTree" class="demo-tree"></div>
+                    </div>
+                </div>
+            </div>
+        </div>
+        <div class="layui-col-md4">
+            <div class="layui-tab" lay-filter="permissionType">
+                <ul class="layui-tab-title">
+                    <li class="layui-this" tabType="depository">仓库</li>
+                    <li tabType="materialType">类型</li>
+                </ul>
+                <div class="layui-tab-content">
+                    <div class="layui-tab-item layui-show">
+                        <div id="depositoryTree" class="demo-tree"></div>
+                    </div>
+                    <div class="layui-tab-item">
+                        <div id="materialTypeTree" class="demo-tree"></div>
+                    </div>
                 </div>
-        </fieldset>
-
-
-        <!--    状态展示-->
-        <script type="text/html" id="switchTpl">
-            <input type="checkbox" name="state" value="{{d.cid}}" lay-skin="switch" lay-text="启用|禁用"
-                   lay-filter="changeState" {{ d.state== 1 ? 'checked' : '' }} >
-        </script>
-
-        <script type="text/html" id="toolbarDemo">
-            <div class="layui-btn-container">
-                <button class="layui-btn layui-btn-normal layui-btn-sm data-add-btn" lay-event="add"> 添加</button>
-                <button class="layui-btn layui-btn-sm layui-btn-danger data-delete-btn" lay-event="delete"> 删除</button>
             </div>
-        </script>
-
-        <table class="layui-hide" id="currentTableId" lay-filter="currentTableFilter"></table>
-
-        <script type="text/html" id="currentTableBar">
-            <a class="layui-btn layui-btn-normal layui-btn-xs data-count-subclass" lay-event="subclass">子公司</a>
-            <a class="layui-btn  layui-btn-xs data-count-edit" lay-event="detail">详情</a>
-            <a class="layui-btn layui-btn-xs layui-btn-danger data-count-delete" lay-event="delete">删除</a>
-            <a class="layui-btn layui-btn-xs layui-btn-danger data-count-delete" th:style="'display:'+${display}"
-               lay-event="realDelete">彻底删除</a>
-        </script>
 
+            <button type="button" class="layui-btn layui-btn-primary layui-border-blue" onclick="Impower()">授权</button>
+        </div>
     </div>
 </div>
+
 <script src="/static/lib/layui-v2.6.3/layui.js" charset="utf-8"></script>
+
 <script>
-    layui.use(['form', 'table'], function () {
+
+
+    function Impower() {
+
+    }
+
+    // 用于标志是否为第一次提交
+    let flagForForm = false;
+    layui.use(['form', 'layer', 'tree', 'element', 'table'], function () {
         var $ = layui.jquery,
             form = layui.form,
-            table = layui.table;
+            tree = layui.tree,
-        var parentId = document.getElementById("parentId").value;
+            element = layui.element,
+            table = layui.table,
+            layer = layui.layer;
+
+
+        let tabType = "person";
+        let permissionType = "depository";
+
+        let depositoryTree;
+        let postTree;
+        let materialTypeTree;
+        element.on('tab(roleSet)', function (data) {
+            tabType = $(this).attr("tabType");
+            if (tabType === "post") {
+                $.ajax({
+                    url: "/company/getOrgAndPostThree",
+                    type: 'get',
+                    dataType: 'json',
+                    contentType: "application/json;charset=utf-8",
+                    beforeSend: function () {
+                    },
+                    success: function (d) {
+                        var data2 = d.data;
+                        postTree.reload({
+                            data: data2
+                        });
+                    },
+
+                });
+            }
+            else {
+                table.reload('currentTableForUser', {
+                    url: '/sys/findUsers',
+                    page: {
+                        curr: 1
+                    },
+                }, 'data');
+            }
+
+        });
+
+
+        depositoryTree = tree.render({
+            elem: '#depositoryTree'
+            , id: "depositoryTree"
+            , showCheckbox: true  //是否显示复选框
+            , data: []
+        });
+
+        materialTypeTree = tree.render({
+            elem: '#materialTypeTree'
+            , id: "materialTypeTree"
+            , showCheckbox: true  //是否显示复选框
+            , data: []
+        });
+
+        $.ajax({
+            url: "/repository/treeMenusOnlyDepository",
+            type: 'get',
+            dataType: 'json',
+            contentType: "application/json;charset=utf-8",
+            beforeSend: function () {
+            },
+            success: function (d) {
+                depositoryTree.reload({
+                    data: d.data
+                });
+            },
+
+        });
+
+        element.on('tab(permissionType)', function (data) {
+            permissionType = $(this).attr("tabType");
+            if (permissionType === "depository") {
+            } else {
+                $.ajax({
+                    url: "/materialType/treeMenus",
+                    type: 'get',
+                    dataType: 'json',
+                    contentType: "application/json;charset=utf-8",
+                    beforeSend: function () {
+                    },
+                    success: function (d) {
+                        materialTypeTree.reload({
+                            data: d.data
+                        });
+                    },
+
+                });
+            }
+
+        });
+
         table.render({
-            elem: "#currentTableId",
+            elem: '#currentTableForUser',
-            url: '/company/allCompanyByParent?parentId=' + parentId,
+            url: '/sys/findUsers',
+            method: "POST",
             parseData: function (res) { //res 即为原始返回的数据
                 return {
                     "status": res.status, //解析接口状态
@@ -96,14 +193,11 @@
                     "data": res.data //解析数据列表
                 };
             },
+            height: 'full-255',//固定高度-即固定表头固定第一行首行
             request: {
                 pageName: 'page', //页码的参数名称，默认：page
                 limitName: 'size' //每页数据量的参数名，默认：limit
             },
-            where: {
-                type: "0"
-            },
-            height: 'full-255',//固定高度-即固定表头固定第一行首行
             response: {
                 statusName: 'status' //规定数据状态的字段名称，默认：code
                 , statusCode: 200 //规定成功的状态码，默认：0
@@ -111,38 +205,70 @@
                 , countName: 'count' //规定数据总数的字段名称，默认：count
                 , dataName: 'data' //规定数据列表的字段名称，默认：data
             },
-            toolbar: '#toolbarDemo',
-            defaultToolbar: ['filter', 'exports', 'print'],
             cols: [
                 [
                     {type: "checkbox", width: 50},
-                    {field: 'cname', width: 120, title: '公司名称', sort: true},
+                    {field: 'number', width: 100, title: '工号', sort: true},
-                    {field: 'introduce', width: 200, title: '公司介绍', sort: true},
+                    {field: 'name', width: 100, title: '姓名'},
-                    {field: 'state', title: '状态', minWidth: 80, templet: '#switchTpl'},
+                    {
-                    {title: '操作', minWidth: 150, toolbar: '#currentTableBar', align: "center"}
+                        field: 'gender', width: 80, title: '性别', templet: function (d) {
+                            if (d.gender === 1) {
+                                return "男性";
+                            } else if (d.gender === 2) {
+                                return "女性";
+                            } else if (d.gender === 3) {
+                                return "中性";
+                            } else {
+                                return "";
+                            }
+                        }
+                    },
+                    {field: 'companyname', width: 200, title: '公司名称'},
+                    {field: 'maindeparmentname', width: 200, title: '主部门'},
+                    {field: 'sunmaindeparmentname', width: 200, title: '岗位'},
+                    {field: 'workpostname', width: 200, title: '工段'},
+                    {field: 'positionname', width: 200, title: '职位'}
                 ]
             ],
-            limits: [10, 15, 20, 25, 50,100],
+            limits: [10, 15, 20, 25, 50, 100],
             limit: 10,
             page: true,
-            skin: 'line'
+            skin: 'line',
+        });
+
+
+        table.on('row(currentTableFilterForUser)', function (obj) {
+            let data = obj.data; //得到当前行数据
+            $.ajax({
+                url: "/repository/findWareHouseForManager",
+                type: 'post',
+                dataType: 'json',
+                contentType: "application/json;charset=utf-8",
+                data: JSON.stringify({"type": "person", "userId": data.id}),
+                success: function (res) {
+                    let data = res.data;
+                    depositoryTree.reload();
+                    let dResult = data.depository;
+                    let mtResult = data.materialType;
+                    tree.setChecked('depositoryTree', dResult);
+                    tree.setChecked('materialTypeTree', mtResult);
+
+                }
+            })
         });
 
-        // 监听搜索操作
         form.on('submit(data-search-btn)', function (data) {
-            var req = {};
             data = data.field;
-            req.type = 1;
+            let req = {};
-            if (data.cid !== '') {
+            if (data.name !== '') {
-                req.id = data.cid;
+                req.name = data.name;
             }
-            if (data.state != '') {
+            if (data.number !== '') {
-                req.state = data.state;
+                req.number = data.number;
             }
-            req.parentId = parentId;
             //执行搜索重载
-            table.reload('currentTableId', {
+            table.reload('currentTableForUser', {
-                url: '/company/companyByCondition',
+                url: '/sys/findUsers',
                 page: {
                     curr: 1
                 },
@@ -151,213 +277,141 @@
             return false;
         });
 
-        /**
+        postTree = tree.render({
-         * toolbar监听事件
+            elem: '#postTree'
-         */
+            , id: "postTree"
-        table.on('toolbar(currentTableFilter)', function (obj) {
+            , showCheckbox: true  //是否显示复选框
-            if (obj.event === 'add') {  // 监听添加操作
+            , data: []
-                var index = layer.open({
+            , click: function (obj) {
-                    title: '申请提交',
+                let data = obj.data; //得到当前点击的节点数据
-                    type: 2,
+                let elem = obj.elem;
-                    shade: 0.2,
+                if ("-1" === data.orgid) {
-                    maxmin: true,
+                    // 如果点击的是岗位
-                    shadeClose: true,
+                    let postId = data.id; // 岗位id
-                    area: ['100%', '100%'],
-                    content: '/company_add',
-                });
-                $(window).on("resize", function () {
-                    layer.full(index);
-                });
-            } else if (obj.event === 'delete') {  // 监听删除操作
-                var checkStatus = table.checkStatus('currentTableId')
-                    , data = checkStatus.data;
-                var req = {};
-                req.ids = [];
-                for (i = 0, len = data.length; i < len; i++) {
-                    req.ids[i] = data[i].cid;
-                }
                     $.ajax({
-                    url: '/company/company_del',
+                        url: "/repository/findWareHouseForManager",
+                        type: 'post',
                         dataType: 'json',
-                    type: 'POST',
                         contentType: "application/json;charset=utf-8",
-                    data: JSON.stringify(req),
+                        data: JSON.stringify({"type": "post", "userid": postId}),
-                    beforeSend: function () {
+                        success: function (res) {
-                        this.layerIndex = layer.load(0, {shade: [0.5, '#393D49']});
+                            let data = res.data;
-                    },
+                            let dResult = data.depository;
-                    success: function (data) {
+                            let mtResult = data.materialType;
-                        layer.close(this.layerIndex);
+                            depositoryTree.reload();
-                        if (data.status >= 300) {
+                            tree.setChecked('depositoryTree', dResult);
-                            layer.msg(data.statusInfo.message);//失败的表情
+                            tree.setChecked('materialTypeTree', mtResult);
-
+                            tree.setChecked('postTree', [postId])
-                        } else {
-                            layer.msg("删除成功", {
-                                icon: 6,//成功的表情
-                                time: 500 //1秒关闭（如果不配置，默认是3秒）
-                            });
-                            //执行搜索重载
-                            table.reload('currentTableId', {
-                                url: '/company/companyByCondition',
-                                page: {
-                                    curr: 1
-                                }
-                            }, 'data');
-                            return false;
-                        }
                         }
                     })
                 }
+            }
         });
 
-        //监听表格复选框选择
-        table.on('checkbox(currentTableFilter)', function (obj) {
-            console.log(obj)
-        });
 
-        table.on('tool(currentTableFilter)', function (obj) {
+        Impower = function () {
-            let data = obj.data;
-            if (obj.event === 'detail') {
-                var index = layer.open({
-                    title: '公司详情',
-                    type: 2,
-                    shade: 0.2,
-                    maxmin: true,
-                    shadeClose: true,
-                    area: ['100%', '100%'],
-                    content: '/company_detail?id=' + data.cid,
-                });
-                $(window).on("resize", function () {
-                    layer.full(index);
-                });
-                return false;
-            } else if (obj.event === 'delete') {
-                var req = {};
-                req.id = data.cid;
-                layer.confirm('真的删除么', {icon: 2, title: '提示'}, function (index) {
-                    $.ajax({
-                        url: '/company/company_del',
-                        dataType: 'json',
-                        type: 'POST',
-                        contentType: "application/json;charset=utf-8",
-                        data: JSON.stringify(req),
-                        beforeSend: function () {
-                            this.layerIndex = layer.load(0, {shade: [0.5, '#393D49']});
-                        },
-                        success: function (data) {
-                            layer.close(this.layerIndex);
-                            if (data.status >= 300) {
-                                layer.msg(data.statusInfo.message);//失败的表情
 
-                            } else {
+            let treeData = [];
-                                obj.del();
+            if(permissionType === "depository"){
-                                layer.msg("删除成功", {
+                treeData = tree.getChecked("depositoryTree")
-                                    icon: 6,//成功的表情
+            }else if(permissionType === "materialType"){
-                                    time: 500 //1秒关闭（如果不配置，默认是3秒）
+                treeData = tree.getChecked("materialTypeTree")
-                                });
             }
+            // 获取选中的Id
+            let userIds = [];
+            if (tabType === "person") {
+                let checkUserData = table.checkStatus('currentTableForUser').data;
+                for (let i = 0, len = checkUserData.length; i < len; i++) {
+                    userIds.push(checkUserData[i].id);
                 }
-                    })
+            } else {
-                });
+                userIds = getAllTreeId(tree.getChecked('postTree'));
-            } else if (obj.event == 'subclass') {
+            }
-                var index = layer.open({
+            // 获取选中的仓库树id
-                    title: '子公司',
+            let allTreeId = getAllTreeId(treeData);
-                    type: 2,
+            if (userIds.length > 0) {
-                    shade: 0.2,
+                if (!flagForForm) {
-                    maxmin: true,
+                    flagForForm = true;
-                    shadeClose: true,
+                    let req = {};
-                    area: ['100%', '100%'],
+                    req.userIds = userIds;
-                    content: '/findCompanyByParentId?parentId=' + data.cid+'&level='+data.level
+                    req.roleIds = allTreeId;
-                });
+                    req.setType = tabType;
-                $(window).on("resize", function () {
+                    req.permissionType = permissionType;
-                    layer.full(index);
+                    req.count = userIds.length * allTreeId.length;
-                });
-                return false;
-            } else if (obj.event == 'realDelete') { // 彻底删除
-                var req = {};
-                req.id = data.cid;
-                layer.confirm('该操作会造成不可逆后果，是否继续？', {
-                    btn: ['继续', '取消'] //按钮
-                }, function () {
                     $.ajax({
-                        url: '/company/realDeleteCompany',
+                        url: "/repository/setManagerRole",
+                        type: 'post',
                         dataType: 'json',
-                        type: 'POST',
                         contentType: "application/json;charset=utf-8",
                         data: JSON.stringify(req),
                         beforeSend: function () {
                             this.layerIndex = layer.load(0, {shade: [0.5, '#393D49']});
                         },
-                        success: function (data) {
+                        success: function (res) {
                             layer.close(this.layerIndex);
-                            if (data.status >= 300) {
+                            if (res.status >= 300) {
-                                layer.msg(data.statusInfo.message);//失败的表情
+                                layer.msg(res.statusInfo.message, {
-
+                                    icon: 5,
+                                    time: 1000
+                                }, function () {
+                                    location.reload();
+                                });//失败的表情
+                                flagForForm = false;
                             } else {
-                                obj.del();
+                                layer.msg("设置成功！", {
-                                layer.msg("删除成功", {
                                         icon: 6,//成功的表情
-                                    time: 500 //1秒关闭（如果不配置，默认是3秒）
+                                        time: 1000
+                                    }, //1秒关闭（如果不配置，默认是3秒）
+                                    function () {
+                                        //do something
+                                        location.reload();
                                     });
                             }
                         }
                     })
-                }, function () {
-                    // 执行重加载
-                    table.reload('currentTableId', {
-                        url: '/materialType/materialTypeRecord',
-                        page: {
-                            curr: 1
-                        },
-                        where: {"parentId": parentId}
-                    });
-                });
                 }
-        });
 
-        //监听状态操作
-        form.on('switch(changeState)', function (obj) {
-            var req = new Map;
-            if (obj.elem.checked) {
-                req["state"] = 1
             }
-            req["id"] = this.value;
+            else {
-            var hasMaterial = false;
+                layer.msg("请选中赋权岗位或人员", {
-            $.ajax({
+                    icon: 5,
-                url: "/company/EditCompanyState",
+                    time: 1000
-                type: 'post',
+                })
-                dataType: 'json',
+            }
-                contentType: "application/json;charset=utf-8",
-                data: JSON.stringify(req),
-                beforeSend: function () {
-                    this.layerIndex = layer.load(0, {shade: [0.5, '#393D49']});
-                },
-                success: function (data) {
-                    layer.close(this.layerIndex);
-                    if (data.status >= 300) {
-                        layer.msg(data.statusInfo.message);//失败的表情
 
+        };
+
+
+        /**
+         * 用于获取选中树的id
+         * @param data
+         */
+        function getAllTreeId(data) {
+            // 用于存储id
+            let idList = [];
+            for (let i = 0; i < data.length; i++) {
+                let temp = data[i];
+                if (temp.orgid !== undefined) {
+                    if (temp.orgid === "-1") {
+                        idList.push(temp.id);
+                    }
                 } else {
-                        layer.msg("修改成功", {
+                    if (temp.children.length === 0) {
-                            icon: 6,//成功的表情
+                        // 如果是底层仓库
-                            time: 500 //1秒关闭（如果不配置，默认是3秒）
+                        idList.push(temp.id);
-                        }, function () {
-                            // 执行表格重加载
-                            table.reload('currentTableId', {
-                                url: '/company/companyByCondition',
-                                page: {
-                                    curr: 1
-                                },
-                                where: {"parentId": parentId}
-                            });
-                        })
                     }
                 }
-            })
+                if (temp.children !== null && temp.children !== undefined && temp.children.length > 0) {
-        });
+                    // 如果存在子树
-        $('body').on('click', '[data-refresh]', function () {
+                    idList.push(...getAllTreeId(temp.children));
-            location.reload();
+                }
-        })
+            }
+            return idList;
+        }
+
     });
+
+
 </script>
 
 </body>

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

@@ -33,6 +33,7 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
 
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
 @RunWith(SpringRunner.class)
@@ -113,25 +114,28 @@ public class OtherTest {
         return null;
     }
 
-    @Test
-    public void someTest(){
-        boolean flag = true;
-        Depository depositoryById = depositoryMapper.findDepositoryById(28);
-        Depository depositoryTop = depositoryById;
-        if (Integer.compare(depositoryById.getParentId(), 0) != 0) {
-            // 如果不是
-            List<Depository> depositoryAll = depositoryMapper.findDepositoryAll();
-            depositoryTop = findParentDepository(depositoryById, depositoryAll);
-        }
 
-        if (!depositoryTop.getDname().contains("前置仓")) {
-            // 如果不是前置仓下的仓库
-            flag = false;
-        }
-        System.out.println(flag);
-        System.out.println(depositoryById);
-        System.out.println(depositoryTop);
 
+
+    @Test
+    public void someTest(){
+        List<Object> list = new ArrayList<>();
+        List<Object> list1 = new ArrayList<>();
+        list1.add(1);
+        list1.add(2);
+        list1.add(3);
+        list1.add(4);
+        list.add(4L);
+        list.add(5L);
+        list.add(6L);
+        list.add(7L);
+        list.add(1L);
+        List<String> collect = list.stream().map(Object::toString).collect(Collectors.toList());
+        List<String> collect1 = list1.stream().map(Object::toString).collect(Collectors.toList());
+        System.out.println(collect);
+        collect.removeAll(collect1);
+        System.out.println(collect);
+        System.out.println(collect1);
     }
 
     @Test