package com.vci.ubcs.code.service.impl;


import com.vci.ubcs.code.constant.MdmBtmTypeConstant;
import com.vci.ubcs.code.dao.DockingPreAttrMappingDaoI;
import com.vci.ubcs.code.dao.DockingPreAttrRangeDaoI;
import com.vci.ubcs.code.model.DockingPreAttrMappingDO;
import com.vci.ubcs.code.model.DockingPreAttrRangeDO;
import com.vci.ubcs.code.service.CodeClassifyTemplateAttrServiceI;
import com.vci.ubcs.code.service.DockingPreAttrMappingSeviceI;
import com.vci.ubcs.code.service.MdmEngineServiceI;
import com.vci.starter.web.constant.QueryOptionConstant;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.DataGrid;
import com.vci.starter.web.pagemodel.PageHelper;
import com.vci.starter.web.util.BeanUtilForVCI;
import com.vci.starter.web.util.VciBaseUtil;
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
import com.vci.web.pageModel.BatchCBO;
import com.vci.web.pageModel.OsEnumItemVO;
import com.vci.web.redis.RedisService;
import com.vci.web.service.OsEnumServiceI;
import com.vci.web.service.WebBoServiceI;
import com.vci.web.util.WebUtil;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.vci.ubcs.code.dto.DockingPreAttrMappingDTO;
import com.vci.ubcs.code.dto.DockingPreAttrRangeDTO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.DockingPreAttrMappingVO;
import com.vci.ubcs.code.vo.pagemodel.DockingPreAttrRangeVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import plm.bs.bom.clientobject.ClientBusinessObject;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
public class DockingPreAttrMappingSeviceImpl implements DockingPreAttrMappingSeviceI {
    /**
     * 日志
     */
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 集成属性映射配置服务
     */
    @Resource
    private DockingPreAttrMappingDaoI dockingPreAttrMappingDaoI;
    /**
     * 集成属性取值范围配置服务
     */
    @Resource
    private DockingPreAttrRangeDaoI dockingPreAttrRangeDODaoI;
    /**
     * 分类操作服务
     */
    @Autowired
    private CodeClassifyServiceImpl codeClassifyService;
    /**
     * 业务类型操作的服务
     */
    @Autowired
    @Lazy
	private WebBoServiceI boService;

    /**
     * 缓存服务
     */
    @Autowired
    private RedisService redisService;

    /**
     * 主数据引擎的服务
     */
    @Autowired
    private MdmEngineServiceI engineService;
    /**
     *枚举服务
     */
    @Autowired
    private OsEnumServiceI osEnumService;
    @Autowired
    private CodeClassifyTemplateAttrServiceI codeClassifyTemplateAttrServiceI;

