Merge branch 'master' of http://dev.vci-tech.com:1065/r/ubcs

 Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/poi/util/ExcelUtil.java

@@ -321,7 +321,6 @@
                    throw new VciBaseException(LangBaseUtil.getErrorMsg(var13), new String[0], var13);
                } finally {
                    IOUtils.closeQuietly(os);

                    try {
                        wb.close();
                    } catch (Throwable var12) {

 Source/UBCS/ubcs-service/ubcs-code/pom.xml

@@ -123,10 +123,10 @@
                    <groupId>javax.servlet</groupId>
                    <artifactId>servlet-api</artifactId>
                </exclusion>
                <exclusion>
                <!--<exclusion>
                    <artifactId>commons-io</artifactId>
                    <groupId>commons-io</groupId>
                </exclusion>
                </exclusion>-->
                <exclusion>
                    <artifactId>geronimo-activation_1.1_spec</artifactId>
                    <groupId>org.apache.geronimo.specs</groupId>

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/controller/DockingManagementController.java

@@ -4,19 +4,14 @@
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;
import com.vci.ubcs.code.dto.DockingSystemConfigDTO;
import com.vci.ubcs.code.dto.DockingSystemDTO;
import com.vci.ubcs.code.dto.DockingTaskDTO;
import com.vci.ubcs.code.dto.UpdateSysInfoStatusDTO;
import com.vci.ubcs.code.entity.DockingData;
import com.vci.ubcs.code.entity.DockingSystem;
import com.vci.ubcs.code.entity.DockingSystemConfig;
import com.vci.ubcs.code.service.IDockingDataService;
import com.vci.ubcs.code.service.IDockingSystemConfigService;
import com.vci.ubcs.code.service.IDockingSystemService;
import com.vci.ubcs.code.vo.pagemodel.DockingDataVO;
import com.vci.ubcs.code.vo.pagemodel.DockingSystemConfigVO;
import com.vci.ubcs.code.vo.pagemodel.DockingSystemVO;
import com.vci.ubcs.code.wrapper.DockingDataWrapper;
import com.vci.ubcs.code.wrapper.DockingSystemWrapper;
import com.vci.ubcs.code.entity.*;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.vo.pagemodel.*;
import com.vci.ubcs.code.wrapper.*;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.web.pagemodel.BaseQueryObject;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
@@ -24,6 +19,8 @@
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.api.R;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

/**
 * ç æ®µåŸºç¡€ä¿¡æ¯æŽ§åˆ¶å™¨
@@ -45,13 +42,15 @@
     * é›†æˆæŽ¥å£é…ç½®æœåŠ¡
     */
    private  final IDockingSystemConfigService dockingSystemConfigService;

    /***
     * å¾…集管理配置服务
     */
    private final IDokingSysManaentService dokingSysManaentService;

    /***
     * å¾…集成数据服务
     * åŒæ­¥é›†æˆæœåŠ¡
     */
    private final IDockingDataService dockingDataService;

    private final     ICodeDuckingSyncService codeDuckingSyncService;

    /**系统集成的系统信息列表
     * @param dockingSystem åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
@@ -188,7 +187,71 @@
    @ApiOperationSupport(order = 3)
    @ApiOperation(value = "分页", notes = "DockingDataVO")
    public R<IPage<DockingDataVO>> gridDockingData(DockingData dockingData, Query query){
        IPage<DockingData> pages = dockingDataService.page(Condition.getPage(query), Condition.getQueryWrapper(dockingData));
        return R.data(DockingDataWrapper.build().pageVO(pages));
        IPage<DockingDataVO> pages = dokingSysManaentService.gridDockingData(dockingData,query);
        return R.data(pages);
    }


    /**
     * data列表
     * @param dockingTask åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return ç³»ç»Ÿé›†æˆçš„系统信息显示对象列表
     */
    @GetMapping("/gridDockingTask")
    @ApiOperationSupport(order = 3)
    @ApiOperation(value = "分页", notes = "DockingTaskVO")
    public R<IPage<DockingTaskVO>> gridDockingTask(DockingTask dockingTask, Query query){
        IPage<DockingTaskVO> pages = dokingSysManaentService.gridDockingTask(dockingTask,query);
        return R.data(pages);
    }

    /**
     * æŽ¨é€æ•°æ®é›†æˆæ—¥å¿—列表
     * @param dockingLog åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return é›†æˆæ—¥å¿—显示对象列表
     */
    @GetMapping("/gridLoge")
    @ApiOperationSupport(order = 3)
    @ApiOperation(value = "分页", notes = "DockingLogeVO")
    public R<IPage<DockingLogeVO>> gridLoge(DockingLog dockingLog, Query query){
        IPage<DockingLogeVO> pages = dokingSysManaentService.gridLoge(dockingLog,query);
        return R.data(pages);
    }

    /**
     * æŽ¥å£param列表
     * @param dockingSysIntParam åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return é›†æˆæ—¥å¿—显示对象列表
     */
    @GetMapping("/gridParam")
    @ApiOperationSupport(order = 3)
    @ApiOperation(value = "分页", notes = "dockingSysIntParam")
    public R<IPage<DockingSysIntParamVO>>gridParam(DockingSysIntParam dockingSysIntParam, Query query){
        IPage<DockingSysIntParamVO> pages = dokingSysManaentService.gridParam(dockingSysIntParam,query);
        return R.data(pages);
    }

    /**
     * æŽ¥å£param列表
     * @param dockingSysIntHeader åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return é›†æˆæ—¥å¿—显示对象列表
     */
    @GetMapping("/gridHeader")
    @ApiOperationSupport(order = 3)
    @ApiOperation(value = "分页", notes = "DockingSysIntHeaderVO")
    public R<IPage<DockingSysIntHeaderVO>>gridHeader(DockingSysIntHeader dockingSysIntHeader, Query query){
        IPage<DockingSysIntHeaderVO>  pages=dokingSysManaentService.gridHeader(dockingSysIntHeader,query);
        return R.data(pages);


    }
    /**
     *批量处理
     * å¿…须要有分类oid和dataoid
     * @return
     */
    @PostMapping("/sendData")
    public  R sendData(String oid){
        return codeDuckingSyncService.sendData(oid);
    }
}

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/IDokingSysManaentService.java

@@ -1,10 +1,49 @@
package com.vci.ubcs.code.service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.vci.ubcs.code.entity.*;
import com.vci.ubcs.code.vo.pagemodel.*;
import org.springblade.core.mp.support.Query;

/***
 * ç³»çµ±ç®¡ç†ç›¸å…³æœåŠ¡
 */
public interface IDokingSysManaentService {
    /**
     * data列表
     * @param dockingTask åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return ç³»ç»Ÿé›†æˆçš„系统信息显示对象列表
     */
    IPage<DockingTaskVO>gridDockingTask(DockingTask dockingTask, Query query);
    /**
     * å¾…集成数据
     * @param dockingData åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return ç³»ç»Ÿé›†æˆåŸºç¡€ä¿¡æ¯æ˜¾ç¤ºå¯¹è±¡åˆ—表
     */
    IPage<DockingDataVO>gridDockingData(DockingData dockingData, Query query);



    /**
     * æŽ¨é€æ•°æ®é›†æˆæ—¥å¿—列表
     * @param dockingLog åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return é›†æˆæ—¥å¿—显示对象列表
     */
    IPage<DockingLogeVO>gridLoge(DockingLog dockingLog, Query query);

    /**
     * æŽ¥å£param列表
     * @param dockingSysIntParam åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return é›†æˆæ—¥å¿—显示对象列表
     */
    IPage<DockingSysIntParamVO>gridParam(DockingSysIntParam dockingSysIntParam, Query query);


    /**
     * æŽ¥å£param列表
     * @param dockingSysIntHeader åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return é›†æˆæ—¥å¿—显示对象列表
     */
    IPage<DockingSysIntHeaderVO>gridHeader(DockingSysIntHeader dockingSysIntHeader, Query query);

}

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeDuckingSyncServiceImpl.java

@@ -1,10 +1,16 @@
package com.vci.ubcs.code.service.impl;


import com.alibaba.cloud.commons.lang.StringUtils;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.vci.ubcs.code.entity.DockingSystem;
import com.vci.ubcs.code.service.ICodeDuckingSyncService;
import com.vci.ubcs.code.service.IDockingSystemService;
import com.vci.ubcs.code.entity.*;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.starter.web.constant.QueryOptionConstant;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import com.vci.ubcs.starter.web.util.VciQueryWrapperForDO;
import com.vci.ubcs.starter.web.util.WebUtil;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.tool.api.R;
import org.springframework.stereotype.Service;
@@ -13,6 +19,8 @@
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.MdmDuckingConstant.*;


/*
@@ -28,7 +36,14 @@
    @Resource
    private  IDockingSystemService dockingSystemService;


    @Resource
    private IDockingDataService dockingDataService;
    @Resource
    private IDockingTaskService dockingTaskService;
    @Resource
    private IDockingSystemConfigService dockingSystemConfigService;
    @Resource
    private ICodeClassifyService codeClassifyService;
    @Override
    public void DockingDataSyncScheduing() {

@@ -45,6 +60,9 @@

    @Override
    public R sendData(String oids) {



        return null;
    }

@@ -54,115 +72,120 @@
     * @param type
     */
    private void initPushDataTaks(int type){
//        //initSysadmin();
//        //sysintinfo查询要推送的主题库和相关系统信息
//        Map<String, String> conditionMap = new HashMap<>();
//        conditionMap.put("usedflag","true");
//        conditionMap.put("pushType",type==2?"2":"1") ;//2是代表分类推送，1是代表数据推送
//
//        Wrappers wrappers=new Wrappers();
//
//        List<DockingSystem> sysIntInfoVOList = dockingSystemService.list(Wrappers.query().lambda().eq());
//        if(CollectionUtils.isEmpty(sysIntInfoVOList)){
//            String title=type==2?"分类推送":"数据推送";
//            log.info("info->所有集成系统，未查询到相关的【"+title+"】的接口配置信息，配置");
//            return;
//        }
//        Map<String ,List<DockingSystem>> sysIntInfoDOMap = new HashMap<String ,List<DockingSystem>>();//key=classifyoid,value=list<map>
//        for (SysIntInfoDO sysIntInfoVOi:sysIntInfoVOList){
//            List<SysIntInfoDO> SysIntInfoVOListi = sysIntInfoDOMap.get(sysIntInfoVOi.getClassifyoid());
//            if(SysIntInfoVOListi==null){
//                SysIntInfoVOListi = new ArrayList<SysIntInfoDO>();
//            }
//            SysIntInfoVOListi.add(sysIntInfoVOi);
//            sysIntInfoDOMap.put(sysIntInfoVOi.getClassifyoid(),SysIntInfoVOListi);
//        }
//        //根据类型去查询需要集成的分类或者数据
//        VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(DockingDataDO.class);
//        queryWrapperForDO.addQueryMap("sendflag","false");
//        if(type==2){
//            queryWrapperForDO.addQueryMap("btmTypeId",DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
//        }else {
//            queryWrapperForDO.addQueryMap("btmTypeId", QueryOptionConstant.NOTIN + "(" + VciBaseUtil.toInSql(DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT)) + ")");
//        }
//        List<DockingDataDO> dataList = dockingDataDaoI.selectByWrapper(queryWrapperForDO);
//
//        for (DockingDataDO mapi:dataList){
//            WebUtil.setPersistence(false);
//            BatchCBO batchCBO = new BatchCBO();
//            String dataoid = mapi.getOid();//data对象的oid
//            String classifyoid = mapi.getClassifyoid();
//            String id = mapi.getId();
//            String uniquecode = mapi.getUniquecode();
//            String btmid = mapi.getBtmid();
//            String btmoid = mapi.getBtmoid();
//            String sendtype = mapi.getSendtype();
//            String classifyid = mapi.getClassifyid();
//            String classifyname = mapi.getClassifyname();
//            String curentClassOid=null;
//            if(type==2){
//                curentClassOid=btmoid;
//            }else{
//                curentClassOid=classifyoid;
//            }
//            List<SysIntInfoDO> effectiveSysIntInfoVOs=new ArrayList<>();
//            //根据当前数据的id，查询获取哪些系统需要做集成
//            List<CodeClassifyDO> parentLeveDO= codeClassifyDaoI.selectAllLevelParentByOid(curentClassOid);
//            if(CollectionUtils.isEmpty(parentLeveDO)){
//                continue;//说明这个分类被删掉了，不做处理
//            }
//            Map<String, CodeClassifyDO> oidCodeclassifyDOMap = parentLeveDO.stream().filter(codeClassifyDO -> codeClassifyDO != null && StringUtils.isNotBlank(codeClassifyDO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
//
//            oidCodeclassifyDOMap.keySet().forEach(oid->{
//                if(sysIntInfoDOMap.containsKey(oid)){
//                    List<SysIntInfoDO> sysIntInfoDOS= sysIntInfoDOMap.get(oid);
//                    effectiveSysIntInfoVOs.addAll(sysIntInfoDOS);
//                }
//            });
//            //如果校验的系统接口信息不存在，则数据不不往信息里推送
//            if(CollectionUtils.isEmpty(effectiveSysIntInfoVOs)){
//                continue;
//            }
//            List<DockingTaskDO> dockingTaskDO_insert = new ArrayList<DockingTaskDO>();
//            for (SysIntInfoDO sysIntInfoVOi:effectiveSysIntInfoVOs){
//                DockingTaskDO dockingTaskDO = new DockingTaskDO();
//                dockingTaskDO.setOid(redisService.getUUIDEveryDay());
//                dockingTaskDO.setSendflag(SEND_FLAG_FALSE);
//                dockingTaskDO.setId(id);//编码
//                dockingTaskDO.setUniquecode(uniquecode);
//                dockingTaskDO.setBtmoid(btmoid);//数据oid
//                dockingTaskDO.setBtmid(btmid);//数据业务类型id
//                dockingTaskDO.setClassifyid(classifyid);//数据在分类id
//                dockingTaskDO.setClassifyoid(classifyoid);//数据所在分类oid
//                dockingTaskDO.setClassifyname(classifyname);//数据所在分类名称
//                dockingTaskDO.setSendtype(sendtype);//数据推送类型
//                dockingTaskDO.setDataoid(dataoid);
//
//                //intinfo
//                dockingTaskDO.setSysinfooid(sysIntInfoVOi.getOid());//intinfo的oid
//                dockingTaskDO.setSystemoid(sysIntInfoVOi.getSysbaseoid());//系统oid
//                dockingTaskDO.setSystemcode(sysIntInfoVOi.getSysbaseid());//系统编码
//                dockingTaskDO.setSystemname(sysIntInfoVOi.getSysbasename());//系统name
//                dockingTaskDO_insert.add(dockingTaskDO);
//            }
//
//            BatchCBO bi = null;
//            if(dockingTaskDO_insert.size()!=0) {
//                bi = dockingTaskDaoI.batchInsert(dockingTaskDO_insert);
//                batchCBO.copyFromOther(bi);
//            }
//            WebUtil.setPersistence(true);
//            boService.persistenceBatch(batchCBO);
//            //dockingTaskDaoI.updateByPrimaryKey方法报错了，所以手写了这个
//            boolean u = updateDockingDatasSendFlag(dataoid,SEND_FLAG_TRUE);
//            if(!u){
//                log.error("集成data分解任务失败！dataoid:"+dataoid);
//                continue;
//            }
//
//        }
        //initSysadmin();

        List<DockingSystemConfig> dockingSystemConfigList = dockingSystemConfigService.list(
            Wrappers.<DockingSystemConfig>query().lambda().eq(DockingSystemConfig::getUsedFlag,"true")
                .eq(DockingSystemConfig::getPushType,type==2?"2":"1"));//2是代表分类推送，1是代表数据推送

        if(CollectionUtils.isEmpty(dockingSystemConfigList)){
            String title=type==2?"分类推送":"数据推送";
            log.info("info->所有集成系统，未查询到相关的【"+title+"】的接口配置信息，配置");
            return;
        }
        Map<String ,List<DockingSystemConfig>> sysIntInfoDOMap = new HashMap<>();//key=classifyoid,value=list<map>
        for (DockingSystemConfig dockingSystemConfig:dockingSystemConfigList){
            List<DockingSystemConfig> dockingSystemList = sysIntInfoDOMap.get(dockingSystemConfig.getClassifyOid());
            if(dockingSystemList==null){
                dockingSystemList = new ArrayList<>();
            }
            dockingSystemList.add(dockingSystemConfig);
            sysIntInfoDOMap.put(dockingSystemConfig.getClassifyOid(),dockingSystemList);
        }
        //根据类型去查询需要集成的分类或者数据
        LambdaQueryWrapper<DockingData> queryWrapper = Wrappers.<DockingData>lambdaQuery();
        queryWrapper.eq(DockingData::getSendFlag,"false");
        if(type==2){
            queryWrapper.eq(DockingData::getBtmId,DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
        }else {
            queryWrapper.notIn(DockingData::getBtmId,DOCKING_DEFAULT_CLASSIFY.toLowerCase(Locale.ROOT));
        }
        List<DockingData> dataList = dockingDataService.list(queryWrapper);

        for (DockingData mapi:dataList){
            WebUtil.setPersistence(false);
            String dataoid = mapi.getOid();//data对象的oid
            String classifyoid = mapi.getClassifyOid();
            String id = mapi.getId();
            String uniquecode = mapi.getUniqueCode();
            String btmid = mapi.getBtmId();
            String btmoid = mapi.getBtmOid();
            String sendtype = mapi.getSendType();
            String classifyid = mapi.getClassifyId();
            String classifyname = mapi.getClassifyName();
            String curentClassOid=null;
            if(type==2){
                curentClassOid=btmoid;
            }else{
                curentClassOid=classifyoid;
            }
            List<DockingSystemConfig> effectiveSysIntInfoVOs=new ArrayList<>();
            //根据当前数据的id，查询获取哪些系统需要做集成
            List<CodeClassify> parentLeveDO= codeClassifyService.selectAllLevelParentByOid(curentClassOid);
            if(CollectionUtils.isEmpty(parentLeveDO)){
                continue;//说明这个分类被删掉了，不做处理
            }
            Map<String, CodeClassify> oidCodeclassifyDOMap = parentLeveDO.stream().filter(codeClassifyDO -> codeClassifyDO != null && StringUtils.isNotBlank(codeClassifyDO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));

            oidCodeclassifyDOMap.keySet().forEach(oid->{
                if(sysIntInfoDOMap.containsKey(oid)){
                    List<DockingSystemConfig> sysIntInfoDOS= sysIntInfoDOMap.get(oid);
                    effectiveSysIntInfoVOs.addAll(sysIntInfoDOS);
                }
            });
            //如果校验的系统接口信息不存在，则数据不不往信息里推送
            if(CollectionUtils.isEmpty(effectiveSysIntInfoVOs)){
                continue;
            }
            List<DockingTask> dockingTask_insert = new ArrayList<>();
            for (DockingSystemConfig sysIntInfoVOi:effectiveSysIntInfoVOs){
                DockingTask dockingTask = new DockingTask();
                dockingTask.setOid(VciBaseUtil.getPk());
                dockingTask.setSendFlag(SEND_FLAG_FALSE);
                dockingTask.setId(id);//编码
                dockingTask.setUniqueCode(uniquecode);
                dockingTask.setBtmOid(btmoid);//数据oid
                dockingTask.setBtmId(btmid);//数据业务类型id
                dockingTask.setClassifyId(classifyid);//数据在分类id
                dockingTask.setClassifyOid(classifyoid);//数据所在分类oid
                dockingTask.setClassifyName(classifyname);//数据所在分类名称
                dockingTask.setSendType(sendtype);//数据推送类型
                dockingTask.setDataOid(dataoid);

                //intinfo
                dockingTask.setSysInfoOid(sysIntInfoVOi.getOid());//intinfo的oid
                dockingTask.setSystemOid(sysIntInfoVOi.getSysBaseOid());//系统oid
                dockingTask.setSystemCode(sysIntInfoVOi.getSysBaseId());//系统编码
                dockingTask.setSystemName(sysIntInfoVOi.getSysBaseName());//系统name
                dockingTask_insert.add(dockingTask);
            }

            if(dockingTask_insert.size()!=0) {
                dockingTaskService.saveBatch(dockingTask_insert);
            }
            //dockingTaskDaoI.updateByPrimaryKey方法报错了，所以手写了这个
            boolean u = updateDockingDatasSendFlag(dataoid,SEND_FLAG_TRUE);
            if(!u){
                log.error("集成data分解任务失败！dataoid:"+dataoid);
                continue;
            }
        }
    }


    /**
     * dockingdata根据oid修改sendflag
     * @param oid
     * @param sendflag
     * @return
     */
    public boolean updateDockingDatasSendFlag(String oid,String sendflag){
        boolean u=false;
        DockingData dockingData=dockingDataService.getById(oid);
        if(dockingData!=null){
            dockingData.setSendFlag(sendflag);
            u=    dockingDataService.updateById(dockingData);
        }
        return u;
    }
}


 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/DockingSystemConfigServiceImpl.java

@@ -98,7 +98,7 @@
    /***
     * ä»»åŠ¡ç”ŸæˆæœåŠ¡
     */
    @Autowired(required = false)
    @Autowired( required = false)
    private IDockingTaskService dockingTaskService;



 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/DokingSysManaentServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,91 @@
package com.vci.ubcs.code.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.entity.*;
import com.vci.ubcs.code.mapper.DockingSystemConfigMapper;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.vo.pagemodel.*;
import com.vci.ubcs.code.wrapper.*;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DokingSysManaentServiceImpl extends ServiceImpl<DockingSystemConfigMapper, DockingSystemConfig> implements IDokingSysManaentService {


    /***
     * ä»»åŠ¡ç”ŸæˆæœåŠ¡
     */
    @Autowired( required = false)
    private IDockingTaskService dockingTaskService;


    /***
     * æ—¥å¿—生成服务
     */
    @Autowired( required = false)
    private IDockingLogeService dockingLogeService;

    /***
     * é›†æˆæŽ¥å£å¤´åè®®æœåŠ¡
     */
    @Autowired( required = false)
    private  IDockingSysIntHeaderService dockingSysIntHeaderService;
    /***
     * é›†æˆæŽ¥å£å‚数服务
     */
    @Autowired( required = false)
    private IDockingSysIntParamService dockingSysIntParamService;

    /***
     * å¾…集成数据服务
     */
    @Autowired( required = false)
    private  IDockingDataService dockingDataService;
    /**
     * data列表
     * @param dockingTask åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return ç³»ç»Ÿé›†æˆçš„系统信息显示对象列表
     */
    @Override
    public IPage<DockingTaskVO> gridDockingTask(DockingTask dockingTask, Query query) {
        IPage<DockingTask> pages=dockingTaskService.page(Condition.getPage(query), Condition.getQueryWrapper(dockingTask));
        return DockingTaskWrapper.build().pageVO(pages);
    }

    @Override
    public IPage<DockingDataVO> gridDockingData(DockingData dockingData, Query query) {
        IPage<DockingData> pages=dockingDataService.page(Condition.getPage(query), Condition.getQueryWrapper(dockingData));
        return DockingDataWrapper.build().pageVO(pages);
    }

    /**
     * æŽ¨é€æ•°æ®é›†æˆæ—¥å¿—列表
     * @param dockingLog åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return é›†æˆæ—¥å¿—显示对象列表
     */
    @Override
    public IPage<DockingLogeVO> gridLoge(DockingLog dockingLog, Query query) {
        IPage<DockingLog> pages=dockingLogeService.page(Condition.getPage(query), Condition.getQueryWrapper(dockingLog));
        return DockingLogeWrapper.build().pageVO(pages);
    }

    @Override
    public IPage<DockingSysIntParamVO> gridParam(DockingSysIntParam dockingSysIntParam, Query query) {
        IPage<DockingSysIntParam> pages=dockingSysIntParamService.page(Condition.getPage(query), Condition.getQueryWrapper(dockingSysIntParam));
        return DockingSysIntParamWrapper.build().pageVO(pages);
    }
    /**
     * æŽ¥å£param列表
     * @param dockingSysIntHeader åŸºç¡€æŸ¥è¯¢å¯¹è±¡ï¼ŒåŒ…含查询条件，分页，排序等
     * @return é›†æˆæ—¥å¿—显示对象列表
     */
    @Override
    public IPage<DockingSysIntHeaderVO> gridHeader(DockingSysIntHeader dockingSysIntHeader , Query query) {
        IPage<DockingSysIntHeader> pages = dockingSysIntHeaderService.page(Condition.getPage(query), Condition.getQueryWrapper(dockingSysIntHeader));
        return DockingSysIntHeaderWrapper.build().pageVO(pages);
    }
}

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmIOServiceImpl.java

@@ -361,16 +361,23 @@
            //参照的自行输入名称
            //分类注入的不用，都是导入后自动处理的
            //编码，状态等字段不导入
            List<CodeClassifyTemplateAttrVO> templateAttrVOS = codeClassifyTemplateVO.getAttributes().stream().filter(s ->
            List<CodeClassifyTemplateAttrVO> codeClassifyTemplateAttrVOList=codeClassifyTemplateVO.getAttributes();
            if(!CollectionUtils.isEmpty(codeClassifyTemplateAttrVOList)) {
                if (CollectionUtils.isEmpty(codeClassifyTemplateAttrVOList)) {
                    throw new VciBaseException("模板没有配置属性");
                }
            }
            List<CodeClassifyTemplateAttrVO> templateAttrVOS = codeClassifyTemplateAttrVOList.stream().filter(s ->
                !DEFAULT_ATTR_LIST.contains(s.getId())
                    && StringUtils.isBlank(s.getComponentRule())
                    && StringUtils.isBlank(s.getClassifyInvokeAttr())
                    && (isHistory || VciBaseUtil.getBoolean(s.getFormDisplayFlag()))
            ).collect(Collectors.toList());

            if(CollectionUtils.isEmpty(templateAttrVOS)){
                throw new VciBaseException("模板没有配置任何【表单显示】为【是】的属性");
            }
                if (CollectionUtils.isEmpty(templateAttrVOS)) {
                    throw new VciBaseException("模板没有配置任何【表单显示】为【是】的属性");
                }

            List<CodeClassifyTemplateAttrVO> idAttrVOList = codeClassifyTemplateVO.getAttributes().stream().filter(s -> s.getId().equalsIgnoreCase(CODE_FIELD)).collect(Collectors.toList());
            LinkedList<WriteExcelData> excelDataList = new LinkedList<>();
            Workbook workbook = new HSSFWorkbook();

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/UniversalInterfaceImpl.java

@@ -1115,7 +1115,7 @@
     * æ ¹æ®å±žæ€§æ˜ å°„转换编码所需字段
     */
    public void getConfigDatas(String systemId,String libray, ApplyDatasVO applyDatasVO,List<CodeClassifyTemplateAttrVO> codeClassifyTemplateAttrVOList,DataObjectVO dataObjectVO) throws Throwable {
        List<ApplyDataVO> applyDataVOList=applyDatasVO.getObject();

        LinkedHashMap<String,LinkedHashMap<String,String>> dataKeyValueMap=new LinkedHashMap<>();
        //如果将数据转换成所需要的数据对象
        Map<String, String> attrMapConfigMap=new HashMap<>();
@@ -1125,15 +1125,23 @@
            Map<String, String> stringStringMap=attributeMapConfig.getSystem_attrmap();
            log.info("集成系统属性映射配置文件条目数-》"+stringStringMap.size());
            //stringStringMap.put("RLM","D:\\RLM.xml");
            LibraryDO libraryDO=gennerAttrMapUtil.getNewInstance().gennerAttrMapBySystem(systemId,stringStringMap);
            List<LibraryClsfDO> libraryClsfDOList=libraryDO.getClsf();
            Map<String, List<ClsfAttrMappingDO>> libPropMaps = libraryClsfDOList.stream().collect(Collectors.toMap(LibraryClsfDO::getLibrary, LibraryClsfDO::getProp, (key1, key2) -> key2));
            log.info("根据参数：libray：-》"+libray+"从配置文件中找对应属性映射配置");
            if(libPropMaps.containsKey(libray)){
                log.info("根据参数：libray：-》"+libray+"匹配到相应的属性映射信息");
                List<ClsfAttrMappingDO> clsfAttrMappingDOList=libPropMaps.get(libray);
                propMaps = clsfAttrMappingDOList.stream().collect(Collectors.toMap(ClsfAttrMappingDO::getSourceKey, ClsfAttrMappingDO::getTargetKey, (key1, key2) -> key2));
                log.info("根据参数：libray：-》"+libray+"匹配到相应的属性映射信息,属性映射条目数+"+clsfAttrMappingDOList.size());
            if(!CollectionUtils.isEmpty(stringStringMap)) {
                log.info("info：需要读取配置文件");
                LibraryDO libraryDO = gennerAttrMapUtil.getNewInstance().gennerAttrMapBySystem(systemId, stringStringMap);
                List<LibraryClsfDO> libraryClsfDOList = libraryDO.getClsf();
                if(!CollectionUtils.isEmpty(libraryClsfDOList)) {
                    Map<String, List<ClsfAttrMappingDO>> libPropMaps = libraryClsfDOList.stream().collect(Collectors.toMap(LibraryClsfDO::getLibrary, LibraryClsfDO::getProp, (key1, key2) -> key2));
                    log.info("根据参数：libray：-》" + libray + "从配置文件中找对应属性映射配置");
                    String path=stringStringMap.get(systemId);
                    if (libPropMaps.containsKey(libray)) {
                        log.info("根据参数：libray：-》" + libray + "匹配到相应的属性映射信息");
                        List<ClsfAttrMappingDO> clsfAttrMappingDOList = libPropMaps.get(libray);
                        propMaps = clsfAttrMappingDOList.stream().collect(Collectors.toMap(ClsfAttrMappingDO::getSourceKey, ClsfAttrMappingDO::getTargetKey, (key1, key2) -> key2));
                        log.info("根据参数：libray：-》" + libray + "匹配到相应的属性映射信息,属性映射条目数+" + clsfAttrMappingDOList.size());
                    }else{
                        throw new Throwable("根据系统标识【"+systemId+"】找到对应的配置文件:【"+path+"】，但未获取到对应的库【"+libray+"】属性映射信息配置");
                    }
                }
            }
            log.info("根据参数：libray：-》"+libray+"从配置文件中找对应属性映射配置 end ");
        }catch (Throwable e){
@@ -1155,6 +1163,11 @@
            dataObjectVO.setColName(rowNameList);//放入属性
            attrMapConfigMap.putAll(propMaps);
            LinkedList<RowDatas> rowDataList = new LinkedList<>();
            List<ApplyDataVO> applyDataVOList=new ArrayList<>();

            if(!CollectionUtils.isEmpty(applyDatasVO.getObject())){
                applyDataVOList=applyDatasVO.getObject();
            }
            //Map<String, List<ProppertyVO>> dataPropMap = applyDataVOList.stream().collect(Collectors.toMap(ApplyDataVO::getId, ApplyDataVO::getProp, (key1, key2) -> key2));
            final int[] rowIndex = {0};
            applyDataVOList.stream().forEach(applyDataVO -> {

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/wrapper/DockingTaskWrapper.java

@@ -12,8 +12,8 @@
import java.util.Objects;

public class DockingTaskWrapper extends BaseEntityWrapper<DockingTask, DockingTaskVO> {
    public static DockingSystemWrapper build() {
        return new DockingSystemWrapper();
    public static DockingTaskWrapper build() {
        return new DockingTaskWrapper();
    }
    @Override
    public DockingTaskVO entityVO(DockingTask entity) {