package com.vci.web.service.impl;
|
|
import cn.hutool.core.io.FileUtil;
|
import cn.hutool.core.util.ZipUtil;
|
import com.alibaba.fastjson.JSONObject;
|
import com.vci.client.common.oq.OQTool;
|
import com.vci.common.qt.object.*;
|
import com.vci.constant.FrameWorkLangCodeConstant;
|
import com.vci.corba.common.PLException;
|
import com.vci.corba.omd.atm.AttributeDef;
|
import com.vci.corba.omd.data.LinkObject;
|
import com.vci.corba.omd.ltm.LinkType;
|
import com.vci.corba.omd.qtm.QTD;
|
import com.vci.corba.omd.qtm.QTInfo;
|
import com.vci.dto.QTInfoDTO;
|
import com.vci.omd.objects.OtherInfo;
|
import com.vci.po.OsLinkTypePO;
|
import com.vci.starter.poi.bo.ReadExcelOption;
|
import com.vci.starter.poi.bo.WriteExcelData;
|
import com.vci.starter.poi.bo.WriteExcelOption;
|
import com.vci.starter.poi.constant.ExcelLangCodeConstant;
|
import com.vci.starter.poi.util.ExcelUtil;
|
import com.vci.starter.web.exception.VciBaseException;
|
import com.vci.starter.web.pagemodel.BaseResult;
|
import com.vci.starter.web.pagemodel.Tree;
|
import com.vci.starter.web.util.*;
|
import com.vci.web.other.LinkQTExportData;
|
import com.vci.web.service.*;
|
import com.vci.web.util.DateUtil;
|
import com.vci.web.util.Func;
|
import com.vci.web.util.PlatformClientUtil;
|
import com.vci.web.util.WebUtil;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.commons.lang3.time.DateFormatUtils;
|
import org.dom4j.DocumentException;
|
import org.dom4j.DocumentHelper;
|
import org.dom4j.Element;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.*;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 查询模板服务
|
* @author yuxc
|
* @date 2024-8-1
|
*/
|
@Service
|
public class OsQueryTemplateImpl implements OsQuereyTemplateServiceI {
|
|
|
/**
|
* 平台的调用工具类
|
*/
|
@Autowired
|
private PlatformClientUtil platformClientUtil;
|
|
private final String EQUAL = "=";
|
private final String UNEQUAL = "!=";
|
private final String CONTAINS = "包含";
|
private final String IN = "in";
|
private final String NOTIN = "not in";
|
private final String GT = ">";
|
private final String GTE = ">=";
|
private final String LT = "<";
|
private final String LTE = "<=";
|
private final String AND = "并且";
|
private final String OR = "或者";
|
|
/**
|
* 查询模板的列表
|
* @param btmName 类型
|
* @param linkFlag 是否链接类型 ：true 链接类型 ，false 业务类型
|
* @return 查询模板的列表
|
*/
|
@Override
|
public BaseResult queryTemplateList(String btmName, Boolean linkFlag) throws PLException {
|
QTD[] qtdArray = null;
|
if(linkFlag){
|
qtdArray = platformClientUtil.getQTDService().getLinkTypeQTDs(btmName);
|
}else {
|
qtdArray = platformClientUtil.getQTDService().getBizTypeQTDs(btmName);
|
}
|
return BaseResult.dataList(Arrays.asList(qtdArray));
|
}
|
|
/**
|
* 查询模板
|
* @param qtd 查询模板实体类
|
* @return 保存结果
|
*/
|
@Override
|
public BaseResult saveTemplate(QTD qtd) throws PLException {
|
//校验参数
|
checkName(qtd);
|
//设置默认值
|
qtd.creator = WebUtil.getCurrentUserId();
|
qtd.createTime = System.currentTimeMillis();
|
boolean addFlag = false;
|
//进行保存
|
addFlag = platformClientUtil.getQTDService().addQTD(qtd);
|
if (addFlag) {
|
return BaseResult.success("增加业务类型查询模板成功");
|
} else {
|
throw new PLException("500", new String[]{"增加业务类型查询模板失败"});
|
}
|
}
|
/**
|
* 修改查询模板
|
* @param qtd 查询模板实体类
|
* @return 保存结果
|
*/
|
@Override
|
public BaseResult updateTemplate(QTD qtd) throws PLException {
|
//校验参数
|
if (qtd.name.equals("")) {
|
throw new PLException("500", new String[]{"请输入模板定义名"});
|
}
|
if (!qtd.name.matches("[a-z A-Z]*")) {
|
throw new PLException("500", new String[]{"模板定义名只能为英文字母"});
|
}
|
qtd.createTime = System.currentTimeMillis();
|
boolean updateFlag = false;
|
//进行保存
|
updateFlag = platformClientUtil.getQTDService().modifyQTD(qtd);
|
if (updateFlag) {
|
return BaseResult.success("修改业务类型查询模板成功");
|
} else {
|
throw new PLException("500", new String[]{"修改业务类型查询模板失败"});
|
}
|
}
|
/**
|
* 删除查询模板
|
* @param name 查询模板名
|
* @return 保存结果
|
*/
|
@Override
|
public BaseResult deleteTemplate(String name) throws PLException {
|
boolean flag = false;
|
flag = platformClientUtil.getQTDService().deleteQTD(name);
|
if (flag) {
|
return BaseResult.success("删除查询模板成功");
|
} else {
|
return BaseResult.fail("删除查询模板失败");
|
}
|
}
|
/**
|
*
|
* @param dataMap 传输的数据对象：
|
* linkTypeName 链接类型、
|
* rdPositive 方向，true正向，false反向
|
* btmName 业务类型名称
|
* combRelaType 业务类型选择值
|
* versionValue 版本班次值
|
* isQueryIsLeaf 是否选择下级
|
* level 子节点层数
|
* @return 查询结果
|
*/
|
@Override
|
public BaseResult getCriteria(QTInfoDTO qtInfoDTO) throws PLException {
|
QueryTemplate qt = getQT(qtInfoDTO);
|
String checkInfo = OQTool.checkQT(qt);
|
if(!checkInfo.equals("OK")){
|
throw new PLException("500", new String[]{checkInfo});
|
}
|
qt.setId("qt1");
|
LinkObject[] result = platformClientUtil.getQueryService().findLTObjects(qt.getId(), OQTool.qtTOXMl(qt).asXML());
|
return BaseResult.dataList(Arrays.asList(result));
|
}
|
|
/**
|
* 查询模板列表
|
* @param btName 类型名称
|
* @return 查询结果
|
*/
|
@Override
|
public BaseResult getObjTypeQTs(String btName) throws PLException, DocumentException {
|
VciBaseUtil.alertNotNull(btName,"类型名");
|
QTInfo[] objTypeQTs = platformClientUtil.getQTDService().getObjTypeQTs(btName);
|
List<QTInfoDTO> dtos = new ArrayList<>();
|
for (QTInfo obj : objTypeQTs) {
|
QTInfoDTO qtInfoDTO = new QTInfoDTO();
|
qtInfoDTO.setCreator(obj.creator);
|
qtInfoDTO.setBtmName(obj.btmName);
|
qtInfoDTO.setQtName(obj.qtName);
|
qtInfoDTO.setLevelFlag(obj.levelFlag);
|
// qtInfoDTO.setQtText(obj.qtText);
|
qtInfoDTO.setQtUIText(obj.qtUIText);
|
if(StringUtils.isNotBlank(obj.qtUIText)){
|
//将给定的String文本解析为XML文档并返回新创建的document
|
qtInfoDTO.setTree(analysisXml(obj));
|
}
|
qtInfoDTO.setQueryTemplate(OQTool.getQTByDoc(DocumentHelper.parseText(obj.qtText), obj.qtName));
|
qtInfoDTO.setCreateTimeText(DateFormatUtils.format(new Date(obj.createTime), DateUtil.PATTERN_DATETIME));
|
dtos.add(qtInfoDTO);
|
}
|
return BaseResult.dataList(dtos);
|
}
|
|
/**
|
* 将客服端界面显示的xml转为hashMap
|
* @param obj 界面对象
|
* @return
|
* @throws DocumentException
|
*/
|
private HashMap<String,Object> analysisXml(QTInfo obj) throws DocumentException {
|
org.dom4j.Document document = DocumentHelper.parseText(obj.qtUIText);
|
if(document == null){
|
return null;
|
}
|
//获取根节点,在例子中就是responsedata节点
|
Element root = document.getRootElement();
|
List<HashMap<String,Object>> treeList = new ArrayList<>();
|
HashMap<String,Object> treeMap = new HashMap<>();
|
treeMap.put("connector",root.getText());
|
List<Element> children = root.elements();
|
List<Object> childList = new ArrayList<>();
|
for(Iterator<Element> i = children.iterator(); i.hasNext();){
|
Element child = i.next();
|
if(AND.equals(child.getText()) || OR.equals(child.getText())){
|
childList.add(addDefaultMutableTree(child));
|
}else {
|
childList.add(child.getText().trim());
|
}
|
}
|
treeMap.put("child",childList);
|
return treeMap;
|
}
|
|
/**
|
* 将子节点转为map结构
|
* @param element
|
*/
|
public Map<String, Object> addDefaultMutableTree(Element element){
|
List<Object> childList = new ArrayList<>();
|
List<Element> children = element.elements();
|
HashMap<String,Object> treeMap = new HashMap<>();
|
treeMap.put("connector",element.getText());
|
for(Iterator<Element> i = children.iterator(); i.hasNext();){
|
Element child = i.next();
|
if(AND.equals(child.getText()) || OR.equals(child.getText())){
|
childList.add(addDefaultMutableTree(child));
|
}else {
|
childList.add(child.getText().trim());
|
}
|
}
|
treeMap.put("child",childList);
|
return treeMap;
|
}
|
|
/**
|
* 检查查询模板名字是否存在
|
* @param name 查询模板名字
|
* @return 查询结果
|
*/
|
@Override
|
public BaseResult isExistsQT(String name) throws PLException {
|
VciBaseUtil.alertNotNull(name,"询模板名");
|
return BaseResult.success(platformClientUtil.getQTDService().isExistsQT(name));
|
}
|
|
/**
|
* 链接类型查询模板保存
|
* @param qtInfoDTO 保存传输对象
|
* @return 保存结果
|
*/
|
@Override
|
public BaseResult linkSave(QTInfoDTO qtInfoDTO) throws PLException {
|
QueryTemplate qt = getQT(qtInfoDTO);
|
String checkInfo = OQTool.checkQT(qt);
|
if(!checkInfo.equals("OK")){
|
throw new PLException("500", new String[]{checkInfo});
|
}
|
boolean saveFlag ;
|
qt.setId(qtInfoDTO.getQtName());
|
qt.setOrderInfoList(qtInfoDTO.getQueryTemplate().getOrderInfoList());
|
QTInfo qtWrapper = new QTInfo();
|
qtWrapper.qtName = qt.getId();
|
qtWrapper.btmName = qt.getLinkType();
|
qtWrapper.creator = WebUtil.getCurrentUserId();
|
qtWrapper.createTime = System.currentTimeMillis();
|
if(qtInfoDTO.getTree() == null){
|
qtWrapper.qtUIText = "";
|
}else{
|
qtWrapper.qtUIText = getSeniorXML(qtInfoDTO);
|
}
|
qtWrapper.levelFlag = qtInfoDTO.getLevelFlag();
|
qtWrapper.qtText = OQTool.qtTOXMl(qt).asXML();
|
saveFlag = platformClientUtil.getQTDService().saveQT(qtWrapper);
|
if(saveFlag){
|
return BaseResult.success();
|
}else{
|
return BaseResult.fail("保存查询模板失败");
|
}
|
}
|
|
/**
|
* 链接类型查询模板树查询，用于界面的导出功能
|
* @return 查询结果
|
*/
|
@Override
|
public BaseResult getLinkTree() throws PLException {
|
LinkType[] linkTypes= null;
|
QTInfo[] qts = null;
|
HashMap<String,Object> tree = new HashMap();
|
tree.put("text","业务类型");
|
if (linkTypes == null) {
|
List<LinkType> es = new ArrayList<LinkType>();
|
linkTypes = platformClientUtil.getLinkTypeService().getLinkTypes();
|
for (LinkType lt : linkTypes) {
|
QTInfo[] qtWrappers = platformClientUtil.getQTDService().getObjTypeQTs(lt.name);
|
if (qtWrappers.length!=0) {
|
es.add(lt);
|
}
|
}
|
linkTypes = es.toArray(new LinkType[es.size()]);
|
//TODO:需修正没有关联查询模板业务类型去掉
|
qts = platformClientUtil.getQTDService().getAllQTs();//获取所有查询模板
|
}
|
List<HashMap<String,Object>> childList = new ArrayList<>();
|
//添加业务类型根节点
|
for (LinkType plAction : linkTypes) {
|
HashMap<String,Object> childTree = new HashMap();
|
childTree.put("text", plAction.tag + "/" +plAction.name);
|
childTree.put("oid", plAction.oid);
|
// tree.put("children", childTree);
|
addExportTreeNode(plAction, qts, childTree);
|
childList.add(childTree);
|
}
|
tree.put("children", childList);
|
return BaseResult.success(tree);
|
}
|
|
/**
|
* 生成导出树选择以及导入树显示
|
* @param linkType
|
* @param qts
|
* @param tree
|
*/
|
private void addExportTreeNode(LinkType linkType/*业务类型*/,QTInfo[] qts/*查询模板对象*/,HashMap<String,Object> tree) {
|
List<String> childList = new ArrayList<>();
|
// 添加查询模板对象子节点
|
for (QTInfo qtItem : qts) {
|
//处理导入时无法进行类型判断
|
int splitLength = linkType.name.indexOf("【");
|
if(splitLength == -1){
|
splitLength = linkType.name.length();
|
}
|
if (qtItem.btmName.equals(linkType.name.substring(0,
|
splitLength))) {
|
childList.add(qtItem.qtName);
|
}
|
}
|
tree.put("children",childList);
|
}
|
|
/**
|
* 将高级条件数据转为xml
|
* @param qtInfoDTO 查询模板列表传输对象
|
* @return xml数据
|
*/
|
private String getSeniorXML(QTInfoDTO qtInfoDTO){
|
HashMap<String, Object> tree = qtInfoDTO.getTree();
|
if(tree.isEmpty()){
|
return "";
|
}
|
StringBuilder xmlStr = new StringBuilder("<?xml version=\"1.0\" encoding=\"UTF-8\"?><root>");
|
xmlStr.append(tree.get("connector"));
|
List<Object> childrens = (List<Object>) tree.get("child");
|
Iterator<Object> children = childrens.iterator();
|
while (children.hasNext()) {
|
Object obj = children.next();
|
if(obj instanceof JSONObject && (((JSONObject) obj).get("connector").equals(AND)
|
|| ((JSONObject) obj).get("connector").equals(OR))){
|
xmlStr.append(getSeniorChildXML((JSONObject) obj));
|
}else{
|
xmlStr.append("<child>").append(obj).append("</child>");
|
}
|
}
|
return xmlStr.append("</root>").toString();
|
|
}
|
|
/**
|
* 将高级条件数据转为xml
|
* @param childs 高级条件数据
|
* @return xml数据
|
*/
|
private String getSeniorChildXML(JSONObject childs){
|
|
StringBuilder xmlStr = new StringBuilder("<child>" + childs.get("connector"));
|
List<Object> childrens = (List<Object>) childs.get("child");
|
if(childrens == null){
|
return "";
|
}
|
Iterator<Object> child = childrens.iterator();
|
while (child.hasNext()) {
|
Object obj = child.next();
|
if(obj instanceof JSONObject && (((JSONObject) obj).get("connector").equals(AND)
|
|| ((JSONObject) obj).get("connector").equals(OR))){
|
xmlStr.append(getSeniorChildXML((JSONObject) obj));
|
}else{
|
xmlStr.append("<child>").append(obj).append("</child>");
|
}
|
}
|
return xmlStr.append("</child>").toString();
|
}
|
|
/**
|
* 组装查询模板
|
* @return
|
*/
|
public QueryTemplate getQT(QTInfoDTO qtInfoDTO) throws PLException {
|
QueryTemplate qt = new QueryTemplate();
|
qt.setType(QTConstants.TYPE_LINK);
|
//TODO String qtId =
|
qt.setLinkType(qtInfoDTO.getBtmName());
|
qt.setDirection(qtInfoDTO.getQueryTemplate().getDirection());
|
qt.setBtmType(qtInfoDTO.getQueryTemplate().getBtmType());
|
|
qt.setVersion(qtInfoDTO.getQueryTemplate().getVersion());
|
qt.setQueryISLeaf(qtInfoDTO.getQueryTemplate().isQueryISLeaf());
|
qt.setLevel(qtInfoDTO.getQueryTemplate().getLevel());
|
List<String> clauseList = new ArrayList<String>();
|
//TODO 查询列 显示列
|
clauseList.add("*");
|
qt.setClauseList(clauseList);
|
Condition con = new Condition();
|
qt.setCondition(con);
|
HashMap<String, ConditionItem> ciMap = getCIMap(qtInfoDTO);
|
con.setCIMap(ciMap);
|
con.setRootCIName(con.getRootCINameByCIMap(ciMap));
|
return qt;
|
}
|
|
/**
|
* 获取查询条件
|
* @return
|
*/
|
private HashMap<String, ConditionItem> getCIMap(QTInfoDTO qtInfoDTO) throws PLException {
|
HashMap<String, ConditionItem> ciMap = new HashMap<>();
|
//普通查询条件
|
if(qtInfoDTO.getLevelFlag() == 0){
|
/**
|
* 加入叶子节点
|
*/
|
for(int i = 0; i < qtInfoDTO.getCondition().size(); i++){
|
ConditionItem ci = new ConditionItem();
|
String id = "ci" + (i + 1);
|
ci.setId(id);
|
ci.setLeafFlag(true);
|
HashMap<String, String> condition = qtInfoDTO.getCondition().get(i);
|
String clause = condition.get("clause");
|
String operator = condition.get("operator");
|
String ordinaryValue = condition.get("ordinaryValue");
|
//add by zhangweiwei 2014/12/09 end 因增加选择查询模板按钮将每行组件数由4改成5
|
LeafInfo leafInfo = new LeafInfo();
|
if(clause.contains("T_OID.") || clause.contains("F_OID.")){
|
//去掉T_OID.或者F_OID.
|
String clause_ = clause.substring(6);
|
//属性为参照属性
|
if(clause_.contains(".")){
|
int fpIndex = clause_.indexOf(".");
|
String refAbName = clause.substring(0, fpIndex + 6);
|
clause = clause.substring(fpIndex + 6 + 1);
|
leafInfo.setClause(refAbName);
|
//去掉T_OID.或者F_OID.
|
refAbName = refAbName.substring(6);
|
leafInfo.setOperator(Operator.IN);
|
QueryTemplate qt = getRefQT(refAbName, clause, operator, ordinaryValue);
|
LeafValue lValue = new LeafValue();
|
lValue.setQueryTemplate(qt);
|
leafInfo.setValue(lValue);
|
//属性为非参照属性
|
}else{
|
leafInfo.setClause(clause);
|
leafInfo.setOperator(operator);
|
LeafValue lValue = new LeafValue();
|
leafInfo.setValue(lValue);
|
//add by zhangweiwei 2014/12/09 start
|
//如果嵌套Link
|
if(ordinaryValue.contains(";")){
|
leafInfo.setOperator(Operator.IN);
|
String[] values = ordinaryValue.split(";");
|
String QTname = values[0];
|
String attr = values[1].substring(0, values[1].length());
|
try {
|
QTInfo qt = platformClientUtil.getQTDService().getQT(QTname);
|
String qtText = qt.qtText;
|
QueryTemplate qt_ = OQTool.getQTByQTText(qt.qtName, qtText);
|
List<String> clauseList = new ArrayList<String>();
|
clauseList.add(attr);
|
qt_.setClauseList(clauseList);
|
lValue.setQueryTemplate(qt_);
|
//lValue.setAttr(attr);
|
} catch (PLException e) {
|
e.printStackTrace();
|
}
|
catch (DocumentException e1) {
|
e1.printStackTrace();
|
}
|
}else{
|
lValue.setOrdinaryValue(ordinaryValue);
|
}
|
//add by zhangweiwei 2014/12/09 end
|
}
|
}else{
|
//属性为参照属性
|
if(clause.contains(".")){
|
int fpIndex = clause.indexOf(".");
|
String refAbName = clause.substring(0, fpIndex);
|
clause = clause.substring(fpIndex + 1);
|
leafInfo.setClause(refAbName);
|
leafInfo.setOperator(Operator.IN);
|
QueryTemplate qt = getRefQT(refAbName, clause, operator, ordinaryValue);
|
LeafValue lValue = new LeafValue();
|
lValue.setQueryTemplate(qt);
|
leafInfo.setValue(lValue);
|
//属性为非参照属性
|
}else{
|
leafInfo.setClause(clause);
|
leafInfo.setOperator(operator);
|
LeafValue lValue = new LeafValue();
|
leafInfo.setValue(lValue);
|
//add by zhangweiwei 2014/12/09 start
|
//如果嵌套Link
|
if(ordinaryValue.contains(";")){
|
leafInfo.setOperator(Operator.IN);
|
String[] values = ordinaryValue.split(";");
|
String QTname = values[0];
|
String attr = values[1].substring(0, values[1].length());
|
try {
|
QTInfo qt = platformClientUtil.getQTDService().getQT(QTname);
|
String qtText = qt.qtText;
|
QueryTemplate qt_ = OQTool.getQTByQTText(qt.qtName, qtText);
|
List<String> clauseList = new ArrayList<String>();
|
clauseList.add(attr);
|
qt_.setClauseList(clauseList);
|
lValue.setQueryTemplate(qt_);
|
//lValue.setAttr(attr);
|
} catch (PLException e) {
|
e.printStackTrace();
|
} catch (DocumentException e1) {
|
e1.printStackTrace();
|
}
|
|
}else{
|
lValue.setOrdinaryValue(ordinaryValue);
|
}
|
//add by zhangweiwei 2014/12/09 end
|
}
|
}
|
|
ci.setLeafInfo(leafInfo);
|
ciMap.put(ci.getId(), ci);
|
}
|
|
Iterator<String> iterator = ciMap.keySet().iterator();
|
ArrayList<ConditionItem> ciList = new ArrayList<ConditionItem>();
|
String lCIId = null;
|
while(iterator.hasNext()){
|
lCIId = iterator.next();
|
break;
|
}
|
int count = ciMap.size();
|
while(iterator.hasNext()){
|
String rCIId = iterator.next();
|
ConditionItem pCI = new ConditionItem();
|
String pId = "ci" + ++count;
|
pCI.setId(pId);
|
pCI.setLeafFlag(false);
|
ChildrenInfo pChildrenInfo = new ChildrenInfo();
|
pChildrenInfo.setLeftCIName(lCIId);
|
pChildrenInfo.setConnector(Connector.AND);
|
pChildrenInfo.setRightCIName(rCIId);
|
pCI.setChildrenInfo(pChildrenInfo);
|
ciList.add(pCI);
|
lCIId = pId;
|
}
|
for(Iterator<ConditionItem> i = ciList.iterator(); i.hasNext();){
|
ConditionItem ci = i.next();
|
ciMap.put(ci.getId(), ci);
|
}
|
//高级查询条件
|
}else if(qtInfoDTO.getLevelFlag() == 1){
|
ciMap = getCIMapForSeniorTree(qtInfoDTO);
|
}
|
return ciMap;
|
}
|
|
/**
|
* 获取高级查询的查询条件集合
|
* @return
|
*/
|
private HashMap<String, ConditionItem> getCIMapForSeniorTree(QTInfoDTO qtInfoDTO) throws PLException {
|
HashMap<String, ConditionItem> ciMap = new HashMap<>();
|
HashMap<String, Object> tree = qtInfoDTO.getTree();
|
if (tree.isEmpty()) {
|
// 无查询条件的查询
|
return null;
|
}
|
ArrayList<ConditionItem> ciList = new ArrayList<ConditionItem>();
|
String connector = String.valueOf(tree.get("connector"));
|
List<Object> childrens = (List<Object>) tree.get("child");
|
Iterator<Object> children = childrens.iterator();
|
while (children.hasNext()) {
|
Object obj = children.next();
|
if(obj instanceof JSONObject && (((JSONObject) obj).get("connector").equals(AND)
|
|| ((JSONObject) obj).get("connector").equals(OR))){
|
List<ConditionItem> subCIList = getCIList((JSONObject) obj, ciList.size() + 1);
|
if(subCIList == null){
|
continue;
|
}
|
if(ciList.size() > 0){
|
ConditionItem leftCI = ciList.get(ciList.size() - 1);
|
ConditionItem rightCI = subCIList.get(subCIList.size() - 1);
|
ciList.addAll(subCIList);
|
ConditionItem pCI = new ConditionItem();
|
pCI.setId("ci" + (ciList.size() + 1));
|
ciList.add(pCI);
|
pCI.setLeafFlag(false);
|
ChildrenInfo cInfo = new ChildrenInfo();
|
pCI.setChildrenInfo(cInfo);
|
cInfo.setLeftCIName(leftCI.getId());
|
cInfo.setConnector(connector);
|
cInfo.setRightCIName(rightCI.getId());
|
}else{
|
ciList.addAll(subCIList);
|
}
|
}else{
|
String text = String.valueOf(obj);
|
if(text == null || text.equals("")){
|
continue;
|
}
|
if(!text.contains(Operator.EQUAL) && !text.contains(Operator.UNEQUAL) && !text.contains(Operator.CONTAINS)
|
&& !text.contains(Operator.IN) && !text.contains(Operator.NOTIN) &&!text.contains(Operator.GTE) && !text.contains(Operator.GT)
|
&& !text.contains(Operator.LTE) && !text.contains(Operator.LT)){
|
continue;
|
}
|
if(ciList.size() > 0){
|
ConditionItem leftCI = ciList.get(ciList.size() - 1);
|
ConditionItem rightCI = getCIByNode(text, ciList.size() + 1);
|
ciList.add(rightCI);
|
ConditionItem pCI = new ConditionItem();
|
pCI.setId("ci" + (ciList.size() + 1));
|
ciList.add(pCI);
|
pCI.setLeafFlag(false);
|
ChildrenInfo cInfo = new ChildrenInfo();
|
pCI.setChildrenInfo(cInfo);
|
cInfo.setLeftCIName(leftCI.getId());
|
cInfo.setConnector(connector);
|
cInfo.setRightCIName(rightCI.getId());
|
}else{
|
ConditionItem ci = getCIByNode(text, ciList.size() + 1);
|
ciList.add(ci);
|
}
|
}
|
}
|
|
for(int i = 0; i < ciList.size(); i++){
|
ConditionItem ci = ciList.get(i);
|
ciMap.put(ci.getId(), ci);
|
}
|
return ciMap;
|
}
|
/**
|
* 树化一个查询条件组节点
|
* @param children
|
* @param beginId
|
* @return
|
*/
|
private List<ConditionItem> getCIList(JSONObject children, int beginId) throws PLException {
|
List<ConditionItem> ciList = new ArrayList<>();
|
String connector = String.valueOf(children.get("connector"));
|
List<Object> childrens = (List<Object>) children.get("child");
|
if(childrens == null){
|
return null;
|
}
|
Iterator<Object> child = childrens.iterator();
|
while (child.hasNext()) {
|
Object obj = child.next();
|
if(obj instanceof JSONObject && (((JSONObject) obj).get("connector").equals(AND)
|
|| ((JSONObject) obj).get("connector").equals(OR))){
|
List<ConditionItem> subCIList = getCIList((JSONObject) obj, beginId);
|
if(ciList.size() > 0){
|
ConditionItem leftCI = ciList.get(ciList.size() - 1);
|
ConditionItem rightCI = subCIList.get(subCIList.size() - 1);
|
ciList.addAll(subCIList);
|
beginId = beginId + subCIList.size();
|
ConditionItem pCI = new ConditionItem();
|
pCI.setId("ci" + beginId);
|
ciList.add(pCI);
|
beginId = beginId + 1;
|
pCI.setLeafFlag(false);
|
ChildrenInfo cInfo = new ChildrenInfo();
|
pCI.setChildrenInfo(cInfo);
|
cInfo.setLeftCIName(leftCI.getId());
|
cInfo.setConnector(connector);
|
cInfo.setRightCIName(rightCI.getId());
|
}else{
|
ciList.addAll(subCIList);
|
beginId = beginId + subCIList.size();
|
}
|
}else{
|
String text = String.valueOf(obj);
|
if(text == null || text.equals("")){
|
continue;
|
}
|
if(!text.contains(Operator.EQUAL) && !text.contains(Operator.UNEQUAL) && !text.contains(Operator.CONTAINS)
|
&& !text.contains(Operator.IN) && !text.contains(Operator.NOTIN) &&!text.contains(Operator.GTE) && !text.contains(Operator.GT)
|
&& !text.contains(Operator.LTE) && !text.contains(Operator.LT)){
|
continue;
|
}
|
if(ciList.size() > 0){
|
ConditionItem leftCI = ciList.get(ciList.size() - 1);
|
ConditionItem rightCI = getCIByNode(text, beginId);
|
ciList.add(rightCI);
|
beginId = beginId + 1;
|
ConditionItem pCI = new ConditionItem();
|
pCI.setId("ci" + beginId);
|
ciList.add(pCI);
|
beginId = beginId + 1;
|
pCI.setLeafFlag(false);
|
ChildrenInfo cInfo = new ChildrenInfo();
|
pCI.setChildrenInfo(cInfo);
|
cInfo.setLeftCIName(leftCI.getId());
|
cInfo.setConnector(connector);
|
cInfo.setRightCIName(rightCI.getId());
|
}else{
|
ConditionItem ci = getCIByNode(text, beginId);
|
ciList.add(ci);
|
beginId = beginId + 1;
|
}
|
}
|
}
|
return ciList;
|
}
|
/**
|
* 高级查询
|
* 把Node内容解析成ConditionItem
|
* @param text
|
* @param id
|
* @return
|
*/
|
private ConditionItem getCIByNode(String text, int id) throws PLException {
|
ConditionItem ci = new ConditionItem();
|
ci.setId("ci" + id);
|
ci.setLeafFlag(true);
|
LeafInfo leafInfo = new LeafInfo();
|
ci.setLeafInfo(leafInfo);
|
String operator = null;
|
if(text.contains(Operator.EQUAL)){
|
operator = Operator.EQUAL;
|
}else if(text.contains(Operator.CONTAINS)){
|
operator = Operator.CONTAINS;
|
}else if(text.contains(Operator.UNEQUAL)){
|
operator = Operator.UNEQUAL;
|
}else if(text.contains(Operator.IN)){
|
operator = Operator.IN;
|
}else if(text.contains(Operator.NOTIN)){
|
operator = Operator.NOTIN;
|
}else if(text.contains(Operator.GTE)){
|
operator = Operator.GTE;
|
}else if(text.contains(Operator.GT)){
|
operator = Operator.GT;
|
}else if(text.contains(Operator.LTE)){
|
operator = Operator.LTE;
|
}else if(text.contains(Operator.LT)){
|
operator = Operator.LT;
|
}
|
int operatorIndex = text.indexOf(operator);
|
String clause = text.substring(0, operatorIndex).trim();
|
String ordinaryValue = text.substring(operatorIndex + 2).trim();
|
if(clause.contains("T_OID.") || clause.contains("F_OID.")){
|
//去掉T_OID.或者F_OID.
|
String clause_ = clause.substring(6);
|
//属性为参照属性
|
if(clause_.contains(".")){
|
int fpIndex = clause_.indexOf(".");
|
String refAbName = clause.substring(0, fpIndex + 6);
|
clause = clause.substring(fpIndex + 6 + 1);
|
leafInfo.setClause(refAbName);
|
//去掉T_OID.或者F_OID.
|
refAbName = refAbName.substring(6);
|
leafInfo.setOperator(Operator.IN);
|
QueryTemplate qt = getRefQT(refAbName, clause, operator, ordinaryValue);
|
LeafValue lValue = new LeafValue();
|
lValue.setQueryTemplate(qt);
|
leafInfo.setValue(lValue);
|
//属性为非参照属性
|
}else{
|
leafInfo.setClause(clause);
|
leafInfo.setOperator(operator);
|
LeafValue lValue = new LeafValue();
|
leafInfo.setValue(lValue);
|
lValue.setOrdinaryValue(ordinaryValue);
|
}
|
}else{
|
//属性为参照属性
|
if(clause.contains(".")){
|
int fpIndex = clause.indexOf(".");
|
String refAbName = clause.substring(0, fpIndex);
|
clause = clause.substring(fpIndex + 1);
|
leafInfo.setClause(refAbName);
|
leafInfo.setOperator(Operator.IN);
|
QueryTemplate qt = getRefQT(refAbName, clause, operator, ordinaryValue);
|
LeafValue lValue = new LeafValue();
|
lValue.setQueryTemplate(qt);
|
leafInfo.setValue(lValue);
|
//属性为非参照属性
|
}else{
|
leafInfo.setClause(clause);
|
leafInfo.setOperator(operator);
|
LeafValue lValue = new LeafValue();
|
leafInfo.setValue(lValue);
|
lValue.setOrdinaryValue(ordinaryValue);
|
}
|
}
|
|
return ci;
|
}
|
|
|
|
/**
|
* 获取参照的查询模板
|
* @param refAbName: 参照属性名
|
* @param clause: 属性参照的业务类型中的属性
|
* @param operator
|
* @param ordinaryValue
|
* @return
|
*/
|
private QueryTemplate getRefQT(String refAbName, String clause,
|
String operator, String ordinaryValue) throws PLException {
|
QueryTemplate qt = new QueryTemplate();
|
List<String> clauseList = new ArrayList<String>();
|
clauseList.add("OID");
|
qt.setClauseList(clauseList);
|
AttributeDef refAb = platformClientUtil.getAttributeService().getAttributeDefByName(refAbName);
|
OtherInfo otherInfo = OtherInfo.getOtherInfoByText(refAb.other);
|
int refFlag = otherInfo.getRefFlag();
|
String type = otherInfo.getRefTypeName();
|
if(refFlag == 0){
|
qt.setType(QTConstants.TYPE_BTM);
|
qt.setBtmType(type);
|
}else if(refFlag == 1){
|
qt.setType(QTConstants.TYPE_LINK);
|
qt.setLinkType(type);
|
}
|
Condition condition = new Condition();
|
qt.setCondition(condition);
|
condition.setRootCIName("ci1");
|
HashMap<String, ConditionItem> ciMap = new HashMap<String, ConditionItem>();
|
condition.setCIMap(ciMap);
|
ConditionItem ci = new ConditionItem();
|
ci.setId("ci1");
|
ciMap.put(ci.getId(), ci);
|
ci.setLeafFlag(true);
|
LeafInfo leafInfo = new LeafInfo();
|
if(clause.contains(".")){
|
int fpIndex = clause.indexOf(".");
|
String refAbName_ = clause.substring(0, fpIndex);
|
clause = clause.substring(fpIndex + 1);
|
leafInfo.setClause(refAbName_);
|
leafInfo.setOperator(Operator.IN);
|
QueryTemplate qt_ = getRefQT(refAbName_, clause, operator, ordinaryValue);
|
LeafValue lValue = new LeafValue();
|
lValue.setQueryTemplate(qt_);
|
leafInfo.setValue(lValue);
|
qt.setId("qt_" + refAbName + "_" + refAbName_);
|
}else{
|
leafInfo.setClause(clause);
|
leafInfo.setOperator(operator);
|
LeafValue lValue = new LeafValue();
|
lValue.setOrdinaryValue(ordinaryValue);
|
leafInfo.setValue(lValue);
|
qt.setId("qt_" + refAbName + "_" + clause);
|
}
|
ci.setLeafInfo(leafInfo);
|
condition.setCIMap(ciMap);
|
return qt;
|
}
|
|
// /**
|
// * 组装查询模板
|
// * @return
|
// */
|
// public QueryTemplate getQT(HashMap<String,Object> dataMap){
|
// QueryTemplate qt = new QueryTemplate();
|
// qt.setType(QTConstants.TYPE_LINK);
|
// //TODO String qtId =
|
// qt.setLinkType((String) dataMap.get("linkTypeName"));
|
// qt.setDirection( (Boolean)dataMap.get("rdPositive") ? QTConstants.DIRECTION_POSITIVE : QTConstants.DIRECTION_OPPOSITE);
|
// qt.setBtmType((String) dataMap.get("btmName"));
|
// if("所有类型".equals(dataMap.get("combRelaType"))){
|
// qt.setBtmType("*");
|
// }
|
// qt.setVersion(getVersion((String) dataMap.get("versionValue")));
|
// qt.setQueryISLeaf((Boolean) dataMap.get("isQueryIsLeaf"));
|
// qt.setLevel(StringUtils.isBlank((CharSequence) dataMap.get("level")) ? 1 : Integer.valueOf(String.valueOf(dataMap.get("level"))));
|
// List<String> clauseList = new ArrayList<String>();
|
// //TODO 查询列 显示列
|
// clauseList.add("*");
|
// qt.setClauseList(clauseList);
|
// Condition con = new Condition();
|
// qt.setCondition(con);
|
// HashMap<String, ConditionItem> ciMap = getCIMap();
|
// con.setCIMap(ciMap);
|
// con.setRootCIName(con.getRootCINameByCIMap(ciMap));
|
// return qt;
|
// }
|
|
|
/**
|
* 返回查询的版本
|
* @return
|
*/
|
public int getVersion(String versionValue){
|
int version = 0;
|
if(versionValue.equals("当前版本当前版次")){
|
version = 1;
|
}else if(versionValue.equals("当前版本最新版次")){
|
version = 2;
|
}else if(versionValue.equals("最新版本最新版次")){
|
version = 3;
|
}else if(versionValue.equals("当前版次")){
|
version = 4;
|
}else if(versionValue.equals("当前版本")){
|
version = 5;
|
}else if(versionValue.equals("当前命名对象")){
|
version = 6;
|
}else if(versionValue.equals("已发布的最新版本")){
|
version = 7;
|
}
|
return version;
|
}
|
|
|
/**
|
* 校验参数
|
* @param qtd
|
* @return
|
*/
|
private void checkName(QTD qtd) throws PLException {
|
if (qtd.name.equals("")) {
|
throw new PLException("500", new String[]{"请输入模板定义名"});
|
}
|
if (!qtd.name.matches("[a-z A-Z]*")) {
|
throw new PLException("500", new String[]{"模板定义名只能为英文字母"});
|
}
|
if (platformClientUtil.getQTDService().isExistsQTD(qtd.name.toLowerCase())) {
|
throw new PLException("500", new String[]{"该模板定义名已经被使用, 请更换"});
|
}
|
}
|
|
|
/**
|
* 导出链接类型查询模板
|
* names 查询模板名
|
* @return
|
*/
|
@Override
|
public void expLinkTemplate(List<String> names, HttpServletResponse response) throws PLException, IOException {
|
String defaultTempFolder = LocalFileUtil.getDefaultTempFolder();
|
String vciqtmfFileName = defaultTempFolder + File.separator + "LinkTemplateExp" + new Date().getTime() + ".vciqtf";
|
LinkQTExportData exportData = new LinkQTExportData();
|
for (String name : names) {
|
QTInfo qt = platformClientUtil.getQTDService().getQT(name);
|
exportData.getAllQTs().put(qt.qtName,qt);
|
LinkType linkType = platformClientUtil.getLinkTypeService().getLinkType(qt.btmName);
|
if(linkType != null && !linkType.oid.equals("")){
|
exportData.getSelectedBtmItems().put(linkType.name, linkType);
|
exportData.getSelectedBtmAttrs().put(linkType.name, linkType.attributes);
|
exportData.getAllQTDs().put(linkType.name, platformClientUtil.getQTDService().getLinkTypeQTDs(linkType.name));
|
}
|
}
|
ObjectOutputStream vciamfFileStream = null;
|
try {
|
File vciqtmfFile = new File(vciqtmfFileName);
|
vciamfFileStream = new ObjectOutputStream(new FileOutputStream(vciqtmfFile));
|
vciamfFileStream.writeObject(exportData);
|
}finally {
|
try {
|
if (vciamfFileStream != null) {
|
vciamfFileStream.flush();
|
vciamfFileStream.close();
|
}
|
} catch (Exception e) {
|
throw new PLException("500",new String[]{"导出流关闭异常！"});
|
}
|
}
|
ControllerUtil.writeFileToResponse(response,vciqtmfFileName);
|
FileUtil.del(defaultTempFolder + File.separator);
|
}
|
/**
|
* 导入链接类型查询模板
|
* @param file 上传的文件
|
* @return 导入结果
|
*/
|
@Override
|
public BaseResult impLinkTemplate(MultipartFile file) throws IOException, ClassNotFoundException {
|
|
if (file == null) {
|
return BaseResult.fail(FrameWorkLangCodeConstant.IMPORT_FAIL, new String[]{"无导入的文件"});
|
}
|
if (!file.getOriginalFilename().endsWith(".vciqtf")) {
|
throw new VciBaseException("仅能上传.vciqtf格式文件，请重新上传！");
|
}
|
ObjectInputStream obj = new ObjectInputStream(
|
file.getInputStream());
|
LinkQTExportData qtExportData = (LinkQTExportData) obj.readObject();
|
List<LinkType> ltsNew = new ArrayList<>();
|
List<QTInfo> qTWrapperNew = new ArrayList<>();
|
Map<String/* 类型名称 */, QTD[]/* 查询模板定义 */> norepQTDs = new HashMap<String, QTD[]>();
|
addImportData(qtExportData, ltsNew, qTWrapperNew, norepQTDs);
|
QTInfo[] qts = qTWrapperNew
|
.toArray(new QTInfo[qTWrapperNew.size()]);
|
//处理树的返回
|
HashMap<String,Object> tree = new HashMap();
|
tree.put("text","链接类型");
|
List<HashMap<String,Object>> childList = new ArrayList<>();
|
//添加业务类型根节点
|
for (LinkType plAction : ltsNew) {
|
HashMap<String,Object> childTree = new HashMap();
|
childTree.put("text", plAction.tag + "/" +plAction.name);
|
childTree.put("oid", plAction.oid);
|
addExportTreeNode(plAction, qts, childTree);
|
childList.add(childTree);
|
}
|
tree.put("children", childList);
|
return BaseResult.success(tree);
|
}
|
|
// 数据过滤
|
private void addImportData(LinkQTExportData qtExportData, List<LinkType> ltsNew, List<QTInfo> qTWrapperNew,
|
Map<String/* 类型名称 */, QTD[]/* 查询模板定义 */> norepQTDs) {
|
Map<String/* 类型名称 */, QTD[]/* 查询模板定义 */> allQTDs = qtExportData
|
.getAllQTDs();
|
Map<String/* 类型名称 */, LinkType/* 类型对象 */> selectedBtmItems = qtExportData
|
.getSelectedBtmItems();
|
Map<String/* 类型名称 */, String[]/* 类型所属属性 */> selectedBtmAttrs = qtExportData
|
.getSelectedBtmAttrs();
|
Map<String/* 查询模板名称 */, QTInfo/* 查询模板对象 */> allSelectedQTs = qtExportData
|
.getAllQTs();
|
if (allQTDs.size() == 0 || allQTDs == null
|
|| selectedBtmItems.size() == 0 || selectedBtmItems == null
|
|| selectedBtmAttrs.size() == 0 || selectedBtmAttrs == null
|
|| allSelectedQTs.size() == 0 || allSelectedQTs == null) {
|
throw new VciBaseException("导入的模板数据有误!!!");
|
}
|
Set<Map.Entry<String, QTD[]>> pLActions = allQTDs.entrySet();
|
Set<Map.Entry<String, QTInfo>> pLQts = allSelectedQTs.entrySet();
|
Set<Map.Entry<String, LinkType>> LinkpLQts = selectedBtmItems.entrySet();
|
for (Map.Entry<String, QTD[]> entry : pLActions) {
|
String string = entry.getKey();
|
QTD[] qtds = entry.getValue();
|
getPLQtIsInDB(string, qtds, norepQTDs);
|
}
|
for (Map.Entry<String, LinkType> entry : LinkpLQts) {
|
String string = entry.getKey();
|
LinkType LinkType = entry.getValue();
|
getPLQtBtmItem(string, LinkType, ltsNew);
|
}
|
Map<String/*类型名称*/, QTD[]/*查询模板定义*/> newNorepQTDs = getnewNorepQTDs(norepQTDs,allSelectedQTs);
|
for (Map.Entry<String, QTInfo> entry : pLQts) {
|
String string = entry.getKey();
|
QTInfo qtWrapper = entry.getValue();
|
getPLQtWrapper(string, qtWrapper, ltsNew, qTWrapperNew, newNorepQTDs);
|
}
|
|
}
|
|
/**
|
* 查询模板定义的处理
|
* @param string
|
* @param qtds
|
*/
|
private void getPLQtIsInDB(String string, QTD[] qtds, Map<String/* 类型名称 */, QTD[]/* 查询模板定义 */> norepQTDs) {
|
// TODO Auto-generated method stub
|
try {
|
QTD[] qtds2 = platformClientUtil.getQTDService().getBizTypeQTDs(string);
|
QTD[] qtdsNewQtds = null;
|
List<QTD> es = new ArrayList<>();
|
for (QTD qtd : qtds) {
|
boolean isleat = true;
|
for (int i = 0; i < qtds2.length; i++) {
|
if (qtd.name.equals(qtds2[i].name)) {
|
isleat = false;
|
break;
|
}
|
}
|
if (isleat) {
|
es.add(qtd);
|
}
|
}
|
if (es.size() != 0) {
|
qtdsNewQtds = es.toArray(new QTD[es.size()]);
|
norepQTDs.put(string, qtdsNewQtds);
|
}
|
} catch (PLException e) {
|
// TODO Auto-generated catch block
|
e.printStackTrace();
|
}
|
}
|
|
private void getPLQtBtmItem(String string, LinkType linkType, List<LinkType> ltsNew) {
|
// TODO Auto-generated method stub
|
try {
|
LinkType queryLinkType = platformClientUtil.getLinkTypeService().getLinkType(string);
|
LinkType[] btmArray = platformClientUtil.getLinkTypeService().getLinkTypes();
|
String[] strings = queryLinkType.attributes;
|
String[] stringsFrom = queryLinkType.btmItemsFrom;
|
String[] stringsTo = queryLinkType.btmItemsTo;
|
boolean b = true;
|
for (int i = 0; i < btmArray.length; i++) {
|
if (btmArray[i].name.equals(string)) {
|
b = false;
|
if (Arrays.equals(linkType.attributes, strings)
|
&& Arrays
|
.equals(linkType.btmItemsFrom, stringsFrom)
|
&& Arrays.equals(linkType.btmItemsTo, stringsTo)) {
|
btmArray[i].name += "【链接类型已存在】";
|
/* this.btmArray[i] = btmArray[i]; */
|
ltsNew.add(btmArray[i]);
|
} else {
|
btmArray[i].name += "【链接类型存在但属性不一致】";
|
ltsNew.add(btmArray[i]);
|
}
|
}
|
}
|
if (b) {
|
linkType.name += "【链接类型不存在】";
|
ltsNew.add(linkType);
|
}
|
} catch (PLException e) {
|
// TODO Auto-generated catch block
|
e.printStackTrace();
|
}
|
}
|
|
private void getPLQtWrapper(String string, QTInfo qtWrapper, List<LinkType> ltsNew, List<QTInfo> qTWrapperNew, Map<String/*类型名称*/, QTD[]/*查询模板定义*/> newNorepQTDs) {
|
try {
|
QTInfo[] qtws = platformClientUtil.getQTDService().getAllQTs();
|
boolean islaet = true;
|
for (int i = 0; i < qtws.length; i++) {
|
if (string.equals(qtws[i].qtName)) {
|
islaet = false;
|
for (LinkType lt : ltsNew) {
|
if (qtWrapper.btmName.equals(lt.name.substring(0,
|
lt.name.indexOf("【")))) {
|
if (lt.name.endsWith("【链接类型已存在】")) {
|
qtWrapper.qtName += "【查询模板已存在，不导入】";
|
qTWrapperNew.add(qtWrapper);
|
}else if(lt.name.endsWith("【链接类型存在但属性不一致】")){
|
qtWrapper.qtName += "【查询模板所属链接类型属性不一致，不导入】";
|
qTWrapperNew.add(qtWrapper);
|
}else{
|
qtWrapper.qtName += "【查询模板所属链接类型不存在，不导入】";
|
qTWrapperNew.add(qtWrapper);
|
}
|
}
|
}
|
}
|
}
|
if (islaet) {
|
for (LinkType btmItem : ltsNew) {
|
if (qtWrapper.btmName.equals(btmItem.name.substring(0,
|
btmItem.name.indexOf("【")))) {
|
if (btmItem.name.endsWith("【链接类型已存在】")) {
|
//判断查询模板定义是否存在，进行保存
|
QTD[] qtds = newNorepQTDs.get(qtWrapper.btmName);
|
if(qtds != null){
|
for (QTD qtd : qtds) {
|
QTD qtdByName = platformClientUtil.getQTDService().getQTDByName(qtd.name);
|
if(!(qtdByName != null && StringUtils.isNotBlank(qtdByName.name))){
|
boolean b = platformClientUtil.getQTDService().addQTD(qtd);
|
if(!b){
|
qtWrapper.qtName += qtWrapper.qtName+"导入查询模板定义【" + qtdByName.name + "】失败！";
|
}
|
}
|
}
|
newNorepQTDs.remove(qtWrapper.btmName);
|
}
|
boolean success = platformClientUtil.getQTDService().saveQT(qtWrapper);
|
if(!success){
|
qtWrapper.qtName += qtWrapper.qtName+"导入失败！";
|
}else {
|
qtWrapper.qtName += "【查询模板导入成功！】";
|
}
|
qTWrapperNew.add(qtWrapper);
|
}else if(btmItem.name.endsWith("【链接类型存在但属性不一致】")){
|
qtWrapper.qtName += "【查询模板所属链接类型属性不一致，不导入】";
|
qTWrapperNew.add(qtWrapper);
|
}else{
|
qtWrapper.qtName += "【查询模板所属链接类型不存在，不导入】";
|
qTWrapperNew.add(qtWrapper);
|
}
|
}
|
}
|
}
|
} catch (PLException e) {
|
e.printStackTrace();
|
}
|
}
|
|
//根据选择的查询模板过滤模板定义
|
private Map<String, QTD[]> getnewNorepQTDs(Map<String, QTD[]> norepQTDs,
|
Map<String, QTInfo> allQTs) {
|
// TODO Auto-generated method stub
|
Map<String, QTD[]> map = new HashMap<String, QTD[]>();
|
Set<Map.Entry<String, QTInfo>> pLQts = allQTs.entrySet();
|
Set<Map.Entry<String, QTD[]>> pLActions = norepQTDs.entrySet();
|
for (Map.Entry<String, QTD[]> entrys : pLActions) {
|
for (Map.Entry<String, QTInfo> entry : pLQts) {
|
if(entry.getValue().btmName.equals(entrys.getKey())){
|
map.put(entrys.getKey(), entrys.getValue());
|
}
|
}
|
}
|
return map;
|
}
|
/**
|
* 查询方案删除
|
* @param templateNames 查询方案名
|
* @return 操作结果
|
*/
|
@Override
|
public BaseResult deleteLinkTemplate(List<String> templateNames) throws PLException {
|
boolean b = platformClientUtil.getQTDService().deleteQTs(templateNames.toArray(new String[0]));
|
if(!b){
|
return BaseResult.fail("删除失败！！！");
|
}
|
return BaseResult.success();
|
}
|
}
|