    /***
     * 属性映射列表
     * @param conditionMap
     * @param pageHelper
     * @param type
     * @return
     * @throws VciBaseException
     */
    @Override
    public DataGrid<DockingPreAttrMappingVO> gridAttrMappings(String clsfId, int type, Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
        if (pageHelper == null) {
            pageHelper = new PageHelper(-1);

        }
        VciBaseUtil.alertNotNull(clsfId,"分类主键");
        VciBaseUtil.alertNotNull(type,"操作类型");
        //VciBaseUtil.alertNotNull(templateOid,"模板主键");
        if(conditionMap==null){
            conditionMap=new HashMap<>();
        }

        /***
         *  1.首先去模板里查询是否有增删属性
         *  2.如果有的话需要校验属性的名称是否有变更
         */
        List<ClientBusinessObject> tempCBO=new ArrayList<>();
        ClientBusinessObject clssCBO=new ClientBusinessObject();
        // List<String> templateIds = VciBaseUtil.str2List(templateOid);
        Map<String,String> cboOidMap=new HashMap<>();
        String btmName= MdmBtmTypeConstant.CODE_CLASSIFY_TEMPLATE_ATTR;
        CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(clsfId);

        if(StringUtils.isBlank(templateVO.getOid())){
            return new DataGrid<>();
        }
        String templateOid=templateVO.getOid();
        String clsfBtmName=MdmBtmTypeConstant.CODE_CLASSIFY;
        String orderbyFiled="";
        if(type==1) {//代表的是wrj
            orderbyFiled="ordernum";
            cboOidMap.put("classifytemplateoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(templateVO.getOid()) + ")");
            btmName=MdmBtmTypeConstant.CODE_CLASSIFY_TEMPLATE_ATTR;
            clsfBtmName=MdmBtmTypeConstant.CODE_CLASSIFY;
        }else{
            orderbyFiled="codeattrseq";
            cboOidMap.put("classifytemplateoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(templateOid) + ")");
            btmName=MdmBtmTypeConstant.DOCKING_PRE_JMETAATRR;
            clsfBtmName=MdmBtmTypeConstant.DOCKING_PRE_JCLASS;
        }
        //按模板顺序展示属性
        PageHelper tempPageHelper=new PageHelper();
        tempPageHelper = new PageHelper(-1);
        tempPageHelper.addDefaultAsc(orderbyFiled);
        tempCBO = boService.queryCBO(btmName,cboOidMap,tempPageHelper);
        if(CollectionUtils.isEmpty(tempCBO)){
            throw new VciBaseException("根据模板主键未查询到相应的属性信息");
        }
        clssCBO= boService.selectCBOByOid(clsfId,clsfBtmName);
        if(clssCBO==null||StringUtils.isBlank(clssCBO.getOid())){
            throw new VciBaseException("根据分类主键未查询到分类信息");
        }
        pageHelper.addDefaultDesc("createTime");
        //根据源分类id和模板id查询模板映射数据
       // conditionMap.put("jsourceClsfId",clsfId);
        conditionMap.put("jviewModeId", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(templateOid) + ")");

        List<DockingPreAttrMappingDO> doList = dockingPreAttrMappingDaoI.selectByCondition(conditionMap,pageHelper);
        Map<String/**中文名称**/, DockingPreAttrMappingDO/**数据对象**/> dockingAttrmappingOidToMap = doList.stream().collect(Collectors.toMap(s -> s.getJmetaListId(), t -> t,(o1, o2)->o2));
        List<DockingPreAttrMappingDO> newDockingPreAttrMappingDOS=new ArrayList<>();
        ClientBusinessObject finalClssCBO = clssCBO;
        tempCBO.stream().forEach(cbo ->{
            DockingPreAttrMappingDO dockingPreAttrMappingDO=new DockingPreAttrMappingDO();
            String oid=cbo.getOid();//属性oid
            if(dockingAttrmappingOidToMap.containsKey(oid)){
                dockingPreAttrMappingDO=dockingAttrmappingOidToMap.get(oid);
            }else{
                dockingPreAttrMappingDO.setOid(redisService.getUUIDEveryDay());
                dockingPreAttrMappingDO.setJmetaListId(oid);//源系统的属性oid
                dockingPreAttrMappingDO.setJdefaultValue("");//默认值
                dockingPreAttrMappingDO.setJsourceAttrKey(cbo.getId());//源系统属性内部名称
                dockingPreAttrMappingDO.setJsourceAttrName(cbo.getName());//源系统属性名称
                dockingPreAttrMappingDO.setJsourceClsfId(clsfId);//源系统的分类oid
                dockingPreAttrMappingDO.setJsourceClsfName(finalClssCBO.getName());//源系统的分类名称
                dockingPreAttrMappingDO.setJviewModeId(templateOid);//暂时不存,模板视图的oid
                dockingPreAttrMappingDO.setJviewModeName(templateVO.getName());//暂时不存，模板名称
                dockingPreAttrMappingDO.setJtargetAttrId("");//目标系统属性系id
                dockingPreAttrMappingDO.setJtargetAttrName("");//目标系统属性名称
                dockingPreAttrMappingDO.setJtargetAttrKey("");//目标系统属性内部值
                dockingPreAttrMappingDO.setJtargetClsfId("");//目标系统分类oid
            }
            newDockingPreAttrMappingDOS.add(dockingPreAttrMappingDO);
        } );

        DataGrid<DockingPreAttrMappingVO> dataGrid=new DataGrid<DockingPreAttrMappingVO>();
        if (!CollectionUtils.isEmpty(newDockingPreAttrMappingDOS)) {
            dataGrid.setData(dockingPreAttrMappingDO2VOs(newDockingPreAttrMappingDOS));
            dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(dockingPreAttrMappingDaoI.countByCondition(conditionMap))));
        }
        return dataGrid;
    }

    /***
     * 获取属性枚举
     * @param conditionMap
     * @param pageHelper
     * @return
     * @throws VciBaseException
     */
    @Override
    public DataGrid<DockingPreAttrRangeVO> gridAttrRanges(String attrOid, int type, Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
        VciBaseUtil.alertNotNull(attrOid,"属性主键");
        VciBaseUtil.alertNotNull(type,"操作类型");
        if (pageHelper == null) {
            pageHelper = new PageHelper(-1);
        }
        if(conditionMap==null){
            conditionMap=new HashMap<>();
        }
        pageHelper.addDefaultDesc("createTime");
        conditionMap.put("jmetaListId",attrOid);
        List<DockingPreAttrRangeDO> doList =dockingPreAttrRangeDODaoI.selectByCondition(conditionMap,pageHelper);
        Map<String/**枚举内部名称**/, DockingPreAttrRangeDO/**数据对象**/> dockingPreAttrRangeValueMap = doList.stream().collect(Collectors.toMap(s -> s.getJnumTextValue(), t -> t,(o1, o2)->o2));
        CodeClassifyTemplateAttrVO codeClassifyTemplateAttrVO= codeClassifyTemplateAttrServiceI.getObjectByOid(attrOid);
        String attrkey= codeClassifyTemplateAttrVO.getId();
        Map<String,String> cboOidMap=new HashMap<>();
        List<DockingPreAttrRangeDO> newDockingPreAttrRangeDO=new ArrayList<>();
        if(type==1){
            List<OsEnumItemVO> osEnumItemVOList= osEnumService.listEnumByAttriteKey(attrkey);
            if(!CollectionUtils.isEmpty(osEnumItemVOList)) {
                osEnumItemVOList.stream().forEach(osEnumItemVO -> {
                    DockingPreAttrRangeDO dockingPreAttrRangeDO = dockingPreAttrRangeValueMap.get(osEnumItemVO.getId());
                    if (!dockingPreAttrRangeValueMap.containsKey(osEnumItemVO.getId())) {
                        dockingPreAttrRangeDO = new DockingPreAttrRangeDO();
                        dockingPreAttrRangeDO.setOid(redisService.getUUIDEveryDay());
                        dockingPreAttrRangeDO.setJmetaListId(attrOid);//属性oid
                        dockingPreAttrRangeDO.setJnumText(osEnumItemVO.getName());//属性枚举显示值
                        dockingPreAttrRangeDO.setJnumTextValue(osEnumItemVO.getId());//枚举内部值
                        dockingPreAttrRangeDO.setJtargeNumText("");//配置的显示值
                        dockingPreAttrRangeDO.setJtargeNumTextValue("");//配置的内部值
                    }
                    newDockingPreAttrRangeDO.add(dockingPreAttrRangeDO);
                });
            }
        }
        DataGrid<DockingPreAttrRangeVO> dataGrid=new DataGrid<>();
        if (!CollectionUtils.isEmpty(newDockingPreAttrRangeDO)) {
            dataGrid.setData(dockingPreAttrRangeDO2VOs(newDockingPreAttrRangeDO));
            dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(dockingPreAttrRangeDODaoI.countByCondition(conditionMap))));
        }
        return dataGrid;
    }

    /***
     *保存属性映射配置组件
     * @param dockingPreAttrMappingDTOS 属性映射配置数据传输对象
     * @return
     * @throws VciBaseException
     */
    @Override
    public  List<DockingPreAttrMappingVO> batchAddSave(List<DockingPreAttrMappingDTO> dockingPreAttrMappingDTOS) throws VciBaseException {
        List<DockingPreAttrMappingVO> dockingPreAttrMappingVOS=new ArrayList<>();
       if(CollectionUtils.isEmpty(dockingPreAttrMappingDTOS)){
           return new ArrayList<>();
       }
        /**
         * 1.传递过来的有可能主数据模板新增属性，这样的需要添加，也有可能删除的属性，这样的映射需要删除
         * 也有更新的这样则更新
         */
        List<DockingPreAttrMappingDO> newDockingPreAttrMappingDOS=new ArrayList<>();
        List<String>oidList=new ArrayList<>();
        List<String>attrIdList=new ArrayList<>();
        List<String> attributeOidList=new ArrayList<>();
        List<DockingPreAttrRangeDO> newDockingPreAttrRangeDTOList=new ArrayList<>();
        dockingPreAttrMappingDTOS.stream().forEach(dockingPreAttrMappingDTO -> {
            List<DockingPreAttrRangeDTO>dockingPreAttrRangeDTOList=dockingPreAttrMappingDTO.getDockingPreAttrRangeDTOS();
            DockingPreAttrMappingDO dockingPreAttrMappingDO=new DockingPreAttrMappingDO();
            oidList.add(dockingPreAttrMappingDTO.getOid());
            if(!CollectionUtils.isEmpty(dockingPreAttrRangeDTOList)) {
                attrIdList.add(dockingPreAttrMappingDTO.getJmetaListId());
                List<DockingPreAttrRangeDO> dockingPreAttrRangeDOList = dockingPreAttrRangeDTO2DOs(dockingPreAttrRangeDTOList);
                newDockingPreAttrRangeDTOList.addAll(dockingPreAttrRangeDOList);
            }
            BeanUtilForVCI.copyPropertiesIgnoreCase(dockingPreAttrMappingDTO, dockingPreAttrMappingDO);
            newDockingPreAttrMappingDOS.add(dockingPreAttrMappingDO);
        });
        List<DockingPreAttrRangeDO> dockingPreAttrRangeDOList=new ArrayList<>();
        if(!CollectionUtils.isEmpty(attrIdList)) {
            //获取存在的属性取值范围.
            dockingPreAttrRangeDOList = dockingPreAttrRangeDODaoI.selectByAttrOid(StringUtils.join(attrIdList, ","));
        }
        //获取存在的属性映射.
        List<DockingPreAttrMappingDO> dataAttrMapping = dockingPreAttrMappingDaoI.selectByOid(StringUtils.join(oidList, ","));
        Map<String/**oid**/,DockingPreAttrMappingDO/**属性对象**/> allSaveAttrMappingMap = newDockingPreAttrMappingDOS.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t,(o1, o2)->o2));
        Map<String/**oid**/,DockingPreAttrMappingDO/**对象**/> oldAttrMappingMap =dataAttrMapping.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t,(o1, o2)->o2));

        WebUtil.setPersistence(false);//不执行保存
        BatchCBO batchCbos = new BatchCBO();
        //需要新增的属性映射
        List<DockingPreAttrMappingDO> needSaveCboList = newDockingPreAttrMappingDOS.stream().filter(cbo -> {
            String oid =cbo.getOid();
            return !oldAttrMappingMap.containsKey(oid);
        }).collect(Collectors.toList());
        if(needSaveCboList.size()>0) {
            BatchCBO addCOB = dockingPreAttrMappingDaoI.batchInsert(needSaveCboList);
            batchCbos.copyFromOther(addCOB);
        }
        Map<String/**oid**/,DockingPreAttrMappingDO/**对象**/> saveAttrMappingMap = needSaveCboList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t,(o1, o2)->o2));
        //要把以上的错误的都抛出后，需要更新的属性映射
        List<DockingPreAttrMappingDO> needEditCboList = newDockingPreAttrMappingDOS.stream().filter(cbo -> {
            String oid =cbo.getOid();
            return !saveAttrMappingMap.containsKey(oid);
        }).collect(Collectors.toList());
        if(needEditCboList.size()>0) {
            List<DockingPreAttrMappingDO> editCboList=new ArrayList<>();
            needEditCboList.stream().forEach(cbo->{
                String oid=cbo.getOid();
                if(oldAttrMappingMap.containsKey(oid)){
                    DockingPreAttrMappingDO dockingPreAttrMappingDO=  oldAttrMappingMap.get(oid);
                    dockingPreAttrMappingDO.setJtargetAttrKey(cbo.getJtargetAttrKey());
                    dockingPreAttrMappingDO.setJtargetAttrName(cbo.getJtargetAttrName());
                    dockingPreAttrMappingDO.setJtargetAttrId(cbo.getJtargetAttrId());
                    dockingPreAttrMappingDO.setJtargetClsfId(cbo.getJtargetClsfId());
                    dockingPreAttrMappingDO.setJdefaultValue(cbo.getJdefaultValue());
                    editCboList.add(dockingPreAttrMappingDO);
                }
            });
            BatchCBO editCOB = dockingPreAttrMappingDaoI.batchUpdate(editCboList);
            batchCbos.copyFromOther(editCOB);
        }
        //需要删除的属性映射
        List<String> deleteIdList=new ArrayList<>();
         dataAttrMapping.stream().forEach(cbo -> {
            String oid =cbo.getOid();
            if(!allSaveAttrMappingMap.containsKey(oid)){
                deleteIdList.add(oid);
            }
        });
        if(deleteIdList.size()>0) {
            BatchCBO deleteCBO = dockingPreAttrMappingDaoI.batchDeleteByOids(deleteIdList);
            batchCbos.copyFromOther(deleteCBO);
        }
        //取值范围处理
        if(!CollectionUtils.isEmpty(newDockingPreAttrRangeDTOList)) {
            Map<String/**oid**/, DockingPreAttrRangeDO/**属性对象**/> allSaveAttrAttrRangeDOMap =newDockingPreAttrRangeDTOList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t, (o1, o2) -> o2));
            Map<String/**oid**/, DockingPreAttrRangeDO/**对象**/> oldSaveAttrAttrRangeDOMap = dockingPreAttrRangeDOList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t, (o1, o2) -> o2));
            //需要新增的属性取值范围
            List<DockingPreAttrRangeDO> needSaveRangeCboList = newDockingPreAttrRangeDTOList.stream().filter(cbo -> {
                String oid = cbo.getOid();
                return !oldSaveAttrAttrRangeDOMap.containsKey(oid);
            }).collect(Collectors.toList());
            if(needSaveRangeCboList.size()>0) {
                BatchCBO addRangeCOB = dockingPreAttrRangeDODaoI.batchInsert(needSaveRangeCboList);
                batchCbos.copyFromOther(addRangeCOB);
            }
            //需要更新的属性取值范围
            Map<String/**oid**/, DockingPreAttrRangeDO/**对象**/> saveRangeMap = needSaveRangeCboList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t, (o1, o2) -> o2));
            List<DockingPreAttrRangeDO> needEditRangeCboList = newDockingPreAttrRangeDTOList.stream().filter(cbo -> {
                String oid = cbo.getOid();
                return !saveRangeMap.containsKey(oid);
            }).collect(Collectors.toList());

            if(needEditRangeCboList.size()>0) {
                List<DockingPreAttrRangeDO> editCboList=new ArrayList<>();
                needEditRangeCboList.stream().forEach(cbo->{
                        String oid=cbo.getOid();
                        if(oldSaveAttrAttrRangeDOMap.containsKey(oid)){
                            DockingPreAttrRangeDO dockingPreAttrRangeDO=  oldSaveAttrAttrRangeDOMap.get(oid);
                            dockingPreAttrRangeDO.setJtargeNumText(cbo.getJtargeNumText());
                            dockingPreAttrRangeDO.setJtargeNumTextValue(cbo.getJtargeNumTextValue());
                            editCboList.add(dockingPreAttrRangeDO);
                        }
                    });
                BatchCBO editRangeCOB = dockingPreAttrRangeDODaoI.batchUpdate(editCboList);
                batchCbos.copyFromOther(editRangeCOB);
            }
            //需要删除的属性取值范围
            List<String> deleteRangeIdList = new ArrayList<>();
            dockingPreAttrRangeDOList.stream().forEach(cbo -> {
                String oid = cbo.getOid();
                if (!allSaveAttrAttrRangeDOMap.containsKey(oid)) {
                    deleteRangeIdList.add(oid);
                }
            });
            if(deleteIdList.size()>0) {
                BatchCBO deleteRangeCBO = dockingPreAttrRangeDODaoI.batchDeleteByOids(deleteIdList);
                batchCbos.copyFromOther(deleteRangeCBO);
            }
        }

        WebUtil.setPersistence(true);
        this.boService.persistenceBatch(batchCbos);//更改数据
        return dockingPreAttrMappingVOS;
    }

    /***
     * 根据条件查询属性映射信息
     * @param conditionMap
     * @return
     * @throws VciBaseException
     */
    @Override
    public List<DockingPreAttrMappingVO> selectAttrMappings(Map<String, String> conditionMap) throws VciBaseException {
        List<DockingPreAttrMappingVO> dockingPreAttrMappingVOList=new ArrayList<>();
        VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(DockingPreAttrMappingDO.class);
        queryWrapperForDO.setConditionMap(conditionMap);
        List<DockingPreAttrMappingDO> dockingPreAttrMappingDOS=dockingPreAttrMappingDaoI.selectByWrapper(queryWrapperForDO);
       List<String> attributOids=new ArrayList<>();
        if(!CollectionUtils.isEmpty(dockingPreAttrMappingDOS)){
            dockingPreAttrMappingDOS.stream().forEach(dockingPreAttrMappingDO -> {
              String attrOid= dockingPreAttrMappingDO.getJmetaListId();
                attributOids.add(attrOid);
            });
            dockingPreAttrMappingVOList= dockingPreAttrMappingDO2VOs(dockingPreAttrMappingDOS);
            Map<String/**oid**/,DockingPreAttrMappingVO/**对象**/> attrMappingMap = dockingPreAttrMappingVOList.stream().collect(Collectors.toMap(s -> s.getJmetaListId(), t -> t,(o1, o2)->o2));

            VciQueryWrapperForDO queryWrapperForDO2 = new VciQueryWrapperForDO(DockingPreAttrRangeDO.class);
            Map<String,String> condtionMap=new HashMap<>();
            condtionMap.put("jmetaListId", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(attributOids.toArray(new String[]{})) + ")");
            queryWrapperForDO.setConditionMap(conditionMap);
           List<DockingPreAttrRangeDO> dockingPreAttrRangeDOS=dockingPreAttrRangeDODaoI.selectByWrapper(queryWrapperForDO2);
           Map<String,List<DockingPreAttrRangeVO>> attribueOidMap=new HashMap<>();
           if(!CollectionUtils.isEmpty(dockingPreAttrRangeDOS)){
               dockingPreAttrRangeDOS.stream().forEach(dockingPreAttrRangeDO -> {
                  String attributeOid= dockingPreAttrRangeDO.getJmetaListId();
                  List<DockingPreAttrRangeVO> dockingPreAttrRangeVOS=new ArrayList<>();
                   dockingPreAttrRangeVOS.add(dockingPreAttrRangeDO2VO(dockingPreAttrRangeDO));
                  if(attribueOidMap.containsKey(attributeOid)){
                      List<DockingPreAttrRangeVO> oldDockingPreAttrRangeVOS= attribueOidMap.get(attributeOid);
                      dockingPreAttrRangeVOS.addAll(oldDockingPreAttrRangeVOS);
                  }
                   attribueOidMap.put(attributeOid,dockingPreAttrRangeVOS);
               });
           }
           if(!CollectionUtils.isEmpty(attribueOidMap)){
               attribueOidMap.keySet().forEach(attoributeOid->{
                   List<DockingPreAttrRangeVO> dockingPreAttrRangeVOList= attribueOidMap.get(attoributeOid);
                   if(attrMappingMap.containsKey(attoributeOid)){
                       DockingPreAttrMappingVO dockingPreAttrMappingVO=    attrMappingMap.get(attoributeOid);
                       dockingPreAttrMappingVO.setDockingPreAttrRangeVOS(dockingPreAttrRangeVOList);
                   }
               });
           }
        }
        return dockingPreAttrMappingVOList;
    }

    /***
     * 属性枚举对象转换
     * @param doList
     * @return
     */
    private List<DockingPreAttrRangeDO> dockingPreAttrRangeDTO2DOs(List<DockingPreAttrRangeDTO> doList) {
        List<DockingPreAttrRangeDO> voList = new ArrayList<>();
        if(!CollectionUtils.isEmpty(doList)){
            for(DockingPreAttrRangeDTO s: doList){
                DockingPreAttrRangeDO doBO =  dockingPreAttrRangeDTO2DO(s);
                if(doBO != null){
                    voList.add(doBO);
                }
            }
        }
        return voList;
    }

    /***
     * 属性枚举映射
     * @param dockingPreAttrRangeDTO
     * @return
     */
    private DockingPreAttrRangeDO dockingPreAttrRangeDTO2DO(DockingPreAttrRangeDTO dockingPreAttrRangeDTO) {
        DockingPreAttrRangeDO dockingPreAttrRangeDO = new DockingPreAttrRangeDO();
        if(dockingPreAttrRangeDTO != null){
            BeanUtilForVCI.copyPropertiesIgnoreCase(dockingPreAttrRangeDTO,dockingPreAttrRangeDO);
            //如果有lcstatus的类的话
        }
        return dockingPreAttrRangeDO;
    }

    /***
     * 属性枚举对象转换
     * @param doList
     * @return
     */
    private List<DockingPreAttrRangeVO> dockingPreAttrRangeDO2VOs(List<DockingPreAttrRangeDO> doList) {
        List<DockingPreAttrRangeVO> voList = new ArrayList<>();
        if(!CollectionUtils.isEmpty(doList)){
            for(DockingPreAttrRangeDO s: doList){
                DockingPreAttrRangeVO vo =  dockingPreAttrRangeDO2VO(s);
                if(vo != null){
                    voList.add(vo);
                }
            }
        }
        return voList;
    }

    /***
     * 属性枚举映射
     * @param dockingPreAttrRangeDO
     * @return
     */
    private DockingPreAttrRangeVO dockingPreAttrRangeDO2VO(DockingPreAttrRangeDO dockingPreAttrRangeDO) {
        DockingPreAttrRangeVO vo = new DockingPreAttrRangeVO();
        if(dockingPreAttrRangeDO != null){
            BeanUtilForVCI.copyPropertiesIgnoreCase(dockingPreAttrRangeDO,vo);
            //如果有lcstatus的类的话
        }
        return vo;
    }

    /***
     * 属性映射对象转换
     * @param doList
     * @return
     */
    private List<DockingPreAttrMappingVO> dockingPreAttrMappingDO2VOs(List<DockingPreAttrMappingDO> doList) {
        List<DockingPreAttrMappingVO> voList = new ArrayList<>();
        if(!CollectionUtils.isEmpty(doList)){
            for(DockingPreAttrMappingDO s: doList){
                DockingPreAttrMappingVO vo =  dockingPreAttrMappingDO2VO(s);
                if(vo != null){
                    voList.add(vo);
                }
            }
        }
        return voList;
    }

    private DockingPreAttrMappingVO dockingPreAttrMappingDO2VO(DockingPreAttrMappingDO dockingPreAttrMappingDO) {
        DockingPreAttrMappingVO vo = new DockingPreAttrMappingVO();
        if(dockingPreAttrMappingDO != null){
            BeanUtilForVCI.copyPropertiesIgnoreCase(dockingPreAttrMappingDO,vo);
            //如果有lcstatus的类的话
        }
        return vo;
    }
}