主数据定义接口移植

 Source/UBCS-WEB/src/const/code/codebutton.js

@@ -237,7 +237,7 @@
    // },
    {
      label: "状态",
      prop: "lcstatusName",
      prop: "lcStatusText",
      slot: true,
      display: false
    },
@@ -253,7 +253,7 @@
      search: true,
      hide: true,
      display: true,
      prop: "lcstatus",
      prop: "lcStatus",
      rules: [{
        required: true,
        message: "状态",
@@ -289,7 +289,7 @@
    // },
    {
      label: "按钮的位置",
      prop: "usedpositiontypeName",
      prop: "usedpositiontypeText",
      slot: true,
      display: false
    },

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

@@ -18,16 +18,13 @@

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.vci.ubcs.code.dto.CodeClassifyTemplateButtonDTO;
import com.vci.ubcs.code.entity.CodeClassifyTemplateButton;
import com.vci.ubcs.code.service.ICodeTempbuttonService;
import com.vci.ubcs.code.service.ICodeClassifyTemplateButtonService;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateButtonVO;
import com.vci.ubcs.starter.web.pagemodel.BaseQueryObject;
import com.vci.ubcs.starter.web.pagemodel.DataGrid;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import io.swagger.annotations.Api;
import lombok.AllArgsConstructor;
import org.springblade.core.boot.ctrl.BladeController;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.api.R;
import org.springframework.web.bind.annotation.*;

@@ -49,7 +46,7 @@
    /**
     * ä¸»é¢˜åº“里模板包含的按钮 æœåŠ¡
     */
    private final ICodeTempbuttonService codeClassifyTemplateButtonService;
    private final ICodeClassifyTemplateButtonService codeClassifyTemplateButtonService;

    /**
     * ä¸»é¢˜åº“里模板包含的按钮列表

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

@@ -95,6 +95,16 @@
    }

    /**
     * ä¿®æ”¹ åˆ†ç±»æ¨¡æ¿å¯¹è±¡
     * @param codeClassifyTemplateDTO åˆ†ç±»æ¨¡æ¿å¯¹è±¡æ•°æ®ä¼ è¾“对象
     * @return æ‰§è¡Œç»“果，success为true表示成功，msg是失败的提示信息，obj是添加完成后的显示对象
     */
    @PutMapping("/editSave")
    public R<CodeClassifyTemplateVO> editSave(@RequestBody CodeClassifyTemplateDTO codeClassifyTemplateDTO){
        return plCodeClstemplateService.editSave(codeClassifyTemplateDTO);
    }

    /**
     * ç¼–码库定义-模板管理 æ–°å¢ž
     */
    @PostMapping("/save")
@@ -209,6 +219,15 @@
    public List<Tree> referTree(TreeQueryObject treeQueryObject)  {
        return plCodeClstemplateService.referTree(treeQueryObject);
    }
    /**
     * å¢žåŠ  åˆ†ç±»æ¨¡æ¿å¯¹è±¡
     * @param codeClassifyTemplateDTO åˆ†ç±»æ¨¡æ¿å¯¹è±¡æ•°æ®ä¼ è¾“对象
     * @return æ‰§è¡Œç»“果，success为true表示成功，msg是失败的提示信息，obj是添加完成后的显示对象
     */
    @PostMapping( "/addSave")
    public R<CodeClassifyTemplateVO> addSave(@RequestBody CodeClassifyTemplateDTO codeClassifyTemplateDTO){
        return plCodeClstemplateService.addSave(codeClassifyTemplateDTO);
    }

    /**
     * å¯ç”¨

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

@@ -3,26 +3,25 @@

import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.common.utils.StringUtils;
import com.vci.ubcs.code.dto.CodeDeleteBatchDTO;
import com.vci.ubcs.code.dto.CodeOrderDTO;
import com.vci.ubcs.code.dto.CodeOrderSecDTO;
import com.vci.ubcs.code.dto.datapush.BaseModelDTO;
import com.vci.ubcs.code.service.ICodeRuleService;
import com.vci.ubcs.code.service.MdmEngineService;
import com.vci.ubcs.code.service.MdmIOService;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
import com.vci.ubcs.code.vo.pagemodel.CodeImProtRusultVO;
import com.vci.ubcs.code.vo.pagemodel.MdmUIInfoVO;
import com.vci.ubcs.code.vo.pagemodel.*;
import com.vci.ubcs.starter.annotation.VciBusinessLog;
import com.vci.ubcs.starter.util.LocalFileUtil;
import com.vci.ubcs.starter.web.pagemodel.BaseQueryObject;
import com.vci.ubcs.starter.web.pagemodel.DataGrid;
import com.vci.ubcs.starter.web.pagemodel.Tree;
import com.vci.ubcs.starter.web.util.ControllerUtil;
import com.vci.ubcs.starter.web.util.LangBaseUtil;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import io.swagger.annotations.Api;
import lombok.AllArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.core.boot.ctrl.BladeController;
import org.springblade.core.tool.api.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@@ -36,36 +35,35 @@
import java.util.Map;

@RestController
@AllArgsConstructor
//@AllArgsConstructor
@RequestMapping("/mdmEngineController")
@Api(value = "编码数据管理", tags = "编码数据管理")
public class MdmEngineController extends BladeController {
public class MdmEngineController {

//    /**
//     * æ—¥å¿—
//     */
    private Logger logger = LoggerFactory.getLogger(getClass());
    /**
     * ä¸»æ•°æ®å¼•æ“ŽæœåŠ¡
     */
    private final MdmEngineService engineService;
    @Autowired
    private MdmEngineService engineService;
    /**
     * ä¸»æ•°æ®å¯¼å…¥å¯¼å‡ºæœåŠ¡
     */
    @Autowired
    private MdmIOService mdmIOService;

    /**
     * æ ¹æ®åˆ†ç±»id获取模板信息
     * @param codeClassifyOid
     * @return
     * ä¸‹è½½æ‰¹é‡ç”³è¯·çš„导入模板
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @param response å“åº”对象
     * @throws IOException æŠ›å‡ºå¼‚常
     */
    @GetMapping("/getUsedTemplateByClassifyOid")
    public R<CodeClassifyTemplateVO> getUsedTemplateByClassifyOid(String codeClassifyOid){
        CodeClassifyTemplateVO codeClassifyTemplateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
        return R.data(codeClassifyTemplateVO);
    }


//    /**
//     * ä¸‹è½½æ‰¹é‡ç”³è¯·çš„导入模板
//     * @param codeClassifyOid åˆ†ç±»çš„主键
//     * @param response å“åº”对象
//     * @throws IOException æŠ›å‡ºå¼‚常
//     */
//    @GetMapping("/downloadImportExcel")
//    @VciBusinessLog(operateName = "下载批量申请编码的导入模板")
//    public void downloadImportExcel(String codeClassifyOid, HttpServletResponse response) throws IOException{
    @GetMapping("/downloadImportExcel")
    @VciBusinessLog(operateName = "下载批量申请编码的导入模板")
    public void downloadImportExcel(String codeClassifyOid, HttpServletResponse response) throws IOException{
//        String excelName = mdmIOService.createImportExcel(codeClassifyOid,false);
//        try {
//            ControllerUtil.writeFileToResponse(response,excelName);
@@ -77,26 +75,26 @@
//            }
//            ControllerUtil.writeDataToResponse(response,msg.getBytes(StandardCharsets.UTF_8),null);
//        }
//    }
//
//
//    /**
//     * æ‰¹é‡ç”³è¯·ç¼–码的信息
//     * @param secDTOList ç”³è¯·ç¼–码的信息，必须包含码段和分类主键的信息
//     * @param file æ–‡ä»¶çš„内容
//     */
//    @VciBusinessLog(operateName = "批量申请编码的信息")
//    @PostMapping("/batchImportCode")
//    public R batchImportCode(String secDTOList, String codeClassifyOid, MultipartFile file, HttpServletResponse response) throws Throwable {
//        CodeOrderDTO orderDTO = new CodeOrderDTO();
//        orderDTO.setCodeClassifyOid(codeClassifyOid);
//        if(StringUtils.isNotBlank(secDTOList)){
//            List<CodeOrderSecDTO> secDTOS = JSONObject.parseArray(secDTOList, CodeOrderSecDTO.class);
//            orderDTO.setSecDTOList(secDTOS);
//        }
//        String excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + LocalFileUtil.getFileNameForIE(file.getOriginalFilename());
//        File file1 = new File(excelFileName);
//        try {
    }


    /**
     * æ‰¹é‡ç”³è¯·ç¼–码的信息
     * @param secDTOList ç”³è¯·ç¼–码的信息，必须包含码段和分类主键的信息
     * @param file æ–‡ä»¶çš„内容
     */
    @VciBusinessLog(operateName = "批量申请编码的信息")
    @PostMapping("/batchImportCode")
    public R batchImportCode(String secDTOList, String codeClassifyOid, MultipartFile file, HttpServletResponse response) throws Throwable {
        CodeOrderDTO orderDTO = new CodeOrderDTO();
        orderDTO.setCodeClassifyOid(codeClassifyOid);
        if(StringUtils.isNotBlank(secDTOList)){
            List<CodeOrderSecDTO> secDTOS = JSONObject.parseArray(secDTOList, CodeOrderSecDTO.class);
            orderDTO.setSecDTOList(secDTOS);
        }
        String excelFileName = LocalFileUtil.getDefaultTempFolder() + File.separator + LocalFileUtil.getFileNameForIE(file.getOriginalFilename());
        File file1 = new File(excelFileName);
        try {
//            file.transferTo(new File(excelFileName));
//            CodeImProtRusultVO codeImProtRusultVO = mdmIOService.batchImportCode(orderDTO,file1);
//            if(StringUtils.isNotBlank(codeImProtRusultVO.getFilePath())||StringUtils.isNotBlank(codeImProtRusultVO.getRedisUuid())){
@@ -111,80 +109,364 @@
//            }else {
//                return R.success("操作成功！");
//            }
//        }catch (Throwable e) {
//            logger.error("导入错误",e);
//            String errorFile = LocalFileUtil.getDefaultTempFolder() + File.separator + "错误.txt";
//            LocalFileUtil.writeContentToFile( LangBaseUtil.getErrorMsg(e),errorFile);
//            String uuid=ControllerUtil.putErrorFile(errorFile);
//            CodeImProtRusultVO codeImProtRusultVO =new CodeImProtRusultVO();
//            codeImProtRusultVO.setRedisUuid("");
//            codeImProtRusultVO.setFileOid(uuid);
//            codeImProtRusultVO.setFilePath(errorFile);
//            R result = R.fail("导入失败");
//            result.setData(codeImProtRusultVO);
////            result.setObj(codeImProtRusultVO);
//            return result;
//        }finally {
//            file1.delete();
//        }
//    }
//
//
//    /**
//     * ä¿®æ”¹çŠ¶æ€
//     * @param baseModelDTO æ•°æ®ä¼ è¾“对象
//     * @return æ‰§è¡Œç»“æžœ
//     */
//    @PostMapping("changeStatus")
//    public R changeStatus(BaseModelDTO baseModelDTO) {
//        engineService.changeStatus(baseModelDTO);
//        return R.success("操作成功！");
//    }
//
//
//    /**
//     * ç”³è¯·ç¼–码保存
//     * @param orderDTO ç¼–码申请相关的信息，需要有属性和码段相关的信息
//     * @return æ‰§è¡Œç»“æžœ
//     */
//    @PostMapping("/addSaveCode")
//    @VciBusinessLog(operateName = "申请单个编码")
//    public R addSaveCode(@RequestBody CodeOrderDTO orderDTO){
//        return R.success(engineService.addSaveCode(orderDTO));
//    }
//
//
//    /**
//     * ä½¿ç”¨æ¨¡æ¿çš„主键获取表单的定义
//     * @param templateOid æ¨¡æ¿çš„主键
//     * @param codeClassifyOid ä½¿ç”¨æ¨¡æ¿çš„分类主键
//     * @return UI相关的信息（仅包含表单）
//     */
//    @GetMapping("/getFormDefineByTemplateOid")
//    public MdmUIInfoVO getFormDefineByTemplateOid(String templateOid, String codeClassifyOid){
//        return engineService.getFormDefineByTemplateOid(templateOid,codeClassifyOid);
//    }
//
//    /**
//     * ç›¸ä¼¼é¡¹æŸ¥è¯¢
//     * @param orderDTO ç¼–码的相关信息
//     * @return æ•°æ®åˆ—表
//     */
//    @PostMapping("/resembleQuery")
//    public DataGrid<Map<String,String>> resembleQuery(@RequestBody CodeOrderDTO orderDTO){
//        return engineService.resembleQuery(orderDTO);
//    }
//
//    /**
//     * ä¿®æ”¹å•æ¡ä¸»é¢˜åº“的数据
//     * @param orderDTO ç¼–码申请相关的信息，不需要码段的信息
//     * @return æ‰§è¡Œç»“æžœ
//     */
//    @PutMapping("/editSaveCode")
//    @VciBusinessLog(operateName = "修改编码数据")
//    public R editSaveCode(@RequestBody CodeOrderDTO orderDTO){
//        engineService.editSaveCode(orderDTO);
//        return  R.success("修改成功！");
//    }
        }catch (Throwable e) {
            logger.error("导入错误",e);
            String errorFile = LocalFileUtil.getDefaultTempFolder() + File.separator + "错误.txt";
            LocalFileUtil.writeContentToFile( LangBaseUtil.getErrorMsg(e),errorFile);
            String uuid=ControllerUtil.putErrorFile(errorFile);
            CodeImProtRusultVO codeImProtRusultVO =new CodeImProtRusultVO();
            codeImProtRusultVO.setRedisUuid("");
            codeImProtRusultVO.setFileOid(uuid);
            codeImProtRusultVO.setFilePath(errorFile);
            R result = R.fail("导入失败");
            result.setData(codeImProtRusultVO);
//            result.setObj(codeImProtRusultVO);
            return result;
        }finally {
            file1.delete();
        }
        return null;
    }


    /**
     * ä¿®æ”¹çŠ¶æ€
     * @param baseModelDTO æ•°æ®ä¼ è¾“对象
     * @return æ‰§è¡Œç»“æžœ
     */
    @PostMapping("changeStatus")
    public R changeStatus(BaseModelDTO baseModelDTO) {
        engineService.changeStatus(baseModelDTO);
        return R.success("操作成功！");
    }


    /**
     * ç”³è¯·ç¼–码保存
     * @param orderDTO ç¼–码申请相关的信息，需要有属性和码段相关的信息
     * @return æ‰§è¡Œç»“æžœ
     */
    @PostMapping("/addSaveCode")
    @VciBusinessLog(operateName = "申请单个编码")
    public R addSaveCode(@RequestBody CodeOrderDTO orderDTO){
        return R.success(engineService.addSaveCode(orderDTO));
    }


    /**
     * ä½¿ç”¨æ¨¡æ¿çš„主键获取表单的定义
     * @param templateOid æ¨¡æ¿çš„主键
     * @param codeClassifyOid ä½¿ç”¨æ¨¡æ¿çš„分类主键
     * @return UI相关的信息（仅包含表单）
     */
    @GetMapping("/getFormDefineByTemplateOid")
    public MdmUIInfoVO getFormDefineByTemplateOid(String templateOid, String codeClassifyOid){
        return engineService.getFormDefineByTemplateOid(templateOid,codeClassifyOid);
    }

    /**
     * ç›¸ä¼¼é¡¹æŸ¥è¯¢
     * @param orderDTO ç¼–码的相关信息
     * @return æ•°æ®åˆ—表
     */
    @PostMapping("/resembleQuery")
    public DataGrid<Map<String,String>> resembleQuery(@RequestBody CodeOrderDTO orderDTO){
        return engineService.resembleQuery(orderDTO);
    }

    /**
     * ä¿®æ”¹å•æ¡ä¸»é¢˜åº“的数据
     * @param orderDTO ç¼–码申请相关的信息，不需要码段的信息
     * @return æ‰§è¡Œç»“æžœ
     */
    @PutMapping("/editSaveCode")
    @VciBusinessLog(operateName = "修改编码数据")
    public R editSaveCode(@RequestBody CodeOrderDTO orderDTO){
        engineService.editSaveCode(orderDTO);
        return  R.success("修改成功！");
    }

    /**
     * æ‰¹é‡åˆ é™¤ä¸»é¢˜åº“的数据
     * @param deleteBatchDTO åˆ é™¤çš„信息，必须要有主键和分类的主键
     * @return æ‰§è¡Œç»“æžœ
     */
    @VciBusinessLog(operateName = "批量删除主题库的数据")
    @DeleteMapping("/deleteCode")
    public R deleteCode(@RequestBody CodeDeleteBatchDTO deleteBatchDTO){
        engineService.deleteCode(deleteBatchDTO);
        return R.success("删除成功！");
    }

    /**
     * ä½¿ç”¨åˆ†ç±»å’Œé˜¶æ®µçš„编号，获取包含的属性
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @param phase é˜¶æ®µçš„名称
     * @return åŒ…含的属性，请获取obj属性
     */
    @VciBusinessLog(operateName = "获取阶段的属性信息")
    @GetMapping("/listPhaseAttrByClassifyOid")
    public R listPhaseAttrByClassifyOid(String codeClassifyOid,String phase){
        return R.data(engineService.listPhaseAttrByClassifyOid(codeClassifyOid,phase));
    }

    /**
     * èŽ·å–当前分类所在路径上的分类属性
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @return åŒ…含了当前分类的上级和所有层级的下级
     */
    @GetMapping("/hasSelfClassifyTree")
    public List<Tree> hasSelfClassifyTree(String codeClassifyOid){
        return engineService.hasSelfClassifyTree(codeClassifyOid);
    }

    /**
     * ä½¿ç”¨åˆ†ç±»èŽ·å–对应的数据
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @param templateOid æ¨¡æ¿çš„主键
     * @param queryObject åŸºç¡€æŸ¥è¯¢å¯¹è±¡
     * @return æ•°æ®çš„信息（包含下级分类）
     */
    @GetMapping("/gridTableDataByClassifyOid")
    @VciBusinessLog(operateName = "查询主题库分类的数据")
    public DataGrid<Map<String,String>> gridTableDataByClassifyOid(String codeClassifyOid, String templateOid, BaseQueryObject queryObject){
        //TODO后续可以定义查询模板来查询
        return engineService.gridTableDataByClassifyOid(codeClassifyOid,templateOid,queryObject.getConditionMap(),queryObject.getPageHelper());
    }


    /***
     * èŽ·å–分类对象
     * @param redisOid
     * @return
     */
    @GetMapping("/gridclassifys")
    public R gridclassifys(String redisOid){
        List<CodeImportTemplateVO> codeImportTemplateVOs=mdmIOService.gridclassifys(redisOid);
        return R.data(codeImportTemplateVOs);
    }

    /***
     * ä»Žredis缓存里获取到导入正确的数据
     * @param codeClassifyOid
     * @param redisOid
     * @return
     */
    @GetMapping("/gridValidata")
    public DataGrid<Map<String,String>> gridValidata(String codeClassifyOid,String redisOid){
        return mdmIOService.gridDatas(codeClassifyOid,redisOid);
    }

    /***
     * ä»Žredis缓存里获取到导入正确的数据
     * @param dataOid
     * @param redisOid
     * @return
     */
    @GetMapping("/gridRowResemble")
    public DataGrid<Map<String,String>> gridRowResemble(String dataOid,String redisOid){
        return mdmIOService.gridRowResemble(dataOid,redisOid);
    }

    /***
     * ä»Žredis缓存里获取到导入具有相似项的数据
     * @param codeClassifyOid
     * @param redisOid
     * @return
     */
    @GetMapping("/gridResemble")
    public DataGrid<Map<String,String>> gridResemble(String codeClassifyOid,String redisOid){
        return mdmIOService.gridDatas(codeClassifyOid,redisOid);
    }

    /**
     * æ‰¹é‡ä¿å­˜æµç¨‹æ‰§è¡Œé¡µé¢ä¿®æ”¹çš„内容
     * @param orderDTOList ç¼–码相关的信息，不需要码段的信息
     * @return æ‰§è¡Œç»“æžœ
     */
    @PostMapping("/batchUpdateCode")
    public R batchUpdateCode(@RequestBody List<CodeOrderDTO> orderDTOList){
        return engineService.batchUpdateCode(orderDTOList);
    }

    /**
     * æ ‡è®°æµç¨‹ä¸­ä¸šåŠ¡æ•°æ®æ˜¯å¦é€šè¿‡
     * @param oid ä¸šåŠ¡æ•°æ®ä¸»é”®
     * @param btmName ä¸šåŠ¡ç±»åž‹
     * @param pass æ˜¯å¦é€šè¿‡ true-通过;false-不通过
     * @return æ‰§è¡Œç»“æžœ
     */
    @PostMapping("/markPass")
    public R markDataPassing(String oid,String btmName,Boolean pass){
        return engineService.markDataPassing(oid,btmName,pass);
    }

    /**
     * ç»„合规则的预览的内容
     * @param orderDTO ç”³è¯·ç¼–码信息
     * @return å…¬å¼è½¬æ¢åŽçš„值
     */
    @PostMapping("/previewCompRule")
    public R previewCompRule(@RequestBody CodeOrderDTO orderDTO){
        return R.data(engineService.previewCompRule(orderDTO));
    }

    /**
     * åˆ†ç±»æ³¨å…¥çš„内容
     * @param orderDTO ç”³è¯·ç¼–码的信息，包含分类的主键和模板的主键
     * @return æ‰§è¡Œç»“æžœ
     */
    @PostMapping("/previewClassify")
    public R previewClassify(@RequestBody CodeOrderDTO orderDTO){
        VciBaseUtil.alertNotNull(orderDTO,"申请的信息",orderDTO.getCodeClassifyOid(),"分类主键",orderDTO.getTemplateOid(),"模板的主键");
        Map<String,String> classifyMap = engineService.previewClassify(orderDTO.getCodeClassifyOid(),orderDTO.getTemplateOid());
        return R.data(classifyMap);
    }

    /**
     * ä¸‹è½½é”™è¯¯çš„文件信息
     * @param uuid å”¯ä¸€æ ‡è¯†
     * @param response å“åº”对象
     * @throws IOException æŠ›å‡ºå¼‚常
     */
    @GetMapping("/downloadErrorFile")
    public void downloadErrorFile(String uuid,HttpServletResponse response) throws IOException {
        ControllerUtil.downloadErrorFile(response,uuid);
    }

    /**
     * å‡ç‰ˆç¼–码数据
     * @param orderDTO ç¼–码相关的信息，不需要码段的信息
     * @return æ‰§è¡Œç»“æžœ
     */
    @VciBusinessLog(operateName = "升版编码数据")
    @PostMapping("/upSaveCode")
    public R upSaveCode(@RequestBody CodeOrderDTO orderDTO){
        engineService.upSaveCode(orderDTO);
        return  R.success("操作成功！");
    }

    /**
     * ä½¿ç”¨ç æ®µçš„主键获取分类的码值内容
     * @param classifySecOid ç æ®µçš„主键
     * @param parentClassifyValueOid ä¸Šçº§åˆ†ç±»çš„主键
     * @return åˆ†ç±»ç å€¼çš„内容
     */
    @GetMapping("/listCodeClassifyValueBySecOid")
    public DataGrid<CodeClassifyValueVO> listCodeClassifyValueBySecOid(String classifySecOid, String parentClassifyValueOid){
        List<CodeClassifyValueVO> valueVOS = engineService.listCodeClassifyValueBySecOid(classifySecOid, parentClassifyValueOid);
        DataGrid<CodeClassifyValueVO> dataGrid = new DataGrid<>();
        dataGrid.setData(valueVOS);
        dataGrid.setTotal(valueVOS==null?0:valueVOS.size());
        return dataGrid;
    }

    /**
     * ä½¿ç”¨åˆ†ç±»çš„主键来获取编码规则
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @return ç¼–码规则的内容
     */
    @GetMapping("/getCodeRuleByClassifyOid")
//    @VciUnCheckRight
    public R<CodeRuleVO> getCodeRuleByClassifyOid(String codeClassifyOid){
        return R.data(engineService.getCodeRuleByClassifyOid(codeClassifyOid));
    }

    /**
     * ä½¿ç”¨ä¸»é”®èŽ·å–数据
     * @param oid æ•°æ®ä¸»é”®
     * @param templateOid æ¨¡æ¿çš„主键
     * @return æ•°æ®å†…容
     */
    @GetMapping("/getDataByOid")
    public R<List<Map<String,String>>> getDataByOid(String oid,String templateOid){
        return engineService.getDataByOid(oid,templateOid);
    }

    /**
     * ä½¿ç”¨åˆ†ç±»æ¨¡æ¿ä¸»é”®+模板流程名称获取在审批页面上左侧显示的属性
     * @param templateOid åˆ†ç±»æ¨¡æ¿çš„主键
     * @param executionId æµç¨‹æ‰§è¡Œid
     * @param processUse æµç¨‹çš„用途
     * @return æ ‘节点显示的名称
     */
    @GetMapping("/getFieldByProcessTemplate")
    public List<String> getFieldByProcessTemplate(String templateOid,String executionId,String processUse){
        return engineService.getFieldByProcessTemplate(templateOid,executionId,processUse);
    }

    /**
     * ä½¿ç”¨åˆ†ç±»çš„主键获取业务数据
     * @param btmType ä¸šåŠ¡ç±»åž‹
     * @param queryObject æŸ¥è¯¢å¯¹è±¡
     * @return è¡¨æ ¼çš„显示对象值
     */
    @GetMapping("/getTableDataByOids")
    public DataGrid<Map<String,String>> getTableDataByOids(String btmType,BaseQueryObject queryObject){
        return engineService.getTableDataByExecutionId(btmType,queryObject);
    }

    /**
     * ä½¿ç”¨åˆ†ç±»çš„主键获取表格的定义
     * @param codeClassifyOid åˆ†ç±»ä¸»é”®
     * @param phase é˜¶æ®µçš„名称
     * @return UI相关的信息（仅包含表单)
     */
    @GetMapping("/getTableDefineByClassifyOid")
    public MdmUIInfoVO getTableDefineByClassifyOid(String codeClassifyOid,String phase){
        return engineService.getTableDefineByClassifyOid_v2(codeClassifyOid,phase);
    }

    /**
     * ä½¿ç”¨åˆ†ç±»çš„的编号路径，获取表单的定义
     * @param idPath ç¼–号的路径
     * @return UI相关的信息（仅包含表单)
     */
//    @VciUnCheckRight
    @GetMapping("/getFormDefineByClassifyIdPath")
    public MdmUIInfoVO getFormDefineByClassifyIdPath(String idPath){
        return engineService.getFormDefineByClassifyIdPath(idPath);
    }

    /**
     * ä½¿ç”¨åˆ†ç±»çš„主键获取表单的定义
     * @param codeClassifyOid åˆ†ç±»ä¸»é”®
     * @return UI相关的信息（仅包含表单)
     */
    @GetMapping("/getFormDefineByClassifyOid")
    public MdmUIInfoVO getFormDefineByClassifyOid(String codeClassifyOid){
        return engineService.getFormDefineByClassifyOid(codeClassifyOid);
    }

    /**
     * æ ¹æ®æ¨¡æ¿çš„主键获取表格的定义
     * @param templateOid æ¨¡æ¿çš„主键
     * @return ui相关的信息（仅包含表格）
     */
    @GetMapping("/getTableDefineByTemplateOid")
    public MdmUIInfoVO getTableDefineByTemplateOid(String templateOid){
        return engineService.getTableDefineByTemplateOid(templateOid);
    }

    /**
     * ä½¿ç”¨åˆ†ç±»çš„编号路径，获取表格的相关定义
     * @param codeClassifyIdPath åˆ†ç±»çš„编号路径，必须是从顶层节点开始，xxx/yy/zz这样的格式
     * @param functionId åŠŸèƒ½çš„编号
     * @return UI相关的信息（仅包含表格)
     */
    @GetMapping("/getUIInfoByClassifyIdPath")
    public MdmUIInfoVO getUIInfoByClassifyIdPath(String codeClassifyIdPath,String functionId){
        return engineService.getUIInfoByClassifyIdPath(codeClassifyIdPath,functionId);
    }

    /**
     * ä½¿ç”¨åˆ†ç±»èŽ·å–表格的定义
     * @param codeClassifyOid åˆ†ç±»ä¸»é”®
     * @param functionId åŠŸèƒ½çš„编号
     * @return UI相关的信息（仅包含表格）
     */
    @GetMapping("/getUIInfoByClassifyOid")
    public MdmUIInfoVO getUIInfoByClassifyOid(String codeClassifyOid,String functionId){
        return engineService.getUIInfoByClassifyOid(codeClassifyOid,functionId);
    }
}

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

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

import com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant;
import com.vci.ubcs.starter.web.enumpck.BaseEnum;

public enum CodeAllCodeLC implements BaseEnum {

    /**
     * ç¼–辑中
     */
    EDITING(FrameWorkDefaultValueConstant.FRAMEWORK_RELEASE_EDITING,"编辑中"),

    /**
     * å®¡æ‰¹ä¸­
     */
    AUDITING(FrameWorkDefaultValueConstant.FRAMEWORK_RELEASE_AUDITING,"审批中"),

    /**
     * å·²å‘布
     */
    RELEASED(FrameWorkDefaultValueConstant.FRAMEWORK_RELEASE_RELEASED,"已发布"),

    /**
     * ç å€¼å›žæ”¶
     */
    TASK_BACK(FrameWorkDefaultValueConstant.FRAMEWORK_RELEASE_TAKEBACK,"码值回收"),

    /**
     * ç å€¼æ•°æ®é”€æ¯
     */
    OBSOLETED(FrameWorkDefaultValueConstant.FRAMEWORK_RELEASE_OBSOLETED,"码值数据销毁"),

    /**
     * åœç”¨
     */
    DISABLE(FrameWorkDefaultValueConstant.FRAMEWORK_DATA_DISABLED,"停用");

    /**
     * æžšä¸¾çš„值
     */
    private String value;

    /**
     * æžšä¸¾æ˜¾ç¤ºæ–‡æœ¬
     */
    private String text;

    /**
     * èŽ·å–枚举值
     *
     * @return æžšä¸¾å€¼
     */
    @Override
    public String getValue() {
        return value;
    }

    /**
     * è®¾ç½®æžšä¸¾å€¼
     *
     * @param value æžšä¸¾å€¼
     */
    public void setValue(String value) {
        this.value = value;
    }

    /**
     * èŽ·å–枚举显示文本
     *
     * @return æ˜¾ç¤ºæ–‡æœ¬
     */
    @Override
    public String getText() {
        return text;
    }

    /**
     * è®¾ç½®æ˜¾ç¤ºæ–‡æœ¬
     *
     * @param text æ˜¾ç¤ºæ–‡æœ¬
     */
    public void setText(String text) {
        this.text = text;
    }

    /**
     * æž„造函数
     *
     * @param value å€¼
     * @param text  æ˜¾ç¤ºæ–‡æœ¬
     */
    private CodeAllCodeLC(String value, String text) {
        this.value = value;
        this.text = text;
    }

    /**
     * æ ¹æ®åç§°èŽ·å–对应的枚举值
     *
     * @param text åç§°
     * @return æžšä¸¾å€¼
     */
    public static String getValueByText(String text) {
        for (CodeAllCodeLC wenum : CodeAllCodeLC.values()) {
            if (wenum.getText().equalsIgnoreCase(text)) {
                return wenum.getValue();
            }
        }
        return "";
    }

    /**
     * æ ¹æ®æžšä¸¾å€¼èŽ·å–名称
     *
     * @param value æžšä¸¾å€¼
     * @return åç§°
     */
    public static String getTextByValue(String value) {
        for (CodeAllCodeLC wenum : CodeAllCodeLC.values()) {
            if (wenum.getValue().equalsIgnoreCase(value)) {
                return wenum.getText();
            }
        }
        return "";
    }

    /**
     * æ ¹æ®æžšä¸¾å€¼èŽ·å–枚举对象
     *
     * @param value æžšä¸¾å€¼
     * @return æžšä¸¾å¯¹è±¡ï¼Œä¸å­˜åœ¨æ—¶å€™è¿”回null
     */
    public static CodeAllCodeLC forValue(String value) {
        for (CodeAllCodeLC wenum : CodeAllCodeLC.values()) {
            if (wenum.getValue().equalsIgnoreCase(value)) {
                return wenum;
            }
        }
        return null;
    }
}

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

@@ -252,4 +252,11 @@
     */
    List<CodeClassifyVO> selectCodeClassifyDOByTree(TreeQueryObject treeQueryObject);

    /**
     * ç»Ÿè®¡å­èŠ‚点的个数
     *
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @return ä¸ªæ•°
     */
    int countChildrenByClassifyOid(String codeClassifyOid);
}

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

ÎļþÃû´Ó Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/ICodeTempbuttonService.java ÐÞ¸Ä
@@ -22,9 +22,7 @@
import com.vci.ubcs.code.entity.CodeClassifyTemplateButton;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateButtonVO;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.web.pagemodel.DataGrid;
import com.vci.ubcs.starter.web.pagemodel.PageHelper;
import org.springblade.core.mp.support.Query;
import org.springblade.core.tool.api.R;

import java.util.Collection;
@@ -37,7 +35,7 @@
 * @author yuxc
 * @since 2023-04-20
 */
public interface ICodeTempbuttonService extends IService<CodeClassifyTemplateButton> {
public interface ICodeClassifyTemplateButtonService extends IService<CodeClassifyTemplateButton> {

    /**
     * æŸ¥è¯¢æ‰€æœ‰çš„主题库里模板包含的按钮
@@ -138,4 +136,11 @@
     */
    int codeTemplateDeleteTrigger(String classifyTemplateOid);

    /**
     * ä½¿ç”¨æ¨¡æ¿ä¸»é”®èŽ·å–扩展的按钮
     * @param templateOid æ¨¡æ¿çš„主键
     * @param hasButtonVO æ˜¯å¦åŒ…含按钮的显示信息
     * @return æŒ‰é’®çš„相关的信息
     */
    List<CodeClassifyTemplateButtonVO> listButtonByTemplateOid(String templateOid,boolean hasButtonVO);
}

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

@@ -114,5 +114,29 @@
     */
    R batchSave4Order(List<CodeClassifyValueDTO> dtoList, String codeclassifysecoid);

}
    /**
     * ä½¿ç”¨ç æ®µçš„主键获取分类的码值内容
     * @param classifySecOid ç æ®µçš„主键
     * @param parentClassifyValueOid ä¸Šçº§åˆ†ç±»çš„主键
     * @return åˆ†ç±»ç å€¼çš„内容
     */
    List<CodeClassifyValueVO> listCodeClassifyValueBySecOid(String classifySecOid, String parentClassifyValueOid);

    /**
     * æ•°æ®å¯¹è±¡è½¬æ¢ä¸ºæ˜¾ç¤ºå¯¹è±¡
     * @param  codeClassifyValueDO æ•°æ®å¯¹è±¡
     * @return æ˜¾ç¤ºå¯¹è±¡
     * @throws VciBaseException æ‹·è´å±žæ€§å‡ºé”™çš„时候会抛出异常
     */
    CodeClassifyValueVO codeClassifyValueDO2VO(CodeClassifyValue codeClassifyValueDO) throws VciBaseException;

    /**
     * æ‰¹é‡æ•°æ®å¯¹è±¡è½¬æ¢ä¸ºæ˜¾ç¤ºå¯¹è±¡
     * @param codeClassifyValueDOs æ•°æ®å¯¹è±¡åˆ—表
     * @return æ˜¾ç¤ºå¯¹è±¡
     * @throws VciBaseException å‚数为空或者不存在的时候会抛出异常
     */
    List<CodeClassifyValueVO> codeClassifyValueDO2VOs(Collection<CodeClassifyValue>  codeClassifyValueDOs) throws VciBaseException;

    }


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

@@ -22,6 +22,8 @@
import org.springblade.core.mp.base.BaseService;
import com.baomidou.mybatisplus.core.metadata.IPage;

import java.util.Map;

/**
 * å±žæ€§æ˜¾ç¤ºå¯¹è±¡ æœåŠ¡ç±»
 *
@@ -40,4 +42,7 @@
    IPage<CodeOsattributeVO> selectCodeOsattributePage(IPage<CodeOsattributeVO> page, CodeOsattributeVO CodeOsattribute);


    boolean isDefaultAttr(String selectKey);

    Map<String, CodeOsattributeVO> getDefaultAttributeVOMap();
}

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

@@ -21,6 +21,8 @@
import com.vci.ubcs.code.entity.CodePhaseAttr;
import com.vci.ubcs.code.vo.pagemodel.CodePhaseAttrVO;

import java.util.List;

/**
 * ç¼–码库定义-模板阶段-属性 æœåŠ¡ç±»
 *
@@ -39,4 +41,11 @@
    IPage<CodePhaseAttrVO> selectCodePhaseattrPage(IPage<CodePhaseAttrVO> page, CodePhaseAttrVO CodePhaseattr);


    /**
     * ä½¿ç”¨æ¨¡æ¿ä¸»é”®å’Œé˜¶æ®µç¼–号获取包含的属性
     * @param templateOid æ¨¡æ¿çš„编号
     * @param phaseId é˜¶æ®µçš„编号
     * @return å±žæ€§çš„英文名称
     */
    List<String> listAttrByTemplateOidAndPhaseId(String templateOid, String phaseId);
}

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

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

import com.vci.ubcs.code.vo.pagemodel.CodeResembleRuleVO;

public interface ICodeResembleRuleService {
    CodeResembleRuleVO getObjectByOid(String codeResembleRuleOid);
}

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

@@ -3,20 +3,29 @@

import com.baomidou.mybatisplus.extension.service.IService;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
import com.vci.ubcs.code.dto.CodeDeleteBatchDTO;
import com.vci.ubcs.code.dto.CodeOrderDTO;
import com.vci.ubcs.code.dto.datapush.BaseModelDTO;
import com.vci.ubcs.code.entity.CodeAllCode;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
import com.vci.ubcs.code.entity.CodeKeyAttrRepeat;
import com.vci.ubcs.code.entity.CodeWupinEntity;
import com.vci.ubcs.code.vo.CodeKeyAttrRepeatVO;
import com.vci.ubcs.code.vo.pagemodel.*;
import com.vci.ubcs.code.vo.pagemodel.UITableFieldVO;
import com.vci.ubcs.starter.web.pagemodel.*;
import org.springblade.core.tool.api.R;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.*;
import java.util.stream.Collectors;

/**
 * ä¸»æ•°æ®å¼•æ“ŽæœåŠ¡
 * @author weidy
 * @date 2022-2-21
 */
public interface MdmEngineService extends IService<CodeAllCode> {


public interface MdmEngineService extends IService<CodeWupinEntity> {
    /**
     * ä½¿ç”¨åˆ†ç±»çš„主键获取可以使用的模板对象
     * @param codeClassifyOid åˆ†ç±»çš„主键
@@ -32,112 +41,330 @@
     */
    CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr);

    /**
     * èŽ·å–枚举的下拉选项
     * @param attrVO æ¨¡æ¿å±žæ€§çš„对象
     * @return ä¸‹æ‹‰é€‰é¡¹
     */
    List<KeyValue> listComboboxItems(CodeClassifyTemplateAttrVO attrVO);

    /**
     * ä¿®æ”¹çŠ¶æ€
     * @param baseModelDTO æ•°æ®ä¼ è¾“对象
     */
    void changeStatus(BaseModelDTO baseModelDTO);

    /**
     * ç”³è¯·å•ä¸€ç¼–码
     * @param orderDTO ç”³è¯·çš„信息，需要包含属性的内容和码段相关的内容
     * @return è¿”回编码的内容
     */
    String addSaveCode(CodeOrderDTO orderDTO);

    /**
     * åˆ¤æ–­ç¼–码的码段是否输入或者选择了码值
     * @param ruleVO è§„则的显示对象
     * @param orderDTO ç¼–码申请的内容
     */
    void checkSecValueOnOrder(CodeRuleVO ruleVO, CodeOrderDTO orderDTO);

    /**
     * å°è£…关键属性的查询语句
     *
     * @param value        å½“前的值
     * @param keyRuleVO    å…³é”®å±žæ€§çš„控制规则，可以为空
     * @param attrId       å±žæ€§çš„编号
     * @param trim         æ˜¯å¦åŽ»é™¤ç©ºæ ¼
     * @param ignoreCase   æ˜¯å¦ä¸åŒºåˆ†å¤§å°å†™
     * @param ignoreWidth  æ˜¯å¦å¿½ç•¥å…¨åŠè§’
     * @param trimAll      æ˜¯å¦å¿½ç•¥å…¨éƒ¨ç©ºæ ¼
     * @param conditionMap æŸ¥è¯¢æ¡ä»¶
     */
    void wrapperKeyAttrConditionMap(String value, CodeKeyAttrRepeatVO keyRuleVO, String attrId,
                               boolean trim, boolean ignoreCase, boolean ignoreWidth,
                               boolean trimAll, Map<String, String> conditionMap);

    /**
     * åˆå§‹åŒ–业务类型
     * --创建人默认为当前用户，如果需要修改，可以在获取后自行处理
     * @param btmName ä¸šåŠ¡ç±»åž‹çš„名称，会自动变成小写
     * @return CodeWupinEntity
     */
    CodeWupinEntity createCBOByBtmName(String btmName);

    /**
     * ä¿å­˜å¯è¾“可选的信息
     *
     * @param templateVO æ¨¡æ¿çš„对象
     * @param cboList    æ•°æ®çš„内容
     */
    void batchSaveSelectChar(CodeClassifyTemplateVO templateVO, /*List<ClientBusinessObject> cboList*/
                             List<String> cboList);

    /**
     * ä½¿ç”¨æ¨¡æ¿çš„主键获取表单的信息
     * @param templateOid æ¨¡æ¿çš„主键
     * @param codeClassifyOid ä½¿ç”¨æ¨¡æ¿çš„分类的主键
     * @return ui相关的内容
     */
    MdmUIInfoVO getFormDefineByTemplateOid(String templateOid, String codeClassifyOid);

    /**
     * æ¨¡æ¿å±žæ€§è½¬æ¢ä¸ºè¡¨å•çš„字段
     *
     * @param attrVO  æ¨¡æ¿å±žæ€§
     * @param btmType ä¸šåŠ¡ç±»åž‹
     * @return è¡¨å•çš„字段
     */
    UIFormItemVO templateAttr2FormField(CodeClassifyTemplateAttrVO attrVO, String btmType) ;

    /**
     * æ¨¡æ¿å±žæ€§è½¬æ¢ä¸ºè¡¨æ ¼æ˜¾ç¤ºçš„配置
     *
     * @param attrVO æ¨¡æ¿å±žæ€§
     * @param forEdit æ˜¯å¦æ˜¯ç¼–辑所需
     * @return è¡¨æ ¼çš„字段
     */
    UITableFieldVO templateAttr2TableField(CodeClassifyTemplateAttrVO attrVO, boolean forEdit);

    /**
     * ç›¸ä¼¼é¡¹æŸ¥è¯¢
     * @param orderDTO ç¼–码的相关信息
     * @return æ•°æ®åˆ—表
     */
    DataGrid<Map<String, String>> resembleQuery(CodeOrderDTO orderDTO);

    /**
     * ä¿®æ”¹ä¸»é¢˜åº“数据
     * @param orderDTO æ•°æ®çš„内容，不用包含码段的内容了
     */
    void editSaveCode(CodeOrderDTO orderDTO);

    /**
     * å°è£…相似项查询的查询条件的映射
     *
     * @param value          å€¼
     * @param resembleRuleVO ç›¸ä¼¼é¡¹è§„则
     * @param attrId         å±žæ€§çš„编号
     * @param conditionMap   æŸ¥è¯¢æ¡ä»¶
     */
    void wrapperResembleConditionMap(String value, CodeResembleRuleVO resembleRuleVO, String attrId, Map<String, String> conditionMap);
    /**
     * èŽ·å–使用的相似查询规则
     *
     * @param fullInfoBO        ç±»å…¨éƒ¨ä¿¡æ¯
     * @param currentClassifyVO å½“前的分类
     * @return è§„则，如果不存在会返回Null
     */
    CodeResembleRuleVO getUseResembleRule(CodeClassifyFullInfoBO fullInfoBO, CodeClassifyVO currentClassifyVO);


    /**
     * æŸ¥è¯¢ç¼–码数据的列表
     *
     * @param btmType      ä¸šåŠ¡ç±»åž‹
     * @param templateVO   æ¨¡æ¿çš„对象，需要包含模板的属性
     * @param conditionMap æŸ¥è¯¢æ¡ä»¶
     * @param pageHelper   åˆ†é¡µå¯¹è±¡
     * @return æ•°æ®åˆ—表
     */
    DataGrid<Map<String, String>> queryGrid(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper);

    /**
     * å°è£…查询出来的数据
     *
     * @param dataMap              æ•°æ®çš„映射
     * @param templateVO           æ¨¡æ¿çš„属性
     * @param onlySelectAttrIdList ä»…仅查询的属性字段
     * @param form è¡¨å•é‡Œä½¿ç”¨
     */
    void wrapperData(List<Map<String, String>> dataMap, CodeClassifyTemplateVO templateVO,
                     Collection<String> onlySelectAttrIdList, boolean form);

    /**
     * æ ¹æ®æ¨¡æ¿å±žæ€§ç”Ÿæˆç›¸åº”çš„sql信息
     *
     * @param btmType      ä¸šåŠ¡ç±»åž‹
     * @param templateVO   æ¨¡æ¿æ˜¾ç¤ºå¯¹è±¡ï¼Œå¿…须包含属性
     * @param conditionMap æŸ¥è¯¢æ¡ä»¶
     * @param pageHelper   åˆ†é¡µå’ŒæŽ’序对象
     * @return sql的相关信息
     */
    CodeTemplateAttrSqlBO getSqlByTemplateVO(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper);

    void deleteCode(CodeDeleteBatchDTO deleteBatchDTO);

    /**
     * ä½¿ç”¨åˆ†ç±»å’Œé˜¶æ®µçš„编号，获取包含的属性
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @param phase é˜¶æ®µçš„名称
     * @return å±žæ€§çš„英文名称
     */
    List<String> listPhaseAttrByClassifyOid(String codeClassifyOid, String phase);

    /**
     * è·¯å¾„上包含当前分类的所有分类信息
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @return åˆ†ç±»æ ‘
     */
    List<Tree> hasSelfClassifyTree(String codeClassifyOid);

    /**
     * ä½¿ç”¨åˆ†ç±»èŽ·å–对应的数据
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @param templateOid æ¨¡æ¿çš„主键
     * @param conditionMap æŸ¥è¯¢æ¡ä»¶
     * @param pageHelper åˆ†é¡µçš„对象
     * @return æ•°æ®ï¼ˆåŒ…含下级分类）
     */
    DataGrid<Map<String, String>> gridTableDataByClassifyOid(String codeClassifyOid, String templateOid, Map<String, String> conditionMap, PageHelper pageHelper);

    /**
     * æ‰¹é‡ä¿å­˜æµç¨‹æ‰§è¡Œé¡µé¢ä¿®æ”¹çš„内容
     * @param orderDTOList ç¼–码相关的信息，不需要码段的信息
     * @return æ‰§è¡Œç»“æžœ
     */
    R batchUpdateCode(List<CodeOrderDTO> orderDTOList);


    /**
     * æ ‡è®°æµç¨‹ä¸­ä¸šåŠ¡æ•°æ®æ˜¯å¦é€šè¿‡
     * @param oid ä¸šåŠ¡æ•°æ®ä¸»é”®
     * @param btmName ä¸šåŠ¡ç±»åž‹
     * @param pass æ˜¯å¦é€šè¿‡
     * @return æ‰§è¡Œç»“æžœ
     */
    R markDataPassing(String oid, String btmName, Boolean pass);

    /**
     * é¢„览组合规则
     * @param orderDTO ç”³è¯·ç¼–码的信息
     * @return key是组合规则的属性。value是组合后的值，。如果缺少某个属性的值，会作为value返回
     */
    Map<String,String> previewCompRule(CodeOrderDTO orderDTO);

    /**
     * åˆ†ç±»æ³¨å…¥çš„内容预览
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @param templateOid æ¨¡æ¿çš„主键
     * @return key是分类注入的属性，value是注入后的值
     */
    Map<String, String> previewClassify(String codeClassifyOid, String templateOid);

    /**
     * å‡ç‰ˆçš„主题库数据
     * @param orderDTO æ•°æ®çš„内容，不需要包含码段的内容
     */
    void upSaveCode(CodeOrderDTO orderDTO);

    /**
     * ä½¿ç”¨ç æ®µçš„主键获取分类的码值内容
     * @param classifySecOid ç æ®µçš„主键
     * @param parentClassifyValueOid ä¸Šçº§åˆ†ç±»çš„主键
     * @return åˆ†ç±»ç å€¼çš„内容
     */
    List<CodeClassifyValueVO> listCodeClassifyValueBySecOid(String classifySecOid, String parentClassifyValueOid);

    /**
     * ä½¿ç”¨ä¸»é¢˜åº“分类获取编码规则
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @return ç¼–码规则的内容
     */
    CodeRuleVO getCodeRuleByClassifyOid(String codeClassifyOid);

    /**
     * ä½¿ç”¨åˆ†ç±»çš„全部信息获取编码规则
     *
     * @param fullInfoBO åˆ†ç±»çš„全部信息
     * @return è§„则的内容
     */
    CodeRuleVO getCodeRuleByClassifyFullInfo(CodeClassifyFullInfoBO fullInfoBO);

////
////    /**
////     * èŽ·å–枚举的下拉选项
////     * @param attrVO æ¨¡æ¿å±žæ€§çš„对象
////     * @return ä¸‹æ‹‰é€‰é¡¹
////     */
////    List<KeyValue> listComboboxItems(CodeClassifyTemplateAttrVO attrVO);
////
////    /**
////     * ä¿®æ”¹çŠ¶æ€
////     * @param baseModelDTO æ•°æ®ä¼ è¾“对象
////     */
////    void changeStatus(BaseModelDTO baseModelDTO);
////
////    /**
////     * ç”³è¯·å•ä¸€ç¼–码
////     * @param orderDTO ç”³è¯·çš„信息，需要包含属性的内容和码段相关的内容
////     * @return è¿”回编码的内容
////     */
////    String addSaveCode(CodeOrderDTO orderDTO);
////
////    /**
////     * åˆ¤æ–­ç¼–码的码段是否输入或者选择了码值
////     * @param ruleVO è§„则的显示对象
////     * @param orderDTO ç¼–码申请的内容
////     */
////    void checkSecValueOnOrder(CodeRuleVO ruleVO, CodeOrderDTO orderDTO);
////
////    /**
////     * å°è£…关键属性的查询语句
////     *
////     * @param value        å½“前的值
////     * @param keyRuleVO    å…³é”®å±žæ€§çš„控制规则，可以为空
////     * @param attrId       å±žæ€§çš„编号
////     * @param trim         æ˜¯å¦åŽ»é™¤ç©ºæ ¼
////     * @param ignoreCase   æ˜¯å¦ä¸åŒºåˆ†å¤§å°å†™
////     * @param ignoreWidth  æ˜¯å¦å¿½ç•¥å…¨åŠè§’
////     * @param trimAll      æ˜¯å¦å¿½ç•¥å…¨éƒ¨ç©ºæ ¼
////     * @param conditionMap æŸ¥è¯¢æ¡ä»¶
////     */
////    void wrapperKeyAttrConditionMap(String value, CodeKeyattrrepeatVO keyRuleVO, String attrId,
////                               boolean trim, boolean ignoreCase, boolean ignoreWidth,
////                               boolean trimAll, Map<String, String> conditionMap);
////    /**
////     * åˆå§‹åŒ–业务类型
////     * --创建人默认为当前用户，如果需要修改，可以在获取后自行处理
////     * @param btmName ä¸šåŠ¡ç±»åž‹çš„名称，会自动变成小写
////     * @return CodeWupinEntity
////     * @throws VciBaseException åˆå§‹åŒ–出错的是会抛出异常
////     */
////    CodeWupinEntity createCBOByBtmName(String btmName);
////
////    /**
////     * ä¿å­˜å¯è¾“可选的信息
////     *
////     * @param templateVO æ¨¡æ¿çš„对象
////     * @param cboList    æ•°æ®çš„内容
////     */
////    void batchSaveSelectChar(CodeClstemplateVO templateVO, /*List<ClientBusinessObject> cboList*/
////                             List<String> cboList);
////
////    /**
////     * ä½¿ç”¨æ¨¡æ¿çš„主键获取表单的信息
////     * @param templateOid æ¨¡æ¿çš„主键
////     * @param codeClassifyOid ä½¿ç”¨æ¨¡æ¿çš„分类的主键
////     * @return ui相关的内容
////     */
////    MdmUIInfoVO getFormDefineByTemplateOid(String templateOid, String codeClassifyOid);
////
////    /**
////     * æ¨¡æ¿å±žæ€§è½¬æ¢ä¸ºè¡¨å•çš„字段
////     *
////     * @param attrVO  æ¨¡æ¿å±žæ€§
////     * @param btmType ä¸šåŠ¡ç±»åž‹
////     * @return è¡¨å•çš„字段
////     */
////    UIFormItemVO templateAttr2FormField(CodeClstempattrVO attrVO, String btmType) ;
////
////    /**
////     * æ¨¡æ¿å±žæ€§è½¬æ¢ä¸ºè¡¨æ ¼æ˜¾ç¤ºçš„配置
////     *
////     * @param attrVO æ¨¡æ¿å±žæ€§
////     * @param forEdit æ˜¯å¦æ˜¯ç¼–辑所需
////     * @return è¡¨æ ¼çš„字段
////     */
////    UITableFieldVO templateAttr2TableField(CodeClstempattrVO attrVO, boolean forEdit);
////
////    /**
////     * ç›¸ä¼¼é¡¹æŸ¥è¯¢
////     * @param orderDTO ç¼–码的相关信息
////     * @return æ•°æ®åˆ—表
////     */
////    DataGrid<Map<String, String>> resembleQuery(CodeOrderDTO orderDTO);
////
////    /**
////     * ä¿®æ”¹ä¸»é¢˜åº“数据
////     * @param orderDTO æ•°æ®çš„内容，不用包含码段的内容了
////     */
////    void editSaveCode(CodeOrderDTO orderDTO);
    /**
     * ä½¿ç”¨æ•°æ®ä¸»é”®èŽ·å–数据的全部信息
     * @param oid ä¸»é”®
     * @param templateOid æ¨¡æ¿çš„主键
     * @return æ•°æ®çš„内容
     */
    R<List<Map<String, String>>> getDataByOid(String oid, String templateOid);

    /**
     * ä½¿ç”¨åˆ†ç±»æ¨¡æ¿ä¸»é”®+模板流程名称获取在审批页面上左侧显示的属性
     * @param templateOid åˆ†ç±»æ¨¡æ¿çš„主键
     * @param executionId æµç¨‹æ‰§è¡Œid
     * @param processUse æµç¨‹çš„用途
     * @return æ ‘节点显示的名称
     */
    List<String> getFieldByProcessTemplate(String templateOid, String executionId, String processUse);

    /**
     * ä½¿ç”¨åˆ†ç±»çš„主键获取业务数据
     * @param btmType ä¸šåŠ¡ç±»åž‹
     * @param queryObject æŸ¥è¯¢å¯¹è±¡
     * @return è¡¨æ ¼çš„显示对象值
     */
    DataGrid<Map<String, String>> getTableDataByExecutionId(String btmType, BaseQueryObject queryObject);

    /**
     * ä½¿ç”¨åˆ†ç±»çš„主键获取表格的定义
     * @param codeClassifyOid åˆ†ç±»ä¸»é”®
     * @param phase é˜¶æ®µçš„名称
     * @return UI相关的信息（仅包含表单)
     */
    MdmUIInfoVO getTableDefineByClassifyOid_v2(String codeClassifyOid, String phase);

    /**
     * ä½¿ç”¨åˆ†ç±»çš„编号路径，获取表单的相关定义
     * @param idPath ç¼–号的路径，必须从顶层节点开始，xx/yyy/zz
     * @return UI相关的信息（仅包含表单)
     */
    MdmUIInfoVO getFormDefineByClassifyIdPath(String idPath);

    /**
     * ä½¿ç”¨ä¸»é¢˜åº“分类的主键获取表单的信息
     *
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @return ui相关的内容
     */
    MdmUIInfoVO getFormDefineByClassifyOid(String codeClassifyOid);

    /**
     * ä½¿ç”¨æ¨¡æ¿ä¸»é”®èŽ·å–ui相关的内容
     * @param templateOid æ¨¡æ¿çš„主键
     * @return ui相关的内容
     */
    MdmUIInfoVO getTableDefineByTemplateOid(String templateOid);

    /**
     * ä½¿ç”¨åˆ†ç±»çš„编号路径，获取表格的相关定义
     * @param codeClassifyIdPath åˆ†ç±»çš„编号路径，必须是从顶层节点开始，xxx/yy/zz这样的格式
     * @param functionId åŠŸèƒ½çš„编号
     * @return UI相关的信息（仅包含表格)
     */
    MdmUIInfoVO getUIInfoByClassifyIdPath(String codeClassifyIdPath, String functionId);

    /**
     * ä½¿ç”¨æ¨¡æ¿ä¸»é”®èŽ·å–工具栏中的按钮信息
     *
     * @param templateOid æ¨¡æ¿çš„主键
     * @return æŒ‰é’®çš„信息，会按照排序号进行排序
     */
    List<CodeButtonVO> listButtonInToolbarByTemplateOid(String templateOid);

    /**
     * ä½¿ç”¨åˆ†ç±»ä¸»é”®èŽ·å–工具栏中的按钮信息
     *
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @return æŒ‰é’®çš„信息，会按照排序号进行排序
     */
    List<CodeButtonVO> listButtonInToolbarByClassifyOid(String codeClassifyOid);

    /**
     * ä½¿ç”¨åˆ†ç±»ä¸»é”®èŽ·å–页面的内容，包含按钮
     *
     * @param codeClassifyOid ä¸»é¢˜åº“分类主键
     * @param functionId      åŠŸèƒ½çš„编号
     * @return UI相关的内容
     */
    MdmUIInfoVO getUIInfoByClassifyOid(String codeClassifyOid, String functionId);
}

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

@@ -3,16 +3,52 @@
import com.vci.ubcs.code.dto.CodeOrderDTO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
import com.vci.ubcs.code.vo.pagemodel.CodeImProtRusultVO;
import com.vci.ubcs.code.vo.pagemodel.CodeImportTemplateVO;
import com.vci.ubcs.code.vo.webserviceModel.attrmap.DataObjectVO;
import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
import com.vci.ubcs.starter.web.pagemodel.DataGrid;

import java.io.File;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public interface MdmIOService {
    List<CodeImportTemplateVO> gridclassifys(String redisOid);

    /**
     * ç”Ÿæˆå¯¼å…¥çš„文件
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @param isHistory æ˜¯å¦åŽ†å²æ•°æ®å¯¼å…¥
     * @return excel的文件地址
     */
    String createImportExcel(String codeClassifyOid,boolean isHistory);

    /**
     * æ‰¹é‡ç”³è¯·ç¼–码数据
     * @param orderDTO ç¼–码申请信息，必须包含分类主键和码段的信息
     * @param file excel文件的信息
     * @return æœ‰é”™è¯¯ä¿¡æ¯çš„excel
     */
    CodeImProtRusultVO batchImportCode(CodeOrderDTO orderDTO, File file);

    /***
     * ä»Žredis缓存里获取到导入的数据
     * @param codeClassifyOid
     * @param redisOid
     * @return
     */
    DataGrid<Map<String, String>> gridDatas(String codeClassifyOid, String redisOid);

    /***
     * ä»Žredis缓存里获取到导入的数据
     * @param dataOid
     * @param redisOid
     * @return
     */
    DataGrid<Map<String, String>> gridRowResemble(String dataOid, String redisOid);

    void batchSyncEditDatas(CodeClassifyVO codeClassifyVO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs);

    /**
     * é›†æˆæ‰¹é‡ç”³è¯·æ•°æ®
@@ -22,35 +58,4 @@
     * @return æœ‰é”™è¯¯ä¿¡æ¯çš„excel
     */
    void batchSyncApplyCode(CodeOrderDTO orderDTO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO> resultDataObjectDetailDOs);
    /**
     * é›†æˆæ‰¹é‡æ›´æ”¹æ•°æ®
     * @param codeClassifyVO;
     * @param dataObjectVO æ•°æ®ä¿¡æ¯
     * @param resultDataObjectDetailDOs é”™è¯¯ä¿¡æ¯
     * @return æœ‰é”™è¯¯ä¿¡æ¯çš„excel
     */
    void batchSyncEditDatas(CodeClassifyVO codeClassifyVO, DataObjectVO dataObjectVO, LinkedList<XMLResultDataObjectDetailDO>  resultDataObjectDetailDOs);







//
//    /**
//     * ç”Ÿæˆå¯¼å…¥çš„文件
//     * @param codeClassifyOid åˆ†ç±»çš„主键
//     * @param isHistory æ˜¯å¦åŽ†å²æ•°æ®å¯¼å…¥
//     * @return excel的文件地址
//     */
//    String createImportExcel(String codeClassifyOid,boolean isHistory);
//
//    /**
//     * æ‰¹é‡ç”³è¯·ç¼–码数据
//     * @param orderDTO ç¼–码申请信息，必须包含分类主键和码段的信息
//     * @param file excel文件的信息
//     * @return æœ‰é”™è¯¯ä¿¡æ¯çš„excel
//     */
//    CodeImProtRusultVO batchImportCode(CodeOrderDTO orderDTO, File file);
}

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

@@ -6,6 +6,7 @@
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;

import java.util.Collection;
import java.util.List;

public interface MdmProductCodeService {
@@ -20,4 +21,11 @@
    List<String> productCodeAndSaveData(CodeClassifyFullInfoBO classifyFullInfoBO, CodeClassifyTemplateVO templateVO,
                                        CodeRuleVO ruleVO, List<CodeOrderSecDTO> secDTOList, List<CodeWupinEntity> dataCBOList);

    /**
        * å›žæ”¶ç å€¼
     * @param btmId ä¸šåŠ¡æ•°æ®çš„业务类型
     * @param businessOidCollection ä¸šåŠ¡æ•°æ®çš„主键
     * @return æ˜¯å¦æ›´æ–°æˆåŠŸ
     */
    Boolean recycleCode(String btmId, Collection<String> businessOidCollection);
}

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

@@ -2,6 +2,7 @@

import com.alibaba.nacos.common.utils.StringUtils;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
@@ -43,8 +44,7 @@
import org.apache.poi.hssf.util.HSSFColor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.core.cache.utils.CacheUtil;
import org.springblade.core.log.exception.ServiceException;
import org.springblade.core.cache.utils.CacheUtil;import com.vci.ubcs.core.log.exception.ServiceException;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
@@ -1102,4 +1102,20 @@
        }
        return fullInfo;
    }


    /**
     * ç»Ÿè®¡å­èŠ‚点的个数
     *
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @return ä¸ªæ•°
     */
    @Override
    public int countChildrenByClassifyOid(String codeClassifyOid) {
//        Map<String,String> conditionMap = new HashMap<>();
//        conditionMap.put("parentCodeClassifyOid",codeClassifyOid);
        QueryWrapper<CodeClassify> wrapper = new QueryWrapper<>();
        wrapper.eq("parentCodeClassifyOid",codeClassifyOid);
        return codeClassifyMapper.selectCount(wrapper).intValue();
    }
}

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

@@ -22,6 +22,7 @@
import com.vci.ubcs.code.wrapper.CodeClassifyTemplateAttrWrapper;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.revision.service.RevisionModelUtil;
import com.vci.ubcs.starter.util.DefaultAttrAssimtUtil;
import com.vci.ubcs.starter.util.PatternUtil;
import com.vci.ubcs.starter.web.enumpck.VciFieldTypeEnum;
import com.vci.ubcs.starter.web.pagemodel.*;
@@ -328,6 +329,7 @@
        //将DTO转换为DO
        CodeClassifyTemplateAttr codeClassifyTemplateAttrDO = new CodeClassifyTemplateAttr();
        BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateAttrDTO,codeClassifyTemplateAttrDO);
        DefaultAttrAssimtUtil.addDefaultAttrAssimt(codeClassifyTemplateAttrDO,"codeclstempattr");
        baseMapper.insert(codeClassifyTemplateAttrDO);
        return codeClassifyTemplateAttrDO2VO(codeClassifyTemplateAttrDO);
    }

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

ÎļþÃû´Ó Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeTempbuttonServiceImpl.java ÐÞ¸Ä
@@ -17,6 +17,7 @@
package com.vci.ubcs.code.service.impl;

import com.alibaba.nacos.common.utils.StringUtils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@@ -28,7 +29,7 @@
import com.vci.ubcs.code.enumpack.CodeButtonUseEnum;
import com.vci.ubcs.code.mapper.CodeClassifyTemplateButtonMapper;
import com.vci.ubcs.code.service.ICodeButtonService;
import com.vci.ubcs.code.service.ICodeTempbuttonService;
import com.vci.ubcs.code.service.ICodeClassifyTemplateButtonService;
import com.vci.ubcs.code.vo.pagemodel.CodeButtonVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateButtonVO;
import com.vci.ubcs.code.wrapper.CodeTempbuttonWrapper;
@@ -61,7 +62,7 @@
 * @since 2023-04-20
 */
@Service
public class CodeTempbuttonServiceImpl extends ServiceImpl<CodeClassifyTemplateButtonMapper, CodeClassifyTemplateButton> implements ICodeTempbuttonService {
public class CodeClassifyTemplateButtonServiceImpl extends ServiceImpl<CodeClassifyTemplateButtonMapper, CodeClassifyTemplateButton> implements ICodeClassifyTemplateButtonService {

    /**
     * æ•°æ®æ“ä½œå±‚
@@ -400,4 +401,27 @@
        return updateCount;
    }

    /**
     * ä½¿ç”¨æ¨¡æ¿ä¸»é”®èŽ·å–扩展的按钮
     *
     * @param templateOid æ¨¡æ¿çš„主键
     * @param hasButtonVO æ˜¯å¦åŒ…含按钮的显示信息
     * @return æŒ‰é’®çš„相关的信息
     */
    @Override
    public List<CodeClassifyTemplateButtonVO> listButtonByTemplateOid(String templateOid, boolean hasButtonVO) {
        if(StringUtils.isBlank(templateOid)){
            return new ArrayList<>();
        }
        Map<String,String> conditionMap = new HashMap<>();
        conditionMap.put("classifyTemplateOid",templateOid);
        PageHelper pageHelper = new PageHelper(-1);
        pageHelper.addDefaultAsc("orderNum");
        QueryWrapper<CodeClassifyTemplateButton> wrapper = new QueryWrapper<>();
        wrapper.eq("classifyTemplateOid",templateOid);
        wrapper.orderByAsc("orderNum");
        List<CodeClassifyTemplateButton> templateButtonDOS = codeClassifyTemplateButtonMapper.selectList(wrapper);
        return codeClassifyTemplateButtonDO2VOs(templateButtonDOS,hasButtonVO);
    }

}

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

@@ -1,6 +1,7 @@
package com.vci.ubcs.code.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -24,6 +25,7 @@
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -349,4 +351,78 @@
        return codeClassifyValueMapper.selectList(wrapper);
    }

    /**
     * ä½¿ç”¨ç æ®µçš„主键获取分类的码值内容
     *
     * @param classifySecOid         ç æ®µçš„主键
     * @param parentClassifyValueOid ä¸Šçº§åˆ†ç±»çš„主键
     * @return åˆ†ç±»ç å€¼çš„内容
     */
    @Override
    public List<CodeClassifyValueVO> listCodeClassifyValueBySecOid(String classifySecOid, String parentClassifyValueOid) {
        if(StringUtils.isBlank(classifySecOid)){
            return new ArrayList<>();
        }
        CodeBasicSec secDO = codeBasicSecService.getById(classifySecOid);
        if(secDO == null || StringUtils.isBlank(secDO.getOid())){
            throw new VciBaseException("码段的内容在系统中不存在");
        }
        if(StringUtils.isNotBlank(secDO.getParentClassifySecOid()) && StringUtils.isBlank(parentClassifyValueOid)){
            return new ArrayList<>();
            //因为有上级分类的时候，必须先选择上级分类的内容
        }
//        Map<String,String> conditionMap = new HashMap<>();
//        conditionMap.put("codeClassifySecOid",classifySecOid);
//        if(StringUtils.isNotBlank(parentClassifyValueOid)){
//            conditionMap.put("parentClassifyValueOid",parentClassifyValueOid);
//        }
//        PageHelper pageHelper = new PageHelper(-1);
//        pageHelper.addDefaultAsc("ordernum");
        QueryWrapper<CodeClassifyValue> wrapper = new QueryWrapper<>();
        wrapper.eq("codeClassifySecOid",classifySecOid);
        if(StringUtils.isNotBlank(parentClassifyValueOid)){
            wrapper.eq("parentClassifyValueOid",parentClassifyValueOid);
        }
        wrapper.orderByAsc("ordernum");

        List<CodeClassifyValue> valueDOList = codeClassifyValueMapper.selectList(wrapper);
        return codeClassifyValueDO2VOs(valueDOList);
    }

    /**
     * æ‰¹é‡æ•°æ®å¯¹è±¡è½¬æ¢ä¸ºæ˜¾ç¤ºå¯¹è±¡
     * @param codeClassifyValueDOs æ•°æ®å¯¹è±¡åˆ—表
     * @return æ˜¾ç¤ºå¯¹è±¡
     * @throws VciBaseException å‚数为空或者不存在的时候会抛出异常
     */
    @Override
    public List<CodeClassifyValueVO> codeClassifyValueDO2VOs(Collection<CodeClassifyValue>  codeClassifyValueDOs) throws VciBaseException{
        List<CodeClassifyValueVO> voList = new ArrayList<CodeClassifyValueVO>();
        if(!CollectionUtils.isEmpty(codeClassifyValueDOs)){
            for(CodeClassifyValue s: codeClassifyValueDOs){
                CodeClassifyValueVO vo =  codeClassifyValueDO2VO(s);
                if(vo != null){
                    voList.add(vo);
                }
            }
        }
        return voList;
    }

    /**
     * æ•°æ®å¯¹è±¡è½¬æ¢ä¸ºæ˜¾ç¤ºå¯¹è±¡
     * @param  codeClassifyValueDO æ•°æ®å¯¹è±¡
     * @return æ˜¾ç¤ºå¯¹è±¡
     * @throws VciBaseException æ‹·è´å±žæ€§å‡ºé”™çš„时候会抛出异常
     */
    @Override
    public  CodeClassifyValueVO codeClassifyValueDO2VO(CodeClassifyValue codeClassifyValueDO) throws VciBaseException{
        CodeClassifyValueVO vo = new CodeClassifyValueVO();
        if(codeClassifyValueDO != null){
            BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyValueDO,vo);
            //如果有lcstatus的类的话

        }
        return vo;
    }
}

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

@@ -45,7 +45,6 @@
import org.springblade.core.mp.support.Query;
import org.springblade.core.secure.utils.AuthUtil;
import org.springblade.core.tool.api.R;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.context.annotation.Lazy;
@@ -87,7 +86,7 @@
    @Autowired(required = false)
    private CodeTempphaseServiceImpl codeTempphaseServiceImpl;
    @Autowired(required = false)
    private CodeTempbuttonServiceImpl codeTempbuttonServiceImpl;
    private CodeClassifyTemplateButtonServiceImpl codeTempbuttonServiceImpl;
    @Autowired(required = false)
    private ICodeClassifyProcessTempService codeClsflowtempServiceImpl;
//    @Autowired(required = false)
@@ -875,9 +874,11 @@
        CodeClassifyTemplate codeClstemplateQuery = new CodeClassifyTemplate();
//        BeanUtil.toBean(map,codeClstempattrVO);
//        BeanUtil
        BeanMap beanMap = BeanMap.create(codeClstemplateQuery);
        CodeClassifyTemplateDTO codeClassifyTemplateDTO = new CodeClassifyTemplateDTO();
        BeanMap beanMap = BeanMap.create(codeClassifyTemplateDTO);
        beanMap.putAll(conditionMap);
//        BeanUtils.copyProperties(codeClstemplateVO,codeClstemplateQuery);
        BeanUtilForVCI.copyPropertiesIgnoreCase(codeClassifyTemplateDTO,codeClstemplateQuery);
        if (pageHelper == null) {
            pageHelper = new PageHelper(-1);
        }

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

@@ -20,6 +20,16 @@
    }

    @Override
    public boolean isDefaultAttr(String selectKey) {
        return false;
    }

    @Override
    public Map<String, CodeOsattributeVO> getDefaultAttributeVOMap() {
        return null;
    }

    @Override
    public boolean saveBatch(Collection<CodeOsattributeEntity> entityList, int batchSize) {
        return false;
    }

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

@@ -16,13 +16,21 @@
 */
package com.vci.ubcs.code.service.impl;

import com.alibaba.nacos.common.utils.StringUtils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.code.constant.MdmBtmTypeConstant;
import com.vci.ubcs.code.entity.CodePhaseAttr;
import com.vci.ubcs.code.mapper.CodePhaseAttrMapper;
import com.vci.ubcs.code.service.ICodePhaseAttrService;
import com.vci.ubcs.code.vo.pagemodel.CodePhaseAttrVO;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.stream.Collectors;

/**
 * ç¼–码库定义-模板阶段-属性 æœåŠ¡å®žçŽ°ç±»
@@ -38,5 +46,26 @@
        return page.setRecords(baseMapper.selectCodePhaseattrPage(page, codePhaseAttr));
    }

    /**
     * ä½¿ç”¨æ¨¡æ¿ä¸»é”®å’Œé˜¶æ®µç¼–号获取包含的属性
     *
     * @param templateOid æ¨¡æ¿çš„编号
     * @param phaseId     é˜¶æ®µçš„编号
     * @return å±žæ€§çš„英文名称
     */
    @Override
    public List<String> listAttrByTemplateOidAndPhaseId(String templateOid, String phaseId) {
        if(StringUtils.isBlank(templateOid)|| StringUtils.isBlank(phaseId)){
            return new ArrayList<>();
        }
        QueryWrapper<CodePhaseAttr> wrapper = new QueryWrapper();
        wrapper.inSql("codephaseoid","select oid from pl_code_tempphase where codeClassifyTemplateOid ='" + templateOid + "' and lower(name) ='" + phaseId.trim().toLowerCase(Locale.ROOT) + "'");
//        Map<String,String> conditionMap = new HashMap<>();
//        conditionMap.put("codephaseoid", QueryOptionConstant.IN + "(select oid from pl_code_tempphase where codeClassifyTemplateOid ='" + templateOid + "' and lower(name) ='" + phaseId.trim().toLowerCase(Locale.ROOT) + "')");
//        PageHelper pageHelper = new PageHelper(-1);
        List<CodePhaseAttr> attrDOS = baseMapper.selectList(wrapper);
        return CollectionUtils.isEmpty(attrDOS)?new ArrayList<>():attrDOS.stream().map(CodePhaseAttr::getId).collect(Collectors.toList());
    }


}

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

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

import com.vci.ubcs.code.service.ICodeResembleRuleService;
import com.vci.ubcs.code.vo.pagemodel.CodeResembleRuleVO;
import org.springframework.stereotype.Service;

/**
 * ç›¸ä¼¼æŸ¥è¯¢è§„则服务
 * @author weidy
 * @date 2022-04-10
 */
@Service
public class CodeResembleRuleServiceImpl implements ICodeResembleRuleService {
    @Override
    public CodeResembleRuleVO getObjectByOid(String codeResembleRuleOid) {
        return null;
    }
}

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

ÎļþÌ«´ó

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

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

import com.alibaba.cloud.commons.lang.StringUtils;
import com.alibaba.nacos.common.utils.StringUtils;
import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
import com.vci.ubcs.code.dto.CodeOrderDTO;
import com.vci.ubcs.code.service.ICodeClassifyService;
import com.vci.ubcs.code.service.MdmEngineService;
import com.vci.ubcs.code.service.MdmIOService;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO;
import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO;
import com.vci.ubcs.code.vo.pagemodel.*;
import com.vci.ubcs.code.vo.webserviceModel.attrmap.DataObjectVO;
import com.vci.ubcs.code.vo.webserviceModel.attrmap.RowDatas;
import com.vci.ubcs.code.vo.webserviceModel.result.xml.XMLResultDataObjectDetailDO;
import com.vci.ubcs.starter.bo.WriteExcelData;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.poi.bo.ReadExcelOption;
import com.vci.ubcs.starter.poi.bo.SheetDataSet;
import com.vci.ubcs.starter.poi.bo.SheetRowData;
import com.vci.ubcs.starter.poi.bo.WriteExcelOption;
import com.vci.ubcs.starter.poi.util.ExcelUtil;
import com.vci.ubcs.starter.util.LocalFileUtil;
import com.vci.ubcs.starter.web.enumpck.VciFieldTypeEnum;
import com.vci.ubcs.starter.web.pagemodel.DataGrid;
import com.vci.ubcs.starter.web.pagemodel.KeyValue;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Lazy;
import com.vci.ubcs.starter.web.util.VciDateUtil;
import lombok.AllArgsConstructor;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.RichTextString;
import org.apache.poi.ss.usermodel.Workbook;
import org.springblade.core.redis.cache.BladeRedis;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.io.File;
import java.util.*;
import java.util.stream.Collectors;

import static com.alibaba.druid.util.FnvHash.Constants.LIMIT;
import static com.vci.ubcs.code.constant.MdmEngineConstant.*;
import static com.vci.ubcs.starter.poi.util.ExcelUtil.KEY_ATTR_CHAR;
import static com.vci.ubcs.starter.poi.util.ExcelUtil.REQUIRED_CHAR;

@AllArgsConstructor
@Service
@Slf4j
public class MdmIOServiceImpl implements MdmIOService {


    /**
     * åˆ†ç±»æœåŠ¡å±‚
     * ä¸»é¢˜åº“分类的服务
     */
    @Resource
    @Lazy
    private ICodeClassifyService classifyService;

    /**
     * åˆ†ç±»æœåŠ¡å±‚
     * æ¨¡æ¿çš„服务
     */
    @Resource
    @Lazy
    private CodeClstemplateServiceImpl templateService;

    /**
     * ä¸»æ•°æ®å¼•æ“Žçš„服务
     */
    @Resource
    private MdmEngineService engineService;

    private final BladeRedis bladeRedis;

    /**
     * ç”Ÿæˆå¯¼å…¥çš„文件
     *
     * @param codeClassifyOid åˆ†ç±»çš„主键
     * @param isHistory æ˜¯å¦åŽ†å²æ•°æ®å¯¼å…¥
     * @return excel的文件地址
     */
    @Override
    public String createImportExcel(String codeClassifyOid, boolean isHistory) {
        List<CodeClassifyTemplateVO> templateVOList=new ArrayList<>();

        VciBaseUtil.alertNotNull("导出模板","导出的配置",codeClassifyOid,"主题库分类的主键");

        CodeClassifyVO codeClassifyVO = classifyService.getObjectByOid(codeClassifyOid);

        if(isHistory){
            templateVOList= templateService.childTemplates(codeClassifyOid);
        }else{
            //找模板
            CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(codeClassifyOid);
            templateVOList.add(templateVO);
        }

        WriteExcelOption eo = new WriteExcelOption();
        eo.setAppend(true);
        //增加模板的信息导入
        LinkedList<WriteExcelData> tempEDList = new LinkedList<>();
        tempEDList.add(new WriteExcelData(0,0,"模板主键"));
        tempEDList.add(new WriteExcelData(0,1,"模板代号"));
        tempEDList.add(new WriteExcelData(0,2,"模板名称"));
        for(int j=0;j<templateVOList.size();j++){
            CodeClassifyTemplateVO  templateVO=templateVOList.get(j);
            CodeClassifyTemplateVO codeClassifyTemplateVO = new CodeClassifyTemplateVO();
            BeanUtils.copyProperties(templateVO,codeClassifyTemplateVO);
            //组合格式的不导入，
            // æžšä¸¾çš„提供序列的选择
            //时间全部统一为yyyy-MM-dd HH:mm:ss
            //参照的自行输入名称
            //分类注入的不用，都是导入后自动处理的
            //编码，状态等字段不导入
            List<CodeClassifyTemplateAttrVO> templateAttrVOS = codeClassifyTemplateVO.getAttributes().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("模板没有配置任何【表单显示】为【是】的属性");
            }
            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();
            if(isHistory){
                excelDataList.add(new WriteExcelData(0,0,"分类路径"));
                excelDataList.add(new WriteExcelData(0,1,"码段宽度"));
                excelDataList.add(new WriteExcelData(0,2,!CollectionUtils.isEmpty(idAttrVOList)?idAttrVOList.get(0).getName():"企业编码"));
            }
            for (int i = 0; i < templateAttrVOS.size(); i++) {
                CodeClassifyTemplateAttrVO attrVO = templateAttrVOS.get(i);

                Object text = attrVO.getName();
                text = exportKeyAndRequired(workbook,attrVO,text);
                int colIndex = (isHistory?3:0) + i;
                WriteExcelData excelData = new WriteExcelData(0, colIndex, text);
                if(StringUtils.isNotBlank(attrVO.getCodeDateFormat())
                    || VciFieldTypeEnum.VTDateTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())
                    || VciFieldTypeEnum.VTDate.name().equalsIgnoreCase(attrVO.getAttributeDataType())
                    ||VciFieldTypeEnum.VTTime.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
                    excelData.setDateFormat(VciDateUtil.DateTimeFormat);
                }
                if(text instanceof RichTextString){
                    excelData.setFontColor(String.valueOf(HSSFColor.HSSFColorPredefined.RED.getIndex()));
                }
                excelDataList.add(excelData);
                if(StringUtils.isNotBlank(attrVO.getEnumString()) || StringUtils.isNotBlank(attrVO.getEnumId())){
                    //添加数据有效性
                    List<String> enumValueList = new ArrayList<>();
                    enumValueList.add("");
                    List<KeyValue> valueList = engineService.listComboboxItems(attrVO);
                    if(!CollectionUtils.isEmpty(valueList)){
                        valueList.stream().forEach(kv->{
                            enumValueList.add(kv.getValue());
                        });
                    }
                    //默认加1万条
                    WriteExcelData ed = new WriteExcelData(1,colIndex,"");
                    ed.setRowTo(100);
                    ed.setColTo(colIndex);
                    ed.setValidation(true);
                    ed.setValidationDataList(enumValueList);
                    ed.setValidationErrorMsg("请在序列中选择正确的值");
                    excelDataList.add(ed);
                }
                if(VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributeDataType())){
                    List<String> booleanList = new ArrayList<>();

                    booleanList.add("是");
                    booleanList.add("否");
                    //默认加1万条
                    WriteExcelData ed = new WriteExcelData(1,colIndex,"");
                    ed.setRowTo(100);
                    ed.setColTo(colIndex);
                    ed.setValidation(true);
                    ed.setValidationDataList(booleanList);
                    ed.setValidationErrorMsg("请在序列中选择正确的值");
                    excelDataList.add(ed);
                }
            }
            eo.addSheetDataList(j+templateVO.getName(),excelDataList);
            tempEDList.add(new WriteExcelData(j+1,0,templateVO.getOid()));
            tempEDList.add(new WriteExcelData(j+1,1,templateVO.getId()));
            tempEDList.add(new WriteExcelData(j+1,2,templateVO.getName()));
        }
        String excelName = LocalFileUtil.getDefaultTempFolder() + File.separator + codeClassifyVO.getName() + (isHistory?"_历史数据导入模板.xls": "_导入模板.xls");
        eo.addSheetDataList(templateVOList.size()+"模板信息【请勿删除或移动】",tempEDList);
        ExcelUtil.writeDataToFile(excelName,eo);
        return excelName;
    }

    /**
     * å¯¼å‡ºçš„时候封装必输和关键属性
     * @param attrVO å±žæ€§çš„显示对象
     * @param text å•å…ƒæ ¼çš„值
     */
    private Object exportKeyAndRequired(Workbook workbook,CodeClassifyTemplateAttrVO attrVO,Object text){
        //必输加*，关键属性为蓝色
        if (VciBaseUtil.getBoolean(attrVO.getRequireFlag()) || VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())) {
            String value = text.toString();
            if(VciBaseUtil.getBoolean(attrVO.getRequireFlag())) {
                value += REQUIRED_CHAR;
            }
            if(VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())){
                value += KEY_ATTR_CHAR;
            }
            RichTextString ts = new HSSFRichTextString(value);
            if(VciBaseUtil.getBoolean(attrVO.getRequireFlag())){
                Font font =  workbook.createFont();
                font.setColor(HSSFColor.HSSFColorPredefined.RED.getIndex());
                ts.applyFont(font);
            }

            if(VciBaseUtil.getBoolean(attrVO.getKeyAttrFlag())){
                Font font =  workbook.createFont();
                font.setColor(HSSFColor.HSSFColorPredefined.BLUE.getIndex());
                ts.applyFont(font);
            }
            return ts;
        }
        return text;
    }


    /**
     * æ‰¹é‡ç”³è¯·ç¼–码数据
     *
     * @param orderDTO ç¼–码申请信息，必须包含分类主键和码段的信息
     * @param file     excel文件的信息
     * @return  æœ‰é”™è¯¯ä¿¡æ¯çš„excel的文件
     */
    @Override
    public CodeImProtRusultVO batchImportCode(CodeOrderDTO orderDTO, File file) {
        VciBaseUtil.alertNotNull(orderDTO,"编码申请相关的数据",orderDTO.getCodeClassifyOid(),"主题库分类主键");
        ReadExcelOption reo = new ReadExcelOption();
        reo.setReadAllSheet(true);
        List<SheetDataSet> sheetDataSetList = ExcelUtil.readDataObjectFromExcel(file,null,reo);
        if(CollectionUtils.isEmpty(sheetDataSetList) || CollectionUtils.isEmpty(sheetDataSetList.get(0).getRowData())
            ||sheetDataSetList.get(0).getRowData().size()<1){
            throw new VciBaseException("没有读取到任何的数据");
        }
        if(sheetDataSetList.size()>LIMIT+1){
            throw new VciBaseException("为了保证系统的稳定性，请一次不要导入超过1万条的数据");
        }
        //先找到每一行的标题，然后根据标题来获取对应的属性
        SheetDataSet dataSet = sheetDataSetList.get(0);
        //找第一行，为了找标题
        CodeClassifyTemplateVO templateVO = engineService.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid());

        //校验模板是不是最新的
        checkTemplateSync(sheetDataSetList,templateVO,0);
        //先不用管属性是否都存在，先转换一下数据
        Map<String,String> errorMap = new HashMap<>();
        String redisUUid=batchImportCodes(orderDTO,templateVO,dataSet,errorMap,true);
        CodeImProtRusultVO codeImProtRusultVO = new CodeImProtRusultVO();
        List<String> needRowIndexList = new ArrayList<>();
//        String filePath = returnErrorToExcel(dataSet.getRowData(), errorMap, needRowIndexList, dataSet.getColName());
//        if(StringUtils.isNotBlank(filePath)) {
//            codeImProtRusultVO.setFilePath(filePath);
//        }
//        if(StringUtils.isNotBlank(redisUUid)){
//            codeImProtRusultVO.setRedisUuid(redisUUid);
//        }
        return null;
//        return codeImProtRusultVO;
    }

    /**
     * æ ¡éªŒæ¨¡æ¿æ˜¯å¦ä¸ºåŒæ­¥çš„
     * @param sheetDataSetList excel里的内容
     * @param templateVO æ¨¡æ¿çš„信息
     */
    private void checkTemplateSync(List<SheetDataSet> sheetDataSetList,CodeClassifyTemplateVO templateVO,int i){
        String templateOidInExcel = "";
        String templateName="";
        if(!CollectionUtils.isEmpty(sheetDataSetList)
            && sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
            List<SheetRowData>  rowData=  sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
            templateName=rowData.get(i).getData().get(2);
            templateOidInExcel=rowData.get(i).getData().get(0);
            //templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
        }
       /* if(!CollectionUtils.isEmpty(sheetDataSetList)
                && sheetDataSetList.size()>1 && !CollectionUtils.isEmpty(sheetDataSetList.get(sheetDataSetList.size()-1).getColName())){
            List<SheetRowData>  rowData=  sheetDataSetList.get(sheetDataSetList.size()-1).getRowData();
            templateOidInExcel=rowData.get(i).getData().get(0);
           //templateOidInExcel = sheetDataSetList.get(sheetDataSetList.size()-1).getColName().get(sheetDataSetList.size()-i);
        }*/
        if(StringUtils.isBlank(templateOidInExcel) || !templateOidInExcel.equalsIgnoreCase(templateVO.getOid())){
            throw new VciBaseException("模板【"+templateName+"】中的数据获取的模版信息与当前模板不匹配，请确保excel文件里有【模板信息-请勿移动或删除】的工作表，且确保每次导入都是先下载的导入模板后添加的数据");
        }

    }


    /***
     * æ‰¹é‡å¤„理申请数据
     * @param orderDTO
     * @param templateVO
     * @param dataSet
     * @return
     */
    private String batchImportCodes(CodeOrderDTO orderDTO,CodeClassifyTemplateVO templateVO,SheetDataSet dataSet,Map<String,String> errorMap,boolean isEnumType){
        List<String> codeList=new ArrayList<>();
//        CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
        //规则的主键需要去获取
//        CodeRuleVO ruleVO = engineService.getCodeRuleByClassifyFullInfo(classifyFullInfo);
//        //1.判断规则中除了流水码段，是否有其他码段
//        engineService.checkSecValueOnOrder(ruleVO,orderDTO);
//        List<SheetRowData> rowDataList = dataSet.getRowData();
//
//        //除去默认的属性.还有只有表单显示的字段才导入
//        List<CodeClassifyTemplateAttrVO> attrVOS = templateVO.getAttributes().stream().filter(s ->
//            !DEFAULT_ATTR_LIST.contains(s.getId()) && VciBaseUtil.getBoolean(s.getFormdisplayflag())
//        ).collect(Collectors.toList());
//        Map<Integer/**列号**/,String/**字段的名称**/> fieldIndexMap = new HashMap<>();
//        List<String> titleRowData = dataSet.getColName();
//        Map<String/**中文名称**/, String/**英文名称**/> attrNameIdMap = attrVOS.stream().collect(Collectors.toMap(s -> s.getName(), t -> t.getId().toLowerCase(Locale.ROOT),(o1, o2)->o2));
//        getFieldIndexMap(titleRowData,attrNameIdMap,fieldIndexMap);
//
//        //需要判断是否所有的属性都在模板上了
//        List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
//            && StringUtils.isBlank(s.getComponentrule()) && StringUtils.isBlank(s.getClassifyinvokeattr())//组合规则和分类注入确实没给用户导出去
//        ).collect(Collectors.toList());
//        if(!CollectionUtils.isEmpty(unExistAttrVOs)){
//            throw new VciBaseException("【" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "】这些属性在列表中没有找到");
//        }
//        List<ClientBusinessObject> cboList = new ArrayList<>();
//        String fullPath = getFullPath(classifyFullInfo);
//        excelToCbo(classifyFullInfo,fieldIndexMap,rowDataList,templateVO,cboList,fullPath,true);
//
//        //都转换完了。需要批量检查
//        //如果出错了，我们依然执行有效的数据，无效的数据写回到excel中
//        //2.判断必输项。。需要全部的属性，如果是必输，但是表单里面不显示的，只能是分类注入或者组合规则
//        batchCheckRequiredAttrOnOrder(templateVO,cboList,errorMap);
//        //3.判断关键属性
//        CodeImportResultVO keyResultVO = batchCheckKeyAttrOnOrder(classifyFullInfo, templateVO, cboList);
//        Set<String> selfRepeatRowIndexList = keyResultVO.getSelfRepeatRowIndexList();
//        Set<String> keyAttrRepeatRowIndexList = keyResultVO.getKeyAttrRepeatRowIndexList();
//        if(!CollectionUtils.isEmpty(selfRepeatRowIndexList)){
//            selfRepeatRowIndexList.stream().forEach(rowIndex->{
//                errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";在当前处理的数据文件中关键属性重复" );
//            });
//        }
//        if(!CollectionUtils.isEmpty(keyAttrRepeatRowIndexList)){
//            keyAttrRepeatRowIndexList.stream().forEach(rowIndex->{
//                errorMap.put(rowIndex,errorMap.getOrDefault(rowIndex,"") + ";关键属性与系统中的重复" );
//            });
//        }
//        //分类注入
//        batchSwitchClassifyAttrOnOrder(attrVOS,cboList,classifyFullInfo,false);
//        //boolean
//        reSwitchBooleanAttrOnOrder(attrVOS,cboList);
//        //4.校验规则
//        batchCheckVerifyOnOrder(attrVOS, cboList,errorMap);
//        if(isEnumType) {//是否需要校验枚举/参照
//            //5.校验枚举是否正确
//            batchSwitchEnumAttrOnOrder(attrVOS, cboList, errorMap);
//            //7.处理参照的情况
//            batchSwitchReferAttrOnOrder(attrVOS,cboList,errorMap);
//        }
//        //6.时间格式的验证
//        //6.时间的，必须统一为yyyy-MM-dd HH:mm:ss
//        batchSwitchDateAttrOnOrder(attrVOS,cboList,errorMap);
//        //最后弄组合规则
//        batchSwitchComponentAttrOnOrder(attrVOS,cboList);
//        String uuid=redisService.getUUIDEveryDay();
//        Map<String, ClientBusinessObject> rowIndexCboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getAttributeValue((IMPORT_ROW_INDEX)), t -> t));
//
//        if(errorMap.size()>0) {
//            createRedisDatas(uuid + "-error",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, errorMap,false);
//        }
//        boolean isCreateUUid=false;
//        List<ClientBusinessObject> needSaveCboList = cboList.stream().filter(cbo -> {
//            String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
//            return !errorMap.containsKey(rowIndex);
//        }).collect(Collectors.toList());
//        //相似校验
//        Map<String,String>resembleMap=new HashMap<>();
//        List<DataResembleVO> dataResembleVOS=new ArrayList<>();
//        String btmtypeid= classifyFullInfo.getTopClassifyVO().getBtmtypeid();
//        bathcResembleQuery(orderDTO.getCodeClassifyOid(),templateVO,needSaveCboList,resembleMap,btmtypeid,dataResembleVOS);
//        if(resembleMap.size()>0) {
//            isCreateUUid=true;
//            if(!CollectionUtils.isEmpty(dataResembleVOS)) {
//                redisService.setCacheList(uuid + "-resemble-data", dataResembleVOS);
//                createRedisDatas(uuid + "-resemble",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, resembleMap, false);
//            }
//        }
//        //排除错误的，剩下正确的
//        Map<String,String> newErrorMap=new HashMap<>();
//        newErrorMap.putAll(resembleMap);
//        newErrorMap.putAll(errorMap);
//        needSaveCboList = cboList.stream().filter(cbo -> {
//            String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
//            return !newErrorMap.containsKey(rowIndex);
//        }).collect(Collectors.toList());
//        if((errorMap.size()>0&&needSaveCboList.size()>0)||resembleMap.size()>0){
//            isCreateUUid=true;
//        }
//        createRedisByCodeClassify(uuid + "-class",templateVO,dataSet,fieldIndexMap,false);
//        if(newErrorMap.size()>0) {
//            createRedisDatas(uuid + "-ok",templateVO, rowIndexCboMap, dataSet, fieldIndexMap, newErrorMap,true);
//        }else {
//            uuid="";
//            //要把以上的错误的都抛出后，再继续处理时间和组合规则
//            needSaveCboList = cboList.stream().filter(cbo -> {
//                String rowIndex = cbo.getAttributeValue(IMPORT_ROW_INDEX);
//                return !newErrorMap.containsKey(rowIndex);
//            }).collect(Collectors.toList());
//            if (!CollectionUtils.isEmpty(needSaveCboList)) {
//                //9.我们处理业务数据
//                //生成编码的内容
//                codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), needSaveCboList);
//                //如果是编码生成失败，则直接就失败了，其他的判断出来有错误的我们都统一返回到excel里面
//                engineService.batchSaveSelectChar(templateVO, needSaveCboList);
//            }
//        }
//        if(!isCreateUUid){
//            return uuid="";
//        }
//        return uuid;
        return null;
    }

    @Override
    public List<CodeImportTemplateVO> gridclassifys(String redisOid) {
        List<CodeImportTemplateVO> codeImportTemplateVOs=new ArrayList<>();
        VciBaseUtil.alertNotNull(redisOid,"分类",redisOid,"分类缓存主键");

        List<CodeImportTemplateVO> redisServiceCacheObjects=bladeRedis.lRange(redisOid,0,-1);
        if(redisServiceCacheObjects!=null){
            codeImportTemplateVOs=  redisServiceCacheObjects;
        }
        return codeImportTemplateVOs;
    }

    /***
     * ä»Žç¼“存里获取到需要导入的相关数据
     * @param codeClssifyOid
     * @param redisOid
     * @return
     */
    @Override
    public DataGrid<Map<String, String>> gridDatas(String codeClssifyOid, String redisOid) {
        VciBaseUtil.alertNotNull(redisOid,"导入相似数据",redisOid,"数据缓存主键");
        List<CodeImprotDataVO> codeImprotDataVOs = bladeRedis.lRange(redisOid+"-"+codeClssifyOid,0,-1);
//        redisService.getCacheList(redisOid+"-"+codeClssifyOid);
        CodeImprotDataVO codeImprotDataVO=new CodeImprotDataVO();
        if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
            if(StringUtils.isNotBlank(codeClssifyOid)){
                Map<String/**分类名称**/, CodeImprotDataVO/**英文名称**/> codeClassifyDatasMap = codeImprotDataVOs.stream().collect(Collectors.toMap(s -> s.getCodeClassifyOid(), t -> t,(o1, o2)->o2));
                if(codeClassifyDatasMap.containsKey(codeClssifyOid)){
                    codeImprotDataVO= codeClassifyDatasMap.get(codeClssifyOid);
                }else{
                    codeImprotDataVO=  codeImprotDataVOs.get(0);
                }
            }
        }
        DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
        List<Map<String, String>> dataList = new ArrayList<>();
        if(codeImprotDataVO!=null){
            dataList= codeImprotDataVO.getDatas();
        }
        dataGrid.setData(dataList);
        if (!CollectionUtils.isEmpty(dataList)) {
            dataGrid.setTotal(dataList.size());
        }
        return dataGrid;
    }

    /**
     *
     * @param oid
     * @param redisOid
     * @return
     */
    @Override
    public DataGrid<Map<String,String>> gridRowResemble(String oid,String redisOid){
        VciBaseUtil.alertNotNull(redisOid,"导入相似数据",redisOid,"数据缓存主键");
        List<DataResembleVO> codeImprotDataVOs = bladeRedis.lRange(redisOid,0,-1);;
        DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
        List<Map<String, String>> dataList = new ArrayList<>();

        if(!CollectionUtils.isEmpty(codeImprotDataVOs)){
            Map<String/**分类名称**/, DataResembleVO/**数据对象**/> rowResembleDataMap = codeImprotDataVOs.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t,(o1, o2)->o2));
            if(rowResembleDataMap.containsKey(oid)){
                DataResembleVO dataResembleVO=  rowResembleDataMap.get(oid);
                dataList= dataResembleVO.getDataList();
            }
        }

        dataGrid.setData(dataList);
        if (!CollectionUtils.isEmpty(dataList)) {
            dataGrid.setTotal(dataList.size());
        }
        return dataGrid;
    }

    /**
     * é›†æˆæ‰¹é‡ç”³è¯·æ•°æ®
@@ -83,7 +536,7 @@

        //需要判断是否所有的属性都在模板上了
        List<CodeClassifyTemplateAttrVO> unExistAttrVOs = attrVOS.stream().filter(s -> !fieldIndexMap.containsValue(s.getId().toLowerCase(Locale.ROOT))
            && StringUtils.isBlank(s.getComponentRule()) && StringUtils.isBlank(s.getClassifyInvokeAttr())//组合规则和分类注入确实没给用户导出去
            && com.alibaba.cloud.commons.lang.StringUtils.isBlank(s.getComponentRule()) && com.alibaba.cloud.commons.lang.StringUtils.isBlank(s.getClassifyInvokeAttr())//组合规则和分类注入确实没给用户导出去
        ).collect(Collectors.toList());
        if(!CollectionUtils.isEmpty(unExistAttrVOs)){
            throw new VciBaseException("【" + unExistAttrVOs.stream().map(CodeClassifyTemplateAttrVO::getName) + "】这些属性在excel中没有找到");
@@ -139,16 +592,16 @@
            String title = titleRowData.get(i);
            String id = attrNameIdMap.getOrDefault(title.replace(KEY_ATTR_CHAR,"").replace(REQUIRED_CHAR
                ,""),"");
            if(StringUtils.isBlank(id) && "分类路径".equalsIgnoreCase(title)){
            if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "分类路径".equalsIgnoreCase(title)){
                id = CODE_CLASSIFY_OID_FIELD;
            }
            if(StringUtils.isBlank(id) && "码段宽度".equalsIgnoreCase(title)){
            if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "码段宽度".equalsIgnoreCase(title)){
                id = CODE_SEC_LENGTH_FIELD;
            }
            if(StringUtils.isBlank(id) && "企业编码".equalsIgnoreCase(title)){
            if(com.alibaba.cloud.commons.lang.StringUtils.isBlank(id) && "企业编码".equalsIgnoreCase(title)){
                id = CODE_FIELD;
            }
            if(StringUtils.isNotBlank(id)){
            if(com.alibaba.cloud.commons.lang.StringUtils.isNotBlank(id)){
                fieldIndexMap.put(i,id);
            }
        }

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

@@ -11,6 +11,7 @@
import com.vci.ubcs.code.enumpack.CodeGetValueTypeEnum;
import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
import com.vci.ubcs.code.lifecycle.CodeAllCodeLC;
import com.vci.ubcs.code.mapper.CodeSerialValueMapper;
import com.vci.ubcs.code.service.ICodeWupinService;
import com.vci.ubcs.code.service.MdmProductCodeService;
@@ -29,6 +30,7 @@

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

import static com.vci.ubcs.code.constant.MdmEngineConstant.*;
@@ -702,4 +704,42 @@
        return value;

    }

    /**
     * å›žæ”¶ç å€¼
     *
     * @param btmId                 ä¸šåŠ¡æ•°æ®çš„业务类型
     * @param businessOidCollection ä¸šåŠ¡æ•°æ®çš„主键
     * @return æ˜¯å¦æ›´æ–°æˆåŠŸ
     */
    @Override
    public Boolean recycleCode(String btmId, Collection<String> businessOidCollection) {
//        boolean oldPersistence =  WebUtil.isPersistence();
//        WebUtil.setPersistence(false);
//        BatchCBO batchCBO = new BatchCBO();
        AtomicReference<Boolean> updateFlag = new AtomicReference<>(false);
        VciBaseUtil.switchCollectionForOracleIn(businessOidCollection).stream().forEach(oids-> {
//            Map<String, String> conditionMap = new HashMap<>();
//            //编码要记录为回收的状态
//            conditionMap.put("createcodeoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
//            conditionMap.put("createcodebtm", btmId);

            QueryWrapper<CodeAllCode> wrapper = new QueryWrapper<>();
            wrapper.in("createcodeoid",QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
            wrapper.eq("createcodebtm", btmId);


            List<CodeAllCode> allCodeDOS = codeAllCodeService.selectByWrapper(wrapper);
//            allCodeMapper.selectByCondition(conditionMap, new PageHelper(-1));
            if (!CollectionUtils.isEmpty(allCodeDOS)) {
                allCodeDOS.stream().forEach(codeDO->{
                    codeDO.setLcStatus(CodeAllCodeLC.TASK_BACK.getValue());
                });
                updateFlag.set(codeAllCodeService.updateBatchById(allCodeDOS));
//                batchCBO.copyFromOther(allCodeMapper.batchUpdate(allCodeDOS));
            }
        });
//        WebUtil.setPersistence(oldPersistence);
        return updateFlag.get();
    }
}

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

@@ -16,16 +16,12 @@
 */
package com.vci.ubcs.code.wrapper;

import com.vci.ubcs.starter.web.util.BeanUtilForVCI;
import com.vci.ubcs.system.cache.DictCache;
import com.vci.ubcs.code.entity.CodeButton;
import com.vci.ubcs.code.vo.pagemodel.CodeButtonVO;
import org.springblade.core.mp.support.BaseEntityWrapper;
import org.springblade.core.redis.cache.BladeRedis;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.Func;
import org.springframework.boot.autoconfigure.security.SecurityProperties;

import java.util.List;
import java.util.Objects;

/**
@@ -42,7 +38,9 @@

    @Override
    public CodeButtonVO entityVO(CodeButton codebutton) {
        CodeButtonVO codebuttonVO = Objects.requireNonNull(BeanUtil.copy(codebutton, CodeButtonVO.class));
        CodeButtonVO codebuttonVO = new CodeButtonVO();;
        BeanUtilForVCI.copyPropertiesIgnoreCase(codebutton,codebuttonVO);
        Objects.requireNonNull(codebuttonVO);
        codebuttonVO.setUsedpositiontypeText(DictCache.getValue("codeButtonPosition", codebutton.getUsedPositionType()));
        codebuttonVO.setLcStatusText(DictCache.getValue("codeLcstatus", codebutton.getLcStatus()));
        return codebuttonVO;