From c009750456d37d42f514321fe411e841d1b19fb4 Mon Sep 17 00:00:00 2001 From: xiejun <xj@2023> Date: 星期一, 19 六月 2023 14:48:53 +0800 Subject: [PATCH] 接口定时分发其他系统功能开发 --- Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmEngineServiceImpl.java | 3287 ++++++++++++++++++++++++++++++++++++++++++++++++++++++----- 1 files changed, 3,011 insertions(+), 276 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 d99f7e4..626f009 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,57 +1,85 @@ package com.vci.ubcs.code.service.impl; import com.alibaba.fastjson.JSONObject; -import com.alibaba.nacos.common.utils.StringUtils; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; -import com.baomidou.mybatisplus.extension.service.IService; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; -import com.sun.corba.se.impl.orbutil.ObjectUtility; +import com.baomidou.mybatisplus.extension.toolkit.SqlHelper; import com.vci.ubcs.code.bo.CodeClassifyFullInfoBO; +import com.vci.ubcs.code.bo.CodeTemplateAttrSqlBO; +import com.vci.ubcs.code.constant.FrameWorkDefaultValueConstant; +import com.vci.ubcs.code.constant.MdmBtmTypeConstant; +import com.vci.ubcs.code.dto.CodeDeleteBatchDTO; import com.vci.ubcs.code.dto.CodeOrderDTO; import com.vci.ubcs.code.dto.datapush.BaseModelDTO; -import com.vci.ubcs.code.entity.CodeAllCode; -import com.vci.ubcs.code.entity.CodeOsbtmtypeEntity; -import com.vci.ubcs.code.entity.CodeRule; -import com.vci.ubcs.code.entity.CodeWupinEntity; -import com.vci.ubcs.code.enumpack.CodeDefaultLC; -import com.vci.ubcs.code.enumpack.CodeLevelTypeEnum; -import com.vci.ubcs.code.enumpack.CodeSecTypeEnum; -import com.vci.ubcs.code.mapper.CodeAllCodeMapper; -import com.vci.ubcs.code.mapper.CodeOsbtmtypeMapper; -import com.vci.ubcs.code.mapper.CodeRuleMapper; +import com.vci.ubcs.code.entity.*; +import com.vci.ubcs.code.enumpack.*; +import com.vci.ubcs.code.mapper.CodeWupinMapper; +import com.vci.ubcs.code.mapper.CommonsMapper; import com.vci.ubcs.code.service.*; -import com.vci.ubcs.code.vo.CodeClstemplateVO; -import com.vci.ubcs.code.vo.CodeKeyattrrepeatVO; -import com.vci.ubcs.code.vo.pagemodel.CodeBasicSecVO; -import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateAttrVO; -import com.vci.ubcs.code.vo.pagemodel.CodeClassifyVO; -import com.vci.ubcs.code.vo.pagemodel.CodeRuleVO; -import com.vci.ubcs.omd.entity.Dict; +import com.vci.ubcs.code.vo.CodeKeyAttrRepeatVO; +import com.vci.ubcs.code.vo.pagemodel.UITableFieldVO; +import com.vci.ubcs.code.vo.pagemodel.UITablePageVO; +import com.vci.ubcs.code.vo.pagemodel.*; +import com.vci.ubcs.omd.constant.BtmTypeLcStatusConstant; +import com.vci.ubcs.omd.cache.EnumCache; +import com.vci.ubcs.omd.feign.*; +import com.vci.ubcs.omd.utils.VciOmdUtil; +import com.vci.ubcs.omd.vo.BtmTypeAttributeVO; +import com.vci.ubcs.omd.vo.BtmTypeVO; +import com.vci.ubcs.omd.vo.EnumVO; +import com.vci.ubcs.omd.vo.RevisionRuleVO; import com.vci.ubcs.starter.exception.VciBaseException; import com.vci.ubcs.starter.revision.model.BaseModel; +import com.vci.ubcs.starter.revision.model.TreeQueryObject; +import com.vci.ubcs.starter.revision.model.TreeWrapperOptions; +import com.vci.ubcs.starter.revision.service.RevisionModelUtil; +import com.vci.ubcs.starter.web.constant.QueryOptionConstant; +import com.vci.ubcs.starter.web.constant.RegExpConstant; +import com.vci.ubcs.starter.web.enumpck.BooleanEnum; import com.vci.ubcs.starter.web.enumpck.UserSecretEnum; -import com.vci.ubcs.starter.web.pagemodel.KeyValue; +import com.vci.ubcs.starter.web.enumpck.VciFieldTypeEnum; +import com.vci.ubcs.starter.web.pagemodel.*; import com.vci.ubcs.starter.web.toolmodel.DateConverter; -import com.vci.ubcs.starter.web.util.VciBaseUtil; -import com.vci.ubcs.starter.web.util.VciDateUtil; -import com.vci.ubcs.starter.web.util.VciQueryWrapperForDO; -import com.vci.ubcs.starter.web.util.WebUtil; +import com.vci.ubcs.starter.web.util.*; import com.vci.ubcs.system.entity.DictBiz; +import com.vci.ubcs.system.entity.Menu; import com.vci.ubcs.system.feign.IDictBizClient; +import com.vci.ubcs.system.feign.ISysClient; +import com.vci.ubcs.system.user.entity.User; +import com.vci.ubcs.system.user.feign.IUserClient; +import net.logstash.logback.encoder.org.apache.commons.lang3.StringUtils; +import oracle.sql.TIMESTAMP; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.springblade.core.mp.support.Query; +import org.springblade.core.cache.utils.CacheUtil; +import org.springblade.core.launch.constant.AppConstant; import org.springblade.core.secure.utils.AuthUtil; import org.springblade.core.tool.api.R; -import org.springframework.beans.BeanUtils; +import org.springblade.core.tool.utils.StringPool; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.cache.Cache; import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; import org.springframework.util.CollectionUtils; import javax.annotation.Resource; +import java.beans.BeanInfo; +import java.beans.Introspector; +import java.beans.PropertyDescriptor; +import java.lang.reflect.Method; +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.ZonedDateTime; import java.util.*; -import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Supplier; import java.util.stream.Collectors; + +import static com.vci.ubcs.code.constant.FrameWorkLangCodeConstant.DATA_OID_NOT_EXIST; +import static com.vci.ubcs.code.constant.MdmEngineConstant.*; +import static com.vci.ubcs.starter.web.constant.EnumIdConstant.LC_STATUS_SUBFIX; /** * 涓绘暟鎹紩鎿庢湇鍔� @@ -60,34 +88,106 @@ * @date 2022-2-22 */ @Service -public class MdmEngineServiceImpl extends ServiceImpl<CodeAllCodeMapper, CodeAllCode> implements MdmEngineService { +public class MdmEngineServiceImpl extends ServiceImpl<CodeWupinMapper, CodeWupin> implements MdmEngineService { + /** * 妯℃澘鐨勬湇鍔� */ @Resource private CodeClstemplateServiceImpl templateService; - /** - * 妯℃澘鐨勬湇鍔� - */ - @Resource - private CodeOsbtmtypeMapper codeOsbtmtypeMapper; + + /** * 鐢熸垚缂栫爜鐨勬湇鍔� */ @Resource private MdmProductCodeService productCodeService; + + /** + * 鍙緭鍙�夌殑鏈嶅姟 + */ + @Resource + IDictBizClient iDictBizClient; + /** + * 绯荤粺鐨勬湇鍔� + */ + @Resource + ISysClient iSysClient; + /** + * 瀵嗙骇鏈嶅姟 + */ + @Resource + private IWebSecretClient secretService; + /** + * 鐢ㄦ埛鏈嶅姟 + */ + @Resource + IUserClient iUserClient; /** * 瀛楀吀鐨勬湇鍔� */ @Resource - IDictBizClient iDictBizClient; + IEnumClient enumClient; + /** + * 鍏紡鐨勬湇鍔� + */ + @Autowired + private FormulaServiceImpl formulaService; + + /** + * 鐩镐技椤规煡璇㈣鍒� + */ + @Autowired + private ICodeResembleRuleService resembleRuleService; + + /** + * 瀵硅薄鐨勬搷浣� + */ + @Autowired + private RevisionModelUtil revisionModelUtil; + + /** + * 闃舵鐨勬湇鍔� + */ + @Autowired + private ICodePhaseAttrService phaseAttrService; + /** + * 涓氬姟绫诲瀷鐨勬湇鍔� + */ + @Autowired + private IBtmTypeClient btmTypeClient; + /** + * 鐗堟湰瑙勫垯鐨勬湇鍔� + */ + @Resource + private IRevisionRuleClient revisionRuleClient; +// + /** + * 閫氱敤鏌ヨ + */ + @Resource + CommonsMapper commonsMapper; + + @Resource + CodeWupinMapper codeWupinMapper; /** * 缂栫爜瑙勫垯鐨勬湇鍔� */ @Autowired private ICodeRuleService ruleService; + /** + * 缂栫爜瑙勫垯鐨勬湇鍔� + */ + @Autowired + private ICodeAllCodeService codeAllCodeService; + + /** + * 鍒嗙被鐮佸�肩殑鏈嶅姟 + */ + @Autowired + private ICodeClassifyValueService classifyValueService; /** * 鍒嗙被鐨勬湇鍔� @@ -96,17 +196,81 @@ private ICodeClassifyService classifyService; /** + * 妯℃澘鎸夐挳鏈嶅姟 + */ + @Autowired + private ICodeClassifyTemplateButtonService templateButtonService; + + @Autowired + private ICodeClassifyTemplateAttrService codeClassifyTemplateAttrService; +// /** +// * 鐢ㄦ埛鏌ヨ鐨勬湇鍔�,闇�瑕侀棶涓�涓嬫槸鍚﹂渶瑕侀噸鍐欙紝浣跨敤鏌ヨ姝ゅ钩鍙扮殑鐢ㄦ埛琛� +// */ +// @Autowired +// private SmUserQueryServiceI userQueryService; + + /** * 鍏抽敭灞炴�х殑閰嶇疆 */ @Autowired - private ICodeKeyattrrepeatService keyRuleService; + private ICodeKeyAttrRepeatService keyRuleService; /** * 鏃ュ織 */ private Logger logger = LoggerFactory.getLogger(getClass()); - // @Autowired - // private CodeOsbtmtypeMapper codeOsbtmtypeMapper; + /** + * 绌烘牸 + */ + public static final String SPACE = " "; + /** + * 缂撳瓨锝嬶絽锝� + */ + public static final String BTM_INIT_CACHE = "ubcs-code:btm"; + /** + * + */ + public static final String BTM_NAME = "btm:name"; + + /** + * 瀵嗙骇鐨勫瓧娈� + */ + 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;---- + + /** * 浣跨敤鍒嗙被鐨勪富閿幏鍙栧彲浠ヤ娇鐢ㄧ殑妯℃澘瀵硅薄 @@ -115,7 +279,7 @@ * @return 妯℃澘鐨勬樉绀哄璞� */ @Override - public CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid) { + public CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid) { return getUsedTemplateByClassifyOid(codeClassifyOid, true); } @@ -127,8 +291,8 @@ * @return 妯℃澘鐨勬樉绀哄璞� */ @Override - public CodeClstemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr) { - List<CodeClstemplateVO> templateVOs = templateService.listReleaseTemplateByClassifyOid(codeClassifyOid, hasAttr); + public CodeClassifyTemplateVO getUsedTemplateByClassifyOid(String codeClassifyOid, boolean hasAttr) { + List<CodeClassifyTemplateVO> templateVOs = templateService.listReleaseTemplateByClassifyOid(codeClassifyOid, hasAttr); return templateVOs.get(templateVOs.size() - 1); } @@ -140,40 +304,43 @@ */ @Override public List<KeyValue> listComboboxItems(CodeClassifyTemplateAttrVO attrVO) { - List<KeyValue> comboboxKVs = null; + List<KeyValue> comboboxKVs = new ArrayList<>(); 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()) { + R<List<EnumVO>> list = enumClient.getList(attrVO.getEnumId()); + if (list.isSuccess()) { + for (EnumVO datum : list.getData()) { KeyValue keyValue = new KeyValue(); - keyValue.setKey(datum.getDictKey()); - keyValue.setValue(datum.getDictValue()); + keyValue.setKey(datum.getItemValue()); + keyValue.setValue(datum.getItemName()); comboboxKVs.add(keyValue); } } } return comboboxKVs; } + /** * 淇敼鐘舵�� * * @param baseModelDTO 鏁版嵁浼犺緭瀵硅薄 */ + @Transactional @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); + List<BaseModel> baseModels = new ArrayList<>(); + baseModels = selectByTypeAndOid(baseModelDTO.getBtmname(), baseModelDTO.getOid()); + if(baseModels.size() == 0){ + throw new VciBaseException("鏈煡璇㈠埌鐩稿叧鏁版嵁銆�"); + } + // 寰呭畬鍠� + List<BtmTypeVO> cboList = null; // btmTypeClient.selectList(wrapper); //杩橀渶瑕佷慨鏀筧llCode鐨勭敓鍛藉懆鏈� // Map<String, String> conditionMap = new HashMap<>(); QueryWrapper<CodeAllCode> allCodeWrapper = new QueryWrapper<>(); @@ -181,20 +348,25 @@ 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<CodeAllCode> codeCbos = codeAllCodeService.selectByWrapper(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()); + if (CodeDefaultLC.TASK_BACK.getValue().equals(baseModelDTO.getLcStatus())) { + R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(baseModelDTO.getBtmname())); + commonsMapper.deleteByTaleAndOid(listR.getData().get(0).getTableName(),VciBaseUtil.toInSql(baseModelDTO.getOid())); + } else { + for (BaseModel baseModel : baseModels) { + baseModel.setLcStatus(baseModelDTO.getLcStatus()); + } + updateBatchByBaseModel(baseModelDTO.getBtmname(),baseModels); + // lifeCycleService.transCboStatus(cboList, baseModelDTO.getLcStatus()); + } + for (CodeAllCode codeCbo : codeCbos) { + codeCbo.setLcStatus(baseModelDTO.getLcStatus()); + } + codeAllCodeService.updateBatchById(codeCbos); + // lifeCycleService.transCboStatus(codeCbos, baseModelDTO.getLcStatus()); } - /** * 鐢宠鍗曚竴缂栫爜 @@ -203,11 +375,11 @@ * @return 杩斿洖缂栫爜鐨勫唴瀹� */ @Override - public String addSaveCode(CodeOrderDTO orderDTO) { + public String addSaveCode(CodeOrderDTO orderDTO) throws Exception { VciBaseUtil.alertNotNull(orderDTO, "缂栫爜鐢宠鐩稿叧鐨勫睘鎬у拰鐮佹鐨勫唴瀹归兘涓虹┖", orderDTO.getCodeClassifyOid(), "涓婚搴撳垎绫荤殑涓婚敭", orderDTO.getTemplateOid(), "妯℃澘鐨勪富閿�", orderDTO.getCodeRuleOid(), "缂栫爜瑙勫垯鐨勪富閿�"); CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid()); - CodeClstemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid()); + CodeClassifyTemplateVO templateVO = templateService.getObjectHasAttrByOid(orderDTO.getTemplateOid()); CodeRuleVO ruleVO = ruleService.getObjectHasSecByOid(orderDTO.getCodeRuleOid()); //1.鍒ゆ柇瑙勫垯涓櫎浜嗘祦姘寸爜娈碉紝鏄惁鏈夊叾浠栫爜娈� checkSecValueOnOrder(ruleVO, orderDTO); @@ -227,23 +399,30 @@ switchDateAttrOnOrder(templateVO, orderDTO); //9.鐢熸垚缂栫爜鐨勪俊鎭� // ClientBusinessObject cbo = boService.createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()); -// CodeWupinEntity cbo = createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()); + BaseModel cbo = createCBOByBtmName(classifyFullInfo.getTopClassifyVO().getBtmtypeid()); // //榛樿鐨勫睘鎬ч兘涓嶇敤浠庡墠绔嫹璐� // //璁剧疆缂栫爜闇�瑕佺殑榛樿灞炴�х殑鍐呭 -// copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, false); + copyValueToCBO(classifyFullInfo, cbo, orderDTO, templateVO, false); // //TODO:鍥犱负榛樿鐨勫睘鎬ч兘涓嶆嫹璐濓紝鐩墠闆嗗洟鐮佸彨name锛屽苟娌℃湁浠嶥TO鎷疯礉鍒癱bo閲屻�傚鍔犱竴涓崟鐙鐞嗭紝浠ュ悗鍐嶇湅瑕佷笉瑕佽皟鏁� -// cbo.setName(orderDTO.getName() == null ? "" : orderDTO.getName()); + cbo.setName(orderDTO.getName() == null ? "" : orderDTO.getName()); // //end -- modify by lihang @20220407 -// List<CodeWupinEntity> cboList = new ArrayList<>(); -// -// //澶囨敞 -// cbo.setDescription(orderDTO.getDescription()); + List<BaseModel> cboList = new ArrayList<>(); + + //澶囨敞 + cbo.setDescription(orderDTO.getDescription()); + cboList.add(cbo); // // cboList.add(cbo); -// List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList); -//// batchSaveSelectChar(templateVO, cboList); -// return codeList.size() > 0 ? codeList.get(0) : ""; - return null; + List<String> codeList = productCodeService.productCodeAndSaveData(classifyFullInfo, templateVO, ruleVO, orderDTO.getSecDTOList(),cboList); + + +// List<String> charList = new ArrayList<>(); +// for (BaseModel baseModel : cboList) { +// charList.add(baseModel.getId()); +// } + batchSaveSelectChar(templateVO, cboList); + return codeList.size() > 0 ? codeList.get(0) : ""; +// return null; } /** @@ -253,13 +432,12 @@ * @param classifyFullInfoBO 鍒嗙被鐨勫叏璺緞 * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭� */ - private void switchClassifyLevelOnOrder(CodeClstemplateVO templateVO, CodeClassifyFullInfoBO classifyFullInfoBO, CodeOrderDTO 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) -> { @@ -324,7 +502,8 @@ * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬� * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭� */ - private void checkRequiredAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO 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())) @@ -365,7 +544,7 @@ * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚ā鏉垮睘鎬� * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭� */ - private void switchComponentAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO 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); @@ -378,7 +557,7 @@ } dataLowMap.putAll(orderDTO.getData()); compAttrVOMap.forEach((attrId, attrVO) -> { -// dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentrule())); + dataLowMap.put(attrId, formulaService.getValueByFormula(dataLowMap, attrVO.getComponentRule())); }); dataLowMap.forEach((key, value) -> { setValueToOrderDTO(orderDTO, key, value); @@ -409,7 +588,7 @@ * @param templateVO 妯℃澘鐨勪俊鎭紝蹇呴』鍖呭惈灞炴�х殑鍐呭 * @param orderDTO 缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅 */ - private void checkVerifyOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO 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) -> { @@ -429,9 +608,9 @@ * @param templateVO 妯℃澘鐨勫唴瀹癸紝蹇呴』鍖呭惈妯℃澘灞炴�� * @param orderDTO 缂栫爜鐢宠鐨勭浉鍏崇殑淇℃伅 */ - private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClstemplateVO templateVO, CodeOrderDTO orderDTO) { + private void checkKeyAttrOnOrder(CodeClassifyFullInfoBO classifyFullInfo, CodeClassifyTemplateVO templateVO, CodeOrderDTO orderDTO) { //鍏堣幏鍙栧叧閿睘鎬х殑瑙勫垯锛屼篃鍒╃敤缁ф壙鐨勬柟寮� - CodeKeyattrrepeatVO keyRuleVO = keyRuleService.getRuleByClassifyFullInfo(classifyFullInfo); + CodeKeyAttrRepeatVO 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)); @@ -446,29 +625,33 @@ if (value == null) { value = ""; } -// wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap); + wrapperKeyAttrConditionMap(value, keyRuleVO, attrId, trim, ignoreCase, ignoreWidth, trimAll, conditionMap); }); //娌℃湁闄愬埗鍒嗙被锛屼絾鏄竴涓ā鏉垮彧鍙兘鍦ㄤ竴涓笟鍔$被鍨嬮噷闈紝鎵�浠ョ洿鎺ユ煡璇㈣繖涓笟鍔$被鍨嬪嵆鍙� -// if (!CollectionUtils.isEmpty(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' "; + R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(classifyFullInfo.getTopClassifyVO().getBtmtypeid())); +// String referTable = VciBaseUtil.getTableName(referVO.getReferType()); + final String[] sql = {"select count(*) from "+ listR.getData().get(0).getTableName() +" 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 lastR = '1' and lastV = '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); -// } -// } + 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); + } + } } /** @@ -483,54 +666,54 @@ * @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 { -// //涓虹┖鐨勬椂鍊欎笉浠h〃涓嶆牎楠岋紝鍙槸涓嶅幓闄ょ浉鍏崇殑淇℃伅 -// conditionMap.put("t."+attrId, value); -// } -// } -// } + @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 { + //涓虹┖鐨勬椂鍊欎笉浠h〃涓嶆牎楠岋紝鍙槸涓嶅幓闄ょ浉鍏崇殑淇℃伅 + conditionMap.put("t."+attrId, value); + } + } + } /** * 鏍¢獙鏋氫妇鐨勫唴瀹� @@ -538,7 +721,7 @@ * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬� * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭� */ - private void checkEnumOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO 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)); @@ -562,7 +745,7 @@ * @param templateVO 妯℃澘鐨勬樉绀哄璞★紝闇�瑕佸寘鍚睘鎬� * @param orderDTO 缂栫爜鐢宠鐨勪俊鎭� */ - private void switchDateAttrOnOrder(CodeClstemplateVO templateVO, CodeOrderDTO 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) -> { @@ -586,9 +769,9 @@ * @param templateVO 妯℃澘鐨勬樉绀哄璞� * @param edit 鏄惁涓轰慨鏀� */ - private void copyValueToCBO(CodeClassifyFullInfoBO classifyFullInfo, CodeWupinEntity cbo, - CodeOrderDTO orderDTO, CodeClstemplateVO templateVO, - boolean edit) { + private void copyValueToCBO(CodeClassifyFullInfoBO classifyFullInfo, BaseModel 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()))) @@ -598,8 +781,8 @@ } // BeanUtils. - BeanUtils.copyProperties(orderDTO.getData(),cbo); - cbo.setMaterialtype(Short.valueOf("1001")); +// 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))) { @@ -610,25 +793,35 @@ // } // } // }); +// BeanMap beanMap = BeanMap.create(cbo); +// beanMap.putAll(orderDTO.getData()); + 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"); + BeanUtilForVCI.copyPropertiesIgnoreNull(BeanUtilForVCI.convertMap(BaseModel.class,orderDTO.getData()),cbo); + Map<String,String> data = new HashMap<>(); + data.put(CODE_CLASSIFY_OID_FIELD,classifyFullInfo.getCurrentClassifyVO().getOid()); + data.put(CODE_TEMPLATE_OID_FIELD,templateVO.getOid()); + data.put(CODE_FULL_PATH_FILED,fullPath); + cbo.setData(data); + cbo.setOid(VciBaseUtil.getPk()); + cbo.setCreateTime(new Date()); + cbo.setLastModifyTime(new Date()); + cbo.setCreator(AuthUtil.getUser().getUserName()); + cbo.setLastModifier(AuthUtil.getUser().getUserName()); +// cbo.setCodeclsfid(classifyFullInfo.getCurrentClassifyVO().getOid()); +// cbo.setTemplateOid(templateVO.getOid()); +// cbo.setCodeclsfpath(fullPath); + cbo.setTs(new Date()); 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()); + cbo.setLcStatus(CodeDefaultLC.EDITING.getValue()); // } } else { cbo.setLcStatus(CodeDefaultLC.EDITING.getValue()); @@ -636,10 +829,8 @@ } - int secret = VciBaseUtil.getInt(cbo.getSecretGrade().toString()); - //鎻掍釜鐐癸紝鍚庣画鐪嬪瘑绾ф湇鍔℃槸鍚﹀彲鐢� -// if (secret == 0 || !secretService.checkDataSecret(secret)) { - if (secret == 0 ) { + int secret = VciBaseUtil.getInt(String.valueOf(cbo.getSecretGrade())); + if (secret == 0 || !secretService.checkDataSecret(secret).getData()) { 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); @@ -657,92 +848,27 @@ * @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)); + @Override + public BaseModel createCBOByBtmName(String btmName) + throws VciBaseException { + if(btmName!=null){ + btmName = btmName.trim().toLowerCase(); + } + try { + String keyPrefix = BTM_INIT_CACHE.concat(StringPool.COLON).concat(AuthUtil.getTenantId()).concat(StringPool.COLON); + Cache.ValueWrapper valueWrapper = CacheUtil.getCache(keyPrefix).get(keyPrefix.concat(String.valueOf(btmName))); + if(valueWrapper == null){ + CacheUtil.getCache(keyPrefix).put(keyPrefix.concat(String.valueOf(btmName)), createBaseModel(btmName)); + valueWrapper = CacheUtil.getCache(keyPrefix).get(keyPrefix.concat(String.valueOf(btmName))); + } + return (BaseModel) valueWrapper.get(); + } catch (Exception e) { + logger.error("鍒涘缓涓氬姟绫诲瀷瀵硅薄",e); + throw new VciBaseException("initBtmError",new String[]{btmName}); + } } + + /** * 淇濆瓨鍙緭鍙�夌殑淇℃伅 @@ -750,27 +876,2636 @@ * @param templateVO 妯℃澘鐨勫璞� * @param cboList 鏁版嵁鐨勫唴瀹� */ -// @Override -// public void batchSaveSelectChar(CodeClstemplateVO 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)) { + @Override + public void batchSaveSelectChar(CodeClassifyTemplateVO templateVO, /*List<ClientBusinessObject> cboList*/ + List<BaseModel> 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 ArrayList<>(); + cboList.parallelStream().forEach(cbo -> { +// String value = cbo.get.getAttributeValue(attrVO.getId()); + + //灏哹ean杞负map,mybatis缁熶竴澶勭悊 + Map<String,String> map = null; + +// baseModels.stream().forEach(model-> { + try { + map = VciBaseUtil.convertBean2Map(cbo); + } catch (Exception e) { + throw new VciBaseException("绫诲瀷杞崲閿欒锛�" + e.getMessage()); + } +// }); + + String value = map.get(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) { + CodeClassifyTemplateVO 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(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; + } + /** + * 灞炴�х被鍨嬩笌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(CodeClassifyTemplateAttrVO 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.setInputTip(attrVO.getInputTip()); + 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(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 attrVO 妯℃澘灞炴�� + * @param forEdit 鏄惁鏄紪杈戞墍闇� + * @return 琛ㄦ牸鐨勫瓧娈� + */ + @Override + public UITableFieldVO templateAttr2TableField(CodeClassifyTemplateAttrVO 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= VciOmdUtil.enumsToListKeyVale(EnumCache.getList(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("t.lastr", "1"); + andConditionMap.put("t.lastv", "1"); + if (StringUtils.isNotBlank(orderDTO.getOid())) { + andConditionMap.put("t.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<String, String>> maps = commonsMapper.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<>(); + for (String s : map.keySet()) { + data.put(s.toLowerCase(Locale.ROOT), String.valueOf(map.get(s))); + } +// map.forEach((key, value) -> { +// data.put(((String) key).toLowerCase(Locale.ROOT), String.valueOf(value)); // }); -// } + dataList.add(data); + }); + wrapperData(dataList, templateVO, sqlBO.getSelectFieldList(), false); +// maps.stream().forEach(map -> { +// Map<String, String> data = new HashMap<>(); +//// map.forEach((key, value) -> { +//// data.put(((String) key).toLowerCase(Locale.ROOT), String.valueOf(value)); +//// }); +// for (String s : map.keySet()) { +// data.put(((String) s).toLowerCase(Locale.ROOT), String.valueOf(map.get(s))); +// } +// dataList.add(data); +// }); + } +// dataGrid.setData(dataList); +// if (!CollectionUtils.isEmpty(maps)) { +// wrapperData(maps, templateVO, sqlBO.getSelectFieldList(), false); +// maps.stream().forEach(map -> { +// Map<String, String> data = new HashMap<>(); +//// map.forEach((key, value) -> { +//// data.put(((String) key).toLowerCase(Locale.ROOT), String.valueOf(value)); +//// }); +// for (String s : map.keySet()) { +// data.put(((String) s).toLowerCase(Locale.ROOT), String.valueOf(map.get(s))); +// } +// dataList.add(data); +// }); + dataGrid.setData(dataList); + 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, User> userVOMap = new HashMap<>(); + for (String userId : userIds) { + if (!StringUtils.isNumeric(userId)) { + continue; + } + User data = iUserClient.userInfoById(Long.valueOf(userId)).getData(); + if (data != null) { + userVOMap.put(String.valueOf(data.getId()), data); + } + } +// 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)).getRealName() + ")"); + } + 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)).getRealName() + ")"); + } + }); + } + } + + + /** + * 澶勭悊鏃堕棿鏍煎紡 + * + * @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().toUpperCase(Locale.ROOT); + String attrId = enumAttrVO.getId().toLowerCase(Locale.ROOT); + String oldValue = String.valueOf(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"); + } + //浣跨敤浼犲叆鐨勪笟鍔$被鍨嬫煡璇㈣〃 + R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(referVO.getReferType())); +// String referTable = VciBaseUtil.getTableName(referVO.getReferType()); + String referTable = listR.getData().get(0).getTableName(); +// String referTable = "pl_code_classify"; + 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); + }); + } + R<BtmTypeVO> allAttributeByBtmId = btmTypeClient.getDefaultAttrByBtmId(btmType); +// Optional.ofNullable(allAttributeByBtmId.getData()).orElseGet(allAttributeByBtmId.getData().getAttributes()).stream().forEach(attrId -> { +// if (!selectFieldList.contains(attrId.getOid()) && !"secretgrade".equalsIgnoreCase(attrId.getOid())) { +// selectFieldList.add(attrId.getOid()); +// } +// }); + if (allAttributeByBtmId.getData() != null) { + for (BtmTypeAttributeVO attribute : allAttributeByBtmId.getData().getAttributes()) { + if (!selectFieldList.contains(attribute.getId()) && !"secretgrade".equalsIgnoreCase(attribute.getId())) { + selectFieldList.add(attribute.getId()); + } + } + } + + 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,btmType)); + }); + orConditionMap.forEach((k, v) -> { + orSql.add(getConditionSql(k.toLowerCase(), v, referFieldMap, attrVOMap,btmType)); + }); + } + //缁勫悎璧锋潵 + 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().getData(); + } + whereSql += " and ( t.secretGrade <= " + userSecret + ") "; + } +// String tableName = VciBaseUtil.getTableName(btmType); + R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(btmType)); +// String referTable = VciBaseUtil.getTableName(referVO.getReferType()); + String tableName = listR.getData().get(0).getTableName(); + 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,String btmType) { + /*if (!Func.hasEmpty(new Object[]{key,value}) && !key.endsWith("_ignore")) { + if (key.endsWith("_like")) { + String field = UBCSSqlKeyword.getColumn(key, "_like"); + if (referFieldMap.containsKey(field)) { + //璇存槑杩樻槸鍙傜収閲岄潰鐨勶紝鎴戜滑榛樿杩欑鎯呭喌涓嬮兘鏄瓧绗︿覆鍚э紝鍥犱负鍙傜収鐨勫睘鎬т笉涓�瀹氱敤鐨勫钩鍙扮殑灞炴�ф睜閲岀殑锛屾墍浠ュぇ閮ㄥ垎鎯呭喌涓嬶紝鏄剧ず鐨勫睘鎬ч兘鏄瓧绗︿覆鍚� + return referFieldMap.get(field) + SPACE + "LIKE" + SPACE + "concat(%,"+"concat(" + value + ",%)" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "LIKE " + "concat(%,"+"concat(" + getStringValueInWhere(field, value, attrVOMap) + ",%)" + SPACE; + } + } else if (key.endsWith("_notequal")) { + String field = UBCSSqlKeyword.getColumn(key, "_notequal"); + if (referFieldMap.containsKey(field)) { + //璇存槑杩樻槸鍙傜収閲岄潰鐨勶紝鎴戜滑榛樿杩欑鎯呭喌涓嬮兘鏄瓧绗︿覆鍚э紝鍥犱负鍙傜収鐨勫睘鎬т笉涓�瀹氱敤鐨勫钩鍙扮殑灞炴�ф睜閲岀殑锛屾墍浠ュぇ閮ㄥ垎鎯呭喌涓嬶紝鏄剧ず鐨勫睘鎬ч兘鏄瓧绗︿覆鍚� + return referFieldMap.get(field) + SPACE + " != '" + value + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + " != " + getStringValueInWhere(field, value, attrVOMap); + } + } else if (key.endsWith("_likeleft")) { + String field = UBCSSqlKeyword.getColumn(key, "_likeleft"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "LIKE" + SPACE + "concat(%,"+value+")" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "LIKE " + "concat(%,"+getStringValueInWhere(field, value, attrVOMap)+")" + SPACE; + } + } else if (key.endsWith("_likeright")) { + String field = UBCSSqlKeyword.getColumn(key, "_likeright"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "LIKE" + SPACE + "concat("+value+",%)" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "LIKE " + "concat("+getStringValueInWhere(field, value, attrVOMap)+",%)" + SPACE; + } + } else if (key.endsWith("_notlike")) { + String field = UBCSSqlKeyword.getColumn(key, "_notlike"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "NO LIKE" + SPACE + "concat(%,concat("+value+",%)" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "NO LIKE " + "concat(%,concat"+getStringValueInWhere(field, value, attrVOMap)+",%)" + SPACE; + } + } else if (key.endsWith("_ge")) { + String field = UBCSSqlKeyword.getColumn(key, "_ge"); + if (referFieldMap.containsKey(field)) { + //璇存槑杩樻槸鍙傜収閲岄潰鐨勶紝鎴戜滑榛樿杩欑鎯呭喌涓嬮兘鏄瓧绗︿覆鍚э紝鍥犱负鍙傜収鐨勫睘鎬т笉涓�瀹氱敤鐨勫钩鍙扮殑灞炴�ф睜閲岀殑锛屾墍浠ュぇ閮ㄥ垎鎯呭喌涓嬶紝鏄剧ず鐨勫睘鎬ч兘鏄瓧绗︿覆鍚� + return referFieldMap.get(field) + SPACE + " >= '" + value + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + " >= '" + getStringValueInWhere(value, field, attrVOMap) + "'" + SPACE; + } + } else if (key.endsWith("_le")) { + //璇存槑鏄�<=鐨勩�傛垜浠渶瑕佸厛鑾峰彇涓�涓� + String field = UBCSSqlKeyword.getColumn(key, "_le"); + if (referFieldMap.containsKey(field)) { + //璇存槑杩樻槸鍙傜収閲岄潰鐨勶紝鎴戜滑榛樿杩欑鎯呭喌涓嬮兘鏄瓧绗︿覆鍚э紝鍥犱负鍙傜収鐨勫睘鎬т笉涓�瀹氱敤鐨勫钩鍙扮殑灞炴�ф睜閲岀殑锛屾墍浠ュぇ閮ㄥ垎鎯呭喌涓嬶紝鏄剧ず鐨勫睘鎬ч兘鏄瓧绗︿覆鍚� + return referFieldMap.get(field) + SPACE + " <= '" + value + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + " <= '" + getStringValueInWhere(field, value, attrVOMap) + "'" + SPACE; + } + } else if (key.endsWith("_gt")) { + String field = UBCSSqlKeyword.getColumn(key, "_gt"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "> '" + value + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "> '" + getStringValueInWhere(field, value, attrVOMap) + "'" + SPACE; + } + } else if (key.endsWith("_lt")) { + String field = UBCSSqlKeyword.getColumn(key, "_lt"); + if (referFieldMap.containsKey(field)) { + //璇存槑杩樻槸鍙傜収閲岄潰鐨勶紝鎴戜滑榛樿杩欑鎯呭喌涓嬮兘鏄瓧绗︿覆鍚э紝鍥犱负鍙傜収鐨勫睘鎬т笉涓�瀹氱敤鐨勫钩鍙扮殑灞炴�ф睜閲岀殑锛屾墍浠ュぇ閮ㄥ垎鎯呭喌涓嬶紝鏄剧ず鐨勫睘鎬ч兘鏄瓧绗︿覆鍚� + return referFieldMap.get(field) + SPACE + "< '" + value + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "< '" + getStringValueInWhere(field, value, attrVOMap) + "'" + SPACE; + } + } else if (key.endsWith("_datege")) { + String field = UBCSSqlKeyword.getColumn(key, "_datege"); + if (referFieldMap.containsKey(field)) { + //璇存槑杩樻槸鍙傜収閲岄潰鐨勶紝鎴戜滑榛樿杩欑鎯呭喌涓嬮兘鏄瓧绗︿覆鍚э紝鍥犱负鍙傜収鐨勫睘鎬т笉涓�瀹氱敤鐨勫钩鍙扮殑灞炴�ф睜閲岀殑锛屾墍浠ュぇ閮ㄥ垎鎯呭喌涓嬶紝鏄剧ず鐨勫睘鎬ч兘鏄瓧绗︿覆鍚� + return referFieldMap.get(field) + SPACE + ">= '" + DateUtil.parse(String.valueOf(value), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + ">= '" + DateUtil.parse(String.valueOf(getStringValueInWhere(field, value, attrVOMap)), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE; + } + } else if (key.endsWith("_dategt")) { + String field = UBCSSqlKeyword.getColumn(key, "_dategt"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "> '" + DateUtil.parse(String.valueOf(value), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "> '" + DateUtil.parse(String.valueOf(getStringValueInWhere(field, value, attrVOMap)), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE; + } + } else if (key.endsWith("_dateequal")) { + String field = UBCSSqlKeyword.getColumn(key, "_dateequal"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "= '" + DateUtil.parse(String.valueOf(value), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "= '" + DateUtil.parse(String.valueOf(getStringValueInWhere(field, value, attrVOMap)), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE; + } + } else if (key.endsWith("_datele")) { + String field = UBCSSqlKeyword.getColumn(key, "_datele"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "<= '" + DateUtil.parse(String.valueOf(value), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "<= '" + DateUtil.parse(String.valueOf(getStringValueInWhere(field, value, attrVOMap)), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE; + } + } else if (key.endsWith("_datelt")) { + String field = UBCSSqlKeyword.getColumn(key, "_datelt"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "< '" + DateUtil.parse(String.valueOf(value), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "< '" + DateUtil.parse(String.valueOf(getStringValueInWhere(field, value, attrVOMap)), "yyyy-MM-dd HH:mm:ss") + "'" + SPACE; + } + } else if (key.endsWith("_null")) { + String field = UBCSSqlKeyword.getColumn(key, "_null"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "IS NULL" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "IS NULL" + SPACE; + } + } else if (key.endsWith("_notnull")) { + String field = UBCSSqlKeyword.getColumn(key, "_null"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "IS NOT NULL" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "IS NOT NULL" + SPACE; + } + } else { + String field = UBCSSqlKeyword.getColumn(key, "_dateequal"); + if (referFieldMap.containsKey(field)) { + return referFieldMap.get(field) + SPACE + "= '" + value + "'" + SPACE; + } else { + return (field.contains(".") ? "" : "t.") + field + SPACE + "= '" + getStringValueInWhere(field, value, attrVOMap)+ "'" + SPACE; + } + } + + }*/ + 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,btmType); + } else { + return getSqlByValue(key, value, attrVOMap,btmType); + } + } + } + + /** + * 鑾峰彇鏌ヨ鏉′欢涓殑鍊肩殑锛屽鐞嗕笉鍚岀殑绫诲瀷 + * + * @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 selectKey + * @param btmType + * @return + */ + private boolean isDefaultAttr(String selectKey, String btmType){ + if(StringUtils.isBlank(btmType)){ + return false; + } + R<BtmTypeVO> r = btmTypeClient.getDefaultAttrByBtmId(btmType); + List<BtmTypeAttributeVO> attributes = r.getData().getAttributes(); + if(r.getCode() != 200 || attributes.isEmpty()){ + return false; + } + return attributes.stream().anyMatch(item->item.getId().equals(selectKey)); + } + + /** + * 灏佽鏈�缁堢殑sql璇彞涓殑鍊奸儴鍒� + * + * @param selectKey 鏌ヨ鐨勫瓧娈� + * @param value 鍊� + * @param attrVOMap 灞炴�х殑鏄剧ず瀵硅薄鏄犲皠 + * @return sql閲岀殑鍊� + */ + private String getSqlByValue(String selectKey, String value, Map<String, CodeClassifyTemplateAttrVO> attrVOMap,String btmType) { + StringBuilder sql = new StringBuilder(); + // TODO 宸插畬鍠� + if (!selectKey.contains(".") && (attrVOMap.containsKey(selectKey.toLowerCase(Locale.ROOT)) || isDefaultAttr(selectKey,btmType) || 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<BaseModel> cbos = selectByTypeAndOid(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), orderDTO.getOid()); + + if (CollectionUtils.isEmpty(cbos)) { + throw new VciBaseException(DATA_OID_NOT_EXIST); + } +// QueryWrapper<CodeWupin> btmWrapper = new QueryWrapper<>(); +// btmWrapper.eq("OID",orderDTO.getOid()); +// CodeWupin cbo = codeWupinMapper.selectOne(btmWrapper); + BaseModel cbo = cbos.get(0); +// 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( StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription()); + cbo.setName(orderDTO.getName()); +//// cbo.setAttributeValueWithNoCheck("description", orderDTO.getDescription()); +// cbo.setAttributeValue("name", orderDTO.getName()); + } catch (Exception e) { + e.printStackTrace(); + } + cbo.setLastModifyTime(new Date()); + cbo.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId())); + updateBatchByBaseModel(classifyFullInfo.getTopClassifyVO().getBtmtypeid(), Collections.singletonList(cbo)); +// codeWupinMapper.updateById(cbo); +// +// 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, Collections.singletonList(cbo)); +// batchSaveSelectChar(templateVO, Arrays.asList(cbo.getId())); + } + + /** + * 鍒犻櫎涓婚搴撴暟鎹� + * + * @param deleteBatchDTO 鏁版嵁鐨勫唴瀹癸紝蹇呴』瑕佹湁涓婚敭鍜屽垎绫讳富閿� + */ + @Override + public void deleteCode(CodeDeleteBatchDTO deleteBatchDTO) { + VciBaseUtil.alertNotNull(deleteBatchDTO, "缂栫爜鐢宠鐩稿叧鐨勫睘鎬у拰鐮佹鐨勫唴瀹归兘涓虹┖", deleteBatchDTO.getOidList(), "鏁版嵁涓婚敭", + deleteBatchDTO.getCodeClassifyOid(), "涓婚搴撳垎绫荤殑涓婚敭"); + CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(deleteBatchDTO.getCodeClassifyOid()); + //鎵句笟鍔$被鍨嬶紝鐒跺悗浣跨敤涓婚敭鍘昏幏鍙栨暟鎹簱閲岀殑鏁版嵁 + Collection<String> oidCollection = null; + for (Collection<String> strings : VciBaseUtil.switchCollectionForOracleIn(deleteBatchDTO.getOidList())) { + oidCollection.addAll(strings); + } + + List<CodeWupin> cboList = codeWupinMapper.selectBatchIds(oidCollection); + // 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<CodeWupin> editCBOs = cboList.stream().filter(s -> !CodeDefaultLC.EDITING.getValue().equalsIgnoreCase(s.getLcStatus())).collect(Collectors.toList()); + if (!CollectionUtils.isEmpty(editCBOs)) { + CodeWupin cbo = editCBOs.get(0); + throw new VciBaseException("缂栫爜涓簕0}绛夊叡{1}鏉℃暟鎹殑鐘舵�佷笉鏄痆{2}]锛屼笉鍏佽鍒犻櫎", new String[]{cbo.getId(), String.valueOf(editCBOs.size()), CodeDefaultLC.EDITING.getText()}); + } + + //鍙兘鍒犻櫎鑷繁鍒涘缓鐨勬暟鎹� + String userId = AuthUtil.getUser().getUserName(); + for (CodeWupin 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()); + baseMapper.deleteBatchIds(cboList); + // ); +// WebUtil.setPersistence(true); +// boService.persistenceBatch(batchCBO); + } + + /** + * 浣跨敤鍒嗙被鍜岄樁娈电殑缂栧彿锛岃幏鍙栧寘鍚殑灞炴�� + * + * @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 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("t."+CODE_CLASSIFY_OID_FIELD, codeClassifyOid); + } else { +// conditionMap.put(CODE_CLASSIFY_OID_FIELD, QueryOptionConstant.IN + "(select oid from " + VciBaseUtil.getTableName(MdmBtmTypeConstant.CODE_CLASSIFY) + + conditionMap.put("t."+CODE_CLASSIFY_OID_FIELD, QueryOptionConstant.IN + "(select oid from "+ + btmTypeClient.selectByIdCollection(Collections.singletonList(MdmBtmTypeConstant.CODE_CLASSIFY)) + .getData().get(0).getTableName() +" where lcstatus='" + FrameWorkDefaultValueConstant + .FRAMEWORK_DATA_ENABLED + "' start with parentCodeClassifyOid = '" + codeClassifyOid + + "' CONNECT BY PRIOR OID = parentCodeClassifyOid )"); + } + conditionMap.put("t.lastr", "1"); + conditionMap.put("t.lastv", "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 orderDTOList 缂栫爜鐩稿叧鐨勪俊鎭紝涓嶉渶瑕佺爜娈电殑淇℃伅 + * @return 鎵ц缁撴灉 + */ + @Override + public R 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<BaseModel> updateList = new ArrayList<>(); + // 搴旇閮芥槸涓�涓垎绫讳笅鐨勪笟鍔℃暟鎹紝鎵剧涓�鏉$殑灏辫 + CodeClassifyFullInfoBO topClassifyFullInfo = classifyService.getClassifyFullInfo(orderDTOList.get(0).getCodeClassifyOid()); +// Map<String,String> cboOidMap = new HashMap<>(); + if (CollectionUtils.isEmpty(orderDTOMap.keySet())){ + throw new VciBaseException(DATA_OID_NOT_EXIST); + } + + List<BaseModel> cboList = selectByTypeAndOid(topClassifyFullInfo.getTopClassifyVO().getBtmtypeid(), VciBaseUtil.array2String(orderDTOMap.keySet().toArray(new String[0]))); +// 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, BaseModel> 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); + CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid()); + CodeClassifyTemplateVO firstTemplateVO = templateService.getObjectHasAttrByOid(orderDTOMap.values().stream().findFirst().get().getTemplateOid()); + BaseModel cbo = cboMap.get(oid); + String code=cbo.getId(); + if (!cbo.getTs().toString().contains(orderDTO.getTs().toString())) { + 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(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription()); + cbo.setName(orderDTO.getName()); +// try { +// cbo.setAttributeValue("id",code); + cbo.setId(code); + cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription()); +// cbo.setAttributeValueWithNoCheck("description", StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription()); +// cbo.setAttributeValue("name", orderDTO.getName()); + cbo.setName(orderDTO.getName()); +// } catch (VCIError e) { +// e.printStackTrace(); +// } +// batchCBO.getUpdateCbos().add(cbo); + updateList.add(cbo); + batchSaveSelectChar(firstTemplateVO, cboList); + }); +// boService.persistenceBatch(batchCBO); + updateBatchByBaseModel(topClassifyFullInfo.getTopClassifyVO().getBtmtypeid(),updateList); + return R.success("鎿嶄綔鎴愬姛锛�"); + } + + /** + * 鏍囪娴佺▼涓笟鍔℃暟鎹槸鍚﹂�氳繃 + * + * @param oid 涓氬姟鏁版嵁涓婚敭 + * @param btmName 涓氬姟绫诲瀷 + * @param pass 鏄惁閫氳繃 + * @return 鎵ц缁撴灉 + */ + @Override + public R markDataPassing(String oid, String btmName, Boolean pass) { + VciBaseUtil.alertNotNull(oid, "涓氬姟鏁版嵁涓婚敭", btmName, "涓氬姟绫诲瀷", pass, "鏍囪绫诲瀷"); + boolean flag = false; + try { +// QueryWrapper<CodeWupinEntity> wrapper = new QueryWrapper<>(); +// wrapper.eq("oid",oid); + CodeWupin data = baseMapper.selectById(oid); + // ClientBusinessObjectOperation operation = new ClientBusinessObjectOperation(); +// ClientBusinessObject data = operation.readBusinessObjectById(oid, btmName); + if (data == null || StringUtils.isBlank(data.getOid())) { + return R.fail(DATA_OID_NOT_EXIST); + } + data.setPassing(String.valueOf(pass)); + flag = SqlHelper.retBool(baseMapper.updateById(data)); +// flag = operation.updateBuinessObject(data); + } catch (Exception e) { + e.printStackTrace(); + } + if (flag) { + return R.success("鏍囪鎴愬姛锛�"); + } else { + return R.fail("鏍囪澶辫触锛�"); + } + } + + /** + * 棰勮缁勫悎瑙勫垯 + * + * @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 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 鏁版嵁鐨勫唴瀹癸紝涓嶉渶瑕佸寘鍚爜娈电殑鍐呭 + */ + @Override + public void upSaveCode(CodeOrderDTO orderDTO) { + VciBaseUtil.alertNotNull(orderDTO, "缂栫爜鏁版嵁鎵�鍦ㄤ笟鍔$被鍚嶇О", orderDTO.getBtmname()); + String btmName=orderDTO.getBtmname(); + //鎵句笟鍔$被鍨嬶紝鐒跺悗浣跨敤涓婚敭鍘昏幏鍙栨暟鎹簱閲岀殑鏁版嵁 + List<BaseModel> cbos = selectByTypeAndOid(btmName, orderDTO.getCopyFromVersion()); + if (CollectionUtils.isEmpty(cbos)) { + throw new VciBaseException(DATA_OID_NOT_EXIST); + } + BaseModel oldCbo = cbos.get(0); + + if (!CodeDefaultLC.RELEASED.getValue().equalsIgnoreCase(oldCbo.getLcStatus())) { + throw new VciBaseException("鏁版嵁涓嶆槸{0}鐨勭姸鎬侊紝涓嶅厑璁告暟鎹洿鏀�", new String[]{CodeDefaultLC.RELEASED.getText()}); + } + + //鏍规嵁鏁版嵁鑾峰彇鍒嗙被oid + String codeClassifyOid=oldCbo.getData().get(CODE_CLASSIFY_OID_FIELD.toUpperCase()); + orderDTO.setCodeClassifyOid(codeClassifyOid); + CodeClassifyFullInfoBO classifyFullInfo = classifyService.getClassifyFullInfo(orderDTO.getCodeClassifyOid()); + CodeClassifyTemplateVO templateVO= this.getUsedTemplateByClassifyOid(orderDTO.getCodeClassifyOid()); + orderDTO.setTemplateOid(templateVO.getOid()); + VciBaseUtil.alertNotNull(orderDTO, "缂栫爜鐢宠鐩稿叧鐨勫睘鎬х殑鍐呭涓虹┖", orderDTO.getCopyFromVersion(), "鍘熷鏁版嵁鐨勪富閿�", + orderDTO.getCodeClassifyOid(), "涓婚搴撳垎绫荤殑涓婚敭"); + + //闇�瑕佸崌鐗� +// ClientBusinessObjectOperation cboOperation = new ClientBusinessObjectOperation(); + BaseModel cbo = null; +// try { +// //cbo = cboOperation.createBusinessObjectVersion(oldCbo,VciBaseUtil.getCurrentUserId()); + cbo = 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(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription()); + cbo.setName(orderDTO.getName()); +// try { + cbo.setDescription(StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription()); +// cbo.setAttributeValueWithNoCheck("description", StringUtils.isBlank(orderDTO.getDescription())?"":orderDTO.getDescription()); + cbo.setName(orderDTO.getName()); +// } catch (VCIError e) { +// e.printStackTrace(); +// } + //鏁版嵁鐨勬椂鍊欙紝缂栫爜鏄笉鍙樼殑 + cbo.setCreateTime(cbo.getCreateTime()); + cbo.setLastModifyTime(cbo.getLastModifyTime()); +// List<ClientBusinessObject> cboList = new ArrayList<>(); +// cboList.add(cbo); + try { +// cboOperation.saveRevisionBuinessObject(cbo); + insertBatchByType(cbo.getBtmname(), Collections.singletonList(cbo)); + } catch (Exception vciError) { + throw new VciBaseException("鏁版嵁鏇存敼淇濆瓨鍑洪敊浜�", new String[0], vciError); + } + batchSaveSelectChar(templateVO, Collections.singletonList(cbo)); + } + + /** + * 浣跨敤鐮佹鐨勪富閿幏鍙栧垎绫荤殑鐮佸�煎唴瀹� + * + * @param classifySecOid 鐮佹鐨勪富閿� + * @param parentClassifyValueOid 涓婄骇鍒嗙被鐨勪富閿� + * @return 鍒嗙被鐮佸�肩殑鍐呭 + */ + @Override + public List<CodeClassifyValueVO> listCodeClassifyValueBySecOid(String classifySecOid, String parentClassifyValueOid) { + return classifyValueService.listCodeClassifyValueBySecOid(classifySecOid, parentClassifyValueOid); + } + + /** + * 浣跨敤涓婚搴撳垎绫昏幏鍙栫紪鐮佽鍒� + * + * @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 oid 涓婚敭 + * @param templateOid 妯℃澘鐨勪富閿� + * @return 鏁版嵁鐨勫唴瀹� + */ + @Override + public R<List<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 = new HashMap<>(); + conditionMap.put("t.oid", oid); + CodeTemplateAttrSqlBO sqlBO = getSqlByTemplateVO(btmId, templateVO, conditionMap, new PageHelper(-1)); + //鎴戜滑浣跨敤鍜屼笟鍔$被鍨嬬殑鏉ユ煡璇� + List<Map> cbosB = commonsMapper.selectBySql(sqlBO.getSqlUnPage()); + List<Map<String, String>> cbos = new ArrayList<>(); + cbosB.stream().forEach(map -> { + Map<String, String> data = new HashMap<>(); + for (Object o : map.keySet()) { + data.put(((String) o).toLowerCase(Locale.ROOT), String.valueOf(map.get(o))); + } + cbos.add(data); + }); + +// List<ClientBusinessObject> cbos = boService.queryByOnlySql(sqlBO.getSqlUnPage()); + if (CollectionUtils.isEmpty(cbos)) { + throw new VciBaseException("鏁版嵁鍦ㄧ郴缁熶腑涓嶅瓨鍦紝鏄惁鍥犱负淇敼杩囦笟鍔$被鍨嬶紵"); + } +// Map<String, String> data = new HashMap<>(); + Map<String, String> cbo = cbos.get(0); +// WebUtil.copyValueToMapFromCbos(cbo, data); + List<Map<String, String>> dataList = new ArrayList<>(); + dataList.add(cbo); + wrapperData(dataList, templateVO, sqlBO.getSelectFieldList(), true); + R<List<Map<String, String>>> result = R.data(Collections.singletonList(cbo)); + //鎴戜滑瑕佺湅鏄惁涓嶆槸鍗囩増鐨勶紝鍗囩増鐨勮瘽锛岄渶瑕佸姣斾笉鐩哥瓑鐨勫睘鎬� + String copy = cbo.get("copyfromversion"); +// if (StringUtils.isBlank(copy)) { +// copy = cbo.getAttributeValue("copyfromversion"); +// } + if (StringUtils.isNotBlank(copy)) { + //璇存槑鏈夊彉鏇寸殑鍐呭 + + CodeTemplateAttrSqlBO oldSqlBO = getSqlByTemplateVO(btmId, templateVO, WebUtil.getOidQuery(copy), new PageHelper(-1)); + //鎴戜滑浣跨敤鍜屼笟鍔$被鍨嬬殑鏉ユ煡璇� +// List<Map> cbos = commonsMapper.selectBySql(sqlBO.getSqlUnPage()); + List<Map> oldCbos = commonsMapper.selectBySql(oldSqlBO.getSqlUnPage()); + if (!CollectionUtils.isEmpty(oldCbos)) { +// Map<String, String> newData = new HashMap<>(); +// WebUtil.copyValueToMapFromCbos(cbo, newData); + Map<String, String> oldData = new HashMap<>(); + oldData = oldCbos.get(0); + Map<String, String> difFieldMap = new HashMap<>(); + Map<String, String> finalOldData = oldData; + cbo.forEach((key, value) -> { + String oldValue = finalOldData.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 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 wm_concat(distinct (t.codetempattrOidArr)) codetempattroidarr\n" + + "from pl_code_wupin 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); + List<Map> tempAttrOidArr = commonsMapper.selectBySql(sql); + if (CollectionUtils.isEmpty(tempAttrOidArr) || StringUtils.isBlank((CharSequence) tempAttrOidArr.get(0).get("codetempattroidarr"))) { + return new ArrayList<>(); + } + return VciBaseUtil.str2List(tempAttrOidArr.get(0).get("codetempattroidarr").toString()); + } + /** + * 浣跨敤鍒嗙被鐨勪富閿幏鍙栦笟鍔℃暟鎹� + * + * @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<>(); + QueryWrapper<CodeWupin> wrapper = new QueryWrapper(); + if (conditionMap.get("oid").contains(",")) { +// oidMap.put("oid", QueryOptionConstant.IN +"("+ VciBaseUtil.toInSql(oidList.toArray(new String[0])) + ")"); + wrapper.in("oid", oidList); + } else { +// oidMap.put("oid", conditionMap.get("oid")); + wrapper.in("oid", conditionMap.get("oid")); + } + if (CollectionUtils.isEmpty(oidMap)) { + throw new VciBaseException("涓氬姟鏁版嵁涓婚敭涓嶈兘涓虹┖"); + } +// List<ClientBusinessObject> cbos = boService.queryCBO(btmType, oidMap); + List<CodeWupin> cbos = baseMapper.selectList(wrapper); + if (CollectionUtils.isEmpty(cbos)) { + throw new VciBaseException("鏈壘鍒颁笟鍔℃暟鎹�"); + } + CodeWupin cbo = cbos.get(0); + String templateOid = cbo.getCodetemplateoid(); +// Map<String, String> templateOidMap = new HashMap<>(); +// templateOidMap.put("oid", templateOid); + + QueryWrapper<CodeClassifyTemplate> codeClassifyTemplateWrapper = new QueryWrapper<>(); + codeClassifyTemplateWrapper.eq("oid", templateOid); + List<CodeClassifyTemplate> templateDOList = templateService.list(codeClassifyTemplateWrapper); + +// List<CodeClassifyTemplate> templateDOList = boService.queryObject(CodeClassifyTemplate.class, templateOidMap); + QueryWrapper<CodeClassifyTemplateAttr> codeClassifyTemplateAttrWrapper = new QueryWrapper<>(); + codeClassifyTemplateAttrWrapper.eq("CLASSIFYTEMPLATEOID", templateOid); +// templateOidMap.clear(); +// templateOidMap.put("CLASSIFYTEMPLATEOID",templateOid); + List<CodeClassifyTemplateAttr> attrDOList = codeClassifyTemplateAttrService.list(codeClassifyTemplateAttrWrapper); +// boService.queryObject(CodeClassifyTemplateAttr.class, templateOidMap); + if (CollectionUtils.isEmpty(templateDOList)) { + logger.error("鎵句笉鍒颁笟鍔℃暟鎹叧鑱旂殑妯℃澘锛屾ā鏉夸富閿細" + templateOid); + throw new VciBaseException("鎵句笉鍒颁笟鍔℃暟鎹叧鑱旂殑妯℃澘"); + } + CodeClassifyTemplateVO templateVO = templateService.codeClassifyTemplateDO2VO(templateDOList.get(0)); + templateVO.setAttributes(codeClassifyTemplateAttrService.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 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 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 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()); + } + + /** + * 浣跨敤鍒嗙被鐨勭紪鍙疯矾寰勶紝鑾峰彇琛ㄥ崟鐨勭浉鍏冲畾涔� + * + * @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; + } + + /** + * 浣跨敤涓婚搴撳垎绫荤殑涓婚敭鑾峰彇琛ㄥ崟鐨勪俊鎭� + * + * @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; + } + + /** + * 浣跨敤妯℃澘涓婚敭鑾峰彇ui鐩稿叧鐨勫唴瀹� + * + * @param templateOid 妯℃澘鐨勪富閿� + * @return ui鐩稿叧鐨勫唴瀹� + */ + @Override + public MdmUIInfoVO getTableDefineByTemplateOid(String templateOid) { + return getTableDefineByTemplateVO(templateService.getObjectHasAttrByOid(templateOid)); + } + + + /** + * 浣跨敤妯℃澘鏄剧ず瀵硅薄杞崲涓鸿〃鏍肩殑淇℃伅锛堝寘鍚墿灞曠殑鎸夐挳锛� + * + * @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 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; + } + + /** + * 浣跨敤鍒嗙被涓婚敭鑾峰彇椤甸潰鐨勫唴瀹癸紝鍖呭惈鎸夐挳 + * + * @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<Menu> buttonVOS = iSysClient.getMenuButtonByType(uiInfoVO.getTemplateVO().getBtmTypeId()).getData(); +// List<SmOperationVO> operationVOS = operationService.listButtonByFunctionId(functionId); +// if (operationVOS == null) { +// operationVOS = new ArrayList<>(); +// } +// //鏌ヨ鎵╁睍鎸夐挳 +// List<CodeButtonVO> buttonVOS = listButtonInToolbarByClassifyOid(codeClassifyOid); + List<SmOperationVO> operationVOS = new ArrayList<>(); + if (!CollectionUtils.isEmpty(buttonVOS)) { + for (int i = 0; i < buttonVOS.size(); i++) { + Menu buttonVO = buttonVOS.get(i); + SmOperationVO operationVO = new SmOperationVO(); + operationVO.setModuleNo(functionId); + operationVO.setUniqueFlag(buttonVO.getCode()); + operationVO.setName(buttonVO.getName()); + operationVO.setAlias(buttonVO.getAlias()); + operationVO.setOrderNo(String.valueOf(buttonVO.getSort())); +// operationVO.setExecuteJs(buttonVO.getExecuteJs()); +// operationVO.setIconCls(buttonVO.getIconCls()); + operationVOS.add(operationVO); + } + } + uiInfoVO.setButtons(operationVOS); + } + return uiInfoVO; + } + + /** + * 浣跨敤鍒嗙被涓婚敭鑾峰彇宸ュ叿鏍忎腑鐨勬寜閽俊鎭� + * + * @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 btmType 涓氬姟绫诲瀷 + * @param baseModels 澶勭悊鏁版嵁 + * @return 澶勭悊鎴愬姛鏁版嵁鏉℃暟 + */ + @Override + public Integer insertBatchByType(String btmType, List<BaseModel> baseModels) { + //浣跨敤浼犲叆鐨勪笟鍔$被鍨嬫煡璇㈣〃 + R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(btmType)); + if(listR.getData().size() == 0){ + throw new VciBaseException("浼犲叆涓氬姟绫诲瀷鏈煡璇㈠埌鐩稿簲琛ㄥ崟锛岃妫�鏌ワ紒"); + } + //灏哹ean杞负map,mybatis缁熶竴澶勭悊 + List<Map<String,String>> maps = new ArrayList<>(); + baseModels.stream().forEach(model-> { + try { + maps.add(VciBaseUtil.convertBean2Map(model)); + } catch (Exception e) { + throw new VciBaseException("绫诲瀷杞崲閿欒锛�" + e.toString()); + } + }); + return commonsMapper.insertByBaseModel(listR.getData().get(0).getTableName(), maps.get(0), maps); + } + + /** + * 浼犲叆涓氬姟绫诲瀷浠ュ強鐩竜id闆嗗悎鏌ヨ鏁版嵁杩涜杩斿洖 + * + * @param btmType 涓氬姟绫诲瀷 + * @param oids 闇�瑕佹煡璇㈢殑oid闆嗗悎 閫楀彿鍒嗗紑 + * @return 鏌ヨ鍑虹殑鏁版嵁 + */ + @Override + public List<BaseModel> selectByTypeAndOid(String btmType, String oids) { + + //浣跨敤浼犲叆鐨勪笟鍔$被鍨嬫煡璇㈣〃 + R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(btmType)); + if (listR.getData().size() == 0) { + throw new VciBaseException("浼犲叆涓氬姟绫诲瀷鏈煡璇㈠埌鐩稿簲琛ㄥ崟锛岃妫�鏌ワ紒"); + } + //鏌ヨ鏁版嵁 + List<Map> maps = commonsMapper.selectBySql("select * from " + listR.getData().get(0).getTableName() + " where oid in (" + + VciBaseUtil.toInSql(oids.toString()) + ")"); + + List<BaseModel> baseModels = new ArrayList<>(); + //灏嗘煡璇㈠埌鐨勬暟鎹浆鎹负basemodel锛屼娇鐢ㄧ殑鍙嶅皠鏂瑰紡鏉ヨ繘琛屽垱寤虹殑 + try{ + for (Map map : maps) { + Object obj = BaseModel.class.newInstance(); + BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass()); + PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); + for (PropertyDescriptor property : propertyDescriptors) { + Method setter = property.getWriteMethod(); + if (setter != null) { + //oracle鐨勬椂闂翠负TIMESTAMP鐨勶紝闇�瑕佽繘琛岃浆鎹㈡垚data锛屽惁鍒欏皢鎶ラ敊 + if(map.get(property.getName().toUpperCase()) instanceof TIMESTAMP){ + LocalDateTime localDateTime = ((TIMESTAMP) map.get(property.getName().toUpperCase())).toLocalDateTime(); + ZoneId zoneId = ZoneId.systemDefault(); + ZonedDateTime zdt = localDateTime.atZone(zoneId); + Date date = Date.from(zdt.toInstant()); + setter.invoke(obj,date); + map.remove(property.getName().toUpperCase()); + } //oracle鐨勬暟瀛椾负BigDecimal鐨勶紝闇�瑕佽繘琛岃浆鎹㈡垚Integer锛屽惁鍒欏皢鎶ラ敊 + else if (map.get(property.getName().toUpperCase()) instanceof BigDecimal + && ("Integer").equals(setter.getParameterTypes()[0].getSimpleName())){ + setter.invoke(obj, ((BigDecimal)map.get(property.getName().toUpperCase())).intValue()); + map.remove(property.getName().toUpperCase()); + }else if(map.get(property.getName().toUpperCase()) != null){ + setter.invoke(obj, map.get(property.getName().toUpperCase())); + map.remove(property.getName().toUpperCase()); + } + } + } + for (Object key : map.keySet()) { + map.put(key,String.valueOf(map.get(key))); + } + + ((BaseModel) obj).setData(map); + baseModels.add((BaseModel) obj); + } + }catch (Exception e){ + throw new VciBaseException("鏌ヨ澶辫触锛�" + e.getMessage()); + } + return baseModels; + } + + + /** + * 鏍规嵁涓氬姟绫诲瀷鍚嶇О鍒涘缓涓氬姟鏁版嵁婧愬璞� + * @param boName 涓氬姟绫诲瀷鍚嶇О + * @return 涓氬姟鏁版嵁瀵硅薄 + */ + public BaseModel createBaseModel(String boName) { + R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(boName)); + String userName = AuthUtil.getUser().getUserName(); + BaseModel bo = new BaseModel(); +// bo.setOid(VciBaseUtil.getPk()); +// bo.setRevisionid(VciBaseUtil.getPk()); +// bo.setNameoid(VciBaseUtil.getPk()); + bo.setBtmname(boName); + bo.setLastR("1"); + bo.setFirstR("1"); + bo.setFirstV("1"); + bo.setLastV("1"); + bo.setCreator(userName); + bo.setCreateTime(new Date()); + bo.setLastModifier(userName); + bo.setLastModifyTime(new Date()); + bo.setRevisionRule(listR.getData().get(0).getRevisionRuleId()); + bo.setVersionRule(String.valueOf(listR.getData().get(0).getVersionRule())); + if(StringUtils.isNotBlank(listR.getData().get(0).getRevisionRuleId())){ + R<List<RevisionRuleVO>> revisionRuleVO = revisionRuleClient + .selectByIdCollection(Collections.singletonList(listR.getData().get(0).getRevisionRuleId())); + bo.setRevisionValue(revisionRuleVO.getData().get(0).getStartCode()); + } + bo.setRevisionSeq(1); + bo.setVersionSeq(1); + bo.setVersionValue(getVersionValue(WebUtil.getInt(listR.getData().get(0).getVersionRule()))); + bo.setLctid(listR.getData().get(0).getLifeCycleId()); +// if(StringUtils.isNotBlank(listR.getData().get(0).getLifeCycleId())){ +// OsLifeCycleVO lifeCycleVO = lifeService.getLifeCycleById(listR.getData().get(0).getLifeCycleId()); + bo.setLcStatus("Editing"); +// } + bo.setId(""); + bo.setName(""); + bo.setDescription(""); + bo.setOwner(userName); +// bo.setCheckinby(userName); + bo.setCopyFromVersion(""); +// this.initTypeAttributeValue(bo,btmTypeVO); + return bo; + } + + /** + * 鑾峰彇鐗堟鐨勫�� + * @param verRuleName 鐗堟鐨勮鍒� + * @return 鐗堟鐨勫�硷紝娌℃湁瑙勫垯鍒欎负绌� + */ + private String getVersionValue(int verRuleName) { + if (verRuleName == 0) { + return "1"; + } else if (verRuleName == 1) { + return "a"; + } else if (verRuleName == 2) { + return "0"; + } + return ""; + } + + /** + * 浼犲叆涓氬姟绫诲瀷浠ュ強鐩稿叧鏁版嵁杩涜鎵归噺鏇存柊鎿嶄綔 + * + * @param btmType 涓氬姟绫诲瀷 + * @param baseModels 澶勭悊鏁版嵁 + * @return 澶勭悊鐘舵�� + */ + @Override + public R updateBatchByBaseModel(String btmType, List<BaseModel> baseModels) { + //浣跨敤浼犲叆鐨勪笟鍔$被鍨嬫煡璇㈣〃 + R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(btmType)); + if(listR.getData().size() == 0){ + throw new VciBaseException("浼犲叆涓氬姟绫诲瀷鏈煡璇㈠埌鐩稿簲琛ㄥ崟锛岃妫�鏌ワ紒"); + } + //灏哹ean杞负map,mybatis缁熶竴澶勭悊 + List<Map<String,String>> maps = new ArrayList<>(); + + baseModels.stream().forEach(model-> { + try { + maps.add(VciBaseUtil.convertBean2Map(model)); + } catch (Exception e) { + throw new VciBaseException("绫诲瀷杞崲閿欒锛�" + e.getMessage()); + } + }); + try { + //娉ㄦ剰姝ゅ鏇存柊鎴愬姛鏄繑鍥炵殑-1 + commonsMapper.updateBatchByBaseModel(listR.getData().get(0).getTableName(), maps); + }catch (Exception e){ + return R.fail("鏇存柊澶辫触锛�"+e.getMessage()); + } + + return R.success("鏇存柊鎴愬姛锛�"); + } + + /** + * 鑾峰彇鍙傜収鐨勪俊鎭� + * + * @param referConfigVO 鍙傜収鐨勯厤缃� + * @param pageHelper 鍒嗛〉鐨勫伐鍏� + * @return 鍒楄〃鏁版嵁 + */ + @Override + public DataGrid referDataGrid(UIFormReferVO referConfigVO, PageHelper pageHelper) { +// checkReferConfig(referConfigVO); + //浣跨敤涓氬姟绫诲瀷鏌ヨ + R<BtmTypeVO> allAttributeByBtmId = btmTypeClient.getAllAttributeByBtmId(referConfigVO.getReferType()); + BtmTypeVO btmTypeVO = allAttributeByBtmId.getData(); + if (referConfigVO.getWhere() == null) { + referConfigVO.setWhere(new HashMap<>()); + } + /** + * 鍔犱笂鏌ヨ鏈�鏂扮増娆� + */ + Map<String, String> conditionMap = new HashMap<>(); + conditionMap.put("lastr", "1"); + conditionMap.put("lastv", "1"); + referConfigVO.getWhere().putAll(conditionMap); + if (VciBaseUtil.containsKeyUnCaseForMap(referConfigVO.getWhere(), VciQueryWrapperForDO.LC_STATUS_FIELD) && + BtmTypeLcStatusConstant.FRAME_WORK_LIFE_CYCLE_NAME.equalsIgnoreCase(btmTypeVO.getLifeCycleId())) { + referConfigVO.getWhere().put(VciQueryWrapperForDO.LC_STATUS_FIELD, FrameworkDataLCStatus.ENABLED.getValue()); + } + if (VciBaseUtil.containsKeyUnCaseForMap(referConfigVO.getWhere(), VciQueryWrapperForDO.LC_STATUS_FIELD) && + BtmTypeLcStatusConstant.RELEASE_LIFE_CYCLE.equalsIgnoreCase(btmTypeVO.getLifeCycleId())) { + referConfigVO.getWhere().put(VciQueryWrapperForDO.LC_STATUS_FIELD, CodeDefaultLC.RELEASED.getValue()); + } + BaseQueryObject baseQueryObject = new BaseQueryObject(); + Map<String, String> where = referConfigVO.getWhere(); + where.put("domain", AppConstant.APPLICATION_NAME_CODE); + baseQueryObject.setConditionMap(where); + baseQueryObject.setPage(pageHelper.getPage()); + baseQueryObject.setSort(pageHelper.getSort()); + baseQueryObject.setLimit(pageHelper.getLimit()); + baseQueryObject.setOrder(pageHelper.getOrder()); + R<List<BtmTypeVO>> ref = btmTypeClient.getRef(baseQueryObject); + DataGrid<BtmTypeVO> btmTypeVODataGrid = new DataGrid<>(); + List<BtmTypeVO> data = ref.getData(); + btmTypeVODataGrid.setData(data); + btmTypeVODataGrid.setCode(ref.getCode()); + btmTypeVODataGrid.setLimit(pageHelper.getLimit()); + btmTypeVODataGrid.setMsg(ref.getMsg()); + btmTypeVODataGrid.setSort(pageHelper.getSort()); + btmTypeVODataGrid.setOrder(pageHelper.getOrder()); + btmTypeVODataGrid.setPage(pageHelper.getPage()); + return btmTypeVODataGrid; + } + + /** + * 鑾峰彇鏍戝舰鐨勫弬鐓� + * + * @param referConfigVO 鍙傜収鐨勯厤缃� + * @return 鏍戝舰鐨勬暟鎹� + */ + @Override + public List<Tree> referTree(UIFormReferVO referConfigVO, TreeQueryObject queryObject) { + if (queryObject.getConditionMap() == null) { + queryObject.setConditionMap(new HashMap<>()); + } + + if (queryObject.getParentOid()==null){ + LambdaQueryWrapper<CodeClassify> lqw = new LambdaQueryWrapper<>(); + String parentValue = referConfigVO.getParentValue().substring(3); + lqw.inSql(CodeClassify::getOid,parentValue); + List<String> codeClassifies = classifyService.select1(lqw); + String oid = codeClassifies.get(0); + queryObject.setParentOid(oid); + } + String oidFieldName = StringUtils.isNotBlank(referConfigVO.getParentUsedField()) ? referConfigVO.getParentUsedField() : referConfigVO.getValueField(); + if (queryObject.isQueryAllLevel()) { + String parentOidSql = ""; + if (StringUtils.isNotBlank(referConfigVO.getParentValue())) { + String temp = referConfigVO.getParentValue(); + if (temp.startsWith(QueryOptionConstant.IN)) { + temp = temp.substring((QueryOptionConstant.IN).length()).trim(); + parentOidSql = " in " + ((temp.startsWith("(") && temp.endsWith(")")) ? temp : "(" + temp + ")"); + } else if (temp.startsWith(QueryOptionConstant.NOTIN)) { + parentOidSql = " not in " + ((temp.startsWith("(") && temp.endsWith(")")) ? temp : "(" + temp + ")"); + } else if (temp.startsWith(QueryOptionConstant.NOTEQUAL)) { + temp = temp.substring((QueryOptionConstant.NOTEQUAL).length()).trim(); + parentOidSql = QueryOptionConstant.NOTEQUAL + " " + ((temp.startsWith("'") && temp.endsWith("'")) ? temp : "'" + temp + "'"); + } else if (temp.startsWith(QueryOptionConstant.MORETHAN)) { + temp = temp.substring((QueryOptionConstant.MORETHAN).length()).trim(); + parentOidSql = QueryOptionConstant.MORETHAN + " " + ((temp.startsWith("'") && temp.endsWith("'")) ? temp : "'" + temp + "'"); + } else if (temp.startsWith(QueryOptionConstant.MORE)) { + temp = temp.substring((QueryOptionConstant.MORE).length()).trim(); + parentOidSql = QueryOptionConstant.MORE + " " + ((temp.startsWith("'") && temp.endsWith("'")) ? temp : "'" + temp + "'"); + } else if (temp.startsWith(QueryOptionConstant.LESSTHAN)) { + temp = temp.substring((QueryOptionConstant.LESSTHAN).length()).trim(); + parentOidSql = QueryOptionConstant.LESSTHAN + " " + ((temp.startsWith("'") && temp.endsWith("'")) ? temp : "'" + temp + "'"); + } else if (temp.startsWith(QueryOptionConstant.LESS)) { + temp = temp.substring((QueryOptionConstant.LESS).length()).trim(); + parentOidSql = QueryOptionConstant.LESS + " " + ((temp.startsWith("'") && temp.endsWith("'")) ? temp : "'" + temp + "'"); + } else if (temp.startsWith(QueryOptionConstant.ISNOTNULL)) { + parentOidSql = " is not null"; + } else if (temp.startsWith(QueryOptionConstant.ISNULL)) { + parentOidSql = " is null"; + } else if (temp.contains("*")) { + parentOidSql = " like " + ((temp.startsWith("'") && temp.endsWith("'")) ? temp : "'" + temp + "'").replace("*", "%"); + } else { + parentOidSql = " = " + ((temp.startsWith("'") && temp.endsWith("'")) ? temp : "'" + temp + "'"); + } + + } + //鏌ヨ鍏ㄩ儴鐨勪俊鎭� + queryObject.getConditionMap().put("oid", QueryOptionConstant.IN + "(select oid from " + + getTableName(referConfigVO.getReferType())+ + " START WITH " + referConfigVO.getParentFieldName() + " " + + parentOidSql + + " CONNECT BY PRIOR " + oidFieldName + " = " + referConfigVO.getParentFieldName() + ")"); + } else { + if (StringUtils.isNotBlank(referConfigVO.getParentFieldName()) && StringUtils.isNotBlank(queryObject.getParentOid())) { + queryObject.getConditionMap().put(referConfigVO.getParentFieldName(), queryObject.getParentOid()); + } + } + LambdaQueryWrapper<CodeClassify> lqw = new LambdaQueryWrapper<>(); + String sql = queryObject.getConditionMap().get("oid").substring(3); + lqw.inSql(CodeClassify::getOid,sql); + List<CodeClassify> codeClassifies = classifyService.selectByWrapper(lqw); + TreeWrapperOptions treeWrapperOptions = new TreeWrapperOptions(referConfigVO.getParentFieldName()); + treeWrapperOptions.setOidFieldName(oidFieldName); + treeWrapperOptions.setTextFieldName(referConfigVO.getTextField()); + treeWrapperOptions.setMultipleSelect(referConfigVO.isMuti()); + treeWrapperOptions.setParentOid(queryObject.getParentOid()); + return revisionModelUtil.doList2Trees(codeClassifies, treeWrapperOptions, null); + } + + + private String getTableName(String refertype){ + if ("codeclassify".equals(refertype)){ + return "pl_code_classify"; + } + if ("table".equals(refertype)){ + return "pl_code_test_table"; + } + if ("testBtmType".equals(refertype)){ + return "PLBT_code_testBtmType"; + } + + return "pl_code_"+refertype.trim().toLowerCase(); + } + + public BaseModel reviseBusinessObject(BaseModel fromBo) { + BaseModel toBo = new BaseModel(); +// Map<String,String> data = new HashMap<>(); +// toBo.getData().put(data); + toBo.setOid(VciBaseUtil.getPk()); + toBo.setRevisionOid(VciBaseUtil.getPk()); + toBo.setNameOid(fromBo.getNameOid()); + toBo.setBtmname(fromBo.getBtmname()); + toBo.setLastR(String.valueOf(1)); + toBo.setFirstR(String.valueOf(0)); + toBo.setFirstV(String.valueOf(1)); + toBo.setLastV(String.valueOf(1)); + toBo.setCreator(String.valueOf(AuthUtil.getUser().getUserId())); + toBo.setCreateTime(new Date()); + toBo.setLastModifier(String.valueOf(AuthUtil.getUser().getUserId())); + toBo.setLastModifyTime(new Date()); + toBo.setRevisionRule(fromBo.getRevisionRule()); + toBo.setVersionRule(fromBo.getVersionRule()); +// RevisionValueObject rvObj = this.getNextRevision(fromBo.getBtmName(), fromBo.getNameoid(), item.revRuleName, item.revInput, revisionVal); + R<List<BtmTypeVO>> listR = btmTypeClient.selectByIdCollection(Collections.singletonList(fromBo.getBtmname())); + Map<String, Object> nextRevision = commonsMapper.getNextRevision(listR.getData().get(0).getTableName(), fromBo.getNameOid()); + toBo.setRevisionSeq(Integer.parseInt(nextRevision.get("REVISIONSEQ").toString())); + toBo.setRevisionValue(nextRevision.get("REVISIONVAL").toString()); +// VersionValueObject versionObj = this.getVersionValue(item.verRuleName); + toBo.setVersionSeq(Integer.valueOf(nextRevision.get("VERSIONSEQ").toString())); + toBo.setVersionValue(nextRevision.get("VERSIONVAL").toString()); + toBo.setLctid(fromBo.getLctid()); + toBo.setLcStatus("Editing"); + toBo.setId(fromBo.getId()); + toBo.setName(fromBo.getName()); + toBo.setDescription(fromBo.getDescription()); + toBo.setOwner(String.valueOf(AuthUtil.getUser().getUserId())); +// toBo.setCheckinBy(String.valueOf(AuthUtil.getUser().getUserId())); + toBo.setCopyFromVersion(fromBo.getOid()); + toBo.getData().putAll(fromBo.getData()); + toBo.getData().put("CHECKINBY",String.valueOf(AuthUtil.getUser().getUserId())); +// this.initRevisionTypeAttributeValue(fromBo, toBo); + return toBo; + + } } -- Gitblit v1.9.3