package org.jeecg.modules.dnc.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.dnc.dto.ComponentExt;

import org.jeecg.modules.dnc.exception.ExceptionCast;
import org.jeecg.modules.dnc.mapper.ProductInfoMapper;

import org.jeecg.modules.dnc.service.*;
import org.jeecg.modules.dnc.service.support.ProductTreeWrapper;
import org.jeecg.modules.dnc.ucenter.Department;
import org.jeecg.modules.dnc.ucenter.UserDepartExt;
import org.jeecg.modules.dnc.utils.ValidateUtil;

import org.jeecg.modules.dnc.entity.*;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysUserService;

import org.jeecg.modules.dnc.response.ComponentInfoCode;
import org.jeecg.modules.dnc.response.PartsInfoCode;
import org.jeecg.modules.dnc.response.ProductInfoCode;
import org.jeecg.modules.dnc.response.UcenterCode;
import org.jeecg.modules.dnc.response.CommonCode;
import org.jeecg.modules.dnc.response.CommonGenericTree;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service
@Slf4j
public class ProductInfoServiceImpl extends ServiceImpl<ProductInfoMapper,ProductInfo> implements IProductInfoService {
    @Autowired
    @Lazy
    private IComponentInfoService componentInfoService;
    @Autowired
    @Lazy
    private IPartsInfoService partsInfoService;
    @Autowired
    private IProductPermissionService productPermissionService;
    @Autowired
    private IProductDepartmentService productDepartmentService;
    @Autowired
    private IPermissionStreamService permissionStreamService;
    @Autowired
    private IComponentDepartmentService componentDepartmentService;
    @Autowired
    private IComponentPermissionService componentPermissionService;
    @Autowired
    private IPartsDepartmentService partsDepartmentService;
    @Autowired
    private IPartsPermissionService partsPermissionService;
    @Autowired
    private IDepartmentService departmentService;
    @Autowired
    private ISysUserService userService;
    @Autowired
    @Lazy
    private IProcessStreamService processStreamService;
    @Autowired
    private IDocInfoService docInfoService;
    @Autowired
    private INcLogInfoService iNcLogInfoService;

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addProductInfo(ProductInfo productInfo) {
        if(productInfo == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(!ValidateUtil.validateString(productInfo.getProductName()))
            ExceptionCast.cast(ProductInfoCode.PRODUCT_NAME_NONE);
        if(!ValidateUtil.validateString(productInfo.getProductNo())) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_NO_NONE);
        }
        ProductInfo en = getByProductNo(productInfo.getProductNo());
        if(en != null)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_IS_EXIST);
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        productInfo.setProductStatus(1);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("产品结构树");
        //类型
        ncLogInfo.setOperateType(2);
        //日志内容
        ncLogInfo.setLogContent("产品名称："+productInfo.getProductName()+"，产品编号："+productInfo.getProductNo());
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        boolean b = super.save(productInfo);
        if(!b) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
        }
        ProductPermission permission = new ProductPermission();
        permission.setProductId(productInfo.getProductId());
        permission.setUserId(userId);
        b = productPermissionService.save(permission);
        if(!b) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_SAVE_ERROR);
        }
        PermissionStream stream = new PermissionStream();
        stream.setProductId(productInfo.getProductId());
        stream.setUserId(userId);
        return permissionStreamService.save(stream);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean editProductInfo(String id ,ProductInfo productInfo) {
        if(!ValidateUtil.validateString(id) || productInfo == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        ProductInfo en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
        productInfo.setProductId(id);
        productInfo.setProductStatus(null);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("产品结构树");
        //类型
        ncLogInfo.setOperateType(3);
        //日志内容
        ncLogInfo.setLogContent("产品名称："+productInfo.getProductName());
        ncLogInfo.setRemark(JSONObject.toJSONString(en));
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        boolean b = super.updateById(productInfo);
        if(!b)
            return false;
        ProductPermission permission = productPermissionService.getByProductIdAndUserId(id, userId);
        if(permission == null) {
            permission = new ProductPermission();
            permission.setProductId(id);
            permission.setUserId(userId);
            b = productPermissionService.save(permission);
            if(!b) {
                return false;
            }
        }
        PermissionStream stream = permissionStreamService.getByProductIdAndUserId(id, userId);
        if(stream == null) {
            stream = new PermissionStream();
            stream.setProductId(id);
            stream.setUserId(userId);
            return permissionStreamService.save(stream);
        }
        return b;
    }

    @Override
    public List<CommonGenericTree> loadProductTree(String userId) {
        List<ProductInfo> productInfoList = getByUserPerms(userId);
        if(productInfoList == null || productInfoList.isEmpty())
            return Collections.emptyList();
        List<ComponentExt> componentInfoList = componentInfoService.getByUserPermsAs(userId);
        if(componentInfoList == null)
            componentInfoList = Collections.emptyList();
        List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId);
        if(partsInfos == null)
            partsInfos = Collections.emptyList();
        return ProductTreeWrapper.loadTree(productInfoList, componentInfoList, partsInfos);
    }

    @Override
    public List<ProductInfo> getByUserPerms(String userId) {
        if(!ValidateUtil.validateString(userId))
            return Collections.emptyList();
        return super.getBaseMapper().getByUserPerms(userId);
    }

    @Override
    public List<ProductInfo> getByUserPerms(String userId, String queryParam) {
        if(!ValidateUtil.validateString(userId))
            return Collections.emptyList();
        //去除权限  TODO
        LambdaQueryWrapper<ProductInfo> queryWrapper = Wrappers.lambdaQuery();
        if(ValidateUtil.validateString(queryParam)) {
            queryWrapper.and(wrapper -> wrapper.like(ProductInfo::getProductNo, queryParam)
                    .or()
                    .like(ProductInfo::getProductName, queryParam));
        }
        return super.list(queryWrapper);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteProductInfo(String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        ProductInfo productInfo = super.getById(id);
        if(productInfo == null)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
        //验证产品下是否有部件
        List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
        if(componentInfoList != null && !componentInfoList.isEmpty()) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_COMPONENT_EXIST);
        }
        //验证产品下是否有零件
        List<PartsInfo> partsInfoList = partsInfoService.getByProductId(productInfo.getProductId());
        if(partsInfoList != null && !partsInfoList.isEmpty()) {
            ExceptionCast.cast(ProductInfoCode.PRODUCT_PARTS_EXIST);
        }
        List<ProcessStream> processStreams = processStreamService.findByProductId(id);
        if(processStreams != null && !processStreams.isEmpty())
            ExceptionCast.cast(ProductInfoCode.PRODUCT_PROCESS_EXIST);
        boolean b = productPermissionService.deleteByProductId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = productDepartmentService.deleteByProductId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = permissionStreamService.deleteUserPermsByProductId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = permissionStreamService.deleteDepartPermsByProductId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = docInfoService.deleteByProductId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        //添加日志
        NcLogInfo ncLogInfo = new NcLogInfo();
        //模块
        ncLogInfo.setModuleInfo("产品结构树");
        //类型
        ncLogInfo.setOperateType(4);
        //日志内容
        ncLogInfo.setLogContent("产品名称："+productInfo.getProductName());
        iNcLogInfoService.saveLogNcInfos(ncLogInfo);
        return super.removeById(id);
    }

    @Override
    public boolean checkProductPerm(Integer nodeType, String paramId) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        if(nodeType == 1) {
            ProductInfo productInfo = super.getById(paramId);
            if(productInfo == null)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            PermissionStream permission = permissionStreamService.getByProductIdAndUserId(paramId, userId);
            if(permission == null)
                return false;
            return true;
        }else if(nodeType == 2) {
            ComponentInfo componentInfo = componentInfoService.getById(paramId);
            if(componentInfo == null)
                ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            PermissionStream permission = permissionStreamService.getByComponentIdAndUserId(componentInfo.getProductId(), paramId, userId);
            if(permission == null)
                return false;
            return true;
        }else if(nodeType == 3) {
            PartsInfo partsInfo = partsInfoService.getById(paramId);
            if(partsInfo == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            PermissionStream permission = permissionStreamService.getByPartsIdAndUserId(partsInfo.getProductId(), partsInfo.getComponentId(), paramId, userId);
            if(permission == null)
                return false;
            return true;
        }
        return false;
    }

    @Override
    public List<UserDepartExt> getUserPermsList(Integer nodeType, String paramId) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
            return null;
        if(nodeType == 1) {
            return productPermissionService.getUserPermsByProductId(paramId);
        }else if(nodeType == 2) {
            return componentPermissionService.getUserPermsByComponentId(paramId);
        }else if(nodeType == 3) {
            return partsPermissionService.getUserPermsByProductId(paramId);
        }else {
            return null;
        }
    }

    @Override
    public List<SysUser> getUserNonPermsList(Integer nodeType, String paramId) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
            return null;
        if(nodeType == 1) {
            return productPermissionService.getUserNonPermsByProductId(paramId);
        }else if(nodeType == 2) {
            return componentPermissionService.getUserNonPermsByComponentId(paramId);
        }else if(nodeType == 3) {
            return partsPermissionService.getUserNonPermsByProductId(paramId);
        }else {
            return null;
        }
    }

    @Override
    public List<Department> getDepartPermsList(Integer nodeType, String paramId) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
            return null;
        if(nodeType == 1) {
            return productDepartmentService.getDepartPermsByProductId(paramId);
        }else if(nodeType == 2) {
            return componentDepartmentService.getDepartPermsByComponentId(paramId);
        }else if(nodeType == 3) {
            return partsDepartmentService.getDepartPermsByPartsId(paramId);
        }else {
            return null;
        }
    }

    @Override
    public List<Department> getDepartNonPermsList(Integer nodeType, String paramId) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId))
            return null;
        if(nodeType == 1) {
            return productDepartmentService.getDepartNonPermsByProductId(paramId);
        }else if(nodeType == 2) {
            return componentDepartmentService.getDepartNonPermsByComponentId(paramId);
        }else if(nodeType == 3) {
            return partsDepartmentService.getDepartNonPermsByProductId(paramId);
        }else {
            return null;
        }
    }

    /**
     * 1、循环插入优化
     * 2、查询优化
     * 3、封装优化 TODO
     * @param nodeType 1 产品 2 部件 3 零件
     * @param paramId  产品树节点id
     * @param relativeFlag 1 是 2 否
     * @param userIds 添加用户ids
     * @return
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
        //参数校验
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
                !ValidateUtil.validateInteger(relativeFlag))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(userIds == null || userIds.length < 1)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
        List<String> ids = new ArrayList<>(userIds.length);
        Collections.addAll(ids, userIds);
        Collection<SysUser> userList = userService.listByIds(ids);
        if(userList == null || userList.isEmpty() || userList.size() != userIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        //节点类型判定
        if(nodeType == 3) {
            //处理零件
            PartsInfo partsInfo = partsInfoService.getById(paramId);
            if(partsInfo == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(3, partsInfo.getPartsId());
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return partsInfoService.assignAddUser(partsInfo, userList);
        }else if(nodeType == 1) {
            //处理产品
            ProductInfo productInfo = super.getById(paramId);
            if(productInfo == null)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            boolean b1 = checkProductPerm(1, productInfo.getProductId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = this.assignAddUser(productInfo, userList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {

                List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
                if(componentInfoList == null || componentInfoList.isEmpty()){
                    //没有可添加的零部件权限
                    return true;
                }

                //最终保存权限数据初始化
                List<ComponentPermission> componentPermissionList = new ArrayList<>();
                List<PartsPermission> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                //处理子部件
                List<String> componentIds = new ArrayList<>();
                PermissionStream s;

                Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
                Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

                //初始化全体数据
                String key;
                ComponentPermission cp;
                ComponentInfo cpInfo;
                for(ComponentInfo c : componentInfoList){
                    componentIds.add(c.getComponentId());
                    componentInfoMap.put(c.getComponentId(), c);
                    for(SysUser u : userList){
                        key = c.getComponentId() + "," + u.getId();
                        cp = new ComponentPermission(c.getComponentId(), u.getId());
                        componentPermissionMap.put(key, cp);
                    }
                }
                //查询已存在的权限数据
                List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
                if(existList != null && !existList.isEmpty()){
                    //踢出权限数据
                    for(ComponentPermission permission : existList){
                        key = permission.getComponentId() + "," + permission.getUserId();
                        if(componentPermissionMap.containsKey(key)){
                            componentPermissionMap.remove(key);
                        }
                    }
                }
                for(Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()){
                    cp = entry.getValue();
                    componentPermissionList.add(cp);
                    cpInfo = componentInfoMap.get(cp.getComponentId());
                    s = new PermissionStream();
                    s.setProductId(cpInfo.getProductId());
                    s.setComponentId(cpInfo.getComponentId());
                    s.setUserId(cp.getUserId());
                    permissionStreamList.add(s);
                }

                //处理子零件
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
                    Map<String, PartsInfo> partsInfoMap = new HashMap<>();
                    List<String> partsIds = new ArrayList<>();
                    PartsPermission pp;
                    PartsInfo ptInfo;
                    for(PartsInfo p : partsInfoList){
                        partsIds.add(p.getPartsId());
                        partsInfoMap.put(p.getPartsId(), p);
                        for(SysUser u : userList){
                            key = p.getPartsId() + "," + u.getId();
                            pp = new PartsPermission(p.getPartsId(), u.getId());
                            partsPermissionHashMap.put(key, pp);
                        }
                    }

                    //查询已存在的权限数据
                    List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
                    if(existPartsList != null && !existPartsList.isEmpty()){
                        //踢出权限数据
                        for(PartsPermission permission : existPartsList){
                            key = permission.getPartsId() + "," + permission.getUserId();
                            if(partsPermissionHashMap.containsKey(key)){
                                partsPermissionHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()){
                        pp = entry.getValue();
                        partsPermissionList.add(pp);
                        ptInfo = partsInfoMap.get(pp.getPartsId());
                        s = new PermissionStream();
                        s.setProductId(ptInfo.getProductId());
                        s.setComponentId(ptInfo.getComponentId());
                        s.setPartsId(ptInfo.getPartsId());
                        s.setUserId(pp.getUserId());
                        permissionStreamList.add(s);
                    }
                }

                if(!componentPermissionList.isEmpty()){
                    componentPermissionService.saveBatch(componentPermissionList);
                }
                if(!partsPermissionList.isEmpty()){
                    partsPermissionService.saveBatch(partsPermissionList);
                }
                if(!permissionStreamList.isEmpty()){
                    permissionStreamService.saveBatch(permissionStreamList);
                }
            }
            return true;
        }else if(nodeType == 2) {
            //处理部件
            ComponentInfo componentInfo = componentInfoService.getById(paramId);
            if(componentInfo == null)
                ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
            if(!b1){
                //没有当前部件的权限
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            b1 = componentInfoService.assignAddUser(componentInfo, userList);
            if(!b1){
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            if(relativeFlag == 1) {
                //最终保存权限数据初始化
                List<ComponentPermission> componentPermissionList = new ArrayList<>();
                List<PartsPermission> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();

                List<String> componentIds = new ArrayList<>();
                PermissionStream s;
                String key;
                //处理子部件
                List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
                if(childrenList != null && !childrenList.isEmpty()) {
                    Map<String, ComponentPermission> componentPermissionMap = new HashMap<>();
                    Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

                    //初始化全体数据
                    ComponentPermission cp;
                    ComponentInfo cpInfo;
                    for(ComponentInfo c : childrenList){
                        componentIds.add(c.getComponentId());
                        componentInfoMap.put(c.getComponentId(), c);
                        for(SysUser u : userList){
                            key = c.getComponentId() + "," + u.getId();
                            cp = new ComponentPermission(c.getComponentId(), u.getId());
                            componentPermissionMap.put(key, cp);
                        }
                    }
                    //查询已存在的权限数据
                    List<ComponentPermission> existList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
                    if(existList != null && !existList.isEmpty()){
                        //踢出权限数据
                        for(ComponentPermission permission : existList){
                            key = permission.getComponentId() + "," + permission.getUserId();
                            if(componentPermissionMap.containsKey(key)){
                                componentPermissionMap.remove(key);
                            }
                        }
                    }
                    for(Map.Entry<String, ComponentPermission> entry : componentPermissionMap.entrySet()){
                        cp = entry.getValue();
                        componentPermissionList.add(cp);
                        cpInfo = componentInfoMap.get(cp.getComponentId());
                        s = new PermissionStream();
                        s.setProductId(cpInfo.getProductId());
                        s.setComponentId(cpInfo.getComponentId());
                        s.setUserId(cp.getUserId());
                        permissionStreamList.add(s);
                    }
                }
                //处理零件
                componentIds.add(componentInfo.getComponentId());
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIds);
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    Map<String, PartsPermission> partsPermissionHashMap = new HashMap<>();
                    Map<String, PartsInfo> partsInfoMap = new HashMap<>();
                    List<String> partsIds = new ArrayList<>();
                    PartsPermission pp;
                    PartsInfo ptInfo;
                    for(PartsInfo p : partsInfoList){
                        partsIds.add(p.getPartsId());
                        partsInfoMap.put(p.getPartsId(), p);
                        for(SysUser u : userList){
                            key = p.getPartsId() + "," + u.getId();
                            pp = new PartsPermission(p.getPartsId(), u.getId());
                            partsPermissionHashMap.put(key, pp);
                        }
                    }

                    //查询已存在的权限数据
                    List<PartsPermission> existPartsList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
                    if(existPartsList != null && !existPartsList.isEmpty()){
                        //踢出权限数据
                        for(PartsPermission permission : existPartsList){
                            key = permission.getPartsId() + "," + permission.getUserId();
                            if(partsPermissionHashMap.containsKey(key)){
                                partsPermissionHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, PartsPermission> entry : partsPermissionHashMap.entrySet()){
                        pp = entry.getValue();
                        partsPermissionList.add(pp);
                        ptInfo = partsInfoMap.get(pp.getPartsId());
                        s = new PermissionStream();
                        s.setProductId(ptInfo.getProductId());
                        s.setComponentId(ptInfo.getComponentId());
                        s.setPartsId(ptInfo.getPartsId());
                        s.setUserId(pp.getUserId());
                        permissionStreamList.add(s);
                    }
                }
                if(!componentPermissionList.isEmpty()){
                    componentPermissionService.saveBatch(componentPermissionList);
                }
                if(!partsPermissionList.isEmpty()){
                    partsPermissionService.saveBatch(partsPermissionList);
                }
                if(!permissionStreamList.isEmpty()){
                    permissionStreamService.saveBatch(permissionStreamList);
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 待优化 TODO
     * @param nodeType 1 产品 2 部件 3 零件
     * @param paramId  产品树节点id
     * @param relativeFlag 1 是 2 否
     * @param userIds 移除用户ids
     * @return
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveUser(Integer nodeType, String paramId, Integer relativeFlag, String[] userIds) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
                !ValidateUtil.validateInteger(relativeFlag))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(userIds == null || userIds.length < 1)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
        List<String> ids = new ArrayList<>(userIds.length);
        Collections.addAll(ids, userIds);
        Collection<SysUser> userList = userService.listByIds(ids);
        if(userList == null || userList.isEmpty() || userList.size() != userIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(nodeType == 3) {
            //处理零件
            PartsInfo partsInfo = partsInfoService.getById(paramId);
            if(partsInfo == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(3, partsInfo.getPartsId());
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return partsInfoService.assignRemoveUser(partsInfo, userList);
        }else if(nodeType == 1) {
            //处理产品
            ProductInfo productInfo = super.getById(paramId);
            if(productInfo == null)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            boolean b1 = checkProductPerm(1, productInfo.getProductId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = this.assignRemoveUser(productInfo, userList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                //处理产品 下的部件
                List<String> componentIds = new ArrayList<>();
                //总计需要删除的数据信息
                List<ComponentPermission> componentPermissionList = new ArrayList<>();
                List<PartsPermission> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
                if(componentInfoList != null && !componentInfoList.isEmpty()) {
                    for(ComponentInfo componentInfo : componentInfoList){
                        componentIds.add(componentInfo.getComponentId());
                    }
                    componentPermissionList = componentPermissionService.getByComponentIdsAndUserIds(componentIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndUserIds(componentIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                //处理产品 下的零件
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
                List<String> partsIds = new ArrayList<>();
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    for(PartsInfo partsInfo : partsInfoList){
                        partsIds.add(partsInfo.getPartsId());
                    }
                    partsPermissionList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndUserIds(partsIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                if(componentPermissionList != null && !componentPermissionList.isEmpty()){
                    componentPermissionService.removeByCollection(componentPermissionList);
                }
                if(partsPermissionList != null && !partsPermissionList.isEmpty()){
                    partsPermissionService.removeByCollection(partsPermissionList);
                }
                if(permissionStreamList != null && !permissionStreamList.isEmpty()){
                    permissionStreamService.removeByCollection(permissionStreamList);
                }
            }
            return true;
        }else if(nodeType == 2) {
            ComponentInfo componentInfo = componentInfoService.getById(paramId);
            if(componentInfo == null)
                ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = componentInfoService.assignRemoveUser(componentInfo, userList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                List<String> componentIdList = new ArrayList<>();
                //最终需要删除的数据
                List<ComponentPermission> componentPermissionList = new ArrayList<>();
                List<PartsPermission> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
                if(childrenList != null && !childrenList.isEmpty()) {
                    for(ComponentInfo component : childrenList){
                        componentIdList.add(component.getComponentId());
                    }
                    componentPermissionList = componentPermissionService.getByComponentIdsAndUserIds(componentIdList, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndUserIds(componentIdList, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                componentIdList.add(componentInfo.getComponentId());
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
                List<String> partsIds = new ArrayList<>();
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    for(PartsInfo partsInfo : partsInfoList){
                        partsIds.add(partsInfo.getPartsId());
                    }
                    partsPermissionList = partsPermissionService.getByPartsIdsAndUserIds(partsIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndUserIds(partsIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }
                if(componentPermissionList != null && !componentPermissionList.isEmpty()){
                    componentPermissionService.removeByCollection(componentPermissionList);
                }
                if(partsPermissionList != null && !partsPermissionList.isEmpty()){
                    partsPermissionService.removeByCollection(partsPermissionList);
                }
                if(permissionStreamList != null && !permissionStreamList.isEmpty()){
                    permissionStreamService.removeByCollection(permissionStreamList);
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 待优化 TODO
     * @param nodeType 1 产品 2 部件 3 零件
     * @param paramId 产品树节点id
     * @param relativeFlag 1 是 2 否
     * @param departmentIds 添加部门ids
     * @return
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddDepartment(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
                !ValidateUtil.validateInteger(relativeFlag))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(departmentIds == null || departmentIds.length < 1)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
        List<String> ids = new ArrayList<>(departmentIds.length);
        Collections.addAll(ids, departmentIds);
        Collection<Department> departList = departmentService.listByIds(ids);
        if(departList == null || departList.isEmpty() || departList.size() != departmentIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(nodeType == 3) {
            //处理零件
            PartsInfo partsInfo = partsInfoService.getById(paramId);
            if(partsInfo == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(3, partsInfo.getPartsId());
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return partsInfoService.assignAddDepart(partsInfo, departList);
        }else if(nodeType == 1) {
            //处理产品
            ProductInfo productInfo = super.getById(paramId);
            if(productInfo == null)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            boolean b1 = checkProductPerm(1, productInfo.getProductId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = this.assignAddDepartment(productInfo, departList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                //处理产品 下的部件
                List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
                //最终保存权限数据初始化
                List<ComponentDepartment> componentPermissionList = new ArrayList<>();
                List<PartsDepartment> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                //处理子部件
                List<String> componentIds = new ArrayList<>();
                PermissionStream s;

                Map<String, ComponentDepartment> componentPermissionMap = new HashMap<>();
                Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

                //初始化全体数据
                String key;
                ComponentDepartment cp;
                ComponentInfo cpInfo;
                for(ComponentInfo c : componentInfoList){
                    componentIds.add(c.getComponentId());
                    componentInfoMap.put(c.getComponentId(), c);
                    for(Department u : departList){
                        key = c.getComponentId() + "," + u.getDepartId();
                        cp = new ComponentDepartment(c.getComponentId(), u.getDepartId());
                        componentPermissionMap.put(key, cp);
                    }
                }
                //查询已存在的权限数据
                List<ComponentDepartment> existList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, ids);
                if(existList != null && !existList.isEmpty()){
                    //踢出权限数据
                    for(ComponentDepartment permission : existList){
                        key = permission.getComponentId() + "," + permission.getDepartId();
                        if(componentPermissionMap.containsKey(key)){
                            componentPermissionMap.remove(key);
                        }
                    }
                }
                for(Map.Entry<String, ComponentDepartment> entry : componentPermissionMap.entrySet()){
                    cp = entry.getValue();
                    componentPermissionList.add(cp);
                    cpInfo = componentInfoMap.get(cp.getComponentId());
                    s = new PermissionStream();
                    s.setProductId(cpInfo.getProductId());
                    s.setComponentId(cpInfo.getComponentId());
                    s.setDepartId(cp.getDepartId());
                    permissionStreamList.add(s);
                }

                //处理子零件
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    Map<String, PartsDepartment> partsPermissionHashMap = new HashMap<>();
                    Map<String, PartsInfo> partsInfoMap = new HashMap<>();
                    List<String> partsIds = new ArrayList<>();
                    PartsDepartment pp;
                    PartsInfo ptInfo;
                    for(PartsInfo p : partsInfoList){
                        partsIds.add(p.getPartsId());
                        partsInfoMap.put(p.getPartsId(), p);
                        for(Department u : departList){
                            key = p.getPartsId() + "," + u.getDepartId();
                            pp = new PartsDepartment(p.getPartsId(), u.getDepartId());
                            partsPermissionHashMap.put(key, pp);
                        }
                    }

                    //查询已存在的权限数据
                    List<PartsDepartment> existPartsList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
                    if(existPartsList != null && !existPartsList.isEmpty()){
                        //踢出权限数据
                        for(PartsDepartment permission : existPartsList){
                            key = permission.getPartsId() + "," + permission.getDepartId();
                            if(partsPermissionHashMap.containsKey(key)){
                                partsPermissionHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, PartsDepartment> entry : partsPermissionHashMap.entrySet()){
                        pp = entry.getValue();
                        partsPermissionList.add(pp);
                        ptInfo = partsInfoMap.get(pp.getPartsId());
                        s = new PermissionStream();
                        s.setProductId(ptInfo.getProductId());
                        s.setComponentId(ptInfo.getComponentId());
                        s.setPartsId(ptInfo.getPartsId());
                        s.setDepartId(pp.getDepartId());
                        permissionStreamList.add(s);
                    }
                }

                if(!componentPermissionList.isEmpty()){
                    componentDepartmentService.saveBatch(componentPermissionList);
                }
                if(!partsPermissionList.isEmpty()){
                    partsDepartmentService.saveBatch(partsPermissionList);
                }
                if(!permissionStreamList.isEmpty()){
                    permissionStreamService.saveBatch(permissionStreamList);
                }
            }
            return true;
        }else if(nodeType == 2) {
            ComponentInfo componentInfo = componentInfoService.getById(paramId);
            if(componentInfo == null)
                ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = componentInfoService.assignAddDepart(componentInfo, departList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                List<String> componentIdList = new ArrayList<>();
                List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());

                //最终保存权限数据初始化
                List<ComponentDepartment> componentPermissionList = new ArrayList<>();
                List<PartsDepartment> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                //处理子部件
                PermissionStream s;

                Map<String, ComponentDepartment> componentPermissionMap = new HashMap<>();
                Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

                //初始化全体数据
                String key;
                ComponentDepartment cp;
                ComponentInfo cpInfo;
                for(ComponentInfo c : childrenList){
                    componentIdList.add(c.getComponentId());
                    componentInfoMap.put(c.getComponentId(), c);
                    for(Department u : departList){
                        key = c.getComponentId() + "," + u.getDepartId();
                        cp = new ComponentDepartment(c.getComponentId(), u.getDepartId());
                        componentPermissionMap.put(key, cp);
                    }
                }
                //查询已存在的权限数据
                List<ComponentDepartment> existList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIdList, ids);
                if(existList != null && !existList.isEmpty()){
                    //踢出权限数据
                    for(ComponentDepartment permission : existList){
                        key = permission.getComponentId() + "," + permission.getDepartId();
                        if(componentPermissionMap.containsKey(key)){
                            componentPermissionMap.remove(key);
                        }
                    }
                }
                for(Map.Entry<String, ComponentDepartment> entry : componentPermissionMap.entrySet()){
                    cp = entry.getValue();
                    componentPermissionList.add(cp);
                    cpInfo = componentInfoMap.get(cp.getComponentId());
                    s = new PermissionStream();
                    s.setProductId(cpInfo.getProductId());
                    s.setComponentId(cpInfo.getComponentId());
                    s.setDepartId(cp.getDepartId());
                    permissionStreamList.add(s);
                }

                //处理子零件
                componentIdList.add(componentInfo.getComponentId());
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    Map<String, PartsDepartment> partsPermissionHashMap = new HashMap<>();
                    Map<String, PartsInfo> partsInfoMap = new HashMap<>();
                    List<String> partsIds = new ArrayList<>();
                    PartsDepartment pp;
                    PartsInfo ptInfo;
                    for(PartsInfo p : partsInfoList){
                        partsIds.add(p.getPartsId());
                        partsInfoMap.put(p.getPartsId(), p);
                        for(Department u : departList){
                            key = p.getPartsId() + "," + u.getDepartId();
                            pp = new PartsDepartment(p.getPartsId(), u.getDepartId());
                            partsPermissionHashMap.put(key, pp);
                        }
                    }

                    //查询已存在的权限数据
                    List<PartsDepartment> existPartsList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
                    if(existPartsList != null && !existPartsList.isEmpty()){
                        //踢出权限数据
                        for(PartsDepartment permission : existPartsList){
                            key = permission.getPartsId() + "," + permission.getDepartId();
                            if(partsPermissionHashMap.containsKey(key)){
                                partsPermissionHashMap.remove(key);
                            }
                        }
                    }

                    for(Map.Entry<String, PartsDepartment> entry : partsPermissionHashMap.entrySet()){
                        pp = entry.getValue();
                        partsPermissionList.add(pp);
                        ptInfo = partsInfoMap.get(pp.getPartsId());
                        s = new PermissionStream();
                        s.setProductId(ptInfo.getProductId());
                        s.setComponentId(ptInfo.getComponentId());
                        s.setPartsId(ptInfo.getPartsId());
                        s.setDepartId(pp.getDepartId());
                        permissionStreamList.add(s);
                    }
                }

                if(!componentPermissionList.isEmpty()){
                    componentDepartmentService.saveBatch(componentPermissionList);
                }
                if(!partsPermissionList.isEmpty()){
                    partsDepartmentService.saveBatch(partsPermissionList);
                }
                if(!permissionStreamList.isEmpty()){
                    permissionStreamService.saveBatch(permissionStreamList);
                }
            }
            return true;
        }
        return false;
    }

    /**
     * 待优化 TODO
     * @param nodeType 1 产品 2 部件 3 零件
     * @param paramId 产品树节点id
     * @param relativeFlag 1 是 2 否
     * @param departmentIds 移除部门ids
     * @return
     */
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveDepartment(Integer nodeType, String paramId, Integer relativeFlag, String[] departmentIds) {
        if(!ValidateUtil.validateInteger(nodeType) || !ValidateUtil.validateString(paramId) ||
                !ValidateUtil.validateInteger(relativeFlag))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(departmentIds == null || departmentIds.length < 1)
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_NONE);
        List<String> ids = new ArrayList<>(departmentIds.length);
        Collections.addAll(ids, departmentIds);
        Collection<Department> departList = departmentService.listByIds(ids);
        if(departList == null || departList.isEmpty() || departList.size() != departmentIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(nodeType == 3) {
            //处理零件
            PartsInfo partsInfo = partsInfoService.getById(paramId);
            if(partsInfo == null)
                ExceptionCast.cast(PartsInfoCode.PARTS_NOT_EXIST);
            boolean b = checkProductPerm(3, partsInfo.getPartsId());
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
            return partsInfoService.assignRemoveDepart(partsInfo, departList);
        }else if(nodeType == 1) {
            //处理产品
            ProductInfo productInfo = super.getById(paramId);
            if(productInfo == null)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_NOT_EXIST);
            boolean b1 = checkProductPerm(1, productInfo.getProductId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = this.assignRemoveDepartment(productInfo, departList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                //处理产品 下的部件
                List<String> componentIds = new ArrayList<>();
                //总计需要删除的数据信息
                List<ComponentDepartment> componentPermissionList = new ArrayList<>();
                List<PartsDepartment> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();
                List<ComponentInfo> componentInfoList = componentInfoService.getByProductId(productInfo.getProductId());
                if(componentInfoList != null && !componentInfoList.isEmpty()) {
                    for(ComponentInfo componentInfo : componentInfoList){
                        componentIds.add(componentInfo.getComponentId());
                    }
                    componentPermissionList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndDepartIds(componentIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                //处理产品 下的零件
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(productInfo.getProductId(), componentIds);
                List<String> partsIds = new ArrayList<>();
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    for(PartsInfo partsInfo : partsInfoList){
                        partsIds.add(partsInfo.getPartsId());
                    }
                    partsPermissionList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(partsIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                if(componentPermissionList != null && !componentPermissionList.isEmpty()){
                    componentDepartmentService.removeByCollection(componentPermissionList);
                }
                if(partsPermissionList != null && !partsPermissionList.isEmpty()){
                    partsDepartmentService.removeByCollection(partsPermissionList);
                }
                if(permissionStreamList != null && !permissionStreamList.isEmpty()){
                    permissionStreamService.removeByCollection(permissionStreamList);
                }
            }
            return true;
        }else if(nodeType == 2) {
            ComponentInfo componentInfo = componentInfoService.getById(paramId);
            if(componentInfo == null)
                ExceptionCast.cast(ComponentInfoCode.COMPONENT_NOT_EXIST);
            boolean b1 = checkProductPerm(2, componentInfo.getComponentId());
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            b1 = componentInfoService.assignRemoveDepart(componentInfo, departList);
            if(!b1)
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            if(relativeFlag == 1) {
                List<String> componentIdList = new ArrayList<>();
                //总计需要删除的数据信息
                List<ComponentDepartment> componentPermissionList = new ArrayList<>();
                List<PartsDepartment> partsPermissionList = new ArrayList<>();
                List<PermissionStream> permissionStreamList = new ArrayList<>();

                List<ComponentInfo> childrenList = componentInfoService.getByParentId(componentInfo.getComponentId());
                if(childrenList != null && !childrenList.isEmpty()) {
                    for(ComponentInfo cpn : childrenList){
                        componentIdList.add(cpn.getComponentId());
                    }
                    componentPermissionList = componentDepartmentService.getByComponentIdsAndDepartIds(componentIdList, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByComponentIdsAndDepartIds(componentIdList, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                //处理产品 下的零件
                componentIdList.add(componentInfo.getComponentId());
                List<PartsInfo> partsInfoList = partsInfoService.getByComponentIdList(componentInfo.getProductId(), componentIdList);
                List<String> partsIds = new ArrayList<>();
                if(partsInfoList != null && !partsInfoList.isEmpty()) {
                    for(PartsInfo partsInfo : partsInfoList){
                        partsIds.add(partsInfo.getPartsId());
                    }
                    partsPermissionList = partsDepartmentService.getByPartsIdsAndDepartIds(partsIds, ids);
                    List<PermissionStream> existPermissionList = permissionStreamService.getByPartsIdsAndDepartIds(partsIds, ids);
                    if(existPermissionList != null && !existPermissionList.isEmpty()){
                        permissionStreamList.addAll(existPermissionList);
                    }
                }

                if(componentPermissionList != null && !componentPermissionList.isEmpty()){
                    componentDepartmentService.removeByCollection(componentPermissionList);
                }
                if(partsPermissionList != null && !partsPermissionList.isEmpty()){
                    partsDepartmentService.removeByCollection(partsPermissionList);
                }
                if(permissionStreamList != null && !permissionStreamList.isEmpty()){
                    permissionStreamService.removeByCollection(permissionStreamList);
                }
            }
            return true;
        }
        return false;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddUser(ProductInfo productInfo, Collection<SysUser> userList) {
        if(productInfo == null || userList == null || userList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<ProductPermission> permissionList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        userList.forEach(item -> {
            ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
            if(en == null) {
                en = new ProductPermission();
                en.setUserId(item.getId());
                en.setProductId(productInfo.getProductId());
                permissionList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
            if(stream == null) {
                stream = new PermissionStream();
                stream.setUserId(item.getId());
                stream.setProductId(productInfo.getProductId());
                permissionStreamList.add(stream);
            }
        });
        if(!permissionList.isEmpty()) {
            boolean b = productPermissionService.saveBatch(permissionList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.saveBatch(permissionStreamList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveUser(ProductInfo productInfo, Collection<SysUser> userList) {
        if(productInfo == null || userList == null || userList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<ProductPermission> permissionList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        userList.forEach(item -> {
            ProductPermission en = productPermissionService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
            if(en != null) {
                permissionList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByProductIdAndUserId(productInfo.getProductId(), item.getId());
            if(stream != null) {
                permissionStreamList.add(stream);
            }
        });
        //移除用户权限清空校验
        List<ProductPermission> existList = productPermissionService.getByProductId(productInfo.getProductId());
        if(existList.size() <= permissionList.size())
            ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_NONE);
        if(!permissionList.isEmpty()) {
            boolean b = productPermissionService.removeByCollection(permissionList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.removeByCollection(permissionStreamList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignAddDepartment(ProductInfo productInfo, Collection<Department> departmentList) {
        if(productInfo == null || departmentList == null || departmentList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<ProductDepartment> productDepartmentList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        departmentList.forEach(item -> {
            ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getDepartId());
            if(en == null) {
                en = new ProductDepartment();
                en.setDepartId(item.getDepartId());
                en.setProductId(productInfo.getProductId());
                productDepartmentList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getDepartId());
            if(stream == null) {
                stream = new PermissionStream();
                stream.setDepartId(item.getDepartId());
                stream.setProductId(productInfo.getProductId());
                permissionStreamList.add(stream);
            }
        });
        if(!productDepartmentList.isEmpty()) {
            boolean b = productDepartmentService.saveBatch(productDepartmentList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.saveBatch(permissionStreamList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignRemoveDepartment(ProductInfo productInfo, Collection<Department> departmentList) {
        if(productInfo == null || departmentList == null || departmentList.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<ProductDepartment> productDepartmentList = new ArrayList<>();
        List<PermissionStream> permissionStreamList = new ArrayList<>();
        departmentList.forEach(item -> {
            ProductDepartment en = productDepartmentService.getByProductIdAndDepartId(productInfo.getProductId(), item.getDepartId());
            if(en != null) {
                productDepartmentList.add(en);
            }
            PermissionStream stream = permissionStreamService.getByProductIdAndDepartId(productInfo.getProductId(), item.getDepartId());
            if(stream != null) {
                permissionStreamList.add(stream);
            }
        });
        if(!productDepartmentList.isEmpty()) {
            boolean b = productDepartmentService.removeByCollection(productDepartmentList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        if(!permissionStreamList.isEmpty()) {
            boolean b = permissionStreamService.removeByCollection(permissionStreamList);
            if(!b) {
                ExceptionCast.cast(ProductInfoCode.PRODUCT_USER_PERM_ERROR);
            }
        }
        return true;
    }

    @Override
    public List<String> getDepartIdsByParams(Integer nodeType, String paramId) {
        List<String> departIds = new ArrayList<>();
        if(nodeType == 2) {
            ComponentInfo en = componentInfoService.getById(paramId);
            if(en == null)
                return null;
            List<PermissionStream> permissionStreamList = permissionStreamService.getByComponentId(en.getProductId(), en.getComponentId());
            if(permissionStreamList == null || permissionStreamList.isEmpty())
                return null;
            permissionStreamList.forEach(item -> {
                departIds.add(item.getDepartId());
            });
        }else if(nodeType == 3) {
            PartsInfo en = partsInfoService.getById(paramId);
            if(en == null)
                return null;
            List<PermissionStream> permissionStreamList = permissionStreamService.getByPartsId(en.getProductId(), en.getComponentId(), en.getPartsId());
            if(permissionStreamList == null || permissionStreamList.isEmpty())
                return null;
            permissionStreamList.forEach(item -> {
                departIds.add(item.getDepartId());
            });
        }else {
            return null;
        }
        return departIds;
    }

    @Override
    public ProductInfo getByProductNo(String productNo) {
        if(ValidateUtil.validateString(productNo)) {
            List<ProductInfo> list = super.lambdaQuery().eq(ProductInfo::getProductNo, productNo).list();
            if(list == null || list.isEmpty())
                return null;
            return list.get(0);
        }
        return null;
    }

    @Override
    public List<CommonGenericTree> loadBaseTree(String userId) {
        List<ProductInfo> productInfoList = getByUserPerms(userId);
        if(productInfoList == null || productInfoList.isEmpty())
            return Collections.emptyList();
//        List<ComponentExt> componentInfoList = componentInfoService.getByUserPermsAs(userId);
//        if(componentInfoList == null)
//            componentInfoList = Collections.emptyList();
        return ProductTreeWrapper.loadTree(productInfoList);
    }

    @Override
    public List<CommonGenericTree> loadTree(String userId, Integer nodeType, String paramId) {
        if(nodeType == 1) {
            List<ComponentInfo> componentInfoList = componentInfoService.getByProductIdAndUserId(paramId, userId);
            if(componentInfoList == null || componentInfoList.isEmpty())
                return Collections.emptyList();
            List<CommonGenericTree> list = new ArrayList<>();
            CommonGenericTree<ComponentInfo> node;
            for(ComponentInfo c : componentInfoList) {
                node = new CommonGenericTree();
                node.setId(c.getComponentId());
//                node.setLabel("[" + c.getComponentCode()+ "]" +  c.getComponentName());
                node.setLabel(c.getComponentName());
                node.setParentId(c.getProductId());
                node.setIconClass("");
                node.setType(2);
                node.setRField(c.getProductId());
                node.setEntity(c);
                list.add(node);
            }
            return list;
        }else if(nodeType == 2) {
            List<ComponentInfo> componentInfoList = componentInfoService.getByParentIdAndUserId(paramId, userId);
            List<CommonGenericTree> list = new ArrayList<>();
            CommonGenericTree<ComponentInfo> componentNode;
            if(componentInfoList != null && !componentInfoList.isEmpty()) {
                for(ComponentInfo c : componentInfoList) {
                    componentNode = new CommonGenericTree();
                    componentNode.setId(c.getComponentId());
//                    componentNode.setLabel("[" + c.getComponentCode()+ "]" + c.getComponentName());
                    componentNode.setLabel(c.getComponentName());
                    componentNode.setParentId(c.getParentId());
                    componentNode.setIconClass("");
                    componentNode.setType(2);
                    componentNode.setRField(c.getProductId());
                    componentNode.setEntity(c);
                    list.add(componentNode);
                }
            }
            List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, paramId, null);
            if(partsInfos == null || partsInfos.isEmpty())
                return list;
            CommonGenericTree<PartsInfo> partNode;
            for(PartsInfo part : partsInfos) {
                partNode = new CommonGenericTree();
                partNode.setId(part.getPartsId());
//                partNode.setLabel("[" + part.getPartsCode()+ "]" + part.getPartsName());
                partNode.setLabel(part.getPartsName());
                partNode.setParentId(part.getComponentId());
                partNode.setIconClass("");
                partNode.setType(3);
                partNode.setRField(part.getComponentId());
                partNode.setEntity(part);
                partNode.setLeaf(true);
                list.add(partNode);
            }
            return list;
        }else {
            return Collections.emptyList();
        }
    }

    @Override
    public List<CommonGenericTree> searchProductTree(String userId, String queryParam) {
        List<ProductInfo> productInfos = this.getByUserPerms(userId, queryParam);
        List<ComponentInfo> componentInfos = componentInfoService.getByUserPerms(userId, queryParam);
        List<PartsInfo> partsInfos = partsInfoService.getByUserPerms(userId, null, queryParam);

        List<ComponentInfo> componentInfoList = new ArrayList<>();
        List<ProductInfo> productInfoList = new ArrayList<>();

        Map<String, ProductInfo> productInfoMap = new HashMap<>();
        Map<String, ComponentInfo> componentInfoMap = new HashMap<>();

        ProductInfo product;
        ComponentInfo component;

        if(productInfos != null && !productInfos.isEmpty()){
            for(ProductInfo p : productInfos){
                productInfoList.add(p);
                productInfoMap.put(p.getProductId(), p);
            }
        }

        if(componentInfos != null && !componentInfos.isEmpty()){
            for(ComponentInfo c : componentInfos){
                componentInfoList.add(c);
                componentInfoMap.put(c.getComponentId(), c);
            }
        }

        for(PartsInfo p : partsInfos) {
            if(!productInfoMap.containsKey(p.getProductId())) {
                product  = super.getById(p.getProductId());
                if(product != null) {
                    productInfoMap.put(product.getProductId(), product);
                    productInfoList.add(product);
                }
            }

            if(!componentInfoMap.containsKey(p.getComponentId())) {
                component = componentInfoService.getById(p.getComponentId());
                if(component != null) {
                    componentInfoMap.put(component.getComponentId(), component);
                    componentInfoList.add(component);
                }

            }
        }

        List<ComponentInfo> addList = new ArrayList<>();
        log.info("componentInfoList集合大小={}", componentInfoList.size());
        long start = System.currentTimeMillis();
        log.info("开始循环执行时间={}", start);
        String pid;
        for(ComponentInfo c : componentInfoList){
            int rankLevel = c.getRankLevel();
            component = c;
            if(!productInfoMap.containsKey(c.getProductId())) {
                product  = super.getById(c.getProductId());
                if(product != null) {
                    productInfoMap.put(product.getProductId(), product);
                    productInfoList.add(product);
                }
            }
            while((rankLevel - 1) > 0) {
                pid = component.getParentId();
                if(componentInfoMap.containsKey(pid)) {
                    component = componentInfoMap.get(pid);
                    rankLevel = component.getRankLevel();
                    continue;
                }
                component = componentInfoService.getById(pid);
                if(component != null) {
                    log.info("addList添加了新的部件id={}", component.getComponentId());
                    componentInfoMap.put(component.getComponentId(), component);
                    addList.add(component);
                    rankLevel = component.getRankLevel();
                }else {
                    log.info("查询不到部件id={}", pid);
                    break;
                }

            }
        }
        long end = System.currentTimeMillis();
        log.info("循环执行总耗时={}", (end - start));

        if(!addList.isEmpty()){
            componentInfoList.addAll(addList);
        }

        //转换数据
        List<ComponentExt> componentExtList = ComponentExt.convertToExtList(componentInfoList);

        return ProductTreeWrapper.loadTree(productInfoList, componentExtList, partsInfos);
    }
}