From d1e3a87aad6f737394b33852d9496d673472ddbe Mon Sep 17 00:00:00 2001
From: yuxc <653031404@qq.com>
Date: 星期二, 16 五月 2023 18:19:17 +0800
Subject: [PATCH] 主要完成修改Class统一命名，与老平台命名一致，删除多余VOClass等。
---
Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmEngineServiceImpl.java | 4553 +++++++++++++++++++++++------------------------------------
1 files changed, 1,814 insertions(+), 2,739 deletions(-)
diff --git a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmEngineServiceImpl.java b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmEngineServiceImpl.java
index e6d4281..83a94ca 100644
--- a/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmEngineServiceImpl.java
+++ b/Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmEngineServiceImpl.java
@@ -1,63 +1,10 @@
package com.vci.ubcs.code.service.impl;
-import com.alibaba.fastjson.JSONObject;
-import com.vci.ubcs.code.constant.MdmBtmTypeConstant;
-import com.vci.ubcs.code.constant.MdmEngineConstant;
-import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum;
-import com.vci.ubcs.code.enumpack.CodeSecTypeEnum;
-import com.vci.ubcs.code.enumpack.CodeUseButtonPositionTypeEnum;
-import com.vci.ubcs.code.lifecycle.CodeDefaultLC;
-import com.vci.ubcs.code.entity.CodeClassifyTemplateAttrDO;
-import com.vci.ubcs.code.entity.CodeClassifyTemplateDO;
-import com.vci.ubcs.code.utils.DateUtils;
-import com.vci.corba.common.VCIError;
-import com.vci.frameworkcore.compatibility.SmUserQueryServiceI;
-import com.vci.frameworkcore.constant.FrameWorkDefaultValueConstant;
-import com.vci.frameworkcore.lcstatuspck.FrameworkDataLCStatus;
-import com.vci.frameworkcore.pagemodel.SmUserVO;
-import com.vci.starter.revision.bo.TreeWrapperOptions;
-import com.vci.starter.revision.service.RevisionModelUtil;
-import com.vci.starter.web.constant.QueryOptionConstant;
-import com.vci.starter.web.constant.RegExpConstant;
-import com.vci.starter.web.enumpck.BooleanEnum;
-import com.vci.starter.web.enumpck.UserSecretEnum;
-import com.vci.starter.web.enumpck.VciFieldTypeEnum;
-import com.vci.starter.web.exception.VciBaseException;
-import com.vci.starter.web.pagemodel.*;
-import com.vci.starter.web.toolmodel.DateConverter;
-import com.vci.starter.web.util.VciBaseUtil;
-import com.vci.starter.web.util.VciDateUtil;
-import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.vci.ubcs.code.entity.CodeAllCode;
+import com.vci.ubcs.code.mapper.CodeAllCodeMapper;
import com.vci.ubcs.code.service.*;
-import com.vci.ubcs.code.vo.pagemodel.*;
-import com.vci.web.dto.BaseModelDTO;
-import com.vci.web.pageModel.KeyValue;
-import com.vci.web.pageModel.*;
-import com.vci.web.service.*;
-import com.vci.web.service.impl.FormulaServiceImpl;
-import com.vci.web.service.impl.OsEnumServiceImpl;
-import com.vci.web.util.WebUtil;
-import org.apache.commons.lang.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO;
-import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO;
-import com.vci.ubcs.code.dto.CodeDeleteBatchDTO;
-import com.vci.ubcs.code.dto.CodeOrderDTO;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import plm.bs.bom.clientobject.ClientBusinessObject;
-import plm.bs.bom.clientobject.ClientBusinessObjectOperation;
-
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.stream.Collectors;
-
-import static com.vci.frameworkcore.constant.FrameWorkBusLangCodeConstant.DATA_OID_NOT_EXIST;
-import static com.vci.web.constant.EnumIdConstant.LC_STATUS_SUBFIX;
/**
* 涓绘暟鎹紩鎿庢湇鍔�
@@ -66,2690 +13,1818 @@
* @date 2022-2-22
*/
@Service
-public class MdmEngineServiceImpl implements MdmEngineServiceI {
+public class MdmEngineServiceImpl extends ServiceImpl<CodeAllCodeMapper, CodeAllCode> implements MdmEngineService {
- /**
- * 蹇呰緭
- */
- public static final String REQUIRED_CHAR = "*";
- /**
- * 鏇挎崲瀛楃
- */
- public static final String SPECIAL_CHAR = "VCI";
- /**
- * 妯℃澘鐨勬湇鍔�
- */
- @Autowired
- private CodeClassifyTemplateServiceI templateService;
- /**
- * 妯℃澘鎸夐挳鏈嶅姟
- */
- @Autowired
- private CodeClassifyTemplateButtonServiceI templateButtonService;
-
- /**
- * 鍒嗙被鐨勬湇鍔�
- */
- @Autowired
- private CodeClassifyServiceI classifyService;
-
- /**
- * 涓氬姟鏁版嵁鐨勬湇鍔�
- */
- @Autowired
- @Lazy
- private WebBoServiceI boService;
-
- /**
- * 鍏紡鐨勬湇鍔�
- */
- @Autowired
- private FormulaServiceImpl formulaService;
-
- /**
- * 鏋氫妇鐨勬湇鍔�
- */
- @Autowired
- private OsEnumServiceI enumService;
-
- /**
- * 鐢熷懡鍛ㄦ湡鐨勬湇鍔�
- */
- @Autowired
- private OsLifeCycleServiceI lifeCycleService;
-
- /**
- * 缂栫爜瑙勫垯鐨勬湇鍔�
- */
- @Autowired
- private CodeRuleServiceI ruleService;
-
- /**
- * 鍒嗙被鐮佸�肩殑鏈嶅姟
- */
- @Autowired
- private CodeClassifyValueServiceI classifyValueService;
-
- /**
- * 鍏抽敭灞炴�х殑閰嶇疆
- */
- @Autowired
- private CodeKeyAttrRepeatRuleServiceI keyRuleService;
-
-
- /**
- * 鍔熻兘鎸夐挳鐨勬湇鍔�
- */
- @Autowired
- private SmOperationServiceI operationService;
-
- /**
- * 鐢熸垚缂栫爜鐨勬湇鍔�
- */
- @Autowired
- private MdmProductCodeServiceI productCodeService;
-
- /**
- * 闃舵鐨勬湇鍔�
- */
- @Autowired
- private CodePhaseAttrServiceI phaseAttrService;
-
- /**
- * 鏃ュ織
- */
- private Logger logger = LoggerFactory.getLogger(getClass());
-
- /**
- * 瀵嗙骇鐨勬湇鍔�
- */
- @Autowired
- private WebSecretServiceI secretService;
-
- /**
- * 鍙緭鍙��
- */
- @Autowired
- private BdSelectInputCharServiceI charService;
-
- /**
- * 瀵硅薄鐨勬搷浣�
- */
- @Autowired
- private RevisionModelUtil revisionModelUtil;
-
- /**
- * 鐩镐技椤规煡璇㈣鍒�
- */
- @Autowired
- private CodeResembleRuleServiceI resembleRuleService;
-
- /**
- * 灞炴�х殑鏈嶅姟
- */
- @Autowired
- private OsAttributeServiceI attributeService;
-
- /**
- * 鐢ㄦ埛鏌ヨ鐨勬湇鍔�
- */
- @Autowired(required = false)
- private SmUserQueryServiceI userQueryService;
-
- /**
- * 妯℃澘灞炴�х殑鏈嶅姟
- */
- @Autowired
- private CodeClassifyTemplateAttrServiceI templateAttrService;
-
- /**
- * 鎷疯礉鐨勭増鏈�
- */
- public static final String COPY_FROM_VERSION = "copyfromversion";
-
-
- /**
- * 浣跨敤鍒嗙被涓婚敭鑾峰彇椤甸潰鐨勫唴瀹癸紝鍖呭惈鎸夐挳
- *
- * @param codeClassifyOid 涓婚搴撳垎绫讳富閿�
- * @param functionId 鍔熻兘鐨勭紪鍙�
- * @return UI鐩稿叧鐨勫唴瀹�
- */
- @Override
- public MdmUIInfoVO getUIInfoByClassifyOid(String codeClassifyOid, String functionId) {
- VciBaseUtil.alertNotNull(codeClassifyOid, "涓婚搴撳垎绫讳富閿�");
- MdmUIInfoVO uiInfoVO = getTableDefineByTemplateVO(getUsedTemplateByClassifyOid(codeClassifyOid));
- uiInfoVO.setLeaf(classifyService.countChildrenByClassifyOid(codeClassifyOid) == 0);
- if (StringUtils.isNotBlank(functionId) && !"~".equalsIgnoreCase(functionId)) {
- List<SmOperationVO> operationVOS = operationService.listButtonByFunctionId(functionId);
- if (operationVOS == null) {
- operationVOS = new ArrayList<>();
- }
- //鏌ヨ鎵╁睍鎸夐挳
- List<CodeButtonVO> buttonVOS = listButtonInToolbarByClassifyOid(codeClassifyOid);
- if (!CollectionUtils.isEmpty(buttonVOS)) {
- for (int i = 0; i < buttonVOS.size(); i++) {
- CodeButtonVO buttonVO = buttonVOS.get(i);
- SmOperationVO operationVO = new SmOperationVO();
- operationVO.setModuleNo(functionId);
- operationVO.setUniqueFlag(buttonVO.getId());
- operationVO.setName(buttonVO.getName());
- operationVO.setAlias(operationVO.getName());
- operationVO.setExecuteJs(buttonVO.getExecutejs());
- operationVO.setIconCls(buttonVO.getIconcls());
- operationVOS.add(operationVO);
- }
- }
- uiInfoVO.setButtons(operationVOS);
- }
- return uiInfoVO;
- }
-
-
- /**
- * 浣跨敤涓婚搴撳垎绫昏幏鍙杣i鐩稿叧鐨勫唴瀹癸紙涓嶅寘鍚寜閽級
- *
- * @param codeClassifyOid 涓婚搴撶殑鍒嗙被鐨勪富閿�
- * @return UI鐩稿叧鐨勫唴瀹�
- */
- @Override
- public MdmUIInfoVO getTableDefineByClassifyOid(String codeClassifyOid) {
- VciBaseUtil.alertNotNull(codeClassifyOid, "涓婚搴撳垎绫讳富閿�");
- return getTableDefineByTemplateVO(getUsedTemplateByClassifyOid(codeClassifyOid));
- }
-
- /**
- * 浣跨敤妯℃澘鏄剧ず瀵硅薄杞崲涓鸿〃鏍肩殑淇℃伅锛堝寘鍚墿灞曠殑鎸夐挳锛�
- *
- * @param templateVO 妯℃澘鐨勪俊鎭�
- * @return UI鐩稿叧鐨勫唴瀹癸紙浠呭寘鍚〃鏍间俊鎭級
- */
- private MdmUIInfoVO getTableDefineByTemplateVO(CodeClassifyTemplateVO templateVO) {
- //鍏堢湅杩欎釜鍒嗙被鏈韩鏄惁鏈夋ā鏉�
- MdmUIInfoVO uiInfoVO = new MdmUIInfoVO();
- uiInfoVO.setTemplateVO(templateVO);
- //鎴戜滑闇�瑕佸皢妯℃澘杞崲涓鸿〃鏍肩浉鍏崇殑鏄剧ず淇℃伅
- uiInfoVO.setTableDefineVO(wrapperTableDefineByTemplate(uiInfoVO.getTemplateVO(),false));
- //闇�瑕佸幓鐪嬫墿灞曠殑鎸夐挳,鍙湁鍒楄〃閲岄潰鏈韩鎵嶆坊鍔犺繘鍘伙紝宸ュ叿鏍忎笂鐨勫崟鐙幏鍙�
- List<CodeClassifyTemplateButtonVO> buttonVOS = templateButtonService.listButtonByTemplateOid(templateVO.getOid(), true);
- if (!CollectionUtils.isEmpty(buttonVOS)) {
- //鎴戜滑瑕佸垎寮�涓烘寜閽紝杩樻槸鍦ㄦ搷浣滃垪閲岄潰
- List<CodeClassifyTemplateButtonVO> tableButtonVOs = buttonVOS.stream().filter(s -> CodeUseButtonPositionTypeEnum.TABLE.getValue().equalsIgnoreCase(s.getButtonuse())).collect(Collectors.toList());
- if (!CollectionUtils.isEmpty(tableButtonVOs)) {
- UITableFieldVO optionFieldVO = new UITableFieldVO();
- optionFieldVO.setField("options");
- optionFieldVO.setTitle("鎿嶄綔");
- optionFieldVO.setFieldType("text");
- optionFieldVO.setOptionField(true);
- List<KeyValue> buttons = new ArrayList<>();
- Map<String, String> optionJsMap = new HashMap<>();
- tableButtonVOs.stream().forEach(buttonVO -> {
- KeyValue kv = new KeyValue();
- kv.setKey(buttonVO.getId());
- kv.setValue(buttonVO.getClassifybuttonoidName());
- kv.setAttributes(VciBaseUtil.objectToMap(buttonVO));
- buttons.add(kv);
- optionJsMap.put(buttonVO.getId(), buttonVO.getButtonVO().getExecutejs());
- });
- optionFieldVO.setOptionJsMap(optionJsMap);
- uiInfoVO.getTableDefineVO().getCols().get(0).add(optionFieldVO);
- }
- }
- return uiInfoVO;
- }
-
- /**
- * 浣跨敤鍒嗙被鐨勪富閿幏鍙栧彲浠ヤ娇鐢ㄧ殑妯℃澘瀵硅薄
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @return 妯℃澘鐨勬樉绀哄璞�
- */
- @Override
- public CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid) {
- return getUsedTemplateByClassifyOid(codeClassifyOid, true);
- }
-
- /**
- * 浣跨敤鍒嗙被鐨勪富閿幏鍙栧彲浠ヤ娇鐢ㄧ殑妯℃澘瀵硅薄
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @param hasAttr 鍖呭惈灞炴��
- * @return 妯℃澘鐨勬樉绀哄璞�
- */
- @Override
- public CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr) {
- List<CodeClassifyTemplateVO> templateVOs = templateService.listReleaseTemplateByClassifyOid(codeClassifyOid, hasAttr);
- return templateVOs.get(templateVOs.size() - 1);
- }
-
- /**
- * 浣跨敤妯℃澘鐨勪富閿幏鍙栬〃鍗曠殑淇℃伅
- *
- * @param codeClassifyTemplateOid 妯℃澘鐨勪富閿�
- * @return ui鐩稿叧鐨勫唴瀹�
- */
- @Override
- public MdmUIInfoVO getFormDefineByTemplateOid(String codeClassifyTemplateOid) {
- return getFormDefineByTemplateOid(codeClassifyTemplateOid, null);
- }
-
- /**
- * 浣跨敤妯℃澘鐨勪富閿幏鍙栬〃鍗曠殑淇℃伅
- *
- * @param codeClassifyTemplateOid 妯℃澘鐨勪富閿�
- * @param codeClassifyOid 浣跨敤妯℃澘鐨勫垎绫讳富閿�
- * @return ui鐩稿叧鐨勫唴瀹�
- */
- @Override
- public MdmUIInfoVO getFormDefineByTemplateOid(String codeClassifyTemplateOid, String codeClassifyOid) {
- CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(codeClassifyTemplateOid);
- MdmUIInfoVO uiInfoVO = new MdmUIInfoVO();
- uiInfoVO.setTemplateVO(templateVO);
- uiInfoVO.setFormDefineVO(wrapperFormDefineByTemplate(templateVO, codeClassifyOid));
- wrapperResemble(templateVO, uiInfoVO);
- return uiInfoVO;
- }
-
- /**
- * 灏佽鐩镐技椤规煡璇㈢殑鍒楄〃
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞�
- * @param uiInfoVO 椤甸潰鐨勪俊鎭�
- */
- private void wrapperResemble(CodeClassifyTemplateVO templateVO, MdmUIInfoVO uiInfoVO) {
- List<CodeClassifyTemplateAttrVO> resembleAttrList = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())
- || VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).collect(Collectors.toList());
- if (!CollectionUtils.isEmpty(resembleAttrList) && resembleAttrList.size() > 1) {
- UITableDefineVO resembleTable = new UITableDefineVO();
- resembleTable.setOid(templateVO.getOid());
- resembleTable.setBtmType(templateVO.getBtmTypeId());
- resembleTable.setDisplayQueryArea(false);
- resembleTable.setPageVO(new UITablePageVO());
- //澶勭悊鎵�鏈夌殑鍒楋紝杩欎釜妯℃澘娌℃湁鍚堝苟鐨勮〃澶寸殑鎯呭喌
- List<UITableFieldVO> fieldVOList = new ArrayList<>();
- resembleAttrList.forEach(attrVO -> {
- UITableFieldVO tableFieldVO = templateAttr2TableField(attrVO,false);
- tableFieldVO.setHidden(false);
- fieldVOList.add(tableFieldVO);
- });
- List<List<UITableFieldVO>> cols = new ArrayList<>();
- cols.add(fieldVOList);
- resembleTable.setCols(cols);
- uiInfoVO.setResembleTableVO(resembleTable);
- }
- }
-
- /**
- * 浣跨敤妯℃澘鐨勪富閿幏鍙栬〃鍗曠殑淇℃伅
- *
- * @param templateOid 妯℃澘鐨勪富閿�
- * @param executionId 娴佺▼鎵цid
- * @param processUse 娴佺▼妯℃澘鐨勭敤閫�
- * @return ui鐩稿叧鐨勫唴瀹�
- */
- @Override
- public List<String> getFieldByProcessTemplate(String templateOid, String executionId, String processUse) {
- VciBaseUtil.alertNotNull(templateOid, "妯℃澘涓婚敭", executionId, "娴佺▼鐨勬墽琛孖d", processUse, "娴佺▼妯℃澘鐢ㄩ��");
- while (StringUtils.countMatches(executionId, ".") > 1) {
- executionId = executionId.substring(0, executionId.lastIndexOf("."));
- }
- String sql = "select distinct (t.codetempattrOidArr)\n" +
- "from " + VciBaseUtil.getTableName(MdmBtmTypeConstant.CODE_CLASSIFY_PROCESS_TEMPLATE) + " t\n" +
- "join PLFLOWINSTANCE plfi on t.ID = plfi.PLTEMPLATEPUID\n" +
- "where plfi.PLEXECUTIONID = '" + executionId + "' and t.CLASSIFYTEMPLATEOID = '" + templateOid + "' and t.CODEPROCESSUSE = '" + processUse + "'";
- List<ClientBusinessObject> tempAttrOidArr = boService.queryByOnlySql(sql);
- if (CollectionUtils.isEmpty(tempAttrOidArr) || StringUtils.isBlank(tempAttrOidArr.get(0).getAttributeValue("codetempattroidarr"))) {
- return new ArrayList<>();
- }
- return VciBaseUtil.str2List(tempAttrOidArr.get(0).getAttributeValue("codetempattroidarr"));
- }
-
- /**
- * 浣跨敤涓婚搴撳垎绫荤殑涓婚敭鑾峰彇琛ㄥ崟鐨勪俊鎭�
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @return ui鐩稿叧鐨勫唴瀹�
- */
- @Override
- public MdmUIInfoVO getFormDefineByClassifyOid(String codeClassifyOid) {
- MdmUIInfoVO uiInfoVO = new MdmUIInfoVO();
- CodeClassifyTemplateVO templateVO = getUsedTemplateByClassifyOid(codeClassifyOid);
- uiInfoVO.setTemplateVO(templateVO);
- uiInfoVO.setFormDefineVO(wrapperFormDefineByTemplate(templateVO, codeClassifyOid));
- wrapperResemble(templateVO, uiInfoVO);
- return uiInfoVO;
- }
-
- /**
- * 浣跨敤鍒嗙被鐨勪富閿幏鍙栬〃鏍肩殑瀹氫箟
- *
- * @param codeClassifyOid 鍒嗙被涓婚敭
- * @param phase 闃舵鐨勫悕绉�
- * @return UI鐩稿叧鐨勪俊鎭紙浠呭寘鍚〃鍗�)
- */
- @Override
- public MdmUIInfoVO getTableDefineByClassifyOid_v2(String codeClassifyOid, String phase) {
- MdmUIInfoVO uiInfoVO = new MdmUIInfoVO();
- CodeClassifyTemplateVO templateVO = getUsedTemplateByClassifyOid(codeClassifyOid);
- uiInfoVO.setTemplateVO(templateVO);
- UITableDefineVO uiTableDefineVO = wrapperTableDefineByTemplate(templateVO,true);
- List<String> phaseAttrIdList = listPhaseAttrByClassifyOid(codeClassifyOid, phase);
- uiTableDefineVO.getCols().stream().forEach(list -> {
- List<UITableFieldVO> visiableTableField=new ArrayList<>();
- if(StringUtils.isNotBlank(phase)) {
- visiableTableField = list.stream().filter(col ->
- phaseAttrIdList.stream().anyMatch(s -> StringUtils.equalsIgnoreCase(col.getField(), s) ||
- (StringUtils.equalsIgnoreCase(col.getFieldType(), "combox") && StringUtils.equalsIgnoreCase(col.getSortField(), s))
- || (StringUtils.equalsIgnoreCase(col.getFieldType(), "refer") && StringUtils.equalsIgnoreCase(col.getQueryField(), s))
- )).collect(Collectors.toList());
- }else{
- visiableTableField= list.stream().filter(col ->
- templateVO.getAttributes().stream().anyMatch(s ->
- (!s.getReadonlyflag().equalsIgnoreCase("true")&& StringUtils.equalsIgnoreCase(col.getField(), s.getId())) ||
- (StringUtils.equalsIgnoreCase(col.getFieldType(), "combox") && StringUtils.equalsIgnoreCase(col.getSortField(), s.getId()))
- || (StringUtils.equalsIgnoreCase(col.getFieldType(), "refer") && StringUtils.equalsIgnoreCase(col.getQueryField(), s.getId()))
- )).collect(Collectors.toList());
- }
-
- visiableTableField.stream().forEach(vo -> {
- uiTableDefineVO.setHasEditor(true);
- if ("refer".equalsIgnoreCase(vo.getFieldType())) {
- setReferConfig2EditConfig(vo);
- } else if ("combox".equalsIgnoreCase(vo.getFieldType())) {
- setComboxConfig2EditConfig(vo);
- } else if (StringUtils.isNotBlank(vo.getDateFormate())){
- vo.setEdit("date");
- }else {
- vo.setEdit(vo.getFieldType());
- }
- });
- });
- uiInfoVO.setTableDefineVO(uiTableDefineVO);
- wrapperResemble(templateVO, uiInfoVO);
- return uiInfoVO;
- }
-
- /**
- * 鍔犺浇鎴愬弬鐓х殑淇敼閰嶇疆
- * @param vo 琛ㄦ牸瀛楁鏄剧ず瀵硅薄
- */
- private void setReferConfig2EditConfig(UITableFieldVO vo) {
- if (!CollectionUtils.isEmpty(vo.getReferConfig().getWhere())){
- vo.getReferConfig().getWhere().keySet().forEach(key -> {
- vo.getReferConfig().getWhere().put(key, "'" + vo.getReferConfig().getWhere().get(key) + "'");
- });
- }
- if (StringUtils.isNotBlank(vo.getReferConfig().getParentValue())){
- String parentValue = vo.getReferConfig().getParentValue();
- parentValue ="\\" + parentValue.replaceAll("'","{vci-quote}").replaceAll("=","{vci-equals}");
- vo.getReferConfig().setParentValue(parentValue);
- }
- String referConfig = vo.getReferConfig().toString()
- .replaceAll("=",":")
- .replaceAll("UITableCustomDefineVO","")
- .replaceAll("UIFieldSortVO","")
- .replaceAll("UITablePageVO","")
- .replaceAll("UITableFieldVO","")
- .replaceAll("UIFormReferVO","")
- .replaceAll("\\{vci-equals}","=")
- .replaceAll("\\{vci-quote}","\\\\'")
- .replaceAll("'null'","null");
- referConfig = referConfig + ",fieldMap:{" + vo.getQueryField() + ":'" + vo.getReferConfig().getValueField() + "'}";
- vo.setEditConfig("{referConfig:" + referConfig + "}");
- vo.setEdit(vo.getFieldType());
- }
-
- /**
- * 鍔犺浇鎴愪笅鎷夋鐨勪慨鏀归厤缃�
- * @param vo 琛ㄦ牸瀛楁鏄剧ず瀵硅薄
- */
- private void setComboxConfig2EditConfig(UITableFieldVO vo) {
- vo.setEditConfig("{editable:true,comboxKey:'" + vo.getComboxKey() + "'");
- if (!CollectionUtils.isEmpty(vo.getData())){
- vo.setEditConfig(vo.getEditConfig()+", comboxConfig:");
- for (int i = 0; i < vo.getData().size(); i++) {
- KeyValue data = vo.getData().get(i);
- if (i == vo.getData().size() -1){
- vo.setEditConfig(vo.getEditConfig() + "{attributes:"+data.getAttributes()+",key:'"+data.getKey()+"',value:'"+data.getValue()+"'}]}");
- }else if (i == 0){
- vo.setEditConfig(vo.getEditConfig() + "{data:[{attributes:"+data.getAttributes()+",key:'"+data.getKey()+"',value:'"+data.getValue()+"'},");
- }else{
- vo.setEditConfig(vo.getEditConfig() + "{attributes:"+data.getAttributes()+",key:'"+data.getKey()+"',value:'"+data.getValue()+"'},");
- }
- }
- vo.setEditConfig(vo.getEditConfig() + ",valueField:'" + vo.getQueryField() + "'");
- }
- vo.setEditConfig(vo.getEditConfig() + "}");
- vo.setEdit(vo.getFieldType());
- }
-
- /**
- * 浣跨敤妯℃澘涓婚敭鑾峰彇ui鐩稿叧鐨勫唴瀹�
- *
- * @param templateOid 妯℃澘鐨勪富閿�
- * @return ui鐩稿叧鐨勫唴瀹�
- */
- @Override
- public MdmUIInfoVO getTableDefineByTemplateOid(String templateOid) {
- return getTableDefineByTemplateVO(templateService.getObjectHasAttrByOid(templateOid));
- }
-
- /**
- * 浣跨敤鍒嗙被涓婚敭鑾峰彇宸ュ叿鏍忎腑鐨勬寜閽俊鎭�
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @return 鎸夐挳鐨勪俊鎭紝浼氭寜鐓ф帓搴忓彿杩涜鎺掑簭
- */
- @Override
- public List<CodeButtonVO> listButtonInToolbarByClassifyOid(String codeClassifyOid) {
- CodeClassifyTemplateVO templateVO = getUsedTemplateByClassifyOid(codeClassifyOid);
- return listButtonInToolbarByTemplateOid(templateVO.getOid());
- }
-
- /**
- * 浣跨敤妯℃澘涓婚敭鑾峰彇宸ュ叿鏍忎腑鐨勬寜閽俊鎭�
- *
- * @param templateOid 妯℃澘鐨勪富閿�
- * @return 鎸夐挳鐨勪俊鎭紝浼氭寜鐓ф帓搴忓彿杩涜鎺掑簭
- */
- @Override
- public List<CodeButtonVO> listButtonInToolbarByTemplateOid(String templateOid) {
- List<CodeClassifyTemplateButtonVO> buttonVOS = templateButtonService.listButtonByTemplateOid(templateOid, true);
- if (CollectionUtils.isEmpty(buttonVOS)) {
- return new ArrayList<>();
- }
- List<CodeClassifyTemplateButtonVO> toolbarButtons = buttonVOS.stream().filter(s -> CodeUseButtonPositionTypeEnum.TOOLBAR.getValue().equalsIgnoreCase(s.getButtonuse())).collect(Collectors.toList());
- if (CollectionUtils.isEmpty(toolbarButtons)) {
- return new ArrayList<>();
- }
- List<CodeButtonVO> buttonVOList = new ArrayList<>();
- for (int i = 0; i < toolbarButtons.size(); i++) {
- buttonVOList.add(toolbarButtons.get(i).getButtonVO());
- }
- return buttonVOList;
- }
-
- /**
- * 浣跨敤鍒嗙被鑾峰彇瀵瑰簲鐨勬暟鎹�
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @param templateOid 妯℃澘鐨勪富閿�
- * @param conditionMap 鏌ヨ鏉′欢
- * @param pageHelper 鍒嗛〉鐨勫璞�
- * @return 鏁版嵁锛堝寘鍚笅绾у垎绫伙級
- */
- @Override
- public DataGrid<Map<String, String>> gridTableDataByClassifyOid(String codeClassifyOid, String templateOid, Map<String, String> conditionMap, PageHelper pageHelper) {
- //1. 浣跨敤鍒嗙被鑾峰彇鎵�鏈夌殑涓嬬骇鍒嗙被锛岀劧鍚庢牴鎹垎绫绘煡璇㈠搴旂殑鏁版嵁
- //2. 鍏ㄩ儴浣跨敤褰撳墠鍒嗙被鐨勫綋鍓嶆ā鏉挎潵灞曠ず鍐呭
- //3. 濡傛灉妯℃澘涓婃湁鏋氫妇娉ㄥ叆锛岀粍鍚堣鍒欙紝鍜屽弬鐓х殑锛岄渶瑕佹墽琛岃浆鎹�
- //4. 鏌ヨ鐨勬椂鍊欙紝鐩存帴浣跨敤codeclsfpath鏉ユ煡璇�
- CodeClassifyVO topClassifyVO = classifyService.getTopClassifyVO(codeClassifyOid);
- CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(templateOid);
- if (topClassifyVO == null || StringUtils.isBlank(topClassifyVO.getBtmtypeid())) {
- throw new VciBaseException("褰撳墠涓婚搴撳垎绫绘病鏈夐《灞傚垎绫伙紝鎴栬�呴《灞傚垎绫绘病鏈夎缃笟鍔＄被鍨�");
- }
- String btmTypeId = topClassifyVO.getBtmtypeid();
- if (StringUtils.isBlank(btmTypeId)) {
- return new DataGrid<>("杩欎釜鍒嗙被鎵�灞為《灞傚垎绫绘病鏈夋坊鍔犱笟鍔＄被鍨�");
- }
- if (conditionMap == null) {
- conditionMap = new HashMap<>();
- }
- //pageHelper.addDefaultDesc("createTime");
- pageHelper.addDefaultDesc("id");
- if (!classifyService.checkHasChild(codeClassifyOid)) {
- conditionMap.put(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD, codeClassifyOid);
- } else {
- conditionMap.put(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD, QueryOptionConstant.IN + "(select oid from " + VciBaseUtil.getTableName(MdmBtmTypeConstant.CODE_CLASSIFY)
- + " where lcstatus='" + FrameWorkDefaultValueConstant.FRAMEWORK_DATA_ENABLED +
- "' start with parentCodeClassifyOid = '" + codeClassifyOid + "' CONNECT BY PRIOR OID = parentCodeClassifyOid )");
- }
- conditionMap.put("islastr", "1");
- conditionMap.put("islastv", "1");
- return queryGrid(btmTypeId, templateVO, conditionMap, pageHelper);
-// List<String> selectFieldList = templateVO.getAttributes().stream().map(CodeClassifyTemplateAttrVO::getId).collect(Collectors.toList());
-// //鍙傜収璁╁钩鍙扮洿鎺ユ煡璇㈠氨琛�
-// List<String> finalSelectFieldList = selectFieldList;
-// List<CodeClassifyTemplateAttrVO> referAttrVOs = templateVO.getAttributes().stream().filter(
-// s -> StringUtils.isNotBlank(s.getReferbtmid())
-// &&
-// (finalSelectFieldList.size() ==0 || finalSelectFieldList.contains(s.getId().toLowerCase(Locale.ROOT)))
-// ).collect(Collectors.toList());
-// if(!CollectionUtils.isEmpty(referAttrVOs)){
-// for (int i = 0; i < referAttrVOs.size(); i++) {
-// selectFieldList.add(referAttrVOs.get(i).getId() + ".name");
-// }
-// }
-// //鎴戜滑浣跨敤鍜屼笟鍔＄被鍨嬬殑鏉ユ煡璇�
-// DataGrid<Map<String,String>> dataGrid = boService.queryGridByBo(btmTypeId, conditionMap, pageHelper, selectFieldList);
-// //鎴戜滑闇�瑕佷娇鐢ㄦā鏉挎潵杞崲
-// if(!CollectionUtils.isEmpty(dataGrid.getData())){
-// wrapperData(dataGrid.getData(),templateVO,finalSelectFieldList,false);
-// }
-// return dataGrid;
- }
-
- /**
- * 鏌ヨ缂栫爜鏁版嵁鐨勫垪琛�
- *
- * @param btmType 涓氬姟绫诲瀷
- * @param templateVO 妯℃澘鐨勫璞★紝闇�瑕佸寘鍚ā鏉跨殑灞炴��
- * @param conditionMap 鏌ヨ鏉′欢
- * @param pageHelper 鍒嗛〉瀵硅薄
- * @return 鏁版嵁鍒楄〃
- */
- @Override
- public DataGrid<Map<String, String>> queryGrid(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper) {
- CodeTemplateAttrSqlBO sqlBO = getSqlByTemplateVO(btmType, templateVO, conditionMap, pageHelper);
- List<Map> maps = boService.queryByOnlySqlForMap(sqlBO.getSqlHasPage());
- DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
- List<Map<String, String>> dataList = new ArrayList<>();
- if (!CollectionUtils.isEmpty(maps)) {
- maps.stream().forEach(map -> {
- Map<String, String> data = new HashMap<>();
- map.forEach((key, value) -> {
- data.put(((String) key).toLowerCase(Locale.ROOT), (String) value);
- });
- dataList.add(data);
- });
- }
- dataGrid.setData(dataList);
- if (!CollectionUtils.isEmpty(dataList)) {
- wrapperData(dataGrid.getData(), templateVO, sqlBO.getSelectFieldList(), false);
- dataGrid.setTotal(boService.queryCountBySql(sqlBO.getSqlCount(), new HashMap<>()));
- }
- return dataGrid;
- }
-
- /**
- * 鏍规嵁妯℃澘灞炴�х敓鎴愮浉搴旂殑sql淇℃伅
- *
- * @param btmType 涓氬姟绫诲瀷
- * @param templateVO 妯℃澘鏄剧ず瀵硅薄锛屽繀椤诲寘鍚睘鎬�
- * @param conditionMap 鏌ヨ鏉′欢
- * @param pageHelper 鍒嗛〉鍜屾帓搴忓璞�
- * @return sql鐨勭浉鍏充俊鎭�
- */
- @Override
- public CodeTemplateAttrSqlBO getSqlByTemplateVO(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper) {
- //鍥犱负鍙傜収涓嶄竴瀹氭槸鍦ㄥ钩鍙扮殑灞炴�ф睜閲岄潰璁剧疆锛屾墍浠ユ垜浠緱闇�瑕佽嚜琛屽鐞�
- //鍙傝�僔ciQueryWrapper鏉ュ鐞�
- //1. 鎵惧埌鎵�鏈夌殑瀛楁锛�
- Map<String, CodeClassifyTemplateAttrVO> attrVOMap = templateVO.getAttributes().stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- List<String> selectFieldList = attrVOMap.keySet().stream().collect(Collectors.toList());
-
- //鎵�鏈夌殑鍙傜収鐨勫瓧娈�
- Map<String/**灞炴�у瓧娈�**/, String> joinTableList = new ConcurrentHashMap<>();
- List<CodeClassifyTemplateAttrVO> referAttrVOs = templateVO.getAttributes().stream().filter(
- s -> StringUtils.isNotBlank(s.getReferbtmid()) || StringUtils.isNotBlank(s.getReferConfig())
- ).collect(Collectors.toList());
- Map<String/**鍙傜収鐨勫睘鎬�**/, String/**瀹為檯鐨勫瓧娈�**/> referFieldMap = new HashMap<>();
- if (!CollectionUtils.isEmpty(referAttrVOs)) {
- referAttrVOs.parallelStream().forEach(attrVO -> {
- UIFormReferVO referVO = null;
- if (StringUtils.isNotBlank(attrVO.getReferConfig())) {
- referVO = JSONObject.parseObject(attrVO.getReferConfig(), UIFormReferVO.class);
- } else {
- referVO = new UIFormReferVO();
- referVO.setReferType(attrVO.getReferbtmid());
- referVO.setValueField(VciQueryWrapperForDO.OID_FIELD);
- referVO.setTextField("name");
- }
-
- String referTable = VciBaseUtil.getTableName(referVO.getReferType());
- String referTableNick = attrVO.getId() + "0";
- String left = " left join " + referTable + " " + referTableNick + " on " + referTableNick + "." + referVO.getValueField() + " = t." + attrVO.getId();
- joinTableList.put(attrVO.getId(), left);
- String referShowField = attrVO.getId() + "Name";
- List<String> textFields = VciBaseUtil.str2List(referVO.getTextField());
- String showFieldInSource = "";
- if (textFields.contains("name")) {
- showFieldInSource = "name";
- } else {
- showFieldInSource = textFields.get(0);
- }
- referFieldMap.put(attrVO.getId(), referTableNick + "." + showFieldInSource);
- selectFieldList.add(referTableNick + "." + showFieldInSource + " as " + referShowField);
- });
- }
- Optional.ofNullable(attributeService.getDefaultAttributeVOMap()).orElseGet(() -> new HashMap<>()).keySet().stream().forEach(attrId -> {
- if (!selectFieldList.contains(attrId) && !"secretgrade".equalsIgnoreCase(attrId)) {
- selectFieldList.add(attrId);
- }
- });
- if (!selectFieldList.contains(MdmEngineConstant.CODE_FIELD)) {
- selectFieldList.add(MdmEngineConstant.CODE_FIELD);
- }
- if (!selectFieldList.contains(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD)) {
- selectFieldList.add(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD);
- }
- if (!selectFieldList.contains(MdmEngineConstant.CODE_TEMPLATE_OID_FIELD)) {
- selectFieldList.add(MdmEngineConstant.CODE_TEMPLATE_OID_FIELD);
- }
- if (!selectFieldList.contains(MdmEngineConstant.CODE_FULL_PATH_FILED)) {
- selectFieldList.add(MdmEngineConstant.CODE_FULL_PATH_FILED);
- }
-
- //澶勭悊鏌ヨ鏉′欢
- //TODO 楠岃瘉sql娉ㄥ叆
- List<String> andSql = new ArrayList<>();
- List<String> orSql = new ArrayList<>();
- if (!CollectionUtils.isEmpty(conditionMap)) {
- Map<String, String> orConditionMap = new HashMap<>();
- Map<String, String> andCondtionMap = new HashMap<>();
- //鍏堝垎绂籵r鐨勬煡璇㈡潯浠讹紝鍙﹀褰撴煡璇㈡潯浠舵槸绌虹殑鏃跺�欎篃涓嶆煡璇�
- conditionMap.forEach((k, v) -> {
- if (StringUtils.isNotBlank(v)) {
- if (v.startsWith(QueryOptionConstant.OR)) {
- orConditionMap.put(k, v.substring(QueryOptionConstant.OR.length()));
- } else {
- andCondtionMap.put(k, v);
- }
- }
- });
-
- andCondtionMap.forEach((k, v) -> {
- andSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap));
- });
- orConditionMap.forEach((k, v) -> {
- orSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap));
- });
- }
- //缁勫悎璧锋潵
- StringBuilder andSb = new StringBuilder();
- andSql.stream().forEach(s -> {
- andSb.append(s).append(SPACE).append(QueryOptionConstant.AND).append(SPACE);
- });
-
- String andString = andSb.toString().trim();
- String endWithSql = QueryOptionConstant.AND;
- if (andString.endsWith(endWithSql)) {
- andString = andString.substring(0, andString.length() - endWithSql.length());
- }
-
- String orString = orSql.stream().collect(Collectors.joining(" or "));
- String whereSql = "";
- if (StringUtils.isNotBlank(orString)) {
- if (StringUtils.isBlank(andString)) {
- andString = " 1 = 1 ";
- }
- whereSql = SPACE + "(" + SPACE + andString + SPACE + ") and (" + SPACE + orString + SPACE + ")" + SPACE;
- } else {
- whereSql = andString + SPACE;
- }
- if (attrVOMap.keySet().contains("secretgrade")) {
- Integer userSecret = VciBaseUtil.getCurrentUserSecret();
- if (userSecret == null || userSecret == 0) {
- userSecret = secretService.getMinUserSecret();
- }
- whereSql += " and ( t.secretGrade <= " + userSecret + ") ";
- }
- String tableName = VciBaseUtil.getTableName(btmType);
- String sql = "select " + selectFieldList.stream().map(s -> (s.contains(".") ? s : ("t." + s))).collect(Collectors.joining(","))
- + " from " + tableName + SPACE + "t" + SPACE
- + joinTableList.values().stream().collect(Collectors.joining(SPACE))
- + (StringUtils.isBlank(whereSql) ? "" : " where ") + whereSql;
- if (pageHelper == null) {
- pageHelper = new PageHelper(-1);
- }
- //鐪嬬湅鎺掑簭
- String orderSql = pageHelper.getOrderSql("t");
- sql += (orderSql == null ? "" : orderSql);
- String whereSubfixForPage = " ) A where rownum < " + (pageHelper.getLimit() * pageHelper.getPage() + 1) + ") where RN >= "
- + (pageHelper.getLimit() * (pageHelper.getPage() - 1) + 1);
- String sqlHasPage = pageHelper.getLimit() > 0 ? ("select * from (select A.*,rownum RN from (" + sql + whereSubfixForPage) : sql;
- String sqlCount = "select count(1) from " + tableName + SPACE + "t" + SPACE + joinTableList.values().stream().collect(Collectors.joining(SPACE))
- + (StringUtils.isBlank(whereSql) ? "" : " where ") + whereSql;
- CodeTemplateAttrSqlBO sqlBO = new CodeTemplateAttrSqlBO();
- sqlBO.setTableName(tableName);
- sqlBO.setJoinTable(joinTableList);
- sqlBO.setNickName("t");
- sqlBO.setPageHelper(pageHelper);
- sqlBO.setSqlHasPage(sqlHasPage);
- sqlBO.setSqlCount(sqlCount);
- sqlBO.setSqlUnPage(sql);
- return sqlBO;
- }
-
-
- /**
- * 绌烘牸
- */
- public static final String SPACE = " ";
-
- /**
- * 缁勫悎鏌ヨ鏉′欢鐨剆ql
- *
- * @param key 瀛楁
- * @param value 鍚嶅瓧
- * @param referFieldMap 鍙傜収鐨勫瓧娈�
- * @param attrVOMap 灞炴�х殑鏄犲皠
- * @return Sql璇彞
- */
- private String getConditionSql(String key, String value, Map<String/**鍙傜収鐨勫睘鎬�**/, String/**瀹為檯鐨勫睘鎬�**/> referFieldMap, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
- if (key.endsWith("_begin")) {
- //璇存槑鏄�>=鐨勩�傛垜浠渶瑕佸厛鑾峰彇涓�涓�
- String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
- if (referFieldMap.containsKey(field)) {
- //璇存槑杩樻槸鍙傜収閲岄潰鐨勶紝鎴戜滑榛樿杩欑鎯呭喌涓嬮兘鏄瓧绗︿覆鍚э紝鍥犱负鍙傜収鐨勫睘鎬т笉涓�瀹氱敤鐨勫钩鍙扮殑灞炴�ф睜閲岀殑锛屾墍浠ュぇ閮ㄥ垎鎯呭喌涓嬶紝鏄剧ず鐨勫睘鎬ч兘鏄瓧绗︿覆鍚�
- return referFieldMap.get(field) + SPACE + " >= '" + value + "'" + SPACE;
- } else {
- return (field.contains(".") ? "" : "t.") + field + SPACE + " >= " + getStringValueInWhere(value, field, attrVOMap);
- }
- } else if (key.endsWith("_end")) {
- //璇存槑鏄�<=鐨勩�傛垜浠渶瑕佸厛鑾峰彇涓�涓�
- String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
- if (referFieldMap.containsKey(field)) {
- //璇存槑杩樻槸鍙傜収閲岄潰鐨勶紝鎴戜滑榛樿杩欑鎯呭喌涓嬮兘鏄瓧绗︿覆鍚э紝鍥犱负鍙傜収鐨勫睘鎬т笉涓�瀹氱敤鐨勫钩鍙扮殑灞炴�ф睜閲岀殑锛屾墍浠ュぇ閮ㄥ垎鎯呭喌涓嬶紝鏄剧ず鐨勫睘鎬ч兘鏄瓧绗︿覆鍚�
- return referFieldMap.get(field) + SPACE + " <= '" + value + "'" + SPACE;
- } else {
- return (field.contains(".") ? "" : "t.") + field + SPACE + " <= " + getStringValueInWhere(field, value, attrVOMap);
- }
- } else {
- if (referFieldMap.containsKey(key)) {
- //璇存槑鏄弬鐓х殑锛屾垜浠弬鐓х殑鏌ヨ閮借涓烘槸瀛楃涓诧紝濡傛灉鏄椂闂存牸寮忕殑鏌ヨ鑲畾鏈夐棶棰橈紝
- String selectKey = referFieldMap.get(key);
- return getSqlByValue(selectKey, value, null);
- } else {
- return getSqlByValue(key, value, attrVOMap);
- }
- }
-
- }
-
- /**
- * 灏佽鏈�缁堢殑sql璇彞涓殑鍊奸儴鍒�
- *
- * @param selectKey 鏌ヨ鐨勫瓧娈�
- * @param value 鍊�
- * @param attrVOMap 灞炴�х殑鏄剧ず瀵硅薄鏄犲皠
- * @return sql閲岀殑鍊�
- */
- private String getSqlByValue(String selectKey, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
- StringBuilder sql = new StringBuilder();
- if (!selectKey.contains(".") && (attrVOMap.containsKey(selectKey.toLowerCase(Locale.ROOT)) || attributeService.isDefaultAttr(selectKey) || selectKey.matches(RegExpConstant.LETTER))) {
- sql.append("t.");
- }
- if (value.startsWith(QueryOptionConstant.IN)) {
- sql.append(selectKey)
- .append(SPACE)
- .append("in")
- .append(SPACE)
- .append("(")
- .append(value.replace(QueryOptionConstant.IN, ""))
- .append(")");
- } else if (value.startsWith(QueryOptionConstant.NOTIN)) {
- sql.append(selectKey)
- .append(SPACE)
- .append("not in")
- .append(SPACE)
- .append("(")
- .append(value.replace(QueryOptionConstant.NOTIN, ""))
- .append(")");
- } else if (value.startsWith(QueryOptionConstant.NOTEQUAL)) {
- value = value.replace(QueryOptionConstant.NOTEQUAL, "");
- value = getStringValueInWhere(selectKey, value, attrVOMap);
- sql.append(selectKey)
- .append(SPACE)
- .append(QueryOptionConstant.NOTEQUAL)
- .append(SPACE)
- .append(value);
- } else if (value.startsWith(QueryOptionConstant.MORETHAN)) {
- value = value.replace(QueryOptionConstant.MORETHAN, "");
- value = getStringValueInWhere(selectKey, value, attrVOMap);
- sql.append(selectKey)
- .append(SPACE)
- .append(QueryOptionConstant.MORETHAN)
- .append(SPACE)
- .append(value);
- } else if (value.startsWith(QueryOptionConstant.MORE)) {
- value = value.replace(QueryOptionConstant.MORE, "");
- value = getStringValueInWhere(selectKey, value, attrVOMap);
- sql.append(selectKey)
- .append(SPACE)
- .append(QueryOptionConstant.MORE)
- .append(SPACE)
- .append(value);
- } else if (value.startsWith(QueryOptionConstant.LESSTHAN)) {
- value = value.replace(QueryOptionConstant.LESSTHAN, "");
- value = getStringValueInWhere(selectKey, value, attrVOMap);
-
- sql.append(selectKey)
- .append(SPACE)
- .append(QueryOptionConstant.LESSTHAN)
- .append(SPACE)
- .append(value);
- } else if (value.startsWith(QueryOptionConstant.LESS)) {
- value = value.replace(QueryOptionConstant.LESS, "");
- value = getStringValueInWhere(selectKey, value, attrVOMap);
-
- sql.append(selectKey)
- .append(SPACE)
- .append(QueryOptionConstant.LESS)
- .append(SPACE)
- .append(value);
- } else if (value.startsWith(QueryOptionConstant.ISNOTNULL)) {
- sql.append(selectKey)
- .append(SPACE)
- .append(" is not null");
- } else if (value.startsWith(QueryOptionConstant.ISNULL)) {
- sql.append(selectKey)
- .append(SPACE)
- .append(" is null");
- } else if (value.contains("*")) {
- //璇存槑鏄痩ike锛屾垨鑰卨efe like ,right like
- value = getStringValueInWhere(selectKey, value, attrVOMap);
- sql.append(selectKey)
- .append(SPACE)
- .append("like")
- .append(SPACE)
- // .append("'")
- .append(value.replace("*", "%"))
- // .append("'")
- .append(SPACE);
- } else {
- value= value.replace(SPECIAL_CHAR,REQUIRED_CHAR);
- value = getStringValueInWhere(selectKey, value, attrVOMap);
-
- sql.append(selectKey)
- .append(SPACE)
- .append(QueryOptionConstant.EQUAL)
- .append(SPACE)
- .append(value);
- }
- sql.append(SPACE);
- return sql.toString();
- }
-
- /**
- * 榛樿鐨勬椂闂存牸寮�
- */
- private static final String DATETIME_FORMAT = "yyyy-mm-dd hh24:mi:ss";
-
- /**
- * 鏃ユ湡鏍煎紡
- */
- private static final String DATE_FORMAT = "yyyy-mm-dd";
- /**
- * 鍙槸sql
- */
- public static final String ONLY = "${vcionly}";
-
- /**
- * 鑾峰彇鏌ヨ鏉′欢涓殑鍊肩殑锛屽鐞嗕笉鍚岀殑绫诲瀷
- *
- * @param value 鍊�
- * @param field 瀛楁鍚嶇О
- * @return 鏃ユ湡鎴栬�呮椂闂存牸寮忎細鍖呮嫭to_date锛屽瓧绗︿覆浼氬姞'
- */
- private String getStringValueInWhere(String field, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
- if ((field.contains(".") && !field.toLowerCase(Locale.ROOT).startsWith("t.")) || attrVOMap == null
- || !field.replace("t.", "").matches(RegExpConstant.LETTER) || value.startsWith(ONLY)) {
- //璇存槑鍙兘鏄寚瀹氱殑鏌愪釜鏉′欢锛岀洿鎺ヨ繑鍥�
- if (value.startsWith(ONLY)) {
- value = value.replace(ONLY, "");
- }
- if ((value.startsWith("(") && value.endsWith(")")) || (value.startsWith("'") && value.endsWith("'"))) {
- return value;
- }
- if (field.contains(".") && attrVOMap != null && attrVOMap.containsKey(field.split("\\.")[0].toLowerCase(Locale.ROOT))) {
- //鏄弬鐓�
- return "'" + value + "'";
- } else {
- return value;
- }
- } else {
- //鐪嬬湅鏄笉鏄繖涓璞￠噷鐨勫睘鎬�
- if (attrVOMap.containsKey(field)) {
- VciFieldTypeEnum fieldTypeEnum = VciFieldTypeEnum.valueOf(attrVOMap.get(field).getAttributedatatype());
- if ("ts".equalsIgnoreCase(field)) {
- return "to_timestamp('" + value + "', '" + DATETIME_FORMAT + ".ff')";
- }
- DateConverter dateConverter = new DateConverter();
- if (VciFieldTypeEnum.VTDateTime.equals(fieldTypeEnum)) {
- //瀹為檯涓婏紝鏁版嵁搴撻兘鏄痶imestamp鐨勭被鍨�.
- dateConverter.setAsText(value);
- return "to_date('" + dateConverter.getAsText(VciDateUtil.DateTimeFormat) + "','" + DATETIME_FORMAT + "')";
- } else if (VciFieldTypeEnum.VTDate.equals(fieldTypeEnum)) {
- dateConverter.setAsText(value);
- return "to_date('" + dateConverter.getAsText(VciDateUtil.DateFormat) + "','" + DATE_FORMAT + "')";
- } else if (VciFieldTypeEnum.VTDouble.equals(fieldTypeEnum)
- || VciFieldTypeEnum.VTLong.equals(fieldTypeEnum)
- || VciFieldTypeEnum.VTInteger.equals(fieldTypeEnum)) {
- return value;
- } else {
- return "'" + value + "'";
- }
- } else {
- if ((value.startsWith("(") && value.endsWith(")")) || (value.startsWith("'") && value.endsWith("'"))) {
- return value;
- }
- return "'" + value + "'";
- }
- }
-
- }
-
- /**
- * 灏佽寮�鍏崇殑鍐呭锛屽父鐢ㄤ簬瀵煎嚭
- * @param dataMap 鏁版嵁鐨勫唴瀹�
- * @param templateVO 妯℃澘鐨勬樉绀�
- */
- @Override
- public void wrapperBoolean(List<Map<String, String>> dataMap, CodeClassifyTemplateVO templateVO){
- List<String> booleanAttributes = templateVO.getAttributes().stream().filter(s -> VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(s.getAttributedatatype())).map(s -> s.getId().toLowerCase(Locale.ROOT)).collect(Collectors.toList());
- if(!CollectionUtils.isEmpty(booleanAttributes)){
- dataMap.stream().forEach(data -> {
- booleanAttributes.stream().forEach(attrId->{
- if(data.containsKey(attrId)){
- String value = data.get(attrId);
- data.put(attrId, BooleanEnum.TRUE.getValue().equalsIgnoreCase(value)?"鏄�":"鍚�");
- }
- });
- });
- }
- }
-
- /**
- * 灏佽鏌ヨ鍑烘潵鐨勬暟鎹�
- *
- * @param dataMap 鏁版嵁鐨勬槧灏�
- * @param templateVO 妯℃澘鐨勫睘鎬�
- * @param onlySelectAttrIdList 浠呬粎鏌ヨ鐨勫睘鎬у瓧娈�
- * @param form 琛ㄥ崟閲屼娇鐢�
- */
- @Override
- public void wrapperData(List<Map<String, String>> dataMap, CodeClassifyTemplateVO templateVO,
- Collection<String> onlySelectAttrIdList, boolean form) {
- if (onlySelectAttrIdList == null) {
- onlySelectAttrIdList = new ArrayList<>();
- }
- //鍏堣浆鎹竴涓嬫椂闂存牸寮�
- List<String> finalOnlySelectAttrIdList = onlySelectAttrIdList.stream().collect(Collectors.toList());
- List<CodeClassifyTemplateAttrVO> dateFormatAttrVOs = templateVO.getAttributes().stream().filter(
- s -> StringUtils.isNotBlank(s.getCodedateformat()) &&
- (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT)))
- ).collect(Collectors.toList());
- //鏋氫妇鐨勫唴瀹�
- List<CodeClassifyTemplateAttrVO> enumAttrVOs = templateVO.getAttributes().stream().filter(
- s -> (StringUtils.isNotBlank(s.getEnumid()) || StringUtils.isNotBlank(s.getEnumString()))
- &&
- (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT)))
- ).collect(Collectors.toList());
-
- List<String> userIds = new ArrayList<>();
- dataMap.stream().forEach(data -> {
- //澶勭悊鏃堕棿
- if (!form) {
- //琛ㄥ崟鐨勬椂鍊欏彧鑳界敤缁熶竴鐨勬椂闂存牸寮�
- wrapperDateFormat(dateFormatAttrVOs, data);
- }
- //澶勭悊鏋氫妇
- wrapperEnum(enumAttrVOs, data);
- String lcstatus = data.get(VciQueryWrapperForDO.LC_STATUS_FIELD);
- String copyFromVersion = data.getOrDefault(COPY_FROM_VERSION,"");
- if ((CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(lcstatus) || CodeDefaultLC.AUDITING.getValue().equalsIgnoreCase(lcstatus))
- && StringUtils.isBlank(copyFromVersion)
- ) {
- data.put(VciQueryWrapperForDO.ID_FIELD, "******");
- }
- data.put(VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT), CodeDefaultLC.getTextByValue(lcstatus));
- if(CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(lcstatus)
- && StringUtils.isNotBlank(copyFromVersion)){
- data.put(VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT), "淇敼涓�");
- }
- if (data.containsKey("creator")) {
- userIds.add(data.get("creator"));
- }
- if (data.containsKey("lastmodifier")) {
- userIds.add(data.get("lastmodifier"));
- }
- });
- if (!CollectionUtils.isEmpty(userIds)) {
- Map<String, SmUserVO> userVOMap = Optional.ofNullable(userQueryService.listUserByUserIds(userIds)).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- dataMap.stream().forEach(data -> {
- String creator = data.getOrDefault("creator", null);
- if (StringUtils.isNotBlank(creator) && userVOMap.containsKey(creator.toLowerCase(Locale.ROOT))) {
- data.put("creator", creator + "(" + userVOMap.get(creator.toLowerCase(Locale.ROOT)).getName() + ")");
- }
- String lastmodifier = data.getOrDefault("lastmodifier", null);
- if (StringUtils.isNotBlank(lastmodifier) && userVOMap.containsKey(lastmodifier.toLowerCase(Locale.ROOT))) {
- data.put("lastmodifier", lastmodifier + "(" + userVOMap.get(lastmodifier.toLowerCase(Locale.ROOT)).getName() + ")");
- }
- });
- }
- }
-
- /**
- * 澶勭悊鏃堕棿鏍煎紡
- *
- * @param dateFormatAttrVOs 鏃堕棿鏍煎紡鐨勫睘鎬�
- * @param data 褰撳墠琛屾暟鎹�
- */
- private void wrapperDateFormat(Collection<CodeClassifyTemplateAttrVO> dateFormatAttrVOs, Map<String, String> data) {
- if (!CollectionUtils.isEmpty(dateFormatAttrVOs)) {
- dateFormatAttrVOs.stream().forEach(dateFormatAttrVO -> {
- String attrId = dateFormatAttrVO.getId().toLowerCase(Locale.ROOT);
- String oldValue = data.getOrDefault(attrId, null);
- if (StringUtils.isNotBlank(oldValue)) {
- DateConverter dateConverter = new DateConverter();
- try {
- dateConverter.setAsText(oldValue);
- Date value = dateConverter.getValue();
- if (value != null) {
- data.put(attrId, VciDateUtil.date2Str(value, dateFormatAttrVO.getCodedateformat()));
- }
- } catch (Throwable e) {
- //杞崲鍙兘鏈夐棶棰橈紝杩欏氨浣跨敤鍘熸湰瀛樺偍鐨勫��
- }
- }
- });
- }
- }
-
- /**
- * 澶勭悊鏋氫妇鐨勫唴瀹癸紝濡傛灉涓嶅湪鏋氫妇涓紝浼氳繑鍥炲師鏈殑鍊�
- *
- * @param enumAttrVOs 鏋氫妇灞炴��
- * @param data 褰撳墠琛屾暟鎹�
- */
- private void wrapperEnum(Collection<CodeClassifyTemplateAttrVO> enumAttrVOs, Map<String, String> data) {
- //澶勭悊鏋氫妇鐨勫唴瀹癸紝涓轰簡鍏煎浠ュ墠鐨勬暟鎹�,濡傛灉鏁版嵁涓嶈兘浣跨敤鏋氫妇杞崲鐨勮瘽锛岄偅杩樻槸鏄剧ず浠ュ墠鐨勫��
- if (!CollectionUtils.isEmpty(enumAttrVOs)) {
- enumAttrVOs.stream().forEach(enumAttrVO -> {
- String attrId = enumAttrVO.getId().toLowerCase(Locale.ROOT);
- String oldValue = data.getOrDefault(attrId, null);
- if (StringUtils.isNotBlank(oldValue)) {
- List<KeyValue> comboxKVs = listComboboxItems(enumAttrVO);
- String newValue = oldValue;
- KeyValue keyValue = Optional.ofNullable(comboxKVs).orElseGet(() -> new ArrayList<>()).stream().filter(s -> s.getKey().equalsIgnoreCase(oldValue)).findFirst().orElseGet(() -> null);
- if (keyValue != null) {
- newValue = keyValue.getValue();
- }
- data.put(attrId + "Text", newValue);
- }
- });
- }
- }
-
- /**
- * 鑾峰彇鏋氫妇鐨勪笅鎷夐�夐」
- *
- * @param attrVO 妯℃澘灞炴�х殑瀵硅薄
- * @return 涓嬫媺閫夐」
- */
- @Override
- public List<KeyValue> listComboboxItems(CodeClassifyTemplateAttrVO attrVO) {
- List<KeyValue> comboboxKVs;
- if (StringUtils.isNotBlank(attrVO.getEnumString())) {
- comboboxKVs = JSONObject.parseArray(attrVO.getEnumString(), KeyValue.class);
- } else {
- comboboxKVs = enumService.getEnum(attrVO.getEnumid());
- }
- return comboboxKVs;
- }
-
- /**
- * 澶勭悊缁勫悎瑙勫垯鐨勫唴瀹癸紝濡傛灉涓嶅湪鏋氫妇涓紝浼氳繑鍥炲師鏈殑鍊�
- *
- * @param compAttrVOs 缁勫悎瑙勫垯灞炴��
- * @param data 褰撳墠琛屾暟鎹�
- */
- private void wrapperComponentRule(Collection<CodeClassifyTemplateAttrVO> compAttrVOs, Map<String, String> data) {
- if (!CollectionUtils.isEmpty(compAttrVOs)) {
- compAttrVOs.stream().forEach(attrVO -> {
- String attrId = attrVO.getId().toLowerCase(Locale.ROOT);
- //鐢ㄥ叕寮忓幓璁＄畻
- //鍏堢敤褰撳墠鏁版嵁鏇挎崲涓�涓�
- String calculatedValue = formulaService.getValueByFormula(data, attrVO.getComponentrule());
- data.put(attrId, calculatedValue);
- });
- }
- }
-
-
- /**
- * 浣跨敤鏁版嵁涓婚敭鑾峰彇鏁版嵁鐨勫叏閮ㄤ俊鎭�
- *
- * @param oid 涓婚敭
- * @param templateOid 妯℃澘鐨勪富閿�
- * @return 鏁版嵁鐨勫唴瀹�
- */
- @Override
- public BaseResult<Map<String, String>> getDataByOid(String oid, String templateOid) {
- CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(templateOid);
- //涓轰簡闃叉妯℃澘涓婄殑涓氬姟绫诲瀷涓庡垎绫讳笂涓嶅搴�
- CodeClassifyVO topClassifyVO = classifyService.getTopClassifyVO(templateVO.getCodeclassifyoid());
- String btmId = topClassifyVO.getBtmtypeid();
- //鏌ヨ鏁版嵁
- Map<String, String> conditionMap = WebUtil.getOidQuery(oid);
- CodeTemplateAttrSqlBO sqlBO = getSqlByTemplateVO(btmId, templateVO, conditionMap, new PageHelper(-1));
- //鎴戜滑浣跨敤鍜屼笟鍔＄被鍨嬬殑鏉ユ煡璇�
- List<ClientBusinessObject> cbos = boService.queryByOnlySql(sqlBO.getSqlUnPage());
- if (CollectionUtils.isEmpty(cbos)) {
- throw new VciBaseException("鏁版嵁鍦ㄧ郴缁熶腑涓嶅瓨鍦紝鏄惁鍥犱负淇敼杩囦笟鍔＄被鍨嬶紵");
- }
- Map<String, String> data = new HashMap<>();
- ClientBusinessObject cbo = cbos.get(0);
- WebUtil.copyValueToMapFromCbos(cbo, data);
- List<Map<String, String>> dataList = new ArrayList<>();
- dataList.add(data);
- wrapperData(dataList, templateVO, sqlBO.getSelectFieldList(), true);
- BaseResult<Map<String, String>> result = BaseResult.success(data);
- //鎴戜滑瑕佺湅鏄惁涓嶆槸鍗囩増鐨勶紝鍗囩増鐨勮瘽锛岄渶瑕佸姣斾笉鐩哥瓑鐨勫睘鎬�
- String copy = cbo.getCopyFromVersion();
- if (StringUtils.isBlank(copy)) {
- copy = cbo.getAttributeValue("copyfromversion");
- }
- if (StringUtils.isNotBlank(copy)) {
- //璇存槑鏈夊彉鏇寸殑鍐呭
-
- CodeTemplateAttrSqlBO oldSqlBO = getSqlByTemplateVO(btmId, templateVO, WebUtil.getOidQuery(copy), new PageHelper(-1));
- //鎴戜滑浣跨敤鍜屼笟鍔＄被鍨嬬殑鏉ユ煡璇�
- List<ClientBusinessObject> oldCbos = boService.queryByOnlySql(oldSqlBO.getSqlUnPage());
- if (!CollectionUtils.isEmpty(oldCbos)) {
- Map<String, String> newData = new HashMap<>();
- WebUtil.copyValueToMapFromCbos(cbo, newData);
- Map<String, String> oldData = new HashMap<>();
- WebUtil.copyValueToMapFromCbos(oldCbos.get(0), oldData);
- Map<String, String> difFieldMap = new HashMap<>();
- newData.forEach((key, value) -> {
- String oldValue = oldData.getOrDefault(key, "");
- if (value == null) {
- value = "";
- }
- if (oldValue == null) {
- oldValue = "";
- }
- if (!value.equalsIgnoreCase(oldValue)) {
- difFieldMap.put(key, oldValue);
- }
- });
- List<Map<String, String>> difFieldList = new ArrayList<>();
- difFieldList.add(difFieldMap);
- result.setData(difFieldList);
- }
- }
- return result;
- }
-
- /**
- * 浣跨敤涓婚搴撳垎绫昏幏鍙栫紪鐮佽鍒�
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @return 缂栫爜瑙勫垯鐨勫唴瀹�
- */
- @Override
- public CodeRuleVO getCodeRuleByClassifyOid(String codeClassifyOid) {
- VciBaseUtil.alertNotNull(codeClassifyOid, "鍒嗙被鐨勪富閿�");
- CodeClassifyVO classifyVO = classifyService.getObjectByOid(codeClassifyOid);
- String codeRuleOid = classifyVO.getCoderuleoid();
- if (StringUtils.isBlank(codeRuleOid)) {
- //寰�涓婃壘
- CodeClassifyFullInfoBO fullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
- return getCodeRuleByClassifyFullInfo(fullInfo);
- }
- //鎴戜滑鏌ヨ缂栫爜瑙勫垯
- return ruleService.getObjectHasSecByOid(codeRuleOid);
- }
-
- /**
- * 浣跨敤鍒嗙被鐨勫叏閮ㄤ俊鎭幏鍙栫紪鐮佽鍒�
- *
- * @param fullInfoBO 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @return 瑙勫垯鐨勫唴瀹�
- */
- @Override
- public CodeRuleVO getCodeRuleByClassifyFullInfo(CodeClassifyFullInfoBO fullInfoBO) {
- //寰�涓婃壘
- String codeRuleOid = "";
- if (StringUtils.isNotBlank(fullInfoBO.getCurrentClassifyVO().getCoderuleoid())) {
- codeRuleOid = fullInfoBO.getCurrentClassifyVO().getCoderuleoid();
- } else {
- if (CollectionUtils.isEmpty(fullInfoBO.getParentClassifyVOs())) {
- //璇存槑宸茬粡鏄渶楂樺眰绾�,
- throw new VciBaseException("褰撳墠涓婚搴撳垎绫伙紝浠ュ強瀹冪殑鎵�鏈夌殑涓婄骇鍒嗙被閮芥病鏈夎缃紪鐮佽鍒�");
- }
- List<CodeClassifyVO> parentClassifyVOList = fullInfoBO.getParentClassifyVOs().stream().sorted((o1, o2) -> o1.getDataLevel().compareTo(o2.getDataLevel())).collect(Collectors.toList());
- //浠庢渶楂樼殑level寮�濮嬭幏鍙�
- for (int i = 0; i < parentClassifyVOList.size(); i++) {
- CodeClassifyVO record = parentClassifyVOList.get(i);
- if (StringUtils.isNotBlank(record.getCoderuleoid())) {
- codeRuleOid = record.getCoderuleoid();
- break;
- }
- }
- if (StringUtils.isBlank(codeRuleOid)) {
- throw new VciBaseException("褰撳墠涓婚搴撳垎绫伙紝浠ュ強瀹冪殑鎵�鏈夌殑涓婄骇鍒嗙被閮芥病鏈夎缃紪鐮佽鍒�");
- }
- }
- return ruleService.getObjectHasSecByOid(codeRuleOid);
- }
-
- /**
- * 浣跨敤鐮佹鐨勪富閿幏鍙栧垎绫荤殑鐮佸�煎唴瀹�
- *
- * @param classifySecOid 鐮佹鐨勪富閿�
- * @param parentClassifyValueOid 涓婄骇鍒嗙被鐨勪富閿�
- * @return 鍒嗙被鐮佸�肩殑鍐呭
- */
- @Override
- public List<CodeClassifyValueVO> listCodeClassifyValueBySecOid(String classifySecOid, String parentClassifyValueOid) {
- return classifyValueService.listCodeClassifyValueBySecOid(classifySecOid, parentClassifyValueOid);
- }
-
- /**
- * 鐢宠鍗曚竴缂栫爜
- *
- * @param orderDTO 鐢宠鐨勪俊鎭紝闇�瑕佸寘鍚睘鎬х殑鍐呭鍜岀爜娈电浉鍏崇殑鍐呭
- * @return 杩斿洖缂栫爜鐨勫唴瀹�
- */
- @Override
- public String addSaveCode(CodeOrderDTO orderDTO) {
- VciBaseUtil.alertNotNull(orderDTO, "缂栫爜鐢宠鐩稿叧鐨勫睘鎬у拰鐮佹鐨勫唴瀹归兘涓虹┖", orderDTO.getCodeClassifyOid(), "涓婚搴撳垎绫荤殑涓婚敭",
- orderDTO.getTemplateOid(), "妯℃澘鐨勪富閿�", orderDTO.getCodeRuleOid(), "缂栫爜瑙勫垯鐨勪富閿�");
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
- CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
- CodeRuleVO ruleVO = ruleService.getObjectHasSecByOid(orderDTO.getCodeRuleOid());
- //1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈�
- checkSecValueOnOrder(ruleVO, orderDTO);
- //2.鍒ゆ柇蹇呰緭椤�
- checkRequiredAttrOnOrder(templateVO, orderDTO);
- //3.鍏堟敞鍏ワ紝鍐嶇粍鍚堬紝鏈�鍚庢牎楠�
- switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
- //4.澶勭悊缁勫悎瑙勫垯銆傜粍鍚堣鍒欎笉鑳戒娇鐢ㄧ紪鐮佺殑灞炴�э紝鍥犱负缂栫爜鐨勭敓鎴愬彲鑳芥槸闇�瑕佸睘鎬х殑
- switchComponentAttrOnOrder(templateVO, orderDTO);
- //5.鏍￠獙瑙勫垯
- checkVerifyOnOrder(templateVO, orderDTO);
- //6.鍏抽敭灞炴��
- checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
- //7.鏋氫妇杞崲
- checkEnumOnOrder(templateVO, orderDTO);
- //8.澶勭悊鏃堕棿鏍煎紡锛屽湪鏁版嵁搴撻噷闈笉璁烘槸瀛楃涓茶繕鏄棩鏈熸牸寮忥紝閮戒娇鐢ㄧ浉鍚岀殑鏍煎紡瀛樺偍
- switchDateAttrOnOrder(templateVO, orderDTO);
- //9.鐢熸垚缂栫爜鐨勪俊鎭�
- ClientBusinessObject cbo = boService.createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
- //榛樿鐨勫睘鎬ч兘涓嶇敤浠庡墠绔嫹璐�
- //璁剧疆缂栫爜闇�瑕佺殑榛樿灞炴�х殑鍐呭
- copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, false);
- //TODO:鍥犱负榛樿鐨勫睘鎬ч兘涓嶆嫹璐濓紝鐩墠闆嗗洟鐮佸彨name锛屽苟娌℃湁浠嶥TO鎷疯礉鍒癱bo閲屻�傚鍔犱竴涓崟鐙鐞嗭紝浠ュ悗鍐嶇湅瑕佷笉瑕佽皟鏁�
- cbo.setName(orderDTO.getName() == null ? "" : orderDTO.getName());
- //end -- modify by lihang @20220407
- List<ClientBusinessObject> cboList = new ArrayList<>();
-
- //澶囨敞
- cbo.setDescription(orderDTO.getDescription()==null?"":orderDTO.getDescription());
-
- cboList.add(cbo);
- List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(), cboList);
- batchSaveSelectChar(templateVO, cboList);
- return codeList.size() > 0 ? codeList.get(0) : "";
- }
-
- /**
- * 淇敼涓婚搴撴暟鎹�
- *
- * @param orderDTO 鏁版嵁鐨勫唴瀹癸紝涓嶇敤鍖呭惈鐮佹鐨勫唴瀹逛簡
- */
- @Override
- public void editSaveCode(CodeOrderDTO orderDTO) {
- VciBaseUtil.alertNotNull(orderDTO, "缂栫爜鐢宠鐩稿叧鐨勫睘鎬х殑鍐呭閮戒负绌�", orderDTO.getOid(), "鏁版嵁涓婚敭",
- orderDTO.getCodeClassifyOid(), "涓婚搴撳垎绫荤殑涓婚敭");
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
- //鎵句笟鍔＄被鍨嬶紝鐒跺悗浣跨敤涓婚敭鍘昏幏鍙栨暟鎹簱閲岀殑鏁版嵁
- List<ClientBusinessObject> cbos = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), WebUtil.getOidQuery(orderDTO.getOid()));
- if (CollectionUtils.isEmpty(cbos)) {
- throw new VciBaseException(DATA_OID_NOT_EXIST);
- }
- ClientBusinessObject cbo = cbos.get(0);
- if (!cbo.getTs().contains(VciDateUtil.date2Str(orderDTO.getTs(), VciDateUtil.DateTimeFormat))) {
- throw new VciBaseException("鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
- }
- if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
- throw new VciBaseException("鏁版嵁涓嶆槸{0}鐨勭姸鎬侊紝涓嶅厑璁镐慨鏀�", new String[]{CodeDefaultLC.EDITING.getText()});
- }
-
- //娉ㄦ剰妯℃澘涓嶈兘浣跨敤鏁版嵁瀛樺偍鐨勬椂鍊欑殑妯℃澘锛屽洜涓哄彲鑳戒細鍙樺寲
-
- //1. 鍒ゆ柇蹇呰緭椤�
- CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
- checkRequiredAttrOnOrder(templateVO, orderDTO);
- //2.鍏堟敞鍏ワ紝鍐嶇粍鍚堬紝鏈�鍚庢牎楠�
- switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
- //3.澶勭悊缁勫悎瑙勫垯銆傜粍鍚堣鍒欎笉鑳戒娇鐢ㄧ紪鐮佺殑灞炴�э紝鍥犱负缂栫爜鐨勭敓鎴愬彲鑳芥槸闇�瑕佸睘鎬х殑
- switchComponentAttrOnOrder(templateVO, orderDTO);
- //4.鏍￠獙瑙勫垯
- checkVerifyOnOrder(templateVO, orderDTO);
- //5.鍒ゆ柇鍏抽敭灞炴��
- checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
- //6.鏍￠獙鏋氫妇鐨勫唴瀹规槸鍚︽纭�
- checkEnumOnOrder(templateVO, orderDTO);
- //7.澶勭悊鏃堕棿鏍煎紡锛屽湪鏁版嵁搴撻噷闈笉璁烘槸瀛楃涓茶繕鏄棩鏈熸牸寮忥紝閮戒娇鐢ㄧ浉鍚岀殑鏍煎紡瀛樺偍
- switchDateAttrOnOrder(templateVO, orderDTO);
- //榛樿鐨勫唴瀹逛笉鑳藉彉锛屾墍浠ュ彧闇�瑕佹嫹璐濊嚜瀹氫箟鐨勭浉鍏冲睘鎬у嵆鍙�
- copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true);
- //浼佷笟鐮佸拰闆嗗洟鐮佺殑涓嶄慨鏀�
- cbo.setDescription(orderDTO.getDescription()==null?"":orderDTO.getDescription());
- cbo.setName(orderDTO.getName()==null?"":orderDTO.getName());
- try {
- cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
- cbo.setAttributeValue("name", orderDTO.getName());
- } catch (VCIError e) {
- e.printStackTrace();
- }
- //淇敼鐨勬椂鍊欙紝缂栫爜鏄笉鍙樼殑
- BatchCBO batchCBO = new BatchCBO();
- batchCBO.getUpdateCbos().add(cbo);
- List<ClientBusinessObject> cboList = new ArrayList<>();
- cboList.add(cbo);
- boService.persistenceBatch(batchCBO);
- batchSaveSelectChar(templateVO, cboList);
- }
-
- /**
- * 鍗囩増鐨勪富棰樺簱鏁版嵁
- *
- * @param orderDTO 鏁版嵁鐨勫唴瀹癸紝涓嶉渶瑕佸寘鍚爜娈电殑鍐呭
- */
- @Override
- public void upSaveCode(CodeOrderDTO orderDTO) {
- VciBaseUtil.alertNotNull(orderDTO, "缂栫爜鐢宠鐩稿叧鐨勫睘鎬х殑鍐呭涓虹┖", orderDTO.getCopyFromVersion(), "鍘熷鏁版嵁鐨勪富閿�",
- orderDTO.getCodeClassifyOid(), "涓婚搴撳垎绫荤殑涓婚敭");
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
- //鎵句笟鍔＄被鍨嬶紝鐒跺悗浣跨敤涓婚敭鍘昏幏鍙栨暟鎹簱閲岀殑鏁版嵁
- List<ClientBusinessObject> cbos = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), WebUtil.getOidQuery(orderDTO.getCopyFromVersion()));
- if (CollectionUtils.isEmpty(cbos)) {
- throw new VciBaseException(DATA_OID_NOT_EXIST);
- }
- ClientBusinessObject oldCbo = cbos.get(0);
- if (!CodeDefaultLC.RELEASED.getValue().equalsIgnoreCase(oldCbo.getLcStatus())) {
- throw new VciBaseException("鏁版嵁涓嶆槸{0}鐨勭姸鎬侊紝涓嶅厑璁告暟鎹洿鏀�", new String[]{CodeDefaultLC.RELEASED.getText()});
- }
- //闇�瑕佸崌鐗�
- ClientBusinessObjectOperation cboOperation = new ClientBusinessObjectOperation();
- ClientBusinessObject cbo = null;
- try {
- //cbo = cboOperation.createBusinessObjectVersion(oldCbo,VciBaseUtil.getCurrentUserId());
- cbo = cboOperation.reviseBusinessObject(oldCbo, "");
- } catch (VCIError e) {
- throw new VciBaseException("鍒濆鍖栫浉鍏崇殑鍐呭鍑虹幇浜嗛敊璇�", new String[0], e);
- }
- //1. 鍒ゆ柇蹇呰緭椤�
- CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
- checkRequiredAttrOnOrder(templateVO, orderDTO);
- //2.鍏堟敞鍏ワ紝鍐嶇粍鍚堬紝鏈�鍚庢牎楠�
- switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
- //3.澶勭悊缁勫悎瑙勫垯銆傜粍鍚堣鍒欎笉鑳戒娇鐢ㄧ紪鐮佺殑灞炴�э紝鍥犱负缂栫爜鐨勭敓鎴愬彲鑳芥槸闇�瑕佸睘鎬х殑
- switchComponentAttrOnOrder(templateVO, orderDTO);
- //4.鏍￠獙瑙勫垯
- checkVerifyOnOrder(templateVO, orderDTO);
- //5.鍒ゆ柇鍏抽敭灞炴��
- checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
- //6.鏍￠獙鏋氫妇鐨勫唴瀹规槸鍚︽纭�
- checkEnumOnOrder(templateVO, orderDTO);
- //7.澶勭悊鏃堕棿鏍煎紡锛屽湪鏁版嵁搴撻噷闈笉璁烘槸瀛楃涓茶繕鏄棩鏈熸牸寮忥紝閮戒娇鐢ㄧ浉鍚岀殑鏍煎紡瀛樺偍
- switchDateAttrOnOrder(templateVO, orderDTO);
- //榛樿鐨勫唴瀹逛笉鑳藉彉锛屾墍浠ュ彧闇�瑕佹嫹璐濊嚜瀹氫箟鐨勭浉鍏冲睘鎬у嵆鍙�
- copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true);
- //浼佷笟鐮佸拰闆嗗洟鐮佺殑涓嶄慨鏀�
-// cbo.setDescription(orderDTO.getDescription());
-// cbo.setName(orderDTO.getName());
- cbo.setDescription(orderDTO.getDescription()==null?"":orderDTO.getDescription());
- cbo.setName(orderDTO.getName()==null?"":orderDTO.getName());
- try {
- cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
- cbo.setAttributeValue("name", orderDTO.getName());
- } catch (VCIError e) {
- e.printStackTrace();
- }
- //鏁版嵁鐨勬椂鍊欙紝缂栫爜鏄笉鍙樼殑
- cbo.setCreateTime(DateUtils.convert2String(new Date(Long.parseLong(cbo.getCreateTime())), "yyyy-MM-dd HH:mm:ss"));
- cbo.setLastModifyTime(DateUtils.convert2String(new Date(Long.parseLong(cbo.getLastModifyTime())), "yyyy-MM-dd HH:mm:ss"));
- List<ClientBusinessObject> cboList = new ArrayList<>();
- cboList.add(cbo);
- try {
- cboOperation.saveRevisionBuinessObject(cbo);
- } catch (VCIError vciError) {
- throw new VciBaseException("鏁版嵁鏇存敼淇濆瓨鍑洪敊浜�", new String[0], vciError);
- }
- batchSaveSelectChar(templateVO, cboList);
- }
-
- /**
- * 淇濆瓨鍙緭鍙�夌殑淇℃伅
- *
- * @param templateVO 妯℃澘鐨勫璞�
- * @param cboList 鏁版嵁鐨勫唴瀹�
- */
- @Override
- public void batchSaveSelectChar(CodeClassifyTemplateVO templateVO, List<ClientBusinessObject> cboList) {
- if (templateVO != null && !CollectionUtils.isEmpty(cboList)) {
- //鏄紓姝ョ殑锛屾墍浠ョ洿鎺ュ惊鐜�
- List<CodeClassifyTemplateAttrVO> selectAttrVOs = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getLibraryIdentification())).collect(Collectors.toList());
- if (!CollectionUtils.isEmpty(selectAttrVOs)) {
- SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
- selectAttrVOs.parallelStream().forEach(attrVO -> {
- List<String> valuesList = new CopyOnWriteArrayList<>();
- cboList.parallelStream().forEach(cbo -> {
- String value = cbo.getAttributeValue(attrVO.getId());
- if (StringUtils.isNotBlank(value)) {
- valuesList.add(value);
- }
- });
- if (!CollectionUtils.isEmpty(valuesList)) {
- charService.saveBySameNamespaceAndFlag(templateVO.getBtmTypeId(), attrVO.getLibraryIdentification(), valuesList, sessionInfo);
- }
- });
- }
- }
- }
-
- /**
- * 鍒犻櫎涓婚搴撴暟鎹�
- *
- * @param deleteBatchDTO 鏁版嵁鐨勫唴瀹癸紝蹇呴』瑕佹湁涓婚敭鍜屽垎绫讳富閿�
- */
- @Override
- public void deleteCode(CodeDeleteBatchDTO deleteBatchDTO) {
- VciBaseUtil.alertNotNull(deleteBatchDTO, "缂栫爜鐢宠鐩稿叧鐨勫睘鎬у拰鐮佹鐨勫唴瀹归兘涓虹┖", deleteBatchDTO.getOidList(), "鏁版嵁涓婚敭",
- deleteBatchDTO.getCodeClassifyOid(), "涓婚搴撳垎绫荤殑涓婚敭");
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(deleteBatchDTO.getCodeClassifyOid());
- //鎵句笟鍔＄被鍨嬶紝鐒跺悗浣跨敤涓婚敭鍘昏幏鍙栨暟鎹簱閲岀殑鏁版嵁
- Collection<Collection<String>> oidCollection = VciBaseUtil.switchCollectionForOracleIn(deleteBatchDTO.getOidList());
- List<ClientBusinessObject> cboList = new ArrayList<>();
- oidCollection.stream().forEach(oids -> {
- Map<String, String> conditionMap = new HashMap<>();
- conditionMap.put("oid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
- List<ClientBusinessObject> cbos = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), conditionMap);
- cboList.addAll(cbos);
- });
- if (CollectionUtils.isEmpty(cboList)) {
- throw new VciBaseException("鏁版嵁鍏ㄩ儴鍦ㄧ郴缁熶腑涓嶅瓨鍦�");
- }
- List<ClientBusinessObject> editCBOs = cboList.stream().filter(s -> !CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(s.getLcStatus())).collect(Collectors.toList());
- if (!CollectionUtils.isEmpty(editCBOs)) {
- ClientBusinessObject cbo = editCBOs.get(0);
- throw new VciBaseException("缂栫爜涓簕0}绛夊叡{1}鏉℃暟鎹殑鐘舵�佷笉鏄痆{2}]锛屼笉鍏佽鍒犻櫎", new String[]{cbo.getId(), String.valueOf(editCBOs.size()), CodeDefaultLC.EDITING.getText()});
- }
-
- //鍙兘鍒犻櫎鑷繁鍒涘缓鐨勬暟鎹�
- String userId = WebUtil.getCurrentUserId();
- for (ClientBusinessObject clientBusinessObject:cboList){
- String creator = clientBusinessObject.getCreator();
- if(!userId.equalsIgnoreCase(creator)){
- throw new VciBaseException("缂栫爜涓�"+clientBusinessObject.getId()+"鐨勬暟鎹笉鏄綋鍓嶇敤鎴峰垱寤猴紝涓嶈兘鍒犻櫎锛�");
- }
-
- }
- BatchCBO batchCBO = new BatchCBO();
- batchCBO.getDeleteCbos().addAll(cboList);
- WebUtil.setPersistence(false);
- batchCBO.copyFromOther(productCodeService.recycleCode(classifyFullInfo.getCurrentClassifyVO().getBtmtypeid(), deleteBatchDTO.getOidList()));
- WebUtil.setPersistence(true);
- boService.persistenceBatch(batchCBO);
- }
-
- /**
- * 鎷疯礉鏁版嵁鍒癱bo瀵硅薄涓�
- *
- * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @param cbo 涓氬姟鏁版嵁
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- * @param templateVO 妯℃澘鐨勬樉绀哄璞�
- * @param edit 鏄惁涓轰慨鏀�
- */
- private void copyValueToCBO(CodeClassifyFullInfoBO classifyFullInfo, ClientBusinessObject cbo,
- CodeOrderDTO orderDTO, CodeClassifyTemplateVO templateVO,
- boolean edit) {
- String fullPath = "";
- if (!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())) {
- fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel())))
- .map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
- } else {
- fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
- }
- orderDTO.getData().forEach((key, value) -> {
- if (!edit || (!boService.checkUnAttrUnEdit(key) &&
- !VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(key))) {
- try {
- cbo.setAttributeValue(key, value);
- } catch (VCIError e) {
- logger.error("璁剧疆灞炴�х殑鍊奸敊璇�", e);
- }
- }
- });
- try {
- cbo.setAttributeValue(MdmEngineConstant.CODE_CLASSIFY_OID_FIELD, classifyFullInfo.getCurrentClassifyVO().getOid());
- cbo.setAttributeValue(MdmEngineConstant.CODE_TEMPLATE_OID_FIELD, templateVO.getOid());
- cbo.setAttributeValue(MdmEngineConstant.CODE_FULL_PATH_FILED, fullPath);
- if (!edit && StringUtils.isBlank(orderDTO.getLcStatus())) {
- //鎵剧敓鍛藉懆鏈熺殑璧峰鐘舵�侊紝
- if (StringUtils.isNotBlank(cbo.getLctId())) {
- OsLifeCycleVO lifeCycleVO = lifeCycleService.getLifeCycleById(cbo.getLctId());
- if (lifeCycleVO != null) {
- cbo.setLcStatus(lifeCycleVO.getStartStatus());
- } else {
- cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
- }
- } else {
- cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
- }
-
- }
- int secret = VciBaseUtil.getInt(cbo.getAttributeValue(MdmEngineConstant.SECRET_FIELD));
- if (secret == 0 || !secretService.checkDataSecret(secret)) {
- Integer userSecret = VciBaseUtil.getCurrentUserSecret();
- cbo.setAttributeValue(MdmEngineConstant.SECRET_FIELD, String.valueOf((userSecret == null || userSecret == 0) ? UserSecretEnum.NONE.getValue() : userSecret));
- }
- } catch (Throwable e) {
- logger.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�", e);
- }
- }
-
-
- /**
- * 杞崲缁勫悎瑙勫垯鐨勫��
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- */
- private void switchComponentAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
- Map<String, CodeClassifyTemplateAttrVO> compAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getComponentrule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(compAttrVOMap)) {
- Map<String, String> dataMap = WebUtil.objectToMapString(orderDTO);
-
- Map<String, String> dataLowMap = new HashMap<>();
- if (!CollectionUtils.isEmpty(dataMap)) {
- dataMap.forEach((key, value) -> {
- dataLowMap.put(key.toLowerCase(Locale.ROOT), value);
- });
- }
- dataLowMap.putAll(orderDTO.getData());
- compAttrVOMap.forEach((attrId, attrVO) -> {
- dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentrule()));
- });
- dataLowMap.forEach((key, value) -> {
- setValueToOrderDTO(orderDTO, key, value);
- });
- }
- }
-
- /**
- * 澶勭悊鍒嗙被娉ㄥ叆鐨勪俊鎭�
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝蹇呴』瑕佸悗妯℃澘鐨勫睘鎬�
- * @param classifyFullInfoBO 鍒嗙被鐨勫叏璺緞
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- */
- private void switchClassifyLevelOnOrder(CodeClassifyTemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO orderDTO) {
- Map<String, CodeClassifyTemplateAttrVO> classifyAttrVOMap = templateVO.getAttributes().stream().filter(
- s -> StringUtils.isNotBlank(s.getClassifyinvokeattr()) && StringUtils.isNotBlank(s.getClassifyinvokelevel())
- ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (classifyFullInfoBO.getTopClassifyVO() == null) {
- //闇�瑕侀噸鏂版煡璇竴涓嬶紝鍥犱负杩欎釜鏄寚瀹氱殑鍒嗙被杩涙潵鐨�
-
- }
- if (!CollectionUtils.isEmpty(classifyAttrVOMap)) {
- classifyAttrVOMap.forEach((attrId, attrVO) -> {
- //鍒嗙被娉ㄥ叆鐨勭紪鍙锋垨鑰呭悕绉帮紝
- //灞傜骇鍖呭惈鎸囧畾灞傚拰鏈�灏忓眰
- CodeClassifyVO classifyVO = null;
- if (!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyinvokelevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyinvokelevel())) {
- //鎸囧畾浜嗗眰绾х殑
- //娉ㄦ剰锛屽洜涓烘煡璇笂绾у垎绫诲嚭鏉ョ殑灞傜骇鏄�掑簭鐨勶紝鍗抽《灞傝妭鐐规槸鏈�澶х殑鍊�
- List<CodeClassifyVO> classifyVOS = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
- int level = VciBaseUtil.getInt(attrVO.getClassifyinvokelevel());
- if (classifyVOS.size() >= level && level > 0) {
- classifyVO = classifyVOS.get(level - 1);
- }
- } else {
- //褰撳墠鐨勫垎绫�
- classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
- }
- if (classifyVO == null) {
- //璇存槑灞傜骇鏈夎
- orderDTO.getData().put(attrId, "鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyinvokelevel() + "]");
- // classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
- } else {
- Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
- String value = classifyDataMap.getOrDefault(attrVO.getClassifyinvokeattr(), "");
- orderDTO.getData().put(attrId, value);
- }
- });
- }
- }
-
- /**
- * 杞崲鏃堕棿鐨勬牸寮�
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- */
- private void switchDateAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
- Map<String, CodeClassifyTemplateAttrVO> dateAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getCodedateformat())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
- dateAttrVOMap.forEach((attrId, attrVO) -> {
- String value = getValueFromOrderDTO(orderDTO, attrId);
- if (StringUtils.isNotBlank(value)) {
- DateConverter dateConverter = new DateConverter();
- dateConverter.setAsText(value);
- value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
- setValueToOrderDTO(orderDTO, attrId, value);
- }
- });
- }
- }
-
- /**
- * 鏍￠獙鏋氫妇鐨勫唴瀹�
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- */
- private void checkEnumOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
- //濡傛灉鏋氫妇鍙互淇敼锛屽垯涓嶉渶瑕佹牎楠屾槸鍚︾鍚堟灇涓剧殑閫夐」
- Map<String, CodeClassifyTemplateAttrVO> enumAttrVOMap = templateVO.getAttributes().stream().filter(s -> (StringUtils.isNotBlank(s.getEnumString()) || StringUtils.isNotBlank(s.getEnumid())) && !VciBaseUtil.getBoolean(s.getEnumeditflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(enumAttrVOMap)) {
- enumAttrVOMap.forEach((attrId, attrVO) -> {
- String value = getValueFromOrderDTO(orderDTO, attrId);
- if (StringUtils.isNotBlank(value)) {
- //鏈夊�兼墠鑳芥牎楠�
- List<KeyValue> comboboxKVs = listComboboxItems(attrVO);
- if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
- throw new VciBaseException("灞炴�с�恵0}銆戠殑鍊间笉绗﹀悎鏋氫妇鐨勮姹�", new String[]{attrVO.getName()});
- }
- }
- });
- }
- }
-
- /**
- * 鏍￠獙姝ｅ垯琛ㄨ揪寮忔槸鍚︽纭�
- *
- * @param templateVO 妯℃澘鐨勪俊鎭紝蹇呴』鍖呭惈灞炴�х殑鍐呭
- * @param orderDTO 缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
- */
- private void checkVerifyOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
- Map<String, CodeClassifyTemplateAttrVO> verifyAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getVerifyrule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(verifyAttrVOMap)) {
- verifyAttrVOMap.forEach((attrId, attrVO) -> {
- String value = getValueFromOrderDTO(orderDTO, attrId);
- if (StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyrule())) {
- //鏍￠獙姝ｅ垯琛ㄨ揪寮�
- throw new VciBaseException("灞炴�{0}]鐨勫�间笉绗﹀悎鏍￠獙瑙勫垯鐨勮姹�", new String[]{attrVO.getName()});
- }
- });
- }
- }
-
- /**
- * 鏍￠獙鍏抽敭灞炴��
- *
- * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
- * @param templateVO 妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
- * @param orderDTO 缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
- */
- private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
- //鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
- CodeKeyAttrRepeatRuleVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
- //娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
- //鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
- Map<String, CodeClassifyTemplateAttrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyattrflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- Map<String, String> conditionMap = new HashMap<>();
- boolean trimAll = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
- //鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
- boolean trim = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
- boolean ignoreCase = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
- boolean ignoreWidth = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
- ketAttrMap.forEach((attrId, attrVO) -> {
- String value = getValueFromOrderDTO(orderDTO, attrId);
- if (value == null) {
- value = "";
- }
- wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
- });
-
- //娌℃湁闄愬埗鍒嗙被锛屼絾鏄竴涓ā鏉垮彧鍙兘鍦ㄤ竴涓笟鍔＄被鍨嬮噷闈紝鎵�浠ョ洿鎺ユ煡璇㈣繖涓笟鍔＄被鍨嬪嵆鍙�
-
- if (!CollectionUtils.isEmpty(conditionMap)) {
- final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()) + " t where 1 = 1 "};
- conditionMap.forEach((key, value) -> {
- sql[0] += " and " + key + " = " + value;
- });
- if (StringUtils.isNotBlank(orderDTO.getOid())) {
- //淇敼鐨勬椂鍊欙紝闇�瑕佹帓闄よ嚜宸�
- sql[0] += " and oid != '" + orderDTO.getOid() + "'";
- } else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
- sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
- }
- sql[0] += " and islastR = '1' and islastV = '1' ";
- if (boService.queryCountBySql(sql[0], new HashMap<>()) > 0) {
- String ruleInfoMsg = keyRuleVO == null ? "" : "鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}";
- String[] objs = new String[]{trim ? "鏄�" : "鍚�", ignoreCase ? "鏄�" : "鍚�", ignoreWidth ? "鏄�" : "鍚�", trimAll ? "鏄�" : "鍚�"};
- throw new VciBaseException("鏍规嵁鎮ㄥ～鍐欑殑鍏抽敭灞炴�х殑鍐呭锛岀粨鍚堝叧閿睘鎬ф煡璇㈣鍒欙紝鍙戠幇杩欎釜鏁版嵁宸茬粡鍦ㄧ郴缁熶腑瀛樺湪浜嗐�傝淇!銆�" + ruleInfoMsg, objs);
- }
- }
- }
-
- /**
- * 灏佽鍏抽敭灞炴�х殑鏌ヨ璇彞
- *
- * @param value 褰撳墠鐨勫��
- * @param keyRuleVO 鍏抽敭灞炴�х殑鎺у埗瑙勫垯锛屽彲浠ヤ负绌�
- * @param attrId 灞炴�х殑缂栧彿
- * @param trim 鏄惁鍘婚櫎绌烘牸
- * @param ignoreCase 鏄惁涓嶅尯鍒嗗ぇ灏忓啓
- * @param ignoreWidth 鏄惁蹇界暐鍏ㄥ崐瑙�
- * @param trimAll 鏄惁蹇界暐鍏ㄩ儴绌烘牸
- * @param conditionMap 鏌ヨ鏉′欢
- */
- @Override
- public void wrapperKeyAttrConditionMap(String value, CodeKeyAttrRepeatRuleVO keyRuleVO, String attrId,
- boolean trim, boolean ignoreCase, boolean ignoreWidth,
- boolean trimAll, Map<String, String> conditionMap) {
- boolean ignoreSpace = trim || trimAll;
- if (StringUtils.isBlank(value)) {
- //涓虹┖鐨勬椂鍊欙紝涓嶈兘鐢≦ueryOperation.ISNULL锛屽钩鍙颁笉鐭ラ亾鍟ユ椂鍊欎笉澶勭悊杩欑浜�
- conditionMap.put("t."+attrId, "null");
- } else {
- if (keyRuleVO != null) {
- String queryKey = "";
- String queryValue = "";
-
- String temp = "";
- if (ignoreCase && ignoreSpace && ignoreWidth) {
- //蹇界暐澶у皬鍐欙紝涓斿幓绌猴紝蹇界暐鍏ㄥ崐瑙�
- temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(to_single_byte(%s)) " + (trimAll ? ",' ','')" : ")");
- } else if (ignoreCase && ignoreSpace && !ignoreWidth) {
- //蹇界暐澶у皬鍐欍�佸幓绌恒�佷笉蹇界暐鍏ㄥ崐瑙�
- temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(%s) " + (trimAll ? ",' ','')" : ")");
- } else if (ignoreCase && !ignoreSpace && ignoreWidth) {
- //蹇界暐澶у皬鍐欍�佷笉鍘荤┖銆佸拷鐣ュ叏鍗婅
- temp = "UPPER(to_single_byte(%s))";
- } else if (!ignoreCase && ignoreSpace && ignoreWidth) {
- //涓嶅拷鐣ュぇ灏忓啓銆佸幓绌恒�佸拷鐣ュ叏鍗婅
- temp = (trimAll ? "REPLACE" : "TRIM") + "(to_single_byte(%s) " + (trimAll ? ",' ','')" : ")");
- } else if (ignoreCase && !ignoreSpace && !ignoreWidth) {
- //蹇界暐澶у皬鍐欍�佷笉鍘荤┖銆佷笉蹇界暐鍏ㄥ崐瑙�
- temp = "UPPER(%s)";
- } else if (!ignoreCase && !ignoreCase && ignoreWidth) {
- //涓嶅拷鐣ュぇ灏忓啓銆佷笉鍘荤┖銆佸拷鐣ュ叏鍗婅
- temp = "to_single_byte(%s)";
- } else if (!ignoreCase && ignoreSpace && !ignoreWidth) {
- //涓嶅拷鐣ュぇ灏忓啓銆佸幓绌恒�佷笉蹇界暐鍏ㄥ崐瑙�
- temp = (trimAll ? "REPLACE" : "TRIM") + "(%s " + (trimAll ? ",' ','')" : ")");
- } else if (!ignoreCase && !ignoreSpace && !ignoreWidth) {
- //涓嶅拷鐣ュぇ灏忓啓銆佷笉鍘荤┖銆佷笉蹇界暐鍏ㄥ崐瑙�
- temp = "%s";
- }
- queryKey = String.format(temp, "t."+attrId);
- queryValue = String.format(temp, "'" + (trim ? value.trim() : value) + "'");
- conditionMap.put(queryKey, queryValue);
- } else {
- //涓虹┖鐨勬椂鍊欎笉浠ｈ〃涓嶆牎楠岋紝鍙槸涓嶅幓闄ょ浉鍏崇殑淇℃伅
- conditionMap.put("t."+attrId, value);
- }
- }
- }
-
-
- /**
- * 浠庣紪鐮佺敵璇蜂俊鎭璞′笂鑾峰彇鏌愪釜灞炴�х殑鍊�
- *
- * @param orderDTO 缂栫爜鐢宠瀵硅薄
- * @param attrId 灞炴�х殑缂栧彿
- * @return 鍊�
- */
- private String getValueFromOrderDTO(CodeOrderDTO orderDTO, String attrId) {
- attrId = attrId.toLowerCase(Locale.ROOT);
- String value = null;
- if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)
- || VciQueryWrapperForDO.SECRET_MANAGE_FIELD_MAP.containsKey(attrId)
- || VciQueryWrapperForDO.REVISION_MANAGE_FIELD_MAP.containsKey(attrId)
- || VciQueryWrapperForDO.LIFECYCLE_MANAGE_FIELD_MAP.containsKey(attrId)
- || VciQueryWrapperForDO.BASE_MODEL_COMPATIBILITY_MAP.containsValue(attrId)
- ) {
- value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
- } else {
- //璇存槑鏄嚜琛岄厤缃殑
- //鍓嶇蹇呴』瑕佷紶閫掑皬鍐欑殑灞炴��
- value = orderDTO.getData().getOrDefault(attrId, "");
- }
- return value;
- }
-
- /**
- * 璁剧疆鏂扮殑鍊煎埌鐢宠瀵硅薄涓�
- *
- * @param orderDTO 缂栫爜鐢宠瀵硅薄
- * @param attrId 灞炴�х殑缂栧彿
- * @param value 鍊�
- */
- private void setValueToOrderDTO(CodeOrderDTO orderDTO, String attrId, String value) {
- attrId = attrId.toLowerCase(Locale.ROOT);
- if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
- WebUtil.setValueToField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO, value);
- } else {
- orderDTO.getData().put(attrId, value);
- }
- }
-
-
- /**
- * 鏍￠獙灞炴�ф槸鍚︿负蹇呰緭
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
- * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
- */
- private void checkRequiredAttrOnOrder(CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) {
- Map<String, CodeClassifyTemplateAttrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(
- s -> VciBaseUtil.getBoolean(s.getRequireflag()) && StringUtils.isBlank(s.getComponentrule())
- && StringUtils.isBlank(s.getClassifyinvokeattr()))
- .collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
- if (!CollectionUtils.isEmpty(requiredAttrMap)) {
- requiredAttrMap.forEach((attrId, attrVO) -> {
- //鍙湁浼佷笟缂栫爜锛岀姸鎬侊紝澶囨敞锛屾ā鏉夸富閿紝鍒嗙被涓婚敭杩欏嚑涓槸鍥哄畾鐨勶紝鍏朵綑閮芥槸鑷閰嶇疆鐨�
- if (StringUtils.isBlank(getValueFromOrderDTO(orderDTO, attrId))) {
- throw new VciBaseException("灞炴�с�恵0}銆戝繀椤昏杈撳叆(閫夋嫨)鍐呭", new String[]{attrVO.getName()});
- }
- });
- }
- }
-
-
- /**
- * 鍒ゆ柇缂栫爜鐨勭爜娈垫槸鍚﹁緭鍏ユ垨鑰呴�夋嫨浜嗙爜鍊�
- *
- * @param ruleVO 瑙勫垯鐨勬樉绀哄璞�
- * @param orderDTO 缂栫爜鐢宠鐨勫唴瀹�
- */
- @Override
- public void checkSecValueOnOrder(CodeRuleVO ruleVO, CodeOrderDTO orderDTO) {
- List<String> unSerialSecOidList = ruleVO.getSecVOList().stream().filter(
- s -> !(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue().equalsIgnoreCase(s.getSectype())
- || CodeSecTypeEnum.CODE_ATTR_SEC.getValue().equalsIgnoreCase(s.getSectype())
- || CodeSecTypeEnum.CODE_DATE_SEC.getValue().equalsIgnoreCase(s.getSectype())
- || CodeSecTypeEnum.CODE_LEVEL_SEC.getValue().equalsIgnoreCase(s.getSectype())
- || VciBaseUtil.getBoolean(s.getNullableFlag()))
- ).map(CodeBasicSecVO::getOid).collect(Collectors.toList());
- if (!CollectionUtils.isEmpty(unSerialSecOidList)) {
- if (CollectionUtils.isEmpty(orderDTO.getSecDTOList())) {
- throw new VciBaseException("闈炴祦姘寸爜娈�(鎴栬�呭繀杈撶爜娈碉級蹇呴』瑕佽緭鍏�(鎴栭�夋嫨)鐮佸��");
- }
- if (orderDTO.getSecDTOList().stream().anyMatch(s -> !unSerialSecOidList.contains(s.getSecOid())
- && StringUtils.isBlank(s.getSecValue()))) {
- throw new VciBaseException("闈炴祦姘寸爜娈�(鎴栬�呭繀杈撶爜娈碉級蹇呴』瑕佽緭鍏�(鎴栭�夋嫨)鐮佸��");
- }
- }
- }
-
- /**
- * 浣跨敤鍒嗙被鍜岄樁娈电殑缂栧彿锛岃幏鍙栧寘鍚殑灞炴��
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @param phase 闃舵鐨勫悕绉�
- * @return 灞炴�х殑鑻辨枃鍚嶇О
- */
- @Override
- public List<String> listPhaseAttrByClassifyOid(String codeClassifyOid, String phase) {
- CodeClassifyTemplateVO templateVO = getUsedTemplateByClassifyOid(codeClassifyOid, false);
- //鎵鹃樁娈�
- return phaseAttrService.listAttrByTemplateOidAndPhaseId(templateVO.getOid(), phase);
- }
-
- /**
- * 璺緞涓婂寘鍚綋鍓嶅垎绫荤殑鎵�鏈夊垎绫讳俊鎭�
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @return 鍒嗙被鏍�
- */
- @Override
- public List<Tree> hasSelfClassifyTree(String codeClassifyOid) {
- if (StringUtils.isBlank(codeClassifyOid)) {
- return new ArrayList<>();
- }
- CodeClassifyFullInfoBO fullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
- //鏌ヨ瀛�
- List<CodeClassifyVO> childrenClassifys = classifyService.listChildrenClassify(codeClassifyOid, true, "id", true);
- Map<String, CodeClassifyVO> classifyVOMap = new HashMap<>();
- classifyVOMap.putAll(Optional.ofNullable(fullInfo.getParentClassifyVOs()).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t)));
- classifyVOMap.putAll(Optional.ofNullable(childrenClassifys).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t)));
- TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(CodeClassifyServiceImpl.PARENT_FIELD_NAME.toLowerCase(Locale.ROOT));
- return revisionModelUtil.doList2Trees(classifyVOMap.values().stream().collect(Collectors.toList()), treeWrapperOptions, (CodeClassifyVO s) -> {
- return s.getId() + " " + s.getName() + (FrameworkDataLCStatus.DISABLED.getValue().equalsIgnoreCase(s
- .getLcStatus()) ? (" 銆愬仠鐢ㄣ�� ") : "");
- });
- }
-
- /**
- * 鍒嗙被娉ㄥ叆鐨勫唴瀹归瑙�
- *
- * @param codeClassifyOid 鍒嗙被鐨勪富閿�
- * @param codeTemplateOid 妯℃澘鐨勪富閿�
- * @return key鏄垎绫绘敞鍏ョ殑灞炴�э紝value鏄敞鍏ュ悗鐨勫��
- */
- @Override
- public Map<String, String> previewClassify(String codeClassifyOid, String codeTemplateOid) {
- if (StringUtils.isBlank(codeClassifyOid) || StringUtils.isBlank(codeTemplateOid)) {
- return new HashMap<>();
- }
- //鏌ヨ鍒嗙被鐨勪俊鎭紝鏌ヨ妯℃澘鐨勪俊鎭�
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
- CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(codeTemplateOid);
- //
-
- CodeOrderDTO orderDTO = new CodeOrderDTO();
- orderDTO.setData(new HashMap<>());
- switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
- return orderDTO.getData();
- }
-
- /**
- * 棰勮缁勫悎瑙勫垯
- *
- * @param orderDTO 棰勮鐨勪俊鎭紝鍖呭惈妯℃澘鐨勪富閿�
- * @return key鏄粍鍚堣鍒欑殑灞炴�с�倂alue鏄粍鍚堝悗鐨勫�硷紝銆傚鏋滅己灏戞煇涓睘鎬х殑鍊硷紝浼氫綔涓簐alue杩斿洖
- */
- @Override
- public Map<String, String> previewCompRule(CodeOrderDTO orderDTO) {
- VciBaseUtil.alertNotNull(orderDTO, "缂栫爜鐢宠鐩稿叧淇℃伅", orderDTO.getTemplateOid(), "妯℃澘鐨勪富閿�");
- //鏌ヨ鍒嗙被鐨勪俊鎭紝鏌ヨ妯℃澘鐨勪俊鎭�
- CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
- switchComponentAttrOnOrder(templateVO, orderDTO);
- return orderDTO.getData();
- }
-
- /**
- * 淇敼鐘舵��
- *
- * @param baseModelDTO 鏁版嵁浼犺緭瀵硅薄
- */
- @Override
- public void changeStatus(BaseModelDTO baseModelDTO) {
- VciBaseUtil.alertNotNull(baseModelDTO, "鏁版嵁淇℃伅", baseModelDTO.getOid(), "涓婚敭", baseModelDTO.getBtmname(), "涓氬姟绫诲瀷", baseModelDTO.getLcStatus(), "鐩爣鐘舵��");
- List<String> oids = VciBaseUtil.str2List(baseModelDTO.getOid());
- List<ClientBusinessObject> cboList = boService.selectCBOByOidCollection(oids, baseModelDTO.getBtmname());
- //杩橀渶瑕佷慨鏀筧llCode鐨勭敓鍛藉懆鏈�
- Map<String, String> conditionMap = new HashMap<>();
- conditionMap.put("createcodeoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
- conditionMap.put("createcodebtm", baseModelDTO.getBtmname());
- List<ClientBusinessObject> codeCbos = boService.queryCBO(MdmBtmTypeConstant.CODE_ALL_CODE, conditionMap);
- // 鍥炴敹闇�瑕佷笟鍔℃暟鎹垹闄�
- if (CodeDefaultLC.TASK_BACK.getValue().equals(baseModelDTO.getLcStatus())) {
- BatchCBO batchCBO = new BatchCBO();
- batchCBO.getDeleteCbos().addAll(cboList);
- boService.persistenceBatch(batchCBO);
- } else {
- lifeCycleService.transCboStatus(cboList, baseModelDTO.getLcStatus());
- }
- lifeCycleService.transCboStatus(codeCbos, baseModelDTO.getLcStatus());
- }
-
- /**
- * 鐩镐技椤规煡璇�
- *
- * @param orderDTO 缂栫爜鐨勭浉鍏充俊鎭�
- * @return 鏁版嵁鍒楄〃
- */
- @Override
- public DataGrid<Map<String, String>> resembleQuery(CodeOrderDTO orderDTO) {
- VciBaseUtil.alertNotNull(orderDTO, "鐢宠鐨勪俊鎭�", orderDTO.getCodeClassifyOid(), "鍒嗙被涓婚敭", orderDTO.getTemplateOid(), "妯℃澘涓婚敭");
- CodeClassifyFullInfoBO fullInfoBO = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
- CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
- switchClassifyLevelOnOrder(templateVO, fullInfoBO, orderDTO);
- switchDateAttrOnOrder(templateVO, orderDTO);
- switchComponentAttrOnOrder(templateVO, orderDTO);
- //闇�瑕佽幏鍙栨槸鍚︽湁鐩镐技鏌ヨ灞炴��
- Map<String, CodeClassifyTemplateAttrVO> attrVOs = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())).collect(Collectors.toMap(s -> s.getId(), t -> t));
- if (CollectionUtils.isEmpty(attrVOs)) {
- //閮芥病鏈夊睘鎬э紝鑲畾涓嶈兘鏌ヨ浜�
- return new DataGrid<>();
- }
- Map<String, String> conditionMap = new HashMap<>();
- //鎴戜滑棣栧厛鑾峰彇鏈夋病鏈夋煡璇㈣鍒�
- CodeResembleRuleVO resembleRuleVO = Optional.ofNullable(getUseResembleRule(fullInfoBO, fullInfoBO.getCurrentClassifyVO())).orElseGet(() -> new CodeResembleRuleVO());
- attrVOs.forEach((attrId, attrVO) -> {
- String value = getValueFromOrderDTO(orderDTO, attrId);
- if (value == null) {
- value = "";
- }
- wrapperResembleConditionMap(value, resembleRuleVO, attrId, conditionMap);
- });
-
- //娌℃湁闄愬埗鍒嗙被锛屼絾鏄竴涓ā鏉垮彧鍙兘鍦ㄤ竴涓笟鍔＄被鍨嬮噷闈紝鎵�浠ョ洿鎺ユ煡璇㈣繖涓笟鍔＄被鍨嬪嵆鍙�
- if (!CollectionUtils.isEmpty(conditionMap)) {
- Map<String, String> andConditionMap = new HashMap<>();
- andConditionMap.put("islastr", "1");
- andConditionMap.put("islastv", "1");
- if (StringUtils.isNotBlank(orderDTO.getOid())) {
- andConditionMap.put("oid", QueryOptionConstant.NOTEQUAL + orderDTO.getOid());
- }
- conditionMap.putAll(andConditionMap);
- PageHelper pageHelper = new PageHelper(-1);
- pageHelper.addDefaultDesc("id");
- return queryGrid(fullInfoBO.getTopClassifyVO().getBtmtypeid(), templateVO, conditionMap, pageHelper);
- }
- return new DataGrid<>();
- }
-
- /**
- * 灏佽鐩镐技椤规煡璇㈢殑鏌ヨ鏉′欢鐨勬槧灏�
- *
- * @param value 鍊�
- * @param resembleRuleVO 鐩镐技椤硅鍒�
- * @param attrId 灞炴�х殑缂栧彿
- * @param conditionMap 鏌ヨ鏉′欢
- */
- @Override
- public void wrapperResembleConditionMap(String value, CodeResembleRuleVO resembleRuleVO, String attrId, Map<String, String> conditionMap) {
- boolean ignoreSpace = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorespaceflag()) || VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
- if (StringUtils.isBlank(value)) {
- //涓虹┖鐨勬椂鍊欏氨涓嶆煡璇㈠畠灏辨槸
- } else {
- String queryKey = "";
- String queryValue = "";
- boolean ignoreCase = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorecaseflag());
- boolean ignoreWidth = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorewidthflag());
- boolean trimAll = VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
- boolean trim = VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
- String temp = "";
- if (ignoreCase && ignoreSpace && ignoreWidth) {
- //蹇界暐澶у皬鍐欙紝涓斿幓绌猴紝蹇界暐鍏ㄥ崐瑙�
- temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(to_single_byte('%s')) " + (trimAll ? ",' ','')" : ")");
- } else if (ignoreCase && ignoreSpace && !ignoreWidth) {
- //蹇界暐澶у皬鍐欍�佸幓绌恒�佷笉蹇界暐鍏ㄥ崐瑙�
- temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(%s) " + (trimAll ? ",' ','')" : ")");
- } else if (ignoreCase && !ignoreSpace && ignoreWidth) {
- //蹇界暐澶у皬鍐欍�佷笉鍘荤┖銆佸拷鐣ュ叏鍗婅
- temp = "UPPER(to_single_byte('%s'))";
- } else if (!ignoreCase && ignoreSpace && ignoreWidth) {
- //涓嶅拷鐣ュぇ灏忓啓銆佸幓绌恒�佸拷鐣ュ叏鍗婅
- temp = (trimAll ? "REPLACE" : "TRIM") + "(to_single_byte('%s') " + (trimAll ? ",' ','')" : ")");
- } else if (ignoreCase && !ignoreSpace && !ignoreWidth) {
- //蹇界暐澶у皬鍐欍�佷笉鍘荤┖銆佷笉蹇界暐鍏ㄥ崐瑙�
- temp = "UPPER(%s)";
- } else if (!ignoreCase && !ignoreCase && ignoreWidth) {
- //涓嶅拷鐣ュぇ灏忓啓銆佷笉鍘荤┖銆佸拷鐣ュ叏鍗婅
- temp = "to_single_byte('%s')";
- } else if (!ignoreCase && ignoreSpace && !ignoreWidth) {
- //涓嶅拷鐣ュぇ灏忓啓銆佸幓绌恒�佷笉蹇界暐鍏ㄥ崐瑙�
- temp = (trimAll ? "REPLACE" : "TRIM") + "(%s " + (trimAll ? ",' ','')" : ")");
- } else if (!ignoreCase && !ignoreSpace && !ignoreWidth) {
- //涓嶅拷鐣ュぇ灏忓啓銆佷笉鍘荤┖銆佷笉蹇界暐鍏ㄥ崐瑙�
- temp = "%s";
- }
- if (StringUtils.isNotBlank(resembleRuleVO.getLinkCharacter())) {
- List<String> chars = VciBaseUtil.str2List(resembleRuleVO.getLinkCharacter());
- for (int i = 0; i < chars.size(); i++) {
- String s = chars.get(i);
- temp = "replace(" + temp + ",'" + s + "','')";
- }
- }
- queryValue = String.format(temp, (trim ? value.trim() : value));
- temp = temp.replace("to_single_byte('%s')","to_single_byte(%s)");
- queryKey = String.format(temp, "t."+attrId);
- conditionMap.put(queryKey, QueryOptionConstant.OR + queryValue);
- }
- }
-
- /**
- * 浣跨敤鍒嗙被涓婚敭鑾峰彇鐩镐技鏌ヨ瑙勫垯
- *
- * @param codeClassifyOid 鍒嗙被涓婚敭
- * @return 瑙勫垯锛屽鏋滀笉瀛樺湪浼氳繑鍥瀗ull
- */
- @Override
- public CodeResembleRuleVO getUseResembleRuleByClassifyOid(String codeClassifyOid) {
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
- return getUseResembleRule(classifyFullInfo, classifyFullInfo.getCurrentClassifyVO());
- }
-
- /**
- * 鑾峰彇浣跨敤鐨勭浉浼兼煡璇㈣鍒�
- *
- * @param fullInfoBO 绫诲叏閮ㄤ俊鎭�
- * @param currentClassifyVO 褰撳墠鐨勫垎绫�
- * @return 瑙勫垯锛屽鏋滀笉瀛樺湪浼氳繑鍥濶ull
- */
- @Override
- public CodeResembleRuleVO getUseResembleRule(CodeClassifyFullInfoBO fullInfoBO, CodeClassifyVO currentClassifyVO) {
- if (currentClassifyVO == null) {
- return null;
- }
- if (currentClassifyVO != null && StringUtils.isNotBlank(currentClassifyVO.getCodeResembleRuleOid())) {
- //璇存槑宸茬粡瀛樺湪
- return resembleRuleService.getObjectByOid(currentClassifyVO.getCodeResembleRuleOid());
- }
- if (StringUtils.isBlank(currentClassifyVO.getParentcodeclassifyoid())) {
- return null;
- }
- Map<String, CodeClassifyVO> classifyVOMap = fullInfoBO.getParentClassifyVOs().stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
- return getUseResembleRule(fullInfoBO, classifyVOMap.getOrDefault(currentClassifyVO.getParentcodeclassifyoid(), null));
- }
-
-
- /**
- * 妯℃澘灞炴�ц浆鎹负琛ㄥ崟瀹氫箟鐨勪俊鎭�
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞�
- * @param codeClassifyOid 鍒嗙被鐨勪富閿紝涓虹┖鐨勬椂鍊欙紝鑾峰彇妯℃澘鎵�灞炵殑鍒嗙被涓婚敭.鐢ㄤ簬浜х敓鍒嗙被娉ㄥ叆
- * @return 琛ㄦ牸鐨勪俊鎭�
- */
- private UIFormDefineVO wrapperFormDefineByTemplate(CodeClassifyTemplateVO templateVO, String codeClassifyOid) {
- UIFormDefineVO formDefineVO = new UIFormDefineVO();
- formDefineVO.setOid(templateVO.getOid());
- formDefineVO.setBtmType(templateVO.getBtmTypeId());
- if (StringUtils.isBlank(codeClassifyOid)) {
- codeClassifyOid = templateVO.getCodeclassifyoid();
- }
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
-
- List<UIFormItemVO> itemVOS = new ArrayList<>();
- Map<String, List<CodeClassifyTemplateAttrVO>> attrGroupMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getAttributegroup())).collect(Collectors.groupingBy(s -> s.getAttributegroup()));
- templateVO.getAttributes().forEach(attrVO -> {
- UIFormItemVO formItemVO = templateAttr2FormField(attrVO, templateVO.getBtmTypeId());
- itemVOS.add(formItemVO);
- });
- //澶勭悊灞炴�у垎缁�
- if (!CollectionUtils.isEmpty(attrGroupMap)) {
- //鎸夌収鍒嗙粍鐨勫睘鎬ф帓鍒楋紝鎵惧埌姣忎竴涓垎缁勭殑绗竴涓睘鎬�
- for (String key : attrGroupMap.keySet()) {
- List<CodeClassifyTemplateAttrVO> value = attrGroupMap.get(key);
- //鎵惧埌杩欎釜鍒嗙粍鐨勫睘鎬х殑绗竴涓�
- CodeClassifyTemplateAttrVO attrVO = value.stream().sorted(((o1, o2) -> o1.getOrdernum().compareTo(o2.getOrdernum()))).findFirst().get();
- //鎴戜滑鎵惧埌杩欎釜灞炴�у湪鏈�缁堢殑itemVOs閲岀殑浣嶇疆
- UIFormItemVO lineVO = new UIFormItemVO();
- lineVO.setField(attrVO.getId() + "_line");
- lineVO.setType("line");
- lineVO.setText(key);
- //鎵句綅缃�
- for (int i = 0; i < itemVOS.size(); i++) {
- UIFormItemVO record = itemVOS.get(i);
- if (record.getField().equalsIgnoreCase(attrVO.getId())) {
- itemVOS.add(i, lineVO);
- break;
- }
- }
- }
- }
-
- CodeOrderDTO orderDTO = new CodeOrderDTO();
- switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
- if (!CollectionUtils.isEmpty(orderDTO.getData())) {
- orderDTO.getData().forEach((key, value) -> {
- for (int i = 0; i < itemVOS.size(); i++) {
- UIFormItemVO itemVO = itemVOS.get(i);
- if (itemVO.getField().equalsIgnoreCase(key)) {
- itemVO.setDefaultValue(value);
- break;
- }
- }
- });
- }
- formDefineVO.setItems(itemVOS);
- //鏌ヨ鏄惁鏈夊垎绫绘敞鍏ョ殑
- return formDefineVO;
- }
-
-
- /**
- * 妯℃澘灞炴�ц浆鎹负琛ㄦ牸瀹氫箟鐨勪俊鎭�
- *
- * @param templateVO 妯℃澘鐨勬樉绀哄璞�
- * @param forEdit 鏄惁鏄紪杈戞墍闇�
- * @return 琛ㄦ牸鐨勪俊鎭�
- */
- private UITableDefineVO wrapperTableDefineByTemplate(CodeClassifyTemplateVO templateVO,boolean forEdit) {
- //灏佽淇℃伅
- UITableDefineVO tableDefineVO = new UITableDefineVO();
- tableDefineVO.setOid(templateVO.getOid());
- tableDefineVO.setBtmType(templateVO.getBtmTypeId());
- tableDefineVO.setDisplayQueryArea(true);
- //鍓嶇浼氶粯璁ゅ垎椤电殑淇℃伅
-
- //澶勭悊鎵�鏈夌殑鍒楋紝杩欎釜妯℃澘娌℃湁鍚堝苟鐨勮〃澶寸殑鎯呭喌
- List<UITableFieldVO> fieldVOList = new ArrayList<>();
- Map<String, String> comboxOrReferFieldMap = new HashMap<>();
-
- templateVO.getAttributes().forEach(attrVO -> {
- UITableFieldVO tableFieldVO = templateAttr2TableField(attrVO,forEdit);
- if ("combox".equalsIgnoreCase(tableFieldVO.getFieldType())) {
- comboxOrReferFieldMap.put(tableFieldVO.getSortField(), tableFieldVO.getField());
- }
- if ("refer".equalsIgnoreCase(tableFieldVO.getFieldType())) {
- comboxOrReferFieldMap.put(tableFieldVO.getSortField(), tableFieldVO.getField());
- }
- if(StringUtils.isNotBlank(tableFieldVO.getEdit())){
- tableDefineVO.setHasEditor(true);
- }
- fieldVOList.add(tableFieldVO);
- });
- List<List<UITableFieldVO>> cols = new ArrayList<>();
- cols.add(fieldVOList);
- tableDefineVO.setCols(cols);
- Map<String, UITableFieldVO> fieldVOMap = fieldVOList.stream().collect(Collectors.toMap(s -> s.getField().toLowerCase(Locale.ROOT), t -> t));
- //鏌ヨ灞炴��
- List<CodeClassifyTemplateAttrVO> queryAttrVOs = templateVO.getAttributes().stream().filter(s -> BooleanEnum.TRUE.getValue().equalsIgnoreCase(s.getQueryattrflag())).collect(Collectors.toList());
- if (!CollectionUtils.isEmpty(queryAttrVOs)) {
- List<UITableFieldVO> queryFieldVOs = new ArrayList<>();
- queryAttrVOs.stream().forEach(attrVO -> {
- String attrId = attrVO.getId().toLowerCase(Locale.ROOT);
- attrId = comboxOrReferFieldMap.getOrDefault(attrId, attrVO.getId()).toLowerCase(Locale.ROOT);
- if (fieldVOMap.containsKey(attrId)) {
- queryFieldVOs.add(fieldVOMap.get(attrId));
- }
- });
- tableDefineVO.setQueryColumns(queryFieldVOs);
- }
- //楂樼骇灞炴��
- List<CodeClassifyTemplateAttrVO> seniorQueryAttrVOs = templateVO.getAttributes().stream().filter(s -> BooleanEnum.TRUE.getValue().equalsIgnoreCase(s.getSeniorqueryattrflag())).collect(Collectors.toList());
- if (!CollectionUtils.isEmpty(seniorQueryAttrVOs)) {
- List<UITableFieldVO> queryFieldVOs = new ArrayList<>();
- seniorQueryAttrVOs.stream().forEach(attrVO -> {
- String attrId = attrVO.getId().toLowerCase(Locale.ROOT);
- attrId = comboxOrReferFieldMap.getOrDefault(attrId, attrId).toLowerCase(Locale.ROOT);
- if (fieldVOMap.containsKey(attrId)) {
- queryFieldVOs.add(fieldVOMap.get(attrId));
- }
- });
- tableDefineVO.setSeniorQueryColumns(queryFieldVOs);
- }
- return tableDefineVO;
- }
-
- /**
- * 妯℃澘灞炴�ц浆鎹负琛ㄦ牸鏄剧ず鐨勯厤缃�
- *
- * @param attrVO 妯℃澘灞炴��
- * @param forEdit 鏄惁鏄紪杈戞墍闇�
- * @return 琛ㄦ牸鐨勫瓧娈�
- */
- @Override
- public UITableFieldVO templateAttr2TableField(CodeClassifyTemplateAttrVO attrVO,boolean forEdit) {
- UITableFieldVO fieldVO = new UITableFieldVO();
- if (SECRET_FILED.equalsIgnoreCase(attrVO.getId())) {
- attrVO.setEnumid(OsEnumServiceImpl.MY_DATA_SECRET);
- }
- fieldVO.setField(attrVO.getId());
- fieldVO.setTitle(attrVO.getName());
- fieldVO.setFieldType(vciFieldTypeMap.getOrDefault(attrVO.getAttributedatatype(), "text"));
- fieldVO.setSort(true);
- fieldVO.setSortField(fieldVO.getField());
- fieldVO.setQueryField(fieldVO.getField());
- if (forEdit){
- fieldVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getFormdisplayflag()));
- }else {
- fieldVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getTabledisplayflag()));
- }
- if (attrVO.getAttrTableWidth() != null && attrVO.getAttrTableWidth() > 0) {
- fieldVO.setMinWidth(attrVO.getAttrTableWidth());
- fieldVO.setWidth(attrVO.getAttrTableWidth());
- }
- //鐪嬬湅鏄惁鏈夋灇涓�
- if ((StringUtils.isNotBlank(attrVO.getEnumString())
- && !"[]".equalsIgnoreCase(attrVO.getEnumString())) ||
- StringUtils.isNotBlank(attrVO.getEnumid())) {
- fieldVO.setFieldType("combox");
- fieldVO.setField(fieldVO.getField() + "Text");
- fieldVO.setComboxKey(attrVO.getEnumid());
- if (StringUtils.isNotBlank(attrVO.getEnumString())) {
- //鎸囧畾鐨勪笅鎷夋鍐呭
- fieldVO.setData(JSONObject.parseArray(attrVO.getEnumString(), KeyValue.class));
- if (StringUtils.isBlank(attrVO.getEnumid())) {
- fieldVO.setComboxKey(fieldVO.getField() + "_data");
- }
- }else {
- List<KeyValue> osEnumItemVOList= enumService.getEnum(attrVO.getEnumid());
- fieldVO.setData(osEnumItemVOList);
- }
- }
- //鐪嬫槸鍚︽湁鍙傜収
- if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferConfig())) {
- fieldVO.setFieldType("refer");
- fieldVO.setQueryField(fieldVO.getField());
- fieldVO.setField(fieldVO.getField() + "name");
- fieldVO.setShowField(fieldVO.getField());
- if (StringUtils.isNotBlank(attrVO.getReferConfig())) {
- //閰嶇疆鐨勫唴瀹�
- fieldVO.setReferConfig(JSONObject.parseObject(attrVO.getReferConfig(), UIFormReferVO.class));
- } else {
- UIFormReferVO formReferVO = new UIFormReferVO();
- formReferVO.setType("default");
- formReferVO.setReferType(attrVO.getReferbtmid());
- fieldVO.setReferConfig(formReferVO);
- }
- }
- if (VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(fieldVO.getSortField())) {
- fieldVO.setField("lcstatus_text");
- }
- Map<String, String> eventJsMap = new HashMap<>();
- //瓒呴摼鎺ヤ笌妯℃澘鏄簰鏂�
- if (StringUtils.isNotBlank(attrVO.getTablehref())) {
- String event = fieldVO.getSortField() + "_href";
- eventJsMap.put(event, attrVO.getTablehref());
- fieldVO.setTemplet("function(d){ return '<a class=\"layui-btn layui-btn-intable \" lay-event=\"" + event + "\">d." + fieldVO.getField() + "</a>';}");
- }
- if (StringUtils.isNotBlank(attrVO.getTabledisplayjs())) {
- //鐩存帴鍐檉unction(d){ return xxxxx;}
- fieldVO.setTemplet(attrVO.getTabledisplayjs());
- }
- if (StringUtils.isBlank(fieldVO.getTemplet()) && VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributedatatype())) {
- fieldVO.setTemplet("function(d){return $webUtil.formateBoolean(d." + fieldVO.getField() + ");}");
- }
- fieldVO.setOptionJsMap(eventJsMap);
- fieldVO.setStyle(attrVO.getTabledisplaystyle());
- //鍒楄〃閲屼笉鍏佽鐩存帴缂栬緫
- fieldVO.setDateFormate(attrVO.getCodedateformat());
- return fieldVO;
- }
-
- /**
- * 瀵嗙骇鐨勫瓧娈�
- */
- public static final String SECRET_FILED = "secretgrade";
-
- /**
- * 妯℃澘灞炴�ц浆鎹负琛ㄥ崟鐨勫瓧娈�
- *
- * @param attrVO 妯℃澘灞炴��
- * @param btmType 涓氬姟绫诲瀷
- * @return 琛ㄥ崟鐨勫瓧娈�
- */
- @Override
- public UIFormItemVO templateAttr2FormField(CodeClassifyTemplateAttrVO attrVO, String btmType) {
- UIFormItemVO itemVO = new UIFormItemVO();
- if (SECRET_FILED.equalsIgnoreCase(attrVO.getId())) {
- attrVO.setEnumid(OsEnumServiceImpl.MY_DATA_SECRET);
- }
- itemVO.setField(attrVO.getId());
- itemVO.setText(attrVO.getName());
- itemVO.setType(vciFieldTypeMap.getOrDefault(attrVO.getAttributedatatype(), "text"));
- if (VciBaseUtil.getBoolean(attrVO.getTextareaflag())) {
- itemVO.setType("textarea");
- }
- if (VciFieldTypeEnum.VTLong.name().equalsIgnoreCase(attrVO.getAttributedatatype())
- || VciFieldTypeEnum.VTInteger.name().equalsIgnoreCase(attrVO.getAttributedatatype())
- || VciFieldTypeEnum.VTDouble.name().equalsIgnoreCase(attrVO.getAttributedatatype())) {
- itemVO.setVerify("number");
- }
- itemVO.setReadOnly(VciBaseUtil.getBoolean(attrVO.getReadonlyflag()));
- itemVO.setKeyAttr(VciBaseUtil.getBoolean(attrVO.getKeyattrflag()));
- itemVO.setRequired(VciBaseUtil.getBoolean(attrVO.getRequireflag()));
- itemVO.setDefaultValue(attrVO.getDefaultvalue());
- itemVO.setDateFormate(attrVO.getCodedateformat());
- itemVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getFormdisplayflag()));
- itemVO.setVerify(attrVO.getVerifyrule());
- itemVO.setPrefix(attrVO.getPrefixvalue());
- itemVO.setSuffix(attrVO.getSuffixvalue());
- itemVO.setTooltips(attrVO.getExplain());
- itemVO.setSelectLibFlag(attrVO.getLibraryIdentification());
- //鐪嬬湅鏄惁鏈夋灇涓�
- if ((StringUtils.isNotBlank(attrVO.getEnumString())
- && !"[]".equalsIgnoreCase(attrVO.getEnumString())) ||
- StringUtils.isNotBlank(attrVO.getEnumid())) {
- itemVO.setType("combox");
- itemVO.setComboxKey(attrVO.getEnumid());
- if (StringUtils.isNotBlank(attrVO.getEnumString())) {
- //鎸囧畾鐨勪笅鎷夋鍐呭
- itemVO.setData(JSONObject.parseArray(attrVO.getEnumString(), KeyValue.class));
- if (StringUtils.isBlank(attrVO.getEnumid())) {
- itemVO.setComboxKey(itemVO.getField() + "_data");
- }
- }
- }
- //鐪嬫槸鍚︽湁鍙傜収
- if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferConfig())) {
- itemVO.setType("refer");
- itemVO.setShowField(itemVO.getField() + "name");
- if (StringUtils.isNotBlank(attrVO.getReferConfig())) {
- //閰嶇疆鐨勫唴瀹�
- itemVO.setReferConfig(JSONObject.parseObject(attrVO.getReferConfig(), UIFormReferVO.class));
- } else {
- UIFormReferVO formReferVO = new UIFormReferVO();
- formReferVO.setType("default");
- formReferVO.setReferType(attrVO.getReferbtmid());
- itemVO.setReferConfig(formReferVO);
- }
- }
-
- //濡傛灉鏄粍鍚堣鍒欙紝鍒嗙被娉ㄥ叆鐨勶紝鏄剧ず涓哄彧璇�
- if (StringUtils.isNotBlank(attrVO.getComponentrule())) {
- itemVO.setReadOnly(true);
- itemVO.setTooltips("鏈睘鎬т负缁勫悎瑙勫垯");
- itemVO.setRequired(false);
- }
- if (StringUtils.isNotBlank(attrVO.getClassifyinvokeattr())) {
- itemVO.setReadOnly(!VciBaseUtil.getBoolean(attrVO.getClassifyinvokeeditflag()));
- itemVO.setTooltips("鏈睘鎬ф槸鍒嗙被娉ㄥ叆");
- itemVO.setRequired(false);
- }
-
- if (VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(itemVO.getField())) {
- //鏄敓鍛藉懆鏈熺姸鎬�
- itemVO.setType("combox");
- itemVO.setComboxKey(btmType + LC_STATUS_SUBFIX);
- }
- return itemVO;
- }
-
- /**
- * 灞炴�х被鍨嬩笌js涓殑瀛楁绫诲瀷鐨勬槧灏�
- */
- private static Map<String, String> vciFieldTypeMap = new HashMap<String, String>() {{
- put(VciFieldTypeEnum.VTString.name(), "text");
- put(VciFieldTypeEnum.VTInteger.name(), "text");
- put(VciFieldTypeEnum.VTLong.name(), "text");
- put(VciFieldTypeEnum.VTDouble.name(), "text");
- put(VciFieldTypeEnum.VTClob.name(), "text");
- put(VciFieldTypeEnum.VTBoolean.name(), "truefalse");
- put(VciFieldTypeEnum.VTDateTime.name(), "datetime");
- put(VciFieldTypeEnum.VTDate.name(), "datetime");
- put(VciFieldTypeEnum.VTTime.name(), "datetime");
- put(VciFieldTypeEnum.VTFilePath.name(), "file");
- }};
-
- /**
- * 鏍囪娴佺▼涓笟鍔℃暟鎹槸鍚﹂�氳繃
- *
- * @param oid 涓氬姟鏁版嵁涓婚敭
- * @param btmName 涓氬姟绫诲瀷
- * @param pass 鏄惁閫氳繃
- * @return 鎵ц缁撴灉
- */
- @Override
- public BaseResult markDataPassing(String oid, String btmName, Boolean pass) {
- VciBaseUtil.alertNotNull(oid, "涓氬姟鏁版嵁涓婚敭", btmName, "涓氬姟绫诲瀷", pass, "鏍囪绫诲瀷");
- boolean flag = false;
- try {
- ClientBusinessObjectOperation operation = new ClientBusinessObjectOperation();
- ClientBusinessObject data = operation.readBusinessObjectById(oid, btmName);
- if (data == null || StringUtils.isBlank(data.getOid())) {
- return BaseResult.fail(DATA_OID_NOT_EXIST);
- }
- data.setAttributeValue("passing", String.valueOf(pass));
- flag = operation.updateBuinessObject(data);
- } catch (VCIError e) {
- e.printStackTrace();
- }
- if (flag) {
- return BaseResult.success();
- } else {
- return BaseResult.fail("鏍囪澶辫触");
- }
- }
-
- /**
- * 浣跨敤鍒嗙被鐨勪富閿幏鍙栦笟鍔℃暟鎹�
- *
- * @param btmType 涓氬姟绫诲瀷
- * @param queryObject 鏌ヨ瀵硅薄
- * @return 琛ㄦ牸鐨勬樉绀哄璞″��
- */
- @Override
- public DataGrid<Map<String, String>> getTableDataByExecutionId(String btmType, BaseQueryObject queryObject) {
- VciBaseUtil.alertNotNull(btmType, "涓氬姟绫诲瀷");
- if (queryObject == null) {
- queryObject = new BaseQueryObject();
- }
- if (queryObject.getConditionMap() == null) {
- queryObject.setConditionMap(new HashMap<>());
- }
- Map<String, String> conditionMap = queryObject.getConditionMap();
- PageHelper pageHelper = queryObject.getPageHelper();
- if (!conditionMap.containsKey("oid")) {
- throw new VciBaseException("涓氬姟鏁版嵁涓婚敭涓嶈兘涓虹┖");
- }
- List<String> oidList = VciBaseUtil.str2List(conditionMap.get("oid"));
- Map<String, String> oidMap = new HashMap<>();
- if (conditionMap.get("oid").contains(",")) {
- oidMap.put("oid", QueryOptionConstant.IN +"("+ VciBaseUtil.toInSql(oidList.toArray(new String[0])) + ")");
- } else {
- oidMap.put("oid", conditionMap.get("oid"));
- }
- if (CollectionUtils.isEmpty(oidMap)) {
- throw new VciBaseException("涓氬姟鏁版嵁涓婚敭涓嶈兘涓虹┖");
- }
- List<ClientBusinessObject> cbos = boService.queryCBO(btmType, oidMap);
- if (CollectionUtils.isEmpty(cbos)) {
- throw new VciBaseException("鏈壘鍒颁笟鍔℃暟鎹�");
- }
- ClientBusinessObject cbo = cbos.get(0);
- String templateOid = cbo.getAttributeValue("CODETEMPLATEOID");
- Map<String, String> templateOidMap = new HashMap<>();
- templateOidMap.put("oid", templateOid);
- List<CodeClassifyTemplateDO> templateDOList = boService.queryObject(CodeClassifyTemplateDO.class, templateOidMap);
- templateOidMap.clear();
- templateOidMap.put("CLASSIFYTEMPLATEOID",templateOid);
- List<CodeClassifyTemplateAttrDO> attrDOList = boService.queryObject(CodeClassifyTemplateAttrDO.class, templateOidMap);
- if (CollectionUtils.isEmpty(templateDOList)) {
- logger.error("鎵句笉鍒颁笟鍔℃暟鎹叧鑱旂殑妯℃澘锛屾ā鏉夸富閿細" + templateOid);
- throw new VciBaseException("鎵句笉鍒颁笟鍔℃暟鎹叧鑱旂殑妯℃澘");
- }
- CodeClassifyTemplateVO templateVO = templateService.codeClassifyTemplateDO2VO(templateDOList.get(0));
- templateVO.setAttributes(templateAttrService.codeClassifyTemplateAttrDO2VOs(attrDOList));
- try {
- if (oidList.size() > 1){
- DataGrid<Map<String,String>> allDataGrid = new DataGrid<>();
- List<Map<String,String>> allData = new ArrayList<>();
- oidList.forEach(oid -> {
- Map<String,String> condition = new HashMap<>();
- condition.put("oid",oid);
- DataGrid<Map<String, String>> dataGrid = queryGrid(btmType, templateVO, condition, pageHelper);
- allData.addAll(dataGrid.getData());
- });
- allDataGrid.setData(allData);
- return allDataGrid;
- }else {
- return queryGrid(btmType, templateVO, conditionMap, pageHelper);
- }
- } catch (Exception e) {
- System.out.println(e.getMessage());
- return null;
- }
- }
-
- /**
- * 鎵归噺淇濆瓨娴佺▼鎵ц椤甸潰淇敼鐨勫唴瀹�
- *
- * @param orderDTOList 缂栫爜鐩稿叧鐨勪俊鎭紝涓嶉渶瑕佺爜娈电殑淇℃伅
- * @return 鎵ц缁撴灉
- */
- @Override
- public BaseResult batchUpdateCode(List<CodeOrderDTO> orderDTOList) {
- VciBaseUtil.alertNotNull(orderDTOList,"缂栫爜鐢宠鐩稿叧鐨勫睘鎬у唴瀹�");
- orderDTOList.forEach(orderDTO -> {
- VciBaseUtil.alertNotNull(orderDTO, "缂栫爜鐢宠鐩稿叧鐨勫睘鎬х殑鍐呭閮戒负绌�", orderDTO.getOid(), "鏁版嵁涓婚敭",
- orderDTO.getCodeClassifyOid(), "涓婚搴撳垎绫荤殑涓婚敭");
- });
- Map<String, CodeOrderDTO> orderDTOMap = orderDTOList.stream().filter(orderDTO -> orderDTO != null && StringUtils.isNotBlank(orderDTO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
- List<ClientBusinessObject> updateList = new ArrayList<>();
- // 搴旇閮芥槸涓�涓垎绫讳笅鐨勪笟鍔℃暟鎹紝鎵剧涓�鏉＄殑灏辫
- CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTOList.get(0).getCodeClassifyOid());
- Map<String,String> cboOidMap = new HashMap<>();
- if (CollectionUtils.isEmpty(orderDTOMap.keySet())){
- throw new VciBaseException(DATA_OID_NOT_EXIST);
- }
- cboOidMap.put("oid",QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(orderDTOMap.keySet().toArray(new String[0])) + ")");
- List<ClientBusinessObject> cboList = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), cboOidMap);
- if (CollectionUtils.isEmpty(cboList)){
- throw new VciBaseException(DATA_OID_NOT_EXIST);
- }
- BatchCBO batchCBO = new BatchCBO();
- CodeClassifyTemplateVO firstTemplateVO = templateService.getObjectHasAttrByOid(orderDTOMap.values().stream().findFirst().get().getTemplateOid());
- Map<String, ClientBusinessObject> cboMap = cboList.stream().filter(cbo -> cbo != null).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
- orderDTOMap.keySet().stream().forEach(oid -> {
- CodeOrderDTO orderDTO = orderDTOMap.get(oid);
- ClientBusinessObject cbo = cboMap.get(oid);
- if (!cbo.getTs().contains(VciDateUtil.date2Str(orderDTO.getTs(), VciDateUtil.DateTimeFormat))) {
- throw new VciBaseException("鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
- }
- if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
- throw new VciBaseException("鏁版嵁涓嶆槸{0}鐨勭姸鎬侊紝涓嶅厑璁镐慨鏀�", new String[]{CodeDefaultLC.EDITING.getText()});
- }
- //1. 鍒ゆ柇蹇呰緭椤�
- CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
- checkRequiredAttrOnOrder(templateVO, orderDTO);
- //2.鍏堟敞鍏ワ紝鍐嶇粍鍚堬紝鏈�鍚庢牎楠�
- switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
- //3.澶勭悊缁勫悎瑙勫垯銆傜粍鍚堣鍒欎笉鑳戒娇鐢ㄧ紪鐮佺殑灞炴�э紝鍥犱负缂栫爜鐨勭敓鎴愬彲鑳芥槸闇�瑕佸睘鎬х殑
- switchComponentAttrOnOrder(templateVO, orderDTO);
- //4.鏍￠獙瑙勫垯
- checkVerifyOnOrder(templateVO, orderDTO);
- //5.鍒ゆ柇鍏抽敭灞炴��
- checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
- //6.鏍￠獙鏋氫妇鐨勫唴瀹规槸鍚︽纭�
- checkEnumOnOrder(templateVO, orderDTO);
- //7.澶勭悊鏃堕棿鏍煎紡锛屽湪鏁版嵁搴撻噷闈笉璁烘槸瀛楃涓茶繕鏄棩鏈熸牸寮忥紝閮戒娇鐢ㄧ浉鍚岀殑鏍煎紡瀛樺偍
- switchDateAttrOnOrder(templateVO, orderDTO);
- //榛樿鐨勫唴瀹逛笉鑳藉彉锛屾墍浠ュ彧闇�瑕佹嫹璐濊嚜瀹氫箟鐨勭浉鍏冲睘鎬у嵆鍙�
- copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true);
- //浼佷笟鐮佸拰闆嗗洟鐮佺殑涓嶄慨鏀�
- cbo.setDescription(orderDTO.getDescription());
- cbo.setName(orderDTO.getName());
- try {
- cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
- cbo.setAttributeValue("name", orderDTO.getName());
- } catch (VCIError e) {
- e.printStackTrace();
- }
- batchCBO.getUpdateCbos().add(cbo);
- updateList.add(cbo);
- });
- boService.persistenceBatch(batchCBO);
- batchSaveSelectChar(firstTemplateVO, cboList);
- return BaseResult.success();
- }
-
- /**
- * 浣跨敤鍒嗙被鐨勭紪鍙疯矾寰勶紝鑾峰彇琛ㄦ牸鐨勭浉鍏冲畾涔�
- *
- * @param codeClassifyIdPath 鍒嗙被鐨勭紪鍙疯矾寰勶紝蹇呴』鏄粠椤跺眰鑺傜偣寮�濮嬶紝xxx/yy/zz杩欐牱鐨勬牸寮�
- * @param functionId 鍔熻兘鐨勭紪鍙�
- * @return UI鐩稿叧鐨勪俊鎭紙浠呭寘鍚〃鏍�)
- */
- @Override
- public MdmUIInfoVO getUIInfoByClassifyIdPath(String codeClassifyIdPath, String functionId) {
- CodeClassifyVO classifyVO = classifyService.getObjectByIdPath(codeClassifyIdPath);
- if(classifyVO !=null){
- return getUIInfoByClassifyOid(classifyVO.getOid(),functionId);
- }
- return null;
- }
+// /**
+// * 妯℃澘鐨勬湇鍔�
+// */
+// @Resource
+// private CodeClstemplateServiceImpl templateService;
+// /**
+// * 妯℃澘鐨勬湇鍔�
+// */
+// @Resource
+// private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
+// /**
+// * 鐢熸垚缂栫爜鐨勬湇鍔�
+// */
+// @Resource
+// private MdmProductCodeService productCodeService;
+// /**
+// * 瀛楀吀鐨勬湇鍔�
+// */
+// @Resource
+// IDictBizClient iDictBizClient;
+// /**
+// * 鍏紡鐨勬湇鍔�
+// */
+// @Autowired
+// private FormulaServiceImpl formulaService;
+//
+// /**
+// * 閫氱敤鏌ヨ
+// */
+// @Resource
+// CommonsMapper commonsMapper;
+// /**
+// * 缂栫爜瑙勫垯鐨勬湇鍔�
+// */
+// @Autowired
+// private ICodeRuleService ruleService;
+//
+// /**
+// * 鍒嗙被鐨勬湇鍔�
+// */
+// @Resource
+// private ICodeClassifyService classifyService;
+//
+// /**
+// * 鍏抽敭灞炴�х殑閰嶇疆
+// */
+// @Autowired
+// private ICodeKeyattrrepeatService keyRuleService;
+// /**
+// * 鏃ュ織
+// */
+// private Logger logger = LoggerFactory.getLogger(getClass());
+//
+// /**
+// * 绌烘牸
+// */
+// public static final String SPACE = " ";
+//
+// /**
+// * 瀵嗙骇鐨勫瓧娈�
+// */
+// public static final String SECRET_FILED = "secretgrade";
+// /**
+// * 鐢ㄦ埛鏂板鏁版嵁鐨勬椂鍊欏彲浠ユ煡鐪嬬殑瀵嗙骇
+// */
+// public static final String MY_DATA_SECRET = "myDataSecret";
+// /**
+// * 鎷疯礉鐨勭増鏈�
+// */
+// public static final String COPY_FROM_VERSION = "copyfromversion";
+// /**
+// * 鍙槸sql
+// */
+// public static final String ONLY = "${vcionly}";
+//
+// /**
+// * 榛樿鐨勬椂闂存牸寮�
+// */
+// private static final String DATETIME_FORMAT = "yyyy-mm-dd hh24:mi:ss";
+//
+// /**
+// * 鏃ユ湡鏍煎紡
+// */
+// private static final String DATE_FORMAT = "yyyy-mm-dd";
+//
+// /**
+// * 蹇呰緭
+// */
+// public static final String REQUIRED_CHAR = "*";
+// /**
+// * 鏇挎崲瀛楃
+// */
+// public static final String SPECIAL_CHAR = "VCI";
+//// @Autowired
+//// private CodeOsbtmtypeMapper codeOsbtmtypeMapper;
+//
+//
+//
+// /**
+// * 浣跨敤鍒嗙被鐨勪富閿幏鍙栧彲浠ヤ娇鐢ㄧ殑妯℃澘瀵硅薄
+// *
+// * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+// * @return 妯℃澘鐨勬樉绀哄璞�
+// */
+// @Override
+// public CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid) {
+// return getUsedTemplateByClassifyOid(codeClassifyOid, true);
+// }
+//
+// /**
+// * 浣跨敤鍒嗙被鐨勪富閿幏鍙栧彲浠ヤ娇鐢ㄧ殑妯℃澘瀵硅薄
+// *
+// * @param codeClassifyOid 鍒嗙被鐨勪富閿�
+// * @param hasAttr 鍖呭惈灞炴��
+// * @return 妯℃澘鐨勬樉绀哄璞�
+// */
+// @Override
+// public CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr) {
+// List<CodeClstemplateVO> templateVOs = templateService.listReleaseTemplateByClassifyOid(codeClassifyOid, hasAttr);
+// return templateVOs.get(templateVOs.size() - 1);
+// }
+//
+// /**
+// * 鑾峰彇鏋氫妇鐨勪笅鎷夐�夐」
+// *
+// * @param attrVO 妯℃澘灞炴�х殑瀵硅薄
+// * @return 涓嬫媺閫夐」
+// */
+// @Override
+// public List<KeyValue> listComboboxItems(CodeClassifyTemplateAttrVO attrVO) {
+// List<KeyValue> comboboxKVs = null;
+// if (StringUtils.isNotBlank(attrVO.getEnumString())) {
+// comboboxKVs = JSONObject.parseArray(attrVO.getEnumString(), KeyValue.class);
+// } else {
+//// comboboxKVs = enumService.getEnum(attrVO.getEnumid());
+//// Dict dict = new Dict();
+//// dict.setParentId(Long.valueOf(attrVO.getEnumid()));
+// R<List<DictBiz>> list = iDictBizClient.getList(attrVO.getEnumId());
+// if(list.isSuccess()){
+// for (DictBiz datum : list.getData()) {
+// KeyValue keyValue = new KeyValue();
+// keyValue.setKey(datum.getDictKey());
+// keyValue.setValue(datum.getDictValue());
+// comboboxKVs.add(keyValue);
+// }
+// }
+// }
+// return comboboxKVs;
+// }
+// /**
+// * 淇敼鐘舵��
+// *
+// * @param baseModelDTO 鏁版嵁浼犺緭瀵硅薄
+// */
+// @Override
+// public void changeStatus(BaseModelDTO baseModelDTO) {
+// VciBaseUtil.alertNotNull(baseModelDTO, "鏁版嵁淇℃伅", baseModelDTO.getOid(), "涓婚敭", baseModelDTO.getBtmname(), "涓氬姟绫诲瀷", baseModelDTO.getLcStatus(), "鐩爣鐘舵��");
+// List<String> oids = VciBaseUtil.str2List(baseModelDTO.getOid());
+//// List<ClientBusinessObject> cboList = boService.selectCBOByOidCollection(oids, baseModelDTO.getBtmname());
+// //鎻掍釜鐐� 涓氬姟绫诲瀷瀹屾垚鍚庨渶瑕佷慨鏀�
+// QueryWrapper<CodeOsbtmtypeEntity> wrapper = new QueryWrapper<>();
+// wrapper.eq("BTMNAME",baseModelDTO.getBtmname());
+// wrapper.in("OID",oids);
+// List<CodeOsbtmtypeEntity> cboList = codeOsbtmtypeMapper.selectList(wrapper);
+// //杩橀渶瑕佷慨鏀筧llCode鐨勭敓鍛藉懆鏈�
+//// Map<String, String> conditionMap = new HashMap<>();
+// QueryWrapper<CodeAllCode> allCodeWrapper = new QueryWrapper<>();
+// allCodeWrapper.eq("createcodebtm",baseModelDTO.getBtmname());
+// allCodeWrapper.in("createcodeoid",oids);
+//// conditionMap.put("createcodeoid", QueryOptionConstant.IN + "(" + VciBaseUtil.toInSql(oids.toArray(new String[0])) + ")");
+//// conditionMap.put("createcodebtm", baseModelDTO.getBtmname());
+// List<CodeAllCode> codeCbos = baseMapper.selectList(allCodeWrapper);
+//// List<ClientBusinessObject> codeCbos = boService.queryCBO(MdmBtmTypeConstant.CODE_ALL_CODE, conditionMap);
+// // 鍥炴敹闇�瑕佷笟鍔℃暟鎹垹闄�
+// if (CodeDefaultLC.TASK_BACK.getValue().equals(baseModelDTO.getLcStatus())) {
+//// BatchCBO batchCBO = new BatchCBO();
+//// batchCBO.getDeleteCbos().addAll(cboList);
+// codeOsbtmtypeMapper.deleteBatchIds(cboList);
+//// boService.persistenceBatch(batchCBO);
+// } else {
+//// lifeCycleService.transCboStatus(cboList, baseModelDTO.getLcStatus());
+// }
+//// lifeCycleService.transCboStatus(codeCbos, baseModelDTO.getLcStatus());
+// }
+//
+//
+// /**
+// * 鐢宠鍗曚竴缂栫爜
+// *
+// * @param orderDTO 鐢宠鐨勪俊鎭紝闇�瑕佸寘鍚睘鎬х殑鍐呭鍜岀爜娈电浉鍏崇殑鍐呭
+// * @return 杩斿洖缂栫爜鐨勫唴瀹�
+// */
+// @Override
+// public String addSaveCode(CodeOrderDTO orderDTO) {
+// VciBaseUtil.alertNotNull(orderDTO, "缂栫爜鐢宠鐩稿叧鐨勫睘鎬у拰鐮佹鐨勫唴瀹归兘涓虹┖", orderDTO.getCodeClassifyOid(), "涓婚搴撳垎绫荤殑涓婚敭",
+// orderDTO.getTemplateOid(), "妯℃澘鐨勪富閿�", orderDTO.getCodeRuleOid(), "缂栫爜瑙勫垯鐨勪富閿�");
+// CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
+// CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
+// CodeRuleVO ruleVO = ruleService.getObjectHasSecByOid(orderDTO.getCodeRuleOid());
+// //1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈�
+// checkSecValueOnOrder(ruleVO, orderDTO);
+// //2.鍒ゆ柇蹇呰緭椤�
+// checkRequiredAttrOnOrder(templateVO, orderDTO);
+// //3.鍏堟敞鍏ワ紝鍐嶇粍鍚堬紝鏈�鍚庢牎楠�
+// switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
+// //4.澶勭悊缁勫悎瑙勫垯銆傜粍鍚堣鍒欎笉鑳戒娇鐢ㄧ紪鐮佺殑灞炴�э紝鍥犱负缂栫爜鐨勭敓鎴愬彲鑳芥槸闇�瑕佸睘鎬х殑
+// switchComponentAttrOnOrder(templateVO, orderDTO);
+// //5.鏍￠獙瑙勫垯
+// checkVerifyOnOrder(templateVO, orderDTO);
+// //6.鍏抽敭灞炴��
+// checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
+// //7.鏋氫妇杞崲
+// checkEnumOnOrder(templateVO, orderDTO);
+// //8.澶勭悊鏃堕棿鏍煎紡锛屽湪鏁版嵁搴撻噷闈笉璁烘槸瀛楃涓茶繕鏄棩鏈熸牸寮忥紝閮戒娇鐢ㄧ浉鍚岀殑鏍煎紡瀛樺偍
+// switchDateAttrOnOrder(templateVO, orderDTO);
+// //9.鐢熸垚缂栫爜鐨勪俊鎭�
+//// ClientBusinessObject cbo = boService.createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
+// CodeWupinEntity cbo = createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid());
+//// //榛樿鐨勫睘鎬ч兘涓嶇敤浠庡墠绔嫹璐�
+//// //璁剧疆缂栫爜闇�瑕佺殑榛樿灞炴�х殑鍐呭
+// copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, false);
+//// //TODO:鍥犱负榛樿鐨勫睘鎬ч兘涓嶆嫹璐濓紝鐩墠闆嗗洟鐮佸彨name锛屽苟娌℃湁浠嶥TO鎷疯礉鍒癱bo閲屻�傚鍔犱竴涓崟鐙鐞嗭紝浠ュ悗鍐嶇湅瑕佷笉瑕佽皟鏁�
+// cbo.setName(orderDTO.getName() == null ? "" : orderDTO.getName());
+//// //end -- modify by lihang @20220407
+// List<CodeWupinEntity> cboList = new ArrayList<>();
+//
+// //澶囨敞
+// cbo.setDescription(orderDTO.getDescription());
+// cboList.add(cbo);
+////
+//// cboList.add(cbo);
+// List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList);
+//
+//
+// List<String> charList = new ArrayList<>();
+// for (CodeWupinEntity wupinEntity : cboList) {
+// charList.add(wupinEntity.getId());
+// }
+// batchSaveSelectChar(templateVO, charList);
+// return codeList.size() > 0 ? codeList.get(0) : "";
+//// return null;
+// }
+//
+// /**
+// * 澶勭悊鍒嗙被娉ㄥ叆鐨勪俊鎭�
+// *
+// * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝蹇呴』瑕佸悗妯℃澘鐨勫睘鎬�
+// * @param classifyFullInfoBO 鍒嗙被鐨勫叏璺緞
+// * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+// */
+// private void switchClassifyLevelOnOrder(CodeClstemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO orderDTO) {
+// Map<String,CodeClstempattrVO> classifyAttrVOMap = templateVO.getAttributes().stream().filter(
+// s -> StringUtils.isNotBlank(s.getClassifyinvokeattr()) && StringUtils.isNotBlank(s.getClassifyinvokelevel())
+// ).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+// if (classifyFullInfoBO.getTopClassifyVO() == null) {
+// //闇�瑕侀噸鏂版煡璇竴涓嬶紝鍥犱负杩欎釜鏄寚瀹氱殑鍒嗙被杩涙潵鐨�
+//
+// }
+// if (!CollectionUtils.isEmpty(classifyAttrVOMap)) {
+// classifyAttrVOMap.forEach((attrId, attrVO) -> {
+// //鍒嗙被娉ㄥ叆鐨勭紪鍙锋垨鑰呭悕绉帮紝
+// //灞傜骇鍖呭惈鎸囧畾灞傚拰鏈�灏忓眰
+// CodeClassifyVO classifyVO = null;
+// if (!CodeLevelTypeEnum.MIN.getValue().equalsIgnoreCase(attrVO.getClassifyinvokelevel()) && !"min".equalsIgnoreCase(attrVO.getClassifyinvokelevel())) {
+// //鎸囧畾浜嗗眰绾х殑
+// //娉ㄦ剰锛屽洜涓烘煡璇笂绾у垎绫诲嚭鏉ョ殑灞傜骇鏄�掑簭鐨勶紝鍗抽《灞傝妭鐐规槸鏈�澶х殑鍊�
+// List<CodeClassifyVO> classifyVOS = classifyFullInfoBO.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel()))).collect(Collectors.toList());
+// int level = VciBaseUtil.getInt(attrVO.getClassifyinvokelevel());
+// if (classifyVOS.size() >= level && level > 0) {
+// classifyVO = classifyVOS.get(level - 1);
+// }
+// } else {
+// //褰撳墠鐨勫垎绫�
+// classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
+// }
+// if (classifyVO == null) {
+// //璇存槑灞傜骇鏈夎
+// orderDTO.getData().put(attrId, "鍒嗙被鏍戜笂娌℃湁灞傜骇[" + attrVO.getClassifyinvokelevel() + "]");
+// // classifyVO = classifyFullInfoBO.getCurrentClassifyVO();
+// } else {
+// Map<String, String> classifyDataMap = VciBaseUtil.objectToMapString(classifyVO);
+// String value = classifyDataMap.getOrDefault(attrVO.getClassifyinvokeattr(), "");
+// orderDTO.getData().put(attrId, value);
+// }
+// });
+// }
+// }
+//
+//
+// /**
+// * 鍒ゆ柇缂栫爜鐨勭爜娈垫槸鍚﹁緭鍏ユ垨鑰呴�夋嫨浜嗙爜鍊�
+// *
+// * @param ruleVO 瑙勫垯鐨勬樉绀哄璞�
+// * @param orderDTO 缂栫爜鐢宠鐨勫唴瀹�
+// */
+// @Override
+// public void checkSecValueOnOrder(CodeRuleVO ruleVO, CodeOrderDTO orderDTO) {
+// List<String> unSerialSecOidList = ruleVO.getSecVOList().stream().filter(
+// s -> !(CodeSecTypeEnum.CODE_SERIAL_SEC.getValue().equalsIgnoreCase(s.getSecType())
+// || CodeSecTypeEnum.CODE_ATTR_SEC.getValue().equalsIgnoreCase(s.getSecType())
+// || CodeSecTypeEnum.CODE_DATE_SEC.getValue().equalsIgnoreCase(s.getSecType())
+// || CodeSecTypeEnum.CODE_LEVEL_SEC.getValue().equalsIgnoreCase(s.getSecType())
+// || VciBaseUtil.getBoolean(s.getNullableFlag()))
+// ).map(CodeBasicSecVO::getOid).collect(Collectors.toList());
+// if (!CollectionUtils.isEmpty(unSerialSecOidList)) {
+// if (CollectionUtils.isEmpty(orderDTO.getSecDTOList())) {
+// throw new VciBaseException("闈炴祦姘寸爜娈�(鎴栬�呭繀杈撶爜娈碉級蹇呴』瑕佽緭鍏�(鎴栭�夋嫨)鐮佸��");
+// }
+// if (orderDTO.getSecDTOList().stream().anyMatch(s -> !unSerialSecOidList.contains(s.getSecOid())
+// && StringUtils.isBlank(s.getSecValue()))) {
+// throw new VciBaseException("闈炴祦姘寸爜娈�(鎴栬�呭繀杈撶爜娈碉級蹇呴』瑕佽緭鍏�(鎴栭�夋嫨)鐮佸��");
+// }
+// }
+// }
+//
+// /**
+// * 鏍￠獙灞炴�ф槸鍚︿负蹇呰緭
+// *
+// * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
+// * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+// */
+// private void checkRequiredAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
+// Map<String, CodeClstempattrVO> requiredAttrMap = templateVO.getAttributes().stream().filter(
+// s -> VciBaseUtil.getBoolean(s.getRequireflag()) && StringUtils.isBlank(s.getComponentrule())
+// && StringUtils.isBlank(s.getClassifyinvokeattr()))
+// .collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+// if (!CollectionUtils.isEmpty(requiredAttrMap)) {
+// requiredAttrMap.forEach((attrId, attrVO) -> {
+// //鍙湁浼佷笟缂栫爜锛岀姸鎬侊紝澶囨敞锛屾ā鏉夸富閿紝鍒嗙被涓婚敭杩欏嚑涓槸鍥哄畾鐨勶紝鍏朵綑閮芥槸鑷閰嶇疆鐨�
+// if (StringUtils.isBlank(getValueFromOrderDTO(orderDTO, attrId))) {
+// throw new VciBaseException("灞炴�с�恵0}銆戝繀椤昏杈撳叆(閫夋嫨)鍐呭", new String[]{attrVO.getName()});
+// }
+// });
+// }
+// }
+//
+// /**
+// * 浠庣紪鐮佺敵璇蜂俊鎭璞′笂鑾峰彇鏌愪釜灞炴�х殑鍊�
+// *
+// * @param orderDTO 缂栫爜鐢宠瀵硅薄
+// * @param attrId 灞炴�х殑缂栧彿
+// * @return 鍊�
+// */
+// private String getValueFromOrderDTO(CodeOrderDTO orderDTO, String attrId) {
+// attrId = attrId.toLowerCase(Locale.ROOT);
+// String value = null;
+// if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
+// value = WebUtil.getStringValueFromObject(WebUtil.getValueFromField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO));
+// } else {
+// //璇存槑鏄嚜琛岄厤缃殑
+// //鍓嶇蹇呴』瑕佷紶閫掑皬鍐欑殑灞炴��
+// value = orderDTO.getData().getOrDefault(attrId, "");
+// }
+// return value;
+// }
+//
+// /**
+// * 杞崲缁勫悎瑙勫垯鐨勫��
+// *
+// * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬�
+// * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+// */
+// private void switchComponentAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
+// Map<String, CodeClstempattrVO> compAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getComponentrule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+// if (!CollectionUtils.isEmpty(compAttrVOMap)) {
+// Map<String, String> dataMap = WebUtil.objectToMapString(orderDTO);
+//
+// Map<String, String> dataLowMap = new HashMap<>();
+// if (!CollectionUtils.isEmpty(dataMap)) {
+// dataMap.forEach((key, value) -> {
+// dataLowMap.put(key.toLowerCase(Locale.ROOT), value);
+// });
+// }
+// dataLowMap.putAll(orderDTO.getData());
+// compAttrVOMap.forEach((attrId, attrVO) -> {
+// dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentrule()));
+// });
+// dataLowMap.forEach((key, value) -> {
+// setValueToOrderDTO(orderDTO, key, value);
+// });
+// }
+// }
+//
+//
+// /**
+// * 璁剧疆鏂扮殑鍊煎埌鐢宠瀵硅薄涓�
+// *
+// * @param orderDTO 缂栫爜鐢宠瀵硅薄
+// * @param attrId 灞炴�х殑缂栧彿
+// * @param value 鍊�
+// */
+// private void setValueToOrderDTO(CodeOrderDTO orderDTO, String attrId, String value) {
+// attrId = attrId.toLowerCase(Locale.ROOT);
+// if (VciQueryWrapperForDO.BASIC_FIELD_MAP.containsKey(attrId)) {
+// WebUtil.setValueToField(WebUtil.getFieldForObject(attrId, orderDTO.getClass()).getName(), orderDTO, value);
+// } else {
+// orderDTO.getData().put(attrId, value);
+// }
+// }
+//
+// /**
+// * 鏍￠獙姝ｅ垯琛ㄨ揪寮忔槸鍚︽纭�
+// *
+// * @param templateVO 妯℃澘鐨勪俊鎭紝蹇呴』鍖呭惈灞炴�х殑鍐呭
+// * @param orderDTO 缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
+// */
+// private void checkVerifyOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
+// Map<String, CodeClstempattrVO> verifyAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getVerifyrule())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+// if (!CollectionUtils.isEmpty(verifyAttrVOMap)) {
+// verifyAttrVOMap.forEach((attrId, attrVO) -> {
+// String value = getValueFromOrderDTO(orderDTO, attrId);
+// if (StringUtils.isNotBlank(value) && !value.matches(attrVO.getVerifyrule())) {
+// //鏍￠獙姝ｅ垯琛ㄨ揪寮�
+// throw new VciBaseException("灞炴�{0}]鐨勫�间笉绗﹀悎鏍￠獙瑙勫垯鐨勮姹�", new String[]{attrVO.getName()});
+// }
+// });
+// }
+// }
+//
+// /**
+// * 鏍￠獙鍏抽敭灞炴��
+// *
+// * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+// * @param templateVO 妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴��
+// * @param orderDTO 缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅
+// */
+// private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
+// //鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮�
+// CodeKeyattrrepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo);
+// //娉ㄦ剰鐨勬槸keyRuleVO鍙兘涓虹┖锛岃〃绀轰笉浣跨敤瑙勫垯鎺у埗
+// //鑾峰彇鎵�鏈夌殑鍏抽敭灞炴��
+// Map<String, CodeClstempattrVO> ketAttrMap = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getKeyattrflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+// Map<String, String> conditionMap = new HashMap<>();
+// boolean trimAll = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnoreallspaceflag());
+// //鍏ㄩ儴鍘荤┖鐨勪紭鍏堢骇澶т簬鍘荤┖
+// boolean trim = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorespaceflag());
+// boolean ignoreCase = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorecaseflag());
+// boolean ignoreWidth = keyRuleVO == null ? false : VciBaseUtil.getBoolean(keyRuleVO.getIgnorewidthflag());
+// ketAttrMap.forEach((attrId, attrVO) -> {
+// String value = getValueFromOrderDTO(orderDTO, attrId);
+// if (value == null) {
+// value = "";
+// }
+// wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap);
+// });
+//
+// //娌℃湁闄愬埗鍒嗙被锛屼絾鏄竴涓ā鏉垮彧鍙兘鍦ㄤ竴涓笟鍔＄被鍨嬮噷闈紝鎵�浠ョ洿鎺ユ煡璇㈣繖涓笟鍔＄被鍨嬪嵆鍙�
+//
+// if (!CollectionUtils.isEmpty(conditionMap)) {
+// final String[] sql = {"select count(*) from " + VciBaseUtil.getTableName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()) + " t where 1 = 1 "};
+// conditionMap.forEach((key, value) -> {
+// sql[0] += " and " + key + " = " + value;
+// });
+// if (StringUtils.isNotBlank(orderDTO.getOid())) {
+// //淇敼鐨勬椂鍊欙紝闇�瑕佹帓闄よ嚜宸�
+// sql[0] += " and oid != '" + orderDTO.getOid() + "'";
+// } else if (StringUtils.isNotBlank(orderDTO.getCopyFromVersion())) {
+// sql[0] += " and oid != '" + orderDTO.getCopyFromVersion() + "'";
+// }
+// sql[0] += " and islastR = '1' and islastV = '1' ";
+//// if (boService.queryCountBySql(sql[0], new HashMap<>()) > 0) {
+// if (Integer.parseInt(commonsMapper.selectById(sql[0]).get(0)) > 0) {
+// String ruleInfoMsg = keyRuleVO == null ? "" : "鏌ヨ瑙勫垯锛氬幓闄ょ┖鏍�--{0},蹇界暐澶у皬鍐�--{1},蹇界暐鍏ㄥ崐瑙�--{2},蹇界暐鍏ㄩ儴绌烘牸--{3}";
+// String[] objs = new String[]{trim ? "鏄�" : "鍚�", ignoreCase ? "鏄�" : "鍚�", ignoreWidth ? "鏄�" : "鍚�", trimAll ? "鏄�" : "鍚�"};
+// throw new VciBaseException("鏍规嵁鎮ㄥ～鍐欑殑鍏抽敭灞炴�х殑鍐呭锛岀粨鍚堝叧閿睘鎬ф煡璇㈣鍒欙紝鍙戠幇杩欎釜鏁版嵁宸茬粡鍦ㄧ郴缁熶腑瀛樺湪浜嗐�傝淇!銆�" + ruleInfoMsg, objs);
+// }
+// }
+// }
+//
+// /**
+// * 灏佽鍏抽敭灞炴�х殑鏌ヨ璇彞
+// *
+// * @param value 褰撳墠鐨勫��
+// * @param keyRuleVO 鍏抽敭灞炴�х殑鎺у埗瑙勫垯锛屽彲浠ヤ负绌�
+// * @param attrId 灞炴�х殑缂栧彿
+// * @param trim 鏄惁鍘婚櫎绌烘牸
+// * @param ignoreCase 鏄惁涓嶅尯鍒嗗ぇ灏忓啓
+// * @param ignoreWidth 鏄惁蹇界暐鍏ㄥ崐瑙�
+// * @param trimAll 鏄惁蹇界暐鍏ㄩ儴绌烘牸
+// * @param conditionMap 鏌ヨ鏉′欢
+// */
+// @Override
+// public void wrapperKeyAttrConditionMap(String value, CodeKeyattrrepeatVO keyRuleVO, String attrId,
+// boolean trim, boolean ignoreCase, boolean ignoreWidth,
+// boolean trimAll, Map<String, String> conditionMap) {
+// boolean ignoreSpace = trim || trimAll;
+// if (StringUtils.isBlank(value)) {
+// //涓虹┖鐨勬椂鍊欙紝涓嶈兘鐢≦ueryOperation.ISNULL锛屽钩鍙颁笉鐭ラ亾鍟ユ椂鍊欎笉澶勭悊杩欑浜�
+// conditionMap.put("t."+attrId, "null");
+// } else {
+// if (keyRuleVO != null) {
+// String queryKey = "";
+// String queryValue = "";
+//
+// String temp = "";
+// if (ignoreCase && ignoreSpace && ignoreWidth) {
+// //蹇界暐澶у皬鍐欙紝涓斿幓绌猴紝蹇界暐鍏ㄥ崐瑙�
+// temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(to_single_byte(%s)) " + (trimAll ? ",' ','')" : ")");
+// } else if (ignoreCase && ignoreSpace && !ignoreWidth) {
+// //蹇界暐澶у皬鍐欍�佸幓绌恒�佷笉蹇界暐鍏ㄥ崐瑙�
+// temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(%s) " + (trimAll ? ",' ','')" : ")");
+// } else if (ignoreCase && !ignoreSpace && ignoreWidth) {
+// //蹇界暐澶у皬鍐欍�佷笉鍘荤┖銆佸拷鐣ュ叏鍗婅
+// temp = "UPPER(to_single_byte(%s))";
+// } else if (!ignoreCase && ignoreSpace && ignoreWidth) {
+// //涓嶅拷鐣ュぇ灏忓啓銆佸幓绌恒�佸拷鐣ュ叏鍗婅
+// temp = (trimAll ? "REPLACE" : "TRIM") + "(to_single_byte(%s) " + (trimAll ? ",' ','')" : ")");
+// } else if (ignoreCase && !ignoreSpace && !ignoreWidth) {
+// //蹇界暐澶у皬鍐欍�佷笉鍘荤┖銆佷笉蹇界暐鍏ㄥ崐瑙�
+// temp = "UPPER(%s)";
+// } else if (!ignoreCase && !ignoreCase && ignoreWidth) {
+// //涓嶅拷鐣ュぇ灏忓啓銆佷笉鍘荤┖銆佸拷鐣ュ叏鍗婅
+// temp = "to_single_byte(%s)";
+// } else if (!ignoreCase && ignoreSpace && !ignoreWidth) {
+// //涓嶅拷鐣ュぇ灏忓啓銆佸幓绌恒�佷笉蹇界暐鍏ㄥ崐瑙�
+// temp = (trimAll ? "REPLACE" : "TRIM") + "(%s " + (trimAll ? ",' ','')" : ")");
+// } else if (!ignoreCase && !ignoreSpace && !ignoreWidth) {
+// //涓嶅拷鐣ュぇ灏忓啓銆佷笉鍘荤┖銆佷笉蹇界暐鍏ㄥ崐瑙�
+// temp = "%s";
+// }
+// queryKey = String.format(temp, "t."+attrId);
+// queryValue = String.format(temp, "'" + (trim ? value.trim() : value) + "'");
+// conditionMap.put(queryKey, queryValue);
+// } else {
+// //涓虹┖鐨勬椂鍊欎笉浠ｈ〃涓嶆牎楠岋紝鍙槸涓嶅幓闄ょ浉鍏崇殑淇℃伅
+// conditionMap.put("t."+attrId, value);
+// }
+// }
+// }
+//
+// /**
+// * 鏍￠獙鏋氫妇鐨勫唴瀹�
+// *
+// * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
+// * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+// */
+// private void checkEnumOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
+// //濡傛灉鏋氫妇鍙互淇敼锛屽垯涓嶉渶瑕佹牎楠屾槸鍚︾鍚堟灇涓剧殑閫夐」
+//
+// Map<String, CodeClstempattrVO> enumAttrVOMap = templateVO.getAttributes().stream().filter(s -> (StringUtils.isNotBlank(s.getEnumstring()) || StringUtils.isNotBlank(s.getEnumid())) && !VciBaseUtil.getBoolean(s.getEnumeditflag())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+// if (!CollectionUtils.isEmpty(enumAttrVOMap)) {
+// enumAttrVOMap.forEach((attrId, attrVO) -> {
+// String value = getValueFromOrderDTO(orderDTO, attrId);
+// if (StringUtils.isNotBlank(value)) {
+// CodeClassifyTemplateAttrVO codeClassifyTemplateAttrVO = new CodeClassifyTemplateAttrVO();
+// BeanUtils.copyProperties(attrVO,codeClassifyTemplateAttrVO);
+// //鏈夊�兼墠鑳芥牎楠�
+// List<KeyValue> comboboxKVs = listComboboxItems(codeClassifyTemplateAttrVO);
+// if (!comboboxKVs.stream().anyMatch(s -> value.equalsIgnoreCase(s.getKey()))) {
+// throw new VciBaseException("灞炴�с�恵0}銆戠殑鍊间笉绗﹀悎鏋氫妇鐨勮姹�", new String[]{attrVO.getName()});
+// }
+// }
+// });
+// }
+// }
+//
+// /**
+// * 杞崲鏃堕棿鐨勬牸寮�
+// *
+// * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬�
+// * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+// */
+// private void switchDateAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) {
+// Map<String, CodeClstempattrVO> dateAttrVOMap = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getCodedateformat())).collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+// if (!CollectionUtils.isEmpty(dateAttrVOMap)) {
+// dateAttrVOMap.forEach((attrId, attrVO) -> {
+// String value = getValueFromOrderDTO(orderDTO, attrId);
+// if (StringUtils.isNotBlank(value)) {
+// DateConverter dateConverter = new DateConverter();
+// dateConverter.setAsText(value);
+// value = VciDateUtil.date2Str(dateConverter.getValue(), VciDateUtil.DateTimeMillFormat);
+// setValueToOrderDTO(orderDTO, attrId, value);
+// }
+// });
+// }
+// }
+//
+// /**
+// * 鎷疯礉鏁版嵁鍒癱bo瀵硅薄涓�
+// *
+// * @param classifyFullInfo 鍒嗙被鐨勫叏閮ㄤ俊鎭�
+// * @param cbo 涓氬姟鏁版嵁
+// * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭�
+// * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+// * @param edit 鏄惁涓轰慨鏀�
+// */
+// private void copyValueToCBO(CodeClassifyFullInfoBO classifyFullInfo, CodeWupinEntity cbo,
+// CodeOrderDTO orderDTO, CodeClstemplateVO templateVO,
+// boolean edit) {
+// String fullPath = "";
+// if (!CollectionUtils.isEmpty(classifyFullInfo.getParentClassifyVOs())) {
+// fullPath = classifyFullInfo.getParentClassifyVOs().stream().sorted(((o1, o2) -> o2.getDataLevel().compareTo(o1.getDataLevel())))
+// .map(CodeClassifyVO::getOid).collect(Collectors.joining("##"));
+// } else {
+// fullPath = classifyFullInfo.getCurrentClassifyVO().getOid();
+// }
+//
+//// BeanUtils.
+// BeanUtils.copyProperties(orderDTO.getData(),cbo);
+// cbo.setMaterialtype(Short.valueOf("1001"));
+//// orderDTO.getData().forEach((key, value) -> {
+//// if (!edit || (!checkUnAttrUnEdit(key) &&
+//// !VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(key))) {
+//// try {
+//// cbo.setAttributeValue(key, value);
+//// } catch (Exception e) {
+//// logger.error("璁剧疆灞炴�х殑鍊奸敊璇�", e);
+//// }
+//// }
+//// });
+// try {
+//
+// cbo.setCodeclsfid(classifyFullInfo.getCurrentClassifyVO().getOid());
+// cbo.setCodetemplateoid(templateVO.getOid());
+// cbo.setCodeclsfpath(fullPath);
+//// cbo.setMaterialclassify("model_type");
+//// cbo.setMaterialname(orderDTO.getData().get("materialname"));
+//// cbo.setShifoupihaoguanli("true");
+//// cbo.setKucunwl("true");
+//// cbo.setXiaoshouwl("false");
+// if (!edit && StringUtils.isBlank(orderDTO.getLcStatus())) {
+// //鎵剧敓鍛藉懆鏈熺殑璧峰鐘舵�侊紝鎻掍釜鐐癸紝鐪嬬敓鍛藉懆鏈熸槸鍚﹂渶瑕佸垱寤�
+// if (StringUtils.isNotBlank(cbo.getLctid())) {
+//// OsLifeCycleVO lifeCycleVO = lifeCycleService.getLifeCycleById(cbo.getLctid());
+//// if (lifeCycleVO != null) {
+//// cbo.setLcStatus("Editing");
+////// cbo.setLcStatus(lifeCycleVO.getStartStatus());
+//// } else {
+// cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+//// }
+// } else {
+// cbo.setLcStatus(CodeDefaultLC.EDITING.getValue());
+// }
+//
+// }
+//
+// int secret = VciBaseUtil.getInt(cbo.getSecretGrade().toString());
+// //鎻掍釜鐐癸紝鍚庣画鐪嬪瘑绾ф湇鍔℃槸鍚﹀彲鐢�
+//// if (secret == 0 || !secretService.checkDataSecret(secret)) {
+// if (secret == 0 ) {
+// Integer userSecret = VciBaseUtil.getCurrentUserSecret();
+//// cbo.setAttributeValue(SECRET_FIELD, String.valueOf((userSecret == null || userSecret == 0) ? UserSecretEnum.NONE.getValue() : userSecret));
+// cbo.setSecretGrade(userSecret == null || userSecret == 0 ? UserSecretEnum.NONE.getValue() : userSecret);
+// }
+// } catch (Throwable e) {
+// logger.error("璁剧疆榛樿鐨勫睘鎬х殑鍊奸敊璇�", e);
+// }
+// }
+//
+//
+// /**
+// * 鍒濆鍖栦笟鍔＄被鍨�
+// * --鍒涘缓浜洪粯璁や负褰撳墠鐢ㄦ埛锛屽鏋滈渶瑕佷慨鏀癸紝鍙互鍦ㄨ幏鍙栧悗鑷澶勭悊
+// * @param btmName 涓氬姟绫诲瀷鐨勫悕绉帮紝浼氳嚜鍔ㄥ彉鎴愬皬鍐�
+// * @return CodeWupinEntity
+// * @throws VciBaseException 鍒濆鍖栧嚭閿欑殑鏄細鎶涘嚭寮傚父
+// */
+// @Override
+// public CodeWupinEntity createCBOByBtmName(String btmName)
+// throws VciBaseException {
+// if(btmName!=null){
+// btmName = btmName.trim().toLowerCase();
+// }
+// String userid = AuthUtil.getUser().getUserName();
+//// if(!hasCreatedCbos.containsKey(btmName)){
+//// if(StringUtils.isEmpty(userid)){
+//// throw new VciBaseException(msgCodePrefix +"noHasUserid");
+//// }
+//// try {
+//// hasCreatedCbos.put(btmName, createBusinessObject(btmName));
+//// } catch (Exception e) {
+//// logger.error("鍒涘缓涓氬姟绫诲瀷瀵硅薄",e);
+//// throw new VciBaseException(msgCodePrefix + "initBoError",new String[]{btmName});
+//// }
+//// }
+//// ClientBusinessObject cbo = cloneClientBusinessObject(hasCreatedCbos.get(btmName));
+//
+// QueryWrapper<CodeOsbtmtypeEntity> btmWrapper = new QueryWrapper<>();
+// btmWrapper.eq("ID",btmName);
+// CodeOsbtmtypeEntity btmTypeVO = codeOsbtmtypeMapper.selectOne(btmWrapper);
+//// OsBtmTypeVO btmTypeVO = btmService.getBtmById(boName);
+// String userName = AuthUtil.getUser().getUserName();
+// CodeWupinEntity wupinEntity = new CodeWupinEntity();
+// wupinEntity.setOid(null);
+//// bo.setRevisionid((new ObjectUtility()).getNewObjectID36());
+//// bo.setNameoid((new ObjectUtility()).getNewObjectID36());
+// wupinEntity.setBtmname(btmName);
+// wupinEntity.setLastR(String.valueOf(1));
+// wupinEntity.setFirstR(String.valueOf(1));
+// wupinEntity.setFirstV(String.valueOf(1));
+// wupinEntity.setLastV(String.valueOf(1));
+// wupinEntity.setCreator(userName);
+// wupinEntity.setCreateTime(new Date());
+// wupinEntity.setLastModifier(userName);
+// wupinEntity.setLastModifyTime(new Date());
+// wupinEntity.setRevisionRule(btmTypeVO.getRevisionruleid());
+// wupinEntity.setVersionRule(String.valueOf(btmTypeVO.getVersionRule()));
+// if(StringUtils.isNotBlank(btmTypeVO.getRevisionruleid())){
+// //鎻掍釜鐐癸紝闇�瑕侀棶鍕囧摜鐗堟湰闂锛屽睍绀洪粯璁や负1
+//// OsRevisionRuleVO revisionRuleVO = revisionRuleService.getRevisionRuleById(btmTypeVO.getRevisionruleid());
+// wupinEntity.setRevisionValue("1");
+// }
+//
+// wupinEntity.setRevisionSeq(1);
+// wupinEntity.setVersionSeq(1);
+// //鎻掍釜鐐癸紝闇�瑕侀棶鍕囧摜鐗堟湰闂锛屽睍绀洪粯璁や负1
+// wupinEntity.setVersionValue("1");
+// wupinEntity.setLctid("wupinLC");
+// wupinEntity.setLcStatus("Editing");
+// wupinEntity.setId("");
+// wupinEntity.setName("");
+// wupinEntity.setDescription("");
+// wupinEntity.setOwner(userName);
+// wupinEntity.setCheckinby(userName);
+// wupinEntity.setCopyFromVersion("");
+// wupinEntity.setMaterialtype((short) 1001);
+// wupinEntity.setCaigouwl("true");
+// wupinEntity.setShifoupihaoguanli("true");
+// wupinEntity.setKucunwl("true");
+// wupinEntity.setXiaoshouwl("false");
+// wupinEntity.setPassing("true");
+//
+//// this.initTypeAttributeValue(wupinEntity,btmTypeVO);
+// return wupinEntity;
+//
+//
+//// return cbo;
+// }
+//
+// /**
+// * 鏄惁涓轰慨鏀瑰拷鐣ョ殑灞炴��
+// * @param attrName 灞炴�х殑鍚嶅瓧
+// * @return true 琛ㄧず搴旇蹇界暐
+// */
+// boolean checkUnAttrUnEdit(String attrName){
+// return (VciQueryWrapperForDO.OID_FIELD.equalsIgnoreCase(attrName)
+// ||"ts".equalsIgnoreCase(attrName)
+// || "lastmodifier".equalsIgnoreCase(attrName)
+// || "lastmodifytime".equalsIgnoreCase(attrName)
+// || "createtime".equalsIgnoreCase(attrName)
+// || "checkintime".equalsIgnoreCase(attrName)
+// ||"checkouttime".equalsIgnoreCase(attrName));
+// }
+//
+// /**
+// * 淇濆瓨鍙緭鍙�夌殑淇℃伅
+// *
+// * @param templateVO 妯℃澘鐨勫璞�
+// * @param cboList 鏁版嵁鐨勫唴瀹�
+// */
+// @Override
+// public void batchSaveSelectChar(CodeClstemplateVO templateVO, /*List<ClientBusinessObject> cboList*/
+// List<String> cboList) {
+// if (templateVO != null && !CollectionUtils.isEmpty(cboList)) {
+// //鏄紓姝ョ殑锛屾墍浠ョ洿鎺ュ惊鐜�
+// List<CodeClstempattrVO> selectAttrVOs = templateVO.getAttributes().stream().filter(s -> StringUtils.isNotBlank(s.getLibraryidentification())).collect(Collectors.toList());
+//
+// if (!CollectionUtils.isEmpty(selectAttrVOs)) {
+//// SessionInfo sessionInfo = VciBaseUtil.getCurrentUserSessionInfo();
+// selectAttrVOs.parallelStream().forEach(attrVO -> {
+// List<String> valuesList = cboList;
+//// cboList.parallelStream().forEach(cbo -> {
+//// String value = cbo.get.getAttributeValue(attrVO.getId());
+//// if (StringUtils.isNotBlank(value)) {
+//// valuesList.add(value);
+//// }
+//// });
+// if (!CollectionUtils.isEmpty(valuesList)) {
+// for (String s : valuesList) {
+// DictBiz dictBiz = new DictBiz();
+// dictBiz.setCode(templateVO.getBtmTypeId());
+// dictBiz.setDictKey(s);
+// dictBiz.setDictValue(s);
+// //浠庡師鏉ョ殑charService锛堝彲杈撳彲閫夛級鏇存敼涓鸿皟鐢╫md涓殑鎺ュ彛鏉ュ疄鐜�
+// iDictBizClient.getCheck(dictBiz);
+// }
+//// charService.saveBySameNamespaceAndFlag(templateVO.getBtmTypeId(), attrVO.getLibraryIdentification(), valuesList, sessionInfo);
+// }
+// });
+// }
+// }
+// }
+//
+// @Override
+// public MdmUIInfoVO getFormDefineByTemplateOid(String templateOid, String codeClassifyOid) {
+// CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(templateOid);
+// MdmUIInfoVO uiInfoVO = new MdmUIInfoVO();
+// uiInfoVO.setTemplateVO(templateVO);
+// uiInfoVO.setFormDefineVO(wrapperFormDefineByTemplate(templateVO, codeClassifyOid));
+// wrapperResemble(templateVO, uiInfoVO);
+// return uiInfoVO;
+// }
+//
+//
+// /**
+// * 妯℃澘灞炴�ц浆鎹负琛ㄥ崟瀹氫箟鐨勪俊鎭�
+// *
+// * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+// * @param codeClassifyOid 鍒嗙被鐨勪富閿紝涓虹┖鐨勬椂鍊欙紝鑾峰彇妯℃澘鎵�灞炵殑鍒嗙被涓婚敭.鐢ㄤ簬浜х敓鍒嗙被娉ㄥ叆
+// * @return 琛ㄦ牸鐨勪俊鎭�
+// */
+// private UIFormDefineVO wrapperFormDefineByTemplate(CodeClstemplateVO templateVO, String codeClassifyOid) {
+// UIFormDefineVO formDefineVO = new UIFormDefineVO();
+// formDefineVO.setOid(templateVO.getOid());
+// formDefineVO.setBtmType(templateVO.getBtmTypeId());
+// if (StringUtils.isBlank(codeClassifyOid)) {
+// codeClassifyOid = templateVO.getCodeClassifyOid();
+// }
+// CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(codeClassifyOid);
+//
+// List<UIFormItemVO> itemVOS = new ArrayList<>();
+// Map<String, List<CodeClstempattrVO>> attrGroupMap = templateVO.getAttributes().stream().
+// filter(s -> StringUtils.isNotBlank(s.getAttributegroup())).collect(Collectors.groupingBy(s -> s.getAttributegroup()));
+//
+// templateVO.getAttributes().forEach(attrVO -> {
+// UIFormItemVO formItemVO = templateAttr2FormField(attrVO, templateVO.getBtmTypeId());
+// itemVOS.add(formItemVO);
+// });
+// //澶勭悊灞炴�у垎缁�
+// if (!CollectionUtils.isEmpty(attrGroupMap)) {
+// //鎸夌収鍒嗙粍鐨勫睘鎬ф帓鍒楋紝鎵惧埌姣忎竴涓垎缁勭殑绗竴涓睘鎬�
+// for (String key : attrGroupMap.keySet()) {
+// List<CodeClstempattrVO> value = attrGroupMap.get(key);
+// //鎵惧埌杩欎釜鍒嗙粍鐨勫睘鎬х殑绗竴涓�
+// CodeClstempattrVO attrVO = value.stream().sorted(((o1, o2) -> o1.getOrdernum().compareTo(o2.getOrdernum()))).findFirst().get();
+// //鎴戜滑鎵惧埌杩欎釜灞炴�у湪鏈�缁堢殑itemVOs閲岀殑浣嶇疆
+// UIFormItemVO lineVO = new UIFormItemVO();
+// lineVO.setField(attrVO.getId() + "_line");
+// lineVO.setType("line");
+// lineVO.setText(key);
+// //鎵句綅缃�
+// for (int i = 0; i < itemVOS.size(); i++) {
+// UIFormItemVO record = itemVOS.get(i);
+// if (record.getField().equalsIgnoreCase(attrVO.getId())) {
+// itemVOS.add(i, lineVO);
+// break;
+// }
+// }
+// }
+// }
+//
+// CodeOrderDTO orderDTO = new CodeOrderDTO();
+// switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
+// if (!CollectionUtils.isEmpty(orderDTO.getData())) {
+// orderDTO.getData().forEach((key, value) -> {
+// for (int i = 0; i < itemVOS.size(); i++) {
+// UIFormItemVO itemVO = itemVOS.get(i);
+// if (itemVO.getField().equalsIgnoreCase(key)) {
+// itemVO.setDefaultValue(value);
+// break;
+// }
+// }
+// });
+// }
+// formDefineVO.setItems(itemVOS);
+// //鏌ヨ鏄惁鏈夊垎绫绘敞鍏ョ殑
+// return formDefineVO;
+// }
+// /**
+// * 灞炴�х被鍨嬩笌js涓殑瀛楁绫诲瀷鐨勬槧灏�
+// */
+// private static Map<String, String> vciFieldTypeMap = new HashMap<String, String>() {{
+// put(VciFieldTypeEnum.VTString.name(), "text");
+// put(VciFieldTypeEnum.VTInteger.name(), "text");
+// put(VciFieldTypeEnum.VTLong.name(), "text");
+// put(VciFieldTypeEnum.VTDouble.name(), "text");
+// put(VciFieldTypeEnum.VTClob.name(), "text");
+// put(VciFieldTypeEnum.VTBoolean.name(), "truefalse");
+// put(VciFieldTypeEnum.VTDateTime.name(), "datetime");
+// put(VciFieldTypeEnum.VTDate.name(), "datetime");
+// put(VciFieldTypeEnum.VTTime.name(), "datetime");
+// put(VciFieldTypeEnum.VTFilePath.name(), "file");
+// }};
+//
+// /**
+// * 妯℃澘灞炴�ц浆鎹负琛ㄥ崟鐨勫瓧娈�
+// *
+// * @param attrVO 妯℃澘灞炴��
+// * @param btmType 涓氬姟绫诲瀷
+// * @return 琛ㄥ崟鐨勫瓧娈�
+// */
+// @Override
+// public UIFormItemVO templateAttr2FormField(CodeClstempattrVO attrVO, String btmType) {
+//
+// UIFormItemVO itemVO = new UIFormItemVO();
+// if (SECRET_FILED.equalsIgnoreCase(attrVO.getId())) {
+//// attrVO.setEnumid(OsEnumServiceImpl.MY_DATA_SECRET);
+// attrVO.setEnumid(MY_DATA_SECRET);
+// }
+// itemVO.setField(attrVO.getId());
+// itemVO.setText(attrVO.getName());
+// itemVO.setType(vciFieldTypeMap.getOrDefault(attrVO.getAttributedatatype(), "text"));
+// if (VciBaseUtil.getBoolean(attrVO.getTextareaflag())) {
+// itemVO.setType("textarea");
+// }
+// if (VciFieldTypeEnum.VTLong.name().equalsIgnoreCase(attrVO.getAttributedatatype())
+// || VciFieldTypeEnum.VTInteger.name().equalsIgnoreCase(attrVO.getAttributedatatype())
+// || VciFieldTypeEnum.VTDouble.name().equalsIgnoreCase(attrVO.getAttributedatatype())) {
+// itemVO.setVerify("number");
+// }
+// itemVO.setReadOnly(VciBaseUtil.getBoolean(attrVO.getReadonlyflag()));
+// itemVO.setKeyAttr(VciBaseUtil.getBoolean(attrVO.getKeyattrflag()));
+// itemVO.setRequired(VciBaseUtil.getBoolean(attrVO.getRequireflag()));
+// itemVO.setDefaultValue(attrVO.getDefaultvalue());
+// itemVO.setDateFormate(attrVO.getCodedateformat());
+// itemVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getFormdisplayflag()));
+// itemVO.setVerify(attrVO.getVerifyrule());
+// itemVO.setPrefix(attrVO.getPrefixvalue());
+// itemVO.setSuffix(attrVO.getSuffixvalue());
+// itemVO.setTooltips(attrVO.getExplain());
+// itemVO.setSelectLibFlag(attrVO.getLibraryidentification());
+// //鐪嬬湅鏄惁鏈夋灇涓�
+// if ((StringUtils.isNotBlank(attrVO.getEnumstring())
+// && !"[]".equalsIgnoreCase(attrVO.getEnumstring())) ||
+// StringUtils.isNotBlank(attrVO.getEnumid())) {
+// itemVO.setType("combox");
+// itemVO.setComboxKey(attrVO.getEnumid());
+// if (StringUtils.isNotBlank(attrVO.getEnumstring())) {
+// //鎸囧畾鐨勪笅鎷夋鍐呭
+// itemVO.setData(JSONObject.parseArray(attrVO.getEnumstring(), KeyValue.class));
+// if (StringUtils.isBlank(attrVO.getEnumid())) {
+// itemVO.setComboxKey(itemVO.getField() + "_data");
+// }
+// }
+// }
+// //鐪嬫槸鍚︽湁鍙傜収
+// if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferconfig())) {
+// itemVO.setType("refer");
+// itemVO.setShowField(itemVO.getField() + "name");
+// if (StringUtils.isNotBlank(attrVO.getReferconfig())) {
+// //閰嶇疆鐨勫唴瀹�
+// itemVO.setReferConfig(JSONObject.parseObject(attrVO.getReferconfig(), UIFormReferVO.class));
+// } else {
+// UIFormReferVO formReferVO = new UIFormReferVO();
+// formReferVO.setType("default");
+// formReferVO.setReferType(attrVO.getReferbtmid());
+// itemVO.setReferConfig(formReferVO);
+// }
+// }
+//
+// //濡傛灉鏄粍鍚堣鍒欙紝鍒嗙被娉ㄥ叆鐨勶紝鏄剧ず涓哄彧璇�
+// if (StringUtils.isNotBlank(attrVO.getComponentrule())) {
+// itemVO.setReadOnly(true);
+// itemVO.setTooltips("鏈睘鎬т负缁勫悎瑙勫垯");
+// itemVO.setRequired(false);
+// }
+// if (StringUtils.isNotBlank(attrVO.getClassifyinvokeattr())) {
+// itemVO.setReadOnly(!VciBaseUtil.getBoolean(attrVO.getClassifyinvokeeditflag()));
+// itemVO.setTooltips("鏈睘鎬ф槸鍒嗙被娉ㄥ叆");
+// itemVO.setRequired(false);
+// }
+//
+// if (VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(itemVO.getField())) {
+// //鏄敓鍛藉懆鏈熺姸鎬�
+// itemVO.setType("combox");
+// itemVO.setComboxKey(btmType + LC_STATUS_SUBFIX);
+// }
+// return itemVO;
+// }
+//
+//
+// /**
+// * 灏佽鐩镐技椤规煡璇㈢殑鍒楄〃
+// *
+// * @param templateVO 妯℃澘鐨勬樉绀哄璞�
+// * @param uiInfoVO 椤甸潰鐨勪俊鎭�
+// */
+// private void wrapperResemble(CodeClstemplateVO templateVO, MdmUIInfoVO uiInfoVO) {
+// List<CodeClstempattrVO> resembleAttrList = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())
+// || VciQueryWrapperForDO.ID_FIELD.equalsIgnoreCase(s.getId())).collect(Collectors.toList());
+// if (!CollectionUtils.isEmpty(resembleAttrList) && resembleAttrList.size() > 1) {
+// UITableDefineVO resembleTable = new UITableDefineVO();
+// resembleTable.setOid(templateVO.getOid());
+// resembleTable.setBtmType(templateVO.getBtmTypeId());
+// resembleTable.setDisplayQueryArea(false);
+// resembleTable.setPageVO(new UITablePageVO());
+// //澶勭悊鎵�鏈夌殑鍒楋紝杩欎釜妯℃澘娌℃湁鍚堝苟鐨勮〃澶寸殑鎯呭喌
+// List<UITableFieldVO> fieldVOList = new ArrayList<>();
+// resembleAttrList.forEach(attrVO -> {
+// UITableFieldVO tableFieldVO = templateAttr2TableField(attrVO,false);
+// tableFieldVO.setHidden(false);
+// fieldVOList.add(tableFieldVO);
+// });
+// List<List<UITableFieldVO>> cols = new ArrayList<>();
+// cols.add(fieldVOList);
+// resembleTable.setCols(cols);
+// uiInfoVO.setResembleTableVO(resembleTable);
+// }
+// }
+//
+//
+// /**
+// * 妯℃澘灞炴�ц浆鎹负琛ㄦ牸鏄剧ず鐨勯厤缃�
+// *
+// * @param attrVO 妯℃澘灞炴��
+// * @param forEdit 鏄惁鏄紪杈戞墍闇�
+// * @return 琛ㄦ牸鐨勫瓧娈�
+// */
+// @Override
+// public UITableFieldVO templateAttr2TableField(CodeClstempattrVO attrVO,boolean forEdit) {
+// UITableFieldVO fieldVO = new UITableFieldVO();
+// if (SECRET_FILED.equalsIgnoreCase(attrVO.getId())) {
+// attrVO.setEnumid(MY_DATA_SECRET);
+// }
+// fieldVO.setField(attrVO.getId());
+// fieldVO.setTitle(attrVO.getName());
+// fieldVO.setFieldType(vciFieldTypeMap.getOrDefault(attrVO.getAttributedatatype(), "text"));
+// fieldVO.setSort(true);
+// fieldVO.setSortField(fieldVO.getField());
+// fieldVO.setQueryField(fieldVO.getField());
+// if (forEdit){
+// fieldVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getFormdisplayflag()));
+// }else {
+// fieldVO.setHidden(!VciBaseUtil.getBoolean(attrVO.getTabledisplayflag()));
+// }
+// if (attrVO.getAttrtablewidth() != null && attrVO.getAttrtablewidth() > 0) {
+// fieldVO.setMinWidth(Integer.valueOf(attrVO.getAttrtablewidth()));
+// fieldVO.setWidth(Integer.valueOf(attrVO.getAttrtablewidth()));
+// }
+// //鐪嬬湅鏄惁鏈夋灇涓�
+// if ((StringUtils.isNotBlank(attrVO.getEnumstring())
+// && !"[]".equalsIgnoreCase(attrVO.getEnumstring())) ||
+// StringUtils.isNotBlank(attrVO.getEnumid())) {
+// fieldVO.setFieldType("combox");
+// fieldVO.setField(fieldVO.getField() + "Text");
+// fieldVO.setComboxKey(attrVO.getEnumid());
+// if (StringUtils.isNotBlank(attrVO.getEnumstring())) {
+// //鎸囧畾鐨勪笅鎷夋鍐呭
+// fieldVO.setData(JSONObject.parseArray(attrVO.getEnumstring(), KeyValue.class));
+// if (StringUtils.isBlank(attrVO.getEnumid())) {
+// fieldVO.setComboxKey(fieldVO.getField() + "_data");
+// }
+// }else {
+// List<KeyValue> osEnumItemVOList= enumService.getEnum(attrVO.getEnumid());
+// fieldVO.setData(osEnumItemVOList);
+// }
+// }
+// //鐪嬫槸鍚︽湁鍙傜収
+// if (StringUtils.isNotBlank(attrVO.getReferbtmid()) || StringUtils.isNotBlank(attrVO.getReferconfig())) {
+// fieldVO.setFieldType("refer");
+// fieldVO.setQueryField(fieldVO.getField());
+// fieldVO.setField(fieldVO.getField() + "name");
+// fieldVO.setShowField(fieldVO.getField());
+// if (StringUtils.isNotBlank(attrVO.getReferconfig())) {
+// //閰嶇疆鐨勫唴瀹�
+// fieldVO.setReferConfig(JSONObject.parseObject(attrVO.getReferconfig(), UIFormReferVO.class));
+// } else {
+// UIFormReferVO formReferVO = new UIFormReferVO();
+// formReferVO.setType("default");
+// formReferVO.setReferType(attrVO.getReferbtmid());
+// fieldVO.setReferConfig(formReferVO);
+// }
+// }
+// if (VciQueryWrapperForDO.LC_STATUS_FIELD.equalsIgnoreCase(fieldVO.getSortField())) {
+// fieldVO.setField("lcstatus_text");
+// }
+// Map<String, String> eventJsMap = new HashMap<>();
+// //瓒呴摼鎺ヤ笌妯℃澘鏄簰鏂�
+// if (StringUtils.isNotBlank(attrVO.getTablehref())) {
+// String event = fieldVO.getSortField() + "_href";
+// eventJsMap.put(event, attrVO.getTablehref());
+// fieldVO.setTemplet("function(d){ return '<a class=\"layui-btn layui-btn-intable \" lay-event=\"" + event + "\">d." + fieldVO.getField() + "</a>';}");
+// }
+// if (StringUtils.isNotBlank(attrVO.getTabledisplayjs())) {
+// //鐩存帴鍐檉unction(d){ return xxxxx;}
+// fieldVO.setTemplet(attrVO.getTabledisplayjs());
+// }
+// if (StringUtils.isBlank(fieldVO.getTemplet()) && VciFieldTypeEnum.VTBoolean.name().equalsIgnoreCase(attrVO.getAttributedatatype())) {
+// fieldVO.setTemplet("function(d){return $webUtil.formateBoolean(d." + fieldVO.getField() + ");}");
+// }
+// fieldVO.setOptionJsMap(eventJsMap);
+// fieldVO.setStyle(attrVO.getTabledisplaystyle());
+// //鍒楄〃閲屼笉鍏佽鐩存帴缂栬緫
+// fieldVO.setDateFormate(attrVO.getCodedateformat());
+// return fieldVO;
+// }
+//
+//
+// /**
+// * 鐩镐技椤规煡璇�
+// *
+// * @param orderDTO 缂栫爜鐨勭浉鍏充俊鎭�
+// * @return 鏁版嵁鍒楄〃
+// */
+// @Override
+// public DataGrid<Map<String, String>> resembleQuery(CodeOrderDTO orderDTO) {
+// VciBaseUtil.alertNotNull(orderDTO, "鐢宠鐨勪俊鎭�", orderDTO.getCodeClassifyOid(), "鍒嗙被涓婚敭", orderDTO.getTemplateOid(), "妯℃澘涓婚敭");
+// CodeClassifyFullInfoBO fullInfoBO = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
+// CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
+// switchClassifyLevelOnOrder(templateVO, fullInfoBO, orderDTO);
+// switchDateAttrOnOrder(templateVO, orderDTO);
+// switchComponentAttrOnOrder(templateVO, orderDTO);
+// //闇�瑕佽幏鍙栨槸鍚︽湁鐩镐技鏌ヨ灞炴��
+// Map<String, CodeClassifyTemplateAttrVO> attrVOs = templateVO.getAttributes().stream().filter(s -> VciBaseUtil.getBoolean(s.getSamerepeatattrflag())).collect(Collectors.toMap(s -> s.getId(), t -> t));
+// if (CollectionUtils.isEmpty(attrVOs)) {
+// //閮芥病鏈夊睘鎬э紝鑲畾涓嶈兘鏌ヨ浜�
+// return new DataGrid<>();
+// }
+// Map<String, String> conditionMap = new HashMap<>();
+// //鎴戜滑棣栧厛鑾峰彇鏈夋病鏈夋煡璇㈣鍒�
+// CodeResembleRuleVO resembleRuleVO = Optional.ofNullable(getUseResembleRule(fullInfoBO, fullInfoBO.getCurrentClassifyVO())).orElseGet(() -> new CodeResembleRuleVO());
+// attrVOs.forEach((attrId, attrVO) -> {
+// String value = getValueFromOrderDTO(orderDTO, attrId);
+// if (value == null) {
+// value = "";
+// }
+// wrapperResembleConditionMap(value, resembleRuleVO, attrId, conditionMap);
+// });
+//
+// //娌℃湁闄愬埗鍒嗙被锛屼絾鏄竴涓ā鏉垮彧鍙兘鍦ㄤ竴涓笟鍔＄被鍨嬮噷闈紝鎵�浠ョ洿鎺ユ煡璇㈣繖涓笟鍔＄被鍨嬪嵆鍙�
+// if (!CollectionUtils.isEmpty(conditionMap)) {
+// Map<String, String> andConditionMap = new HashMap<>();
+// andConditionMap.put("islastr", "1");
+// andConditionMap.put("islastv", "1");
+// if (StringUtils.isNotBlank(orderDTO.getOid())) {
+// andConditionMap.put("oid", QueryOptionConstant.NOTEQUAL + orderDTO.getOid());
+// }
+// conditionMap.putAll(andConditionMap);
+// PageHelper pageHelper = new PageHelper(-1);
+// pageHelper.addDefaultDesc("id");
+// return queryGrid(fullInfoBO.getTopClassifyVO().getBtmtypeid(), templateVO, conditionMap, pageHelper);
+// }
+// return new DataGrid<>();
+// }
+//
+// /**
+// * 鑾峰彇浣跨敤鐨勭浉浼兼煡璇㈣鍒�
+// *
+// * @param fullInfoBO 绫诲叏閮ㄤ俊鎭�
+// * @param currentClassifyVO 褰撳墠鐨勫垎绫�
+// * @return 瑙勫垯锛屽鏋滀笉瀛樺湪浼氳繑鍥濶ull
+// */
+// @Override
+// public CodeResembleRuleVO getUseResembleRule(CodeClassifyFullInfoBO fullInfoBO, CodeClassifyVO currentClassifyVO) {
+// if (currentClassifyVO == null) {
+// return null;
+// }
+// if (currentClassifyVO != null && StringUtils.isNotBlank(currentClassifyVO.getCodeResembleRuleOid())) {
+// //璇存槑宸茬粡瀛樺湪
+// return resembleRuleService.getObjectByOid(currentClassifyVO.getCodeResembleRuleOid());
+// }
+// if (StringUtils.isBlank(currentClassifyVO.getParentcodeclassifyoid())) {
+// return null;
+// }
+// Map<String, CodeClassifyVO> classifyVOMap = fullInfoBO.getParentClassifyVOs().stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
+// return getUseResembleRule(fullInfoBO, classifyVOMap.getOrDefault(currentClassifyVO.getParentcodeclassifyoid(), null));
+// }
+//
+// /**
+// * 灏佽鐩镐技椤规煡璇㈢殑鏌ヨ鏉′欢鐨勬槧灏�
+// *
+// * @param value 鍊�
+// * @param resembleRuleVO 鐩镐技椤硅鍒�
+// * @param attrId 灞炴�х殑缂栧彿
+// * @param conditionMap 鏌ヨ鏉′欢
+// */
+// @Override
+// public void wrapperResembleConditionMap(String value, CodeResembleRuleVO resembleRuleVO, String attrId, Map<String, String> conditionMap) {
+// boolean ignoreSpace = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorespaceflag()) || VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
+// if (StringUtils.isBlank(value)) {
+// //涓虹┖鐨勬椂鍊欏氨涓嶆煡璇㈠畠灏辨槸
+// } else {
+// String queryKey = "";
+// String queryValue = "";
+// boolean ignoreCase = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorecaseflag());
+// boolean ignoreWidth = VciBaseUtil.getBoolean(resembleRuleVO.getIgnorewidthflag());
+// boolean trimAll = VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
+// boolean trim = VciBaseUtil.getBoolean(resembleRuleVO.getIgnoreallspaceflag());
+// String temp = "";
+// if (ignoreCase && ignoreSpace && ignoreWidth) {
+// //蹇界暐澶у皬鍐欙紝涓斿幓绌猴紝蹇界暐鍏ㄥ崐瑙�
+// temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(to_single_byte('%s')) " + (trimAll ? ",' ','')" : ")");
+// } else if (ignoreCase && ignoreSpace && !ignoreWidth) {
+// //蹇界暐澶у皬鍐欍�佸幓绌恒�佷笉蹇界暐鍏ㄥ崐瑙�
+// temp = (trimAll ? "REPLACE" : "TRIM") + "(UPPER(%s) " + (trimAll ? ",' ','')" : ")");
+// } else if (ignoreCase && !ignoreSpace && ignoreWidth) {
+// //蹇界暐澶у皬鍐欍�佷笉鍘荤┖銆佸拷鐣ュ叏鍗婅
+// temp = "UPPER(to_single_byte('%s'))";
+// } else if (!ignoreCase && ignoreSpace && ignoreWidth) {
+// //涓嶅拷鐣ュぇ灏忓啓銆佸幓绌恒�佸拷鐣ュ叏鍗婅
+// temp = (trimAll ? "REPLACE" : "TRIM") + "(to_single_byte('%s') " + (trimAll ? ",' ','')" : ")");
+// } else if (ignoreCase && !ignoreSpace && !ignoreWidth) {
+// //蹇界暐澶у皬鍐欍�佷笉鍘荤┖銆佷笉蹇界暐鍏ㄥ崐瑙�
+// temp = "UPPER(%s)";
+// } else if (!ignoreCase && !ignoreCase && ignoreWidth) {
+// //涓嶅拷鐣ュぇ灏忓啓銆佷笉鍘荤┖銆佸拷鐣ュ叏鍗婅
+// temp = "to_single_byte('%s')";
+// } else if (!ignoreCase && ignoreSpace && !ignoreWidth) {
+// //涓嶅拷鐣ュぇ灏忓啓銆佸幓绌恒�佷笉蹇界暐鍏ㄥ崐瑙�
+// temp = (trimAll ? "REPLACE" : "TRIM") + "(%s " + (trimAll ? ",' ','')" : ")");
+// } else if (!ignoreCase && !ignoreSpace && !ignoreWidth) {
+// //涓嶅拷鐣ュぇ灏忓啓銆佷笉鍘荤┖銆佷笉蹇界暐鍏ㄥ崐瑙�
+// temp = "%s";
+// }
+// if (StringUtils.isNotBlank(resembleRuleVO.getLinkCharacter())) {
+// List<String> chars = VciBaseUtil.str2List(resembleRuleVO.getLinkCharacter());
+// for (int i = 0; i < chars.size(); i++) {
+// String s = chars.get(i);
+// temp = "replace(" + temp + ",'" + s + "','')";
+// }
+// }
+// queryValue = String.format(temp, (trim ? value.trim() : value));
+// temp = temp.replace("to_single_byte('%s')","to_single_byte(%s)");
+// queryKey = String.format(temp, "t."+attrId);
+// conditionMap.put(queryKey, QueryOptionConstant.OR + queryValue);
+// }
+// }
+//
+//
+// /**
+// * 鏌ヨ缂栫爜鏁版嵁鐨勫垪琛�
+// *
+// * @param btmType 涓氬姟绫诲瀷
+// * @param templateVO 妯℃澘鐨勫璞★紝闇�瑕佸寘鍚ā鏉跨殑灞炴��
+// * @param conditionMap 鏌ヨ鏉′欢
+// * @param pageHelper 鍒嗛〉瀵硅薄
+// * @return 鏁版嵁鍒楄〃
+// */
+// @Override
+// public DataGrid<Map<String, String>> queryGrid(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper) {
+// CodeTemplateAttrSqlBO sqlBO = getSqlByTemplateVO(btmType, templateVO, conditionMap, pageHelper);
+//// List<Map> maps = boService.queryByOnlySqlForMap(sqlBO.getSqlHasPage());
+// List<Map> maps = commonsMapper.selectBySql(sqlBO.getSqlHasPage());
+// DataGrid<Map<String, String>> dataGrid = new DataGrid<>();
+// List<Map<String, String>> dataList = new ArrayList<>();
+// if (!CollectionUtils.isEmpty(maps)) {
+// maps.stream().forEach(map -> {
+// Map<String, String> data = new HashMap<>();
+// map.forEach((key, value) -> {
+// data.put(((String) key).toLowerCase(Locale.ROOT), (String) value);
+// });
+// dataList.add(data);
+// });
+// }
+// dataGrid.setData(dataList);
+// if (!CollectionUtils.isEmpty(dataList)) {
+// wrapperData(dataGrid.getData(), templateVO, sqlBO.getSelectFieldList(), false);
+// dataGrid.setTotal(Long.parseLong(commonsMapper.selectBySql(sqlBO.getSqlCount()).get(0).values().toArray()[0].toString()););
+// }
+// return dataGrid;
+// }
+//
+//
+// /**
+// * 灏佽鏌ヨ鍑烘潵鐨勬暟鎹�
+// *
+// * @param dataMap 鏁版嵁鐨勬槧灏�
+// * @param templateVO 妯℃澘鐨勫睘鎬�
+// * @param onlySelectAttrIdList 浠呬粎鏌ヨ鐨勫睘鎬у瓧娈�
+// * @param form 琛ㄥ崟閲屼娇鐢�
+// */
+// @Override
+// public void wrapperData(List<Map<String, String>> dataMap, CodeClassifyTemplateVO templateVO,
+// Collection<String> onlySelectAttrIdList, boolean form) {
+// if (onlySelectAttrIdList == null) {
+// onlySelectAttrIdList = new ArrayList<>();
+// }
+// //鍏堣浆鎹竴涓嬫椂闂存牸寮�
+// List<String> finalOnlySelectAttrIdList = onlySelectAttrIdList.stream().collect(Collectors.toList());
+// List<CodeClassifyTemplateAttrVO> dateFormatAttrVOs = templateVO.getAttributes().stream().filter(
+// s -> StringUtils.isNotBlank(s.getCodeDateFormat()) &&
+// (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT)))
+// ).collect(Collectors.toList());
+// //鏋氫妇鐨勫唴瀹�
+// List<CodeClassifyTemplateAttrVO> enumAttrVOs = templateVO.getAttributes().stream().filter(
+// s -> (StringUtils.isNotBlank(s.getEnumId()) || StringUtils.isNotBlank(s.getEnumString()))
+// &&
+// (finalOnlySelectAttrIdList.size() == 0 || finalOnlySelectAttrIdList.contains(s.getId().toLowerCase(Locale.ROOT)))
+// ).collect(Collectors.toList());
+//
+// List<String> userIds = new ArrayList<>();
+// dataMap.stream().forEach(data -> {
+// //澶勭悊鏃堕棿
+// if (!form) {
+// //琛ㄥ崟鐨勬椂鍊欏彧鑳界敤缁熶竴鐨勬椂闂存牸寮�
+// wrapperDateFormat(dateFormatAttrVOs, data);
+// }
+// //澶勭悊鏋氫妇
+// wrapperEnum(enumAttrVOs, data);
+// String lcstatus = data.get(VciQueryWrapperForDO.LC_STATUS_FIELD);
+// String copyFromVersion = data.getOrDefault(COPY_FROM_VERSION,"");
+// if ((CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(lcstatus) || CodeDefaultLC.AUDITING.getValue().equalsIgnoreCase(lcstatus))
+// && StringUtils.isBlank(copyFromVersion)
+// ) {
+// data.put(VciQueryWrapperForDO.ID_FIELD, "******");
+// }
+// data.put(VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT), CodeDefaultLC.getTextByValue(lcstatus));
+// if(CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(lcstatus)
+// && StringUtils.isNotBlank(copyFromVersion)){
+// data.put(VciQueryWrapperForDO.LC_STATUS_FIELD_TEXT.toLowerCase(Locale.ROOT), "淇敼涓�");
+// }
+// if (data.containsKey("creator")) {
+// userIds.add(data.get("creator"));
+// }
+// if (data.containsKey("lastmodifier")) {
+// userIds.add(data.get("lastmodifier"));
+// }
+// });
+// if (!CollectionUtils.isEmpty(userIds)) {
+// Map<String, SmUserVO> userVOMap = Optional.ofNullable(userQueryService.listUserByUserIds(userIds)).orElseGet(() -> new ArrayList<>()).stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+// dataMap.stream().forEach(data -> {
+// String creator = data.getOrDefault("creator", null);
+// if (StringUtils.isNotBlank(creator) && userVOMap.containsKey(creator.toLowerCase(Locale.ROOT))) {
+// data.put("creator", creator + "(" + userVOMap.get(creator.toLowerCase(Locale.ROOT)).getName() + ")");
+// }
+// String lastmodifier = data.getOrDefault("lastmodifier", null);
+// if (StringUtils.isNotBlank(lastmodifier) && userVOMap.containsKey(lastmodifier.toLowerCase(Locale.ROOT))) {
+// data.put("lastmodifier", lastmodifier + "(" + userVOMap.get(lastmodifier.toLowerCase(Locale.ROOT)).getName() + ")");
+// }
+// });
+// }
+// }
+//
+//
+// /**
+// * 澶勭悊鏃堕棿鏍煎紡
+// *
+// * @param dateFormatAttrVOs 鏃堕棿鏍煎紡鐨勫睘鎬�
+// * @param data 褰撳墠琛屾暟鎹�
+// */
+// private void wrapperDateFormat(Collection<CodeClassifyTemplateAttrVO> dateFormatAttrVOs, Map<String, String> data) {
+// if (!CollectionUtils.isEmpty(dateFormatAttrVOs)) {
+// dateFormatAttrVOs.stream().forEach(dateFormatAttrVO -> {
+// String attrId = dateFormatAttrVO.getId().toLowerCase(Locale.ROOT);
+// String oldValue = data.getOrDefault(attrId, null);
+// if (StringUtils.isNotBlank(oldValue)) {
+// DateConverter dateConverter = new DateConverter();
+// try {
+// dateConverter.setAsText(oldValue);
+// Date value = dateConverter.getValue();
+// if (value != null) {
+// data.put(attrId, VciDateUtil.date2Str(value, dateFormatAttrVO.getCodeDateFormat()));
+// }
+// } catch (Throwable e) {
+// //杞崲鍙兘鏈夐棶棰橈紝杩欏氨浣跨敤鍘熸湰瀛樺偍鐨勫��
+// }
+// }
+// });
+// }
+// }
+//
+//
+// /**
+// * 澶勭悊鏋氫妇鐨勫唴瀹癸紝濡傛灉涓嶅湪鏋氫妇涓紝浼氳繑鍥炲師鏈殑鍊�
+// *
+// * @param enumAttrVOs 鏋氫妇灞炴��
+// * @param data 褰撳墠琛屾暟鎹�
+// */
+// private void wrapperEnum(Collection<CodeClassifyTemplateAttrVO> enumAttrVOs, Map<String, String> data) {
+// //澶勭悊鏋氫妇鐨勫唴瀹癸紝涓轰簡鍏煎浠ュ墠鐨勬暟鎹�,濡傛灉鏁版嵁涓嶈兘浣跨敤鏋氫妇杞崲鐨勮瘽锛岄偅杩樻槸鏄剧ず浠ュ墠鐨勫��
+// if (!CollectionUtils.isEmpty(enumAttrVOs)) {
+// enumAttrVOs.stream().forEach(enumAttrVO -> {
+// String attrId = enumAttrVO.getId().toLowerCase(Locale.ROOT);
+// String oldValue = data.getOrDefault(attrId, null);
+// if (StringUtils.isNotBlank(oldValue)) {
+// List<KeyValue> comboxKVs = listComboboxItems(enumAttrVO);
+// String newValue = oldValue;
+// KeyValue keyValue = Optional.ofNullable(comboxKVs).orElseGet(() -> new ArrayList<>()).stream().filter(s -> s.getKey().equalsIgnoreCase(oldValue)).findFirst().orElseGet(() -> null);
+// if (keyValue != null) {
+// newValue = keyValue.getValue();
+// }
+// data.put(attrId + "Text", newValue);
+// }
+// });
+// }
+// }
+//
+//
+// /**
+// * 鏍规嵁妯℃澘灞炴�х敓鎴愮浉搴旂殑sql淇℃伅
+// *
+// * @param btmType 涓氬姟绫诲瀷
+// * @param templateVO 妯℃澘鏄剧ず瀵硅薄锛屽繀椤诲寘鍚睘鎬�
+// * @param conditionMap 鏌ヨ鏉′欢
+// * @param pageHelper 鍒嗛〉鍜屾帓搴忓璞�
+// * @return sql鐨勭浉鍏充俊鎭�
+// */
+// @Override
+// public CodeTemplateAttrSqlBO getSqlByTemplateVO(String btmType, CodeClassifyTemplateVO templateVO, Map<String, String> conditionMap, PageHelper pageHelper) {
+// //鍥犱负鍙傜収涓嶄竴瀹氭槸鍦ㄥ钩鍙扮殑灞炴�ф睜閲岄潰璁剧疆锛屾墍浠ユ垜浠緱闇�瑕佽嚜琛屽鐞�
+// //鍙傝�僔ciQueryWrapper鏉ュ鐞�
+// //1. 鎵惧埌鎵�鏈夌殑瀛楁锛�
+// Map<String, CodeClassifyTemplateAttrVO> attrVOMap = templateVO.getAttributes().stream().collect(Collectors.toMap(s -> s.getId().toLowerCase(Locale.ROOT), t -> t));
+// List<String> selectFieldList = attrVOMap.keySet().stream().collect(Collectors.toList());
+//
+// //鎵�鏈夌殑鍙傜収鐨勫瓧娈�
+// Map<String/**灞炴�у瓧娈�**/, String> joinTableList = new ConcurrentHashMap<>();
+// List<CodeClassifyTemplateAttrVO> referAttrVOs = templateVO.getAttributes().stream().filter(
+// s -> StringUtils.isNotBlank(s.getReferBtmId()) || StringUtils.isNotBlank(s.getReferConfig())
+// ).collect(Collectors.toList());
+// Map<String/**鍙傜収鐨勫睘鎬�**/, String/**瀹為檯鐨勫瓧娈�**/> referFieldMap = new HashMap<>();
+// if (!CollectionUtils.isEmpty(referAttrVOs)) {
+// referAttrVOs.parallelStream().forEach(attrVO -> {
+// UIFormReferVO referVO = null;
+// if (StringUtils.isNotBlank(attrVO.getReferConfig())) {
+// referVO = JSONObject.parseObject(attrVO.getReferConfig(), UIFormReferVO.class);
+// } else {
+// referVO = new UIFormReferVO();
+// referVO.setReferType(attrVO.getReferBtmId());
+// referVO.setValueField(VciQueryWrapperForDO.OID_FIELD);
+// referVO.setTextField("name");
+// }
+//
+// String referTable = VciBaseUtil.getTableName(referVO.getReferType());
+// String referTableNick = attrVO.getId() + "0";
+// String left = " left join " + referTable + " " + referTableNick + " on " + referTableNick + "." + referVO.getValueField() + " = t." + attrVO.getId();
+// joinTableList.put(attrVO.getId(), left);
+// String referShowField = attrVO.getId() + "Name";
+// List<String> textFields = VciBaseUtil.str2List(referVO.getTextField());
+// String showFieldInSource = "";
+// if (textFields.contains("name")) {
+// showFieldInSource = "name";
+// } else {
+// showFieldInSource = textFields.get(0);
+// }
+// referFieldMap.put(attrVO.getId(), referTableNick + "." + showFieldInSource);
+// selectFieldList.add(referTableNick + "." + showFieldInSource + " as " + referShowField);
+// });
+// }
+// Optional.ofNullable(attributeService.getDefaultAttributeVOMap()).orElseGet(() -> new HashMap<>()).keySet().stream().forEach(attrId -> {
+// if (!selectFieldList.contains(attrId) && !"secretgrade".equalsIgnoreCase(attrId)) {
+// selectFieldList.add(attrId);
+// }
+// });
+// if (!selectFieldList.contains(CODE_FIELD)) {
+// selectFieldList.add(CODE_FIELD);
+// }
+// if (!selectFieldList.contains(CODE_CLASSIFY_OID_FIELD)) {
+// selectFieldList.add(CODE_CLASSIFY_OID_FIELD);
+// }
+// if (!selectFieldList.contains(CODE_TEMPLATE_OID_FIELD)) {
+// selectFieldList.add(CODE_TEMPLATE_OID_FIELD);
+// }
+// if (!selectFieldList.contains(CODE_FULL_PATH_FILED)) {
+// selectFieldList.add(CODE_FULL_PATH_FILED);
+// }
+//
+// //澶勭悊鏌ヨ鏉′欢
+// //TODO 楠岃瘉sql娉ㄥ叆
+// List<String> andSql = new ArrayList<>();
+// List<String> orSql = new ArrayList<>();
+// if (!CollectionUtils.isEmpty(conditionMap)) {
+// Map<String, String> orConditionMap = new HashMap<>();
+// Map<String, String> andCondtionMap = new HashMap<>();
+// //鍏堝垎绂籵r鐨勬煡璇㈡潯浠讹紝鍙﹀褰撴煡璇㈡潯浠舵槸绌虹殑鏃跺�欎篃涓嶆煡璇�
+// conditionMap.forEach((k, v) -> {
+// if (StringUtils.isNotBlank(v)) {
+// if (v.startsWith(QueryOptionConstant.OR)) {
+// orConditionMap.put(k, v.substring(QueryOptionConstant.OR.length()));
+// } else {
+// andCondtionMap.put(k, v);
+// }
+// }
+// });
+//
+// andCondtionMap.forEach((k, v) -> {
+// andSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap));
+// });
+// orConditionMap.forEach((k, v) -> {
+// orSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap));
+// });
+// }
+// //缁勫悎璧锋潵
+// StringBuilder andSb = new StringBuilder();
+// andSql.stream().forEach(s -> {
+// andSb.append(s).append(SPACE).append(QueryOptionConstant.AND).append(SPACE);
+// });
+//
+// String andString = andSb.toString().trim();
+// String endWithSql = QueryOptionConstant.AND;
+// if (andString.endsWith(endWithSql)) {
+// andString = andString.substring(0, andString.length() - endWithSql.length());
+// }
+//
+// String orString = orSql.stream().collect(Collectors.joining(" or "));
+// String whereSql = "";
+// if (StringUtils.isNotBlank(orString)) {
+// if (StringUtils.isBlank(andString)) {
+// andString = " 1 = 1 ";
+// }
+// whereSql = SPACE + "(" + SPACE + andString + SPACE + ") and (" + SPACE + orString + SPACE + ")" + SPACE;
+// } else {
+// whereSql = andString + SPACE;
+// }
+// if (attrVOMap.keySet().contains("secretgrade")) {
+// Integer userSecret = VciBaseUtil.getCurrentUserSecret();
+// if (userSecret == null || userSecret == 0) {
+// userSecret = secretService.getMinUserSecret();
+// }
+// whereSql += " and ( t.secretGrade <= " + userSecret + ") ";
+// }
+// String tableName = VciBaseUtil.getTableName(btmType);
+// String sql = "select " + selectFieldList.stream().map(s -> (s.contains(".") ? s : ("t." + s))).collect(Collectors.joining(","))
+// + " from " + tableName + SPACE + "t" + SPACE
+// + joinTableList.values().stream().collect(Collectors.joining(SPACE))
+// + (StringUtils.isBlank(whereSql) ? "" : " where ") + whereSql;
+// if (pageHelper == null) {
+// pageHelper = new PageHelper(-1);
+// }
+// //鐪嬬湅鎺掑簭
+// String orderSql = pageHelper.getOrderSql("t");
+// sql += (orderSql == null ? "" : orderSql);
+// String whereSubfixForPage = " ) A where rownum < " + (pageHelper.getLimit() * pageHelper.getPage() + 1) + ") where RN >= "
+// + (pageHelper.getLimit() * (pageHelper.getPage() - 1) + 1);
+// String sqlHasPage = pageHelper.getLimit() > 0 ? ("select * from (select A.*,rownum RN from (" + sql + whereSubfixForPage) : sql;
+// String sqlCount = "select count(1) from " + tableName + SPACE + "t" + SPACE + joinTableList.values().stream().collect(Collectors.joining(SPACE))
+// + (StringUtils.isBlank(whereSql) ? "" : " where ") + whereSql;
+// CodeTemplateAttrSqlBO sqlBO = new CodeTemplateAttrSqlBO();
+// sqlBO.setTableName(tableName);
+// sqlBO.setJoinTable(joinTableList);
+// sqlBO.setNickName("t");
+//// sqlBO.setPageHelper(pageHelper);
+// sqlBO.setSqlHasPage(sqlHasPage);
+// sqlBO.setSqlCount(sqlCount);
+// sqlBO.setSqlUnPage(sql);
+// return sqlBO;
+// }
+//
+//
+// /**
+// * 缁勫悎鏌ヨ鏉′欢鐨剆ql
+// *
+// * @param key 瀛楁
+// * @param value 鍚嶅瓧
+// * @param referFieldMap 鍙傜収鐨勫瓧娈�
+// * @param attrVOMap 灞炴�х殑鏄犲皠
+// * @return Sql璇彞
+// */
+// private String getConditionSql(String key, String value, Map<String/**鍙傜収鐨勫睘鎬�**/, String/**瀹為檯鐨勫睘鎬�**/> referFieldMap, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
+// if (key.endsWith("_begin")) {
+// //璇存槑鏄�>=鐨勩�傛垜浠渶瑕佸厛鑾峰彇涓�涓�
+// String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
+// if (referFieldMap.containsKey(field)) {
+// //璇存槑杩樻槸鍙傜収閲岄潰鐨勶紝鎴戜滑榛樿杩欑鎯呭喌涓嬮兘鏄瓧绗︿覆鍚э紝鍥犱负鍙傜収鐨勫睘鎬т笉涓�瀹氱敤鐨勫钩鍙扮殑灞炴�ф睜閲岀殑锛屾墍浠ュぇ閮ㄥ垎鎯呭喌涓嬶紝鏄剧ず鐨勫睘鎬ч兘鏄瓧绗︿覆鍚�
+// return referFieldMap.get(field) + SPACE + " >= '" + value + "'" + SPACE;
+// } else {
+// return (field.contains(".") ? "" : "t.") + field + SPACE + " >= " + getStringValueInWhere(value, field, attrVOMap);
+// }
+// } else if (key.endsWith("_end")) {
+// //璇存槑鏄�<=鐨勩�傛垜浠渶瑕佸厛鑾峰彇涓�涓�
+// String field = (key.substring(0, key.length() - 6).toLowerCase().trim());
+// if (referFieldMap.containsKey(field)) {
+// //璇存槑杩樻槸鍙傜収閲岄潰鐨勶紝鎴戜滑榛樿杩欑鎯呭喌涓嬮兘鏄瓧绗︿覆鍚э紝鍥犱负鍙傜収鐨勫睘鎬т笉涓�瀹氱敤鐨勫钩鍙扮殑灞炴�ф睜閲岀殑锛屾墍浠ュぇ閮ㄥ垎鎯呭喌涓嬶紝鏄剧ず鐨勫睘鎬ч兘鏄瓧绗︿覆鍚�
+// return referFieldMap.get(field) + SPACE + " <= '" + value + "'" + SPACE;
+// } else {
+// return (field.contains(".") ? "" : "t.") + field + SPACE + " <= " + getStringValueInWhere(field, value, attrVOMap);
+// }
+// } else {
+// if (referFieldMap.containsKey(key)) {
+// //璇存槑鏄弬鐓х殑锛屾垜浠弬鐓х殑鏌ヨ閮借涓烘槸瀛楃涓诧紝濡傛灉鏄椂闂存牸寮忕殑鏌ヨ鑲畾鏈夐棶棰橈紝
+// String selectKey = referFieldMap.get(key);
+// return getSqlByValue(selectKey, value, null);
+// } else {
+// return getSqlByValue(key, value, attrVOMap);
+// }
+// }
+//
+// }
+//
+// /**
+// * 鑾峰彇鏌ヨ鏉′欢涓殑鍊肩殑锛屽鐞嗕笉鍚岀殑绫诲瀷
+// *
+// * @param value 鍊�
+// * @param field 瀛楁鍚嶇О
+// * @return 鏃ユ湡鎴栬�呮椂闂存牸寮忎細鍖呮嫭to_date锛屽瓧绗︿覆浼氬姞'
+// */
+// private String getStringValueInWhere(String field, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
+// if ((field.contains(".") && !field.toLowerCase(Locale.ROOT).startsWith("t.")) || attrVOMap == null
+// || !field.replace("t.", "").matches(RegExpConstant.LETTER) || value.startsWith(ONLY)) {
+// //璇存槑鍙兘鏄寚瀹氱殑鏌愪釜鏉′欢锛岀洿鎺ヨ繑鍥�
+// if (value.startsWith(ONLY)) {
+// value = value.replace(ONLY, "");
+// }
+// if ((value.startsWith("(") && value.endsWith(")")) || (value.startsWith("'") && value.endsWith("'"))) {
+// return value;
+// }
+// if (field.contains(".") && attrVOMap != null && attrVOMap.containsKey(field.split("\\.")[0].toLowerCase(Locale.ROOT))) {
+// //鏄弬鐓�
+// return "'" + value + "'";
+// } else {
+// return value;
+// }
+// } else {
+// //鐪嬬湅鏄笉鏄繖涓璞￠噷鐨勫睘鎬�
+// if (attrVOMap.containsKey(field)) {
+// VciFieldTypeEnum fieldTypeEnum = VciFieldTypeEnum.valueOf(attrVOMap.get(field).getAttributeDataType());
+// if ("ts".equalsIgnoreCase(field)) {
+// return "to_timestamp('" + value + "', '" + DATETIME_FORMAT + ".ff')";
+// }
+// DateConverter dateConverter = new DateConverter();
+// if (VciFieldTypeEnum.VTDateTime.equals(fieldTypeEnum)) {
+// //瀹為檯涓婏紝鏁版嵁搴撻兘鏄痶imestamp鐨勭被鍨�.
+// dateConverter.setAsText(value);
+// return "to_date('" + dateConverter.getAsText(VciDateUtil.DateTimeFormat) + "','" + DATETIME_FORMAT + "')";
+// } else if (VciFieldTypeEnum.VTDate.equals(fieldTypeEnum)) {
+// dateConverter.setAsText(value);
+// return "to_date('" + dateConverter.getAsText(VciDateUtil.DateFormat) + "','" + DATE_FORMAT + "')";
+// } else if (VciFieldTypeEnum.VTDouble.equals(fieldTypeEnum)
+// || VciFieldTypeEnum.VTLong.equals(fieldTypeEnum)
+// || VciFieldTypeEnum.VTInteger.equals(fieldTypeEnum)) {
+// return value;
+// } else {
+// return "'" + value + "'";
+// }
+// } else {
+// if ((value.startsWith("(") && value.endsWith(")")) || (value.startsWith("'") && value.endsWith("'"))) {
+// return value;
+// }
+// return "'" + value + "'";
+// }
+// }
+//
+// }
+//
+// /**
+// * 灏佽鏈�缁堢殑sql璇彞涓殑鍊奸儴鍒�
+// *
+// * @param selectKey 鏌ヨ鐨勫瓧娈�
+// * @param value 鍊�
+// * @param attrVOMap 灞炴�х殑鏄剧ず瀵硅薄鏄犲皠
+// * @return sql閲岀殑鍊�
+// */
+// private String getSqlByValue(String selectKey, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap) {
+// StringBuilder sql = new StringBuilder();
+// if (!selectKey.contains(".") && (attrVOMap.containsKey(selectKey.toLowerCase(Locale.ROOT)) || attributeService.isDefaultAttr(selectKey) || selectKey.matches(RegExpConstant.LETTER))) {
+// sql.append("t.");
+// }
+// if (value.startsWith(QueryOptionConstant.IN)) {
+// sql.append(selectKey)
+// .append(SPACE)
+// .append("in")
+// .append(SPACE)
+// .append("(")
+// .append(value.replace(QueryOptionConstant.IN, ""))
+// .append(")");
+// } else if (value.startsWith(QueryOptionConstant.NOTIN)) {
+// sql.append(selectKey)
+// .append(SPACE)
+// .append("not in")
+// .append(SPACE)
+// .append("(")
+// .append(value.replace(QueryOptionConstant.NOTIN, ""))
+// .append(")");
+// } else if (value.startsWith(QueryOptionConstant.NOTEQUAL)) {
+// value = value.replace(QueryOptionConstant.NOTEQUAL, "");
+// value = getStringValueInWhere(selectKey, value, attrVOMap);
+// sql.append(selectKey)
+// .append(SPACE)
+// .append(QueryOptionConstant.NOTEQUAL)
+// .append(SPACE)
+// .append(value);
+// } else if (value.startsWith(QueryOptionConstant.MORETHAN)) {
+// value = value.replace(QueryOptionConstant.MORETHAN, "");
+// value = getStringValueInWhere(selectKey, value, attrVOMap);
+// sql.append(selectKey)
+// .append(SPACE)
+// .append(QueryOptionConstant.MORETHAN)
+// .append(SPACE)
+// .append(value);
+// } else if (value.startsWith(QueryOptionConstant.MORE)) {
+// value = value.replace(QueryOptionConstant.MORE, "");
+// value = getStringValueInWhere(selectKey, value, attrVOMap);
+// sql.append(selectKey)
+// .append(SPACE)
+// .append(QueryOptionConstant.MORE)
+// .append(SPACE)
+// .append(value);
+// } else if (value.startsWith(QueryOptionConstant.LESSTHAN)) {
+// value = value.replace(QueryOptionConstant.LESSTHAN, "");
+// value = getStringValueInWhere(selectKey, value, attrVOMap);
+//
+// sql.append(selectKey)
+// .append(SPACE)
+// .append(QueryOptionConstant.LESSTHAN)
+// .append(SPACE)
+// .append(value);
+// } else if (value.startsWith(QueryOptionConstant.LESS)) {
+// value = value.replace(QueryOptionConstant.LESS, "");
+// value = getStringValueInWhere(selectKey, value, attrVOMap);
+//
+// sql.append(selectKey)
+// .append(SPACE)
+// .append(QueryOptionConstant.LESS)
+// .append(SPACE)
+// .append(value);
+// } else if (value.startsWith(QueryOptionConstant.ISNOTNULL)) {
+// sql.append(selectKey)
+// .append(SPACE)
+// .append(" is not null");
+// } else if (value.startsWith(QueryOptionConstant.ISNULL)) {
+// sql.append(selectKey)
+// .append(SPACE)
+// .append(" is null");
+// } else if (value.contains("*")) {
+// //璇存槑鏄痩ike锛屾垨鑰卨efe like ,right like
+// value = getStringValueInWhere(selectKey, value, attrVOMap);
+// sql.append(selectKey)
+// .append(SPACE)
+// .append("like")
+// .append(SPACE)
+// // .append("'")
+// .append(value.replace("*", "%"))
+// // .append("'")
+// .append(SPACE);
+// } else {
+// value= value.replace(SPECIAL_CHAR,REQUIRED_CHAR);
+// value = getStringValueInWhere(selectKey, value, attrVOMap);
+//
+// sql.append(selectKey)
+// .append(SPACE)
+// .append(QueryOptionConstant.EQUAL)
+// .append(SPACE)
+// .append(value);
+// }
+// sql.append(SPACE);
+// return sql.toString();
+// }
+//
+// /**
+// * 淇敼涓婚搴撴暟鎹�
+// *
+// * @param orderDTO 鏁版嵁鐨勫唴瀹癸紝涓嶇敤鍖呭惈鐮佹鐨勫唴瀹逛簡
+// */
+// @Override
+// public void editSaveCode(CodeOrderDTO orderDTO) {
+// VciBaseUtil.alertNotNull(orderDTO, "缂栫爜鐢宠鐩稿叧鐨勫睘鎬х殑鍐呭閮戒负绌�", orderDTO.getOid(), "鏁版嵁涓婚敭",
+// orderDTO.getCodeClassifyOid(), "涓婚搴撳垎绫荤殑涓婚敭");
+//// CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
+// CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid());
+// //鎵句笟鍔＄被鍨嬶紝鐒跺悗浣跨敤涓婚敭鍘昏幏鍙栨暟鎹簱閲岀殑鏁版嵁
+//// List<ClientBusinessObject> cbos = boService.queryCBO(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), WebUtil.getOidQuery(orderDTO.getOid()));
+//
+// QueryWrapper<CodeOsbtmtypeEntity> btmWrapper = new QueryWrapper<>();
+// btmWrapper.eq("OID",orderDTO.getOid());
+// CodeWupinEntity cbo = codeOsbtmtypeMapper.selectOne(btmWrapper);
+//
+//// CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
+//// CodeRuleVO ruleVO = ruleService.getObjectHasSecByOid(orderDTO.getCodeRuleOid());
+//
+// if (cbo != null) {
+// throw new VciBaseException(DATA_OID_NOT_EXIST);
+// }
+//// ClientBusinessObject cbo = cbos.get(0);
+// if (!cbo.getTs().toString().contains(VciDateUtil.date2Str(orderDTO.getTs(), VciDateUtil.DateTimeFormat))) {
+// throw new VciBaseException("鏁版嵁涓嶆槸鏈�鏂扮殑锛屽彲鑳戒粬浜哄凡缁忎慨鏀癸紝璇峰埛鏂板悗鍐嶈瘯");
+// }
+// if (!CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(cbo.getLcStatus()) && !orderDTO.isEditInProcess()) {
+// throw new VciBaseException("鏁版嵁涓嶆槸{0}鐨勭姸鎬侊紝涓嶅厑璁镐慨鏀�", new String[]{CodeDefaultLC.EDITING.getText()});
+// }
+//
+// //娉ㄦ剰妯℃澘涓嶈兘浣跨敤鏁版嵁瀛樺偍鐨勬椂鍊欑殑妯℃澘锛屽洜涓哄彲鑳戒細鍙樺寲
+//
+// //1. 鍒ゆ柇蹇呰緭椤�
+// CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid());
+// checkRequiredAttrOnOrder(templateVO, orderDTO);
+// //2.鍏堟敞鍏ワ紝鍐嶇粍鍚堬紝鏈�鍚庢牎楠�
+// switchClassifyLevelOnOrder(templateVO, classifyFullInfo, orderDTO);
+// //3.澶勭悊缁勫悎瑙勫垯銆傜粍鍚堣鍒欎笉鑳戒娇鐢ㄧ紪鐮佺殑灞炴�э紝鍥犱负缂栫爜鐨勭敓鎴愬彲鑳芥槸闇�瑕佸睘鎬х殑
+// switchComponentAttrOnOrder(templateVO, orderDTO);
+// //4.鏍￠獙瑙勫垯
+// checkVerifyOnOrder(templateVO, orderDTO);
+// //5.鍒ゆ柇鍏抽敭灞炴��
+// checkKeyAttrOnOrder(classifyFullInfo, templateVO, orderDTO);
+// //6.鏍￠獙鏋氫妇鐨勫唴瀹规槸鍚︽纭�
+// checkEnumOnOrder(templateVO, orderDTO);
+// //7.澶勭悊鏃堕棿鏍煎紡锛屽湪鏁版嵁搴撻噷闈笉璁烘槸瀛楃涓茶繕鏄棩鏈熸牸寮忥紝閮戒娇鐢ㄧ浉鍚岀殑鏍煎紡瀛樺偍
+// switchDateAttrOnOrder(templateVO, orderDTO);
+// //榛樿鐨勫唴瀹逛笉鑳藉彉锛屾墍浠ュ彧闇�瑕佹嫹璐濊嚜瀹氫箟鐨勭浉鍏冲睘鎬у嵆鍙�
+// copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, true);
+// //浼佷笟鐮佸拰闆嗗洟鐮佺殑涓嶄慨鏀�
+// cbo.setDescription(orderDTO.getDescription());
+// cbo.setName(orderDTO.getName());
+// try {
+// cbo.setDescription(orderDTO.getDescription());
+// cbo.setName(orderDTO.getName());
+////// cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription());
+//// cbo.setAttributeValue("name", orderDTO.getName());
+// } catch (Exception e) {
+// e.printStackTrace();
+// }
+//
+//
+// List<CodeWupinEntity> cboList = new ArrayList<>();
+//
+// //澶囨敞
+// cbo.setDescription(orderDTO.getDescription());
+// cboList.add(cbo);
+////
+//// cboList.add(cbo);
+// List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList);
+//
+//
+// List<String> charList = new ArrayList<>();
+// for (CodeWupinEntity wupinEntity : cboList) {
+// charList.add(wupinEntity.getId());
+// }
+// batchSaveSelectChar(templateVO, charList);
+// return codeList.size() > 0 ? codeList.get(0) : "";
+//
+//
+//
+//
+// //淇敼鐨勬椂鍊欙紝缂栫爜鏄笉鍙樼殑
+//// BatchCBO batchCBO = new BatchCBO();
+//// batchCBO.getUpdateCbos().add(cbo);
+//// List<ClientBusinessObject> cboList = new ArrayList<>();
+//// cboList.add(cbo);
+//// boService.persistenceBatch(batchCBO);
+// batchSaveSelectChar(templateVO, cboList);
+// }
- /**
- * 浣跨敤鍒嗙被鐨勭紪鍙疯矾寰勶紝鑾峰彇琛ㄥ崟鐨勭浉鍏冲畾涔�
- *
- * @param idPath 缂栧彿鐨勮矾寰勶紝蹇呴』浠庨《灞傝妭鐐瑰紑濮嬶紝xx/yyy/zz
- * @return UI鐩稿叧鐨勪俊鎭紙浠呭寘鍚〃鍗�)
- */
- @Override
- public MdmUIInfoVO getFormDefineByClassifyIdPath(String idPath) {
- CodeClassifyVO classifyVO = classifyService.getObjectByIdPath(idPath);
- if(classifyVO !=null){
- return getFormDefineByClassifyOid(classifyVO.getOid());
- }
- return null;
- }
}
--
Gitblit v1.9.3