package com.vci.client.common.oq;
|
|
import java.text.DateFormat;
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Enumeration;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
|
import javax.swing.JTree;
|
import javax.swing.tree.DefaultMutableTreeNode;
|
|
import org.dom4j.Document;
|
import org.dom4j.DocumentException;
|
import org.dom4j.DocumentHelper;
|
import org.dom4j.Element;
|
|
import com.vci.corba.query.data.KV;
|
import com.vci.omd.dataType.VTDataType;
|
import com.vci.omd.objects.OtherInfo;
|
import com.vci.client.common.providers.ServiceProvider;
|
import com.vci.common.qt.object.ChildrenInfo;
|
import com.vci.common.qt.object.Condition;
|
import com.vci.common.qt.object.ConditionItem;
|
import com.vci.common.qt.object.Connector;
|
import com.vci.common.qt.object.LeafInfo;
|
import com.vci.common.qt.object.LeafValue;
|
import com.vci.common.qt.object.Operator;
|
import com.vci.common.qt.object.OrderInfo;
|
import com.vci.common.qt.object.PageInfo;
|
import com.vci.common.qt.object.QTConstants;
|
import com.vci.common.qt.object.QueryTemplate;
|
import com.vci.corba.common.VCIError;
|
import com.vci.corba.omd.atm.AttribItem;
|
|
|
public class OQTool {
|
|
public static final DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
|
/**
|
* 在根节点上循环增加qtNode
|
* @param doc
|
* @return
|
*/
|
public static Element addDoc(Element rootNode , QueryTemplate qt){
|
Element qtNode = rootNode.addElement(QTConstants.QUERYTEMPLATE);
|
qtNode.addAttribute(QTConstants.ID, qt.getId());
|
qtNode.addAttribute(QTConstants.TYPE, qt.getType());
|
//设置clauseList
|
List<String> clauseList = qt.getClauseList();
|
String claValue = QTConstants.BLANK;
|
for(int i = 0; i < clauseList.size(); i++){
|
claValue += clauseList.get(i);
|
if(i < clauseList.size() - 1){
|
claValue += ",";
|
}
|
}
|
Element claListNode = qtNode.addElement(QTConstants.CLAUSELIST);
|
claListNode.setText(claValue);
|
|
//设置查询的linkType
|
String linkType = qt.getLinkType();
|
Element ltNode = qtNode.addElement(QTConstants.LINKTYPE);
|
if(linkType != null){
|
ltNode.setText(linkType);
|
}
|
//设置查询的btmType
|
String btmType = qt.getBtmType();
|
Element btmNode = qtNode.addElement(QTConstants.BTMTYPE);
|
if(btmType != null){
|
btmNode.setText(btmType);
|
}
|
//查询业务对象时，是否查询子类型
|
if(qt.getType().equals(QTConstants.TYPE_BTM)){
|
boolean queryChildrenFlag = qt.isQueryChildren();
|
Element queryChildrenFlagNode = qtNode.addElement(QTConstants.QUERYCHILDRENFLAG);
|
queryChildrenFlagNode.setText(String.valueOf(queryChildrenFlag));
|
}
|
//是否查询是否包含下一级(链接查询)
|
boolean isQueryIsLeaf = qt.isQueryISLeaf();
|
Element queryIsLeafNode = qtNode.addElement(QTConstants.QUERYISLEAF);
|
queryIsLeafNode.setText(String.valueOf(isQueryIsLeaf));
|
//查询时是否加入权限，默认加权限
|
boolean rightFlag = qt.isRightFlag();
|
Element rightFlagNode = qtNode.addElement(QTConstants.RIGHTFlag);
|
rightFlagNode.setText(String.valueOf(rightFlag));
|
|
//weidy@2018-06-19 增加密级控制
|
boolean secretFlag = qt.isSecretFlag();
|
Element secretFlagNode = qtNode.addElement(QTConstants.SECRETFLAG);
|
secretFlagNode.setText(String.valueOf(secretFlag));//end weidy
|
//设置版本版次信息
|
int version = qt.getVersion();
|
Element versionNode = qtNode.addElement(QTConstants.VERSION);
|
versionNode.setText(String.valueOf(version));
|
//设置链接查询的递归层次
|
int levelRec = qt.getLevel();
|
Element levelRecNode = qtNode.addElement(QTConstants.LEVELREC);
|
levelRecNode.setText(String.valueOf(levelRec));
|
//递归返回数据模式
|
int recReturnMode = qt.getRecReturnMode();
|
Element recReturnModeNode = qtNode.addElement(QTConstants.RECRETURNMODE);
|
recReturnModeNode.setText(String.valueOf(recReturnMode));
|
|
if(qt.getType().equals(QTConstants.TYPE_LINK)){
|
//设置链接查询方向
|
String direction = qt.getDirection();
|
Element directionNode = qtNode.addElement(QTConstants.DIRECTION);
|
directionNode.setText(direction);
|
}
|
//设置PageInfo
|
PageInfo pageInfo = qt.getPageInfo();
|
if(pageInfo != null){
|
Element pageInfoNode = qtNode.addElement(QTConstants.PAGEINFO);
|
Element pageNONode = pageInfoNode.addElement(QTConstants.PAGENO);
|
int pageNO = pageInfo.getPageNO();
|
pageNONode.setText(String.valueOf(pageNO));
|
Element rowCountNode = pageInfoNode.addElement(QTConstants.ROWCOUNT);
|
int rowCount = pageInfo.getRowCount();
|
rowCountNode.setText(String.valueOf(rowCount));
|
}
|
//设置ORDER BY
|
List<OrderInfo> orderInfoList = qt.getOrderInfoList();
|
if(orderInfoList != null && orderInfoList.size() > 0){
|
Element orderInfosNode = qtNode.addElement(QTConstants.ORDERINFOS);
|
for(int i = 0; i < orderInfoList.size(); i++){
|
OrderInfo o = orderInfoList.get(i);
|
if(o == null){
|
continue;
|
}
|
Element orderInfoNode = orderInfosNode.addElement(QTConstants.ORDERINFO);
|
String orderField = o.getOrderField();
|
Element orderFieldNode = orderInfoNode.addElement(QTConstants.ORDERFIELD);
|
orderFieldNode.setText(orderField == null ? QTConstants.BLANK : orderField);
|
String orderMode = o.getOrderMode();
|
Element orderModeNode = orderInfoNode.addElement(QTConstants.ORDERMODE);
|
orderModeNode.setText(orderMode == null ? QTConstants.BLANK : orderMode);
|
int level = o.getLevel();
|
Element levelNode = orderInfoNode.addElement(QTConstants.LEVEL);
|
levelNode.setText(String.valueOf(level));
|
}
|
}
|
//设置Condition
|
Condition condition = qt.getCondition();
|
if(condition != null){
|
Element conditionNode = qtNode.addElement(QTConstants.CONDITION);
|
conditionNode.addAttribute(QTConstants.ROOTCINAME, condition.getRootCIName());
|
Map<String, ConditionItem> ciMap = condition.getCIMap();
|
if(ciMap != null){
|
for(Iterator<String> i = ciMap.keySet().iterator(); i.hasNext();){
|
String ciId = i.next();
|
//设置conditionItem
|
ConditionItem cItem = ciMap.get(ciId);
|
Element cItemNode = conditionNode.addElement(QTConstants.CONDITIONITEM);
|
cItemNode.addAttribute(QTConstants.ID, cItem.getId());
|
//设置是否是叶子节点
|
boolean isLeaf = cItem.isLeaf();
|
Element leafFlagNode = cItemNode.addElement(QTConstants.LEAFFLAG);
|
leafFlagNode.setText(String.valueOf(cItem.isLeaf()));
|
//设置conditionItem的leafData
|
if(isLeaf){
|
LeafInfo leafInfo = cItem.getLeafInfo();
|
Element leafInfoNode = cItemNode.addElement(QTConstants.LEAFINFO);
|
Element clauseNode = leafInfoNode.addElement(QTConstants.CLAUSE);
|
clauseNode.setText(leafInfo.getClause());
|
Element operatorNode = leafInfoNode.addElement(QTConstants.OPERATOR);
|
String operator = leafInfo.getOperator();
|
/**
|
* 因<, <= 在xml中不能正确存储, 故将查询模板的<, <=存为LT, LTE;
|
* 从xml读取operator为LT, LTE时, 再转换成查询模板的<, <=.
|
* 将>, >= 做相同处理.
|
*/
|
if(operator.equals(Operator.LT)){
|
operator = Operator.LTTEXT;
|
}else if(operator.equals(Operator.LTE)){
|
operator = Operator.LTETEXT;
|
}else if(operator.equals(Operator.GT)){
|
operator = Operator.GTTEXT;
|
}else if(operator.equals(Operator.GTE)){
|
operator = Operator.GTETEXT;
|
}
|
operatorNode.setText(operator);
|
//设置conditionItem的leafData的LDValue
|
LeafValue lDValue = leafInfo.getValue();
|
Element valueNode = leafInfoNode.addElement(QTConstants.VALUE);
|
Element ordinaryValueNode = valueNode.addElement(QTConstants.ORDINARYVALUE);
|
String ordinaryValue = lDValue.getOrdinaryValue();
|
if(ordinaryValue != null){
|
ordinaryValueNode.setText(ordinaryValue);
|
}
|
Element queryTemplateNode = valueNode.addElement(QTConstants.REFQT);
|
QueryTemplate refQt = lDValue.getQueryTemplate();
|
if(refQt != null){
|
addDoc(rootNode, refQt);
|
queryTemplateNode.setText(lDValue.getQueryTemplate().getId());
|
}
|
}else{
|
//设置conditionItem的childrenData
|
Element childrenInfoNode = cItemNode.addElement(QTConstants.CHILDRENINFO);
|
ChildrenInfo cdInfo = cItem.getChildrenInfo();
|
Element leftNode = childrenInfoNode.addElement(QTConstants.LEFT);
|
leftNode.setText(cdInfo.getLeftCIName());
|
Element rightNode = childrenInfoNode.addElement(QTConstants.RIGHT);
|
rightNode.setText(cdInfo.getRightCIName());
|
Element conncectorNode = childrenInfoNode.addElement(QTConstants.CONNECTOR);
|
conncectorNode.setText(cdInfo.getConnector());
|
}
|
}
|
}
|
|
}
|
|
return rootNode;
|
}
|
|
/**
|
* 将查询模板结构转化成查询模板text
|
* @param qt
|
* @return
|
*/
|
public static String getQTTextByQT(QueryTemplate qt){
|
return qtTOXMl(qt).asXML();
|
}
|
|
/**
|
* 将查询模板, 以及其关联的查询模板
|
* @param qt
|
* @return
|
*/
|
public static Document qtTOXMl(QueryTemplate qt){
|
Document document = DocumentHelper.createDocument();
|
Element rootNode = document.addElement(QTConstants.DATA);
|
addDoc(rootNode, qt);
|
return document;
|
}
|
|
// public static void writeXml(Document document, String xmlPath_){
|
// try {
|
// Writer fileWriter = new FileWriter(xmlPath_);
|
// OutputFormat format = OutputFormat.createCompactFormat();
|
// format.setEncoding("utf-8");
|
// format.setIndent(true);
|
// format.setNewlines(true);
|
// XMLWriter xmlWriter = new XMLWriter(fileWriter, format);
|
// xmlWriter.write(document);
|
// xmlWriter.close();
|
// } catch (IOException e) {
|
// e.printStackTrace();
|
// }
|
// }
|
|
/**
|
* 将查询模板text转化成查询模板结构
|
* @param qtName : 查询模板name
|
* @param qtText : 查询模板text
|
* @return
|
* @throws DocumentException
|
* @throws VCIError
|
*/
|
public static QueryTemplate getQTByQTText(String qtName, String qtText) throws VCIError, DocumentException{
|
return getQTByDoc(DocumentHelper.parseText(qtText), qtName);
|
}
|
|
|
/**
|
* 根据Document, Document中的模板名获取查询模板
|
* @throws VCIError
|
*/
|
public static QueryTemplate getQTByDoc(Document doc, String name) throws VCIError{
|
QueryTemplate qt = new QueryTemplate();
|
|
Element rootNode = doc.getRootElement();
|
List<Element> qtNodes = rootNode.elements(QTConstants.QUERYTEMPLATE);
|
for(Iterator<Element> i = qtNodes.iterator(); i.hasNext();){
|
Element qtNode = i.next();
|
if(qtNode.attributeValue(QTConstants.ID).equals(name)){
|
//设置Id
|
qt.setId(name);
|
String type = qtNode.attributeValue(QTConstants.TYPE);
|
if(type == null ||
|
(!type.equals(QTConstants.TYPE_BTM) && !type.equals(QTConstants.TYPE_LINK))){
|
throw new VCIError("P0010QT-00011", new String[]{"没有正确设置查询模板的类型"});
|
}else{
|
qt.setType(type);
|
}
|
//设置clauseList
|
List<String> clauseList = new ArrayList<String>();
|
String[] clauses = qtNode.elementText(QTConstants.CLAUSELIST).split(",");
|
for(int k = 0; k < clauses.length; k++){
|
clauseList.add(clauses[k]);
|
}
|
qt.setClauseList(clauseList);
|
//设置查询的linkType
|
String linkType = qtNode.elementText(QTConstants.LINKTYPE);
|
qt.setLinkType(linkType == null ? QTConstants.BLANK : linkType);
|
//设置查询的btmType
|
String btmType = qtNode.elementText(QTConstants.BTMTYPE);
|
qt.setBtmType(btmType == null ? QTConstants.BLANK : btmType);
|
if(qt.getType().equals(QTConstants.TYPE_BTM)){
|
//是否查询业务类型的子类型
|
String queryChildrenFlag = qtNode.elementText(QTConstants.QUERYCHILDRENFLAG);
|
qt.setQueryChildrenFlag(Boolean.valueOf(queryChildrenFlag));
|
}
|
//是否查询是否包含下一级(链接查询)
|
String queryIsLeaf = qtNode.elementText(QTConstants.QUERYISLEAF);
|
if(queryIsLeaf == null || queryIsLeaf.equals("")){
|
queryIsLeaf = String.valueOf(Boolean.FALSE);
|
}
|
qt.setQueryISLeaf(Boolean.valueOf(queryIsLeaf));
|
//查询时是否加入权限，默认加权限
|
String rightFlag = qtNode.elementText(QTConstants.RIGHTFlag);
|
if(rightFlag == null || rightFlag.equals("")){
|
rightFlag = String.valueOf(Boolean.TRUE);
|
}
|
qt.setRightFlag(Boolean.valueOf(rightFlag));
|
//weidy@2018-06-19 增加密级控制
|
String secretFlag = qtNode.elementText(QTConstants.SECRETFLAG);
|
if(secretFlag == null || secretFlag.equals("")){
|
secretFlag = String.valueOf(Boolean.TRUE);
|
}
|
qt.setSecretFlag(Boolean.valueOf(secretFlag));
|
//设置版本版次信息
|
String versionStr = qtNode.elementText(QTConstants.VERSION);
|
int version = Integer.valueOf(versionStr == null ? "0" : versionStr);
|
qt.setVersion(version);
|
|
//设置链接查询递归的层次
|
String levelRecStr = qtNode.elementText(QTConstants.LEVELREC);
|
int levelRec = Integer.valueOf(levelRecStr == null ? "1" : levelRecStr);
|
qt.setLevel(levelRec);
|
|
//递归返回数据模式
|
String recReturnModeStr = qtNode.elementText(QTConstants.RECRETURNMODE);
|
int recReturnMode = Integer.valueOf(recReturnModeStr == null ? "1" : recReturnModeStr);
|
qt.setRecReturnMode(recReturnMode);
|
|
//设置链接查询方向
|
if(qt.getType().equals(QTConstants.TYPE_LINK)){
|
String direction = qtNode.elementText(QTConstants.DIRECTION);
|
if(direction == null ||
|
(!direction.equals(QTConstants.DIRECTION_POSITIVE) && !direction.equals(QTConstants.DIRECTION_OPPOSITE))){
|
qt.setDirection(QTConstants.DIRECTION_POSITIVE);
|
}else{
|
qt.setDirection(direction);
|
}
|
}
|
//设置PageInfo
|
Element pageInfoNode = qtNode.element(QTConstants.PAGEINFO);
|
if(pageInfoNode != null && pageInfoNode.element(QTConstants.PAGENO) != null && pageInfoNode.element(QTConstants.ROWCOUNT) != null){
|
PageInfo pageInfo = new PageInfo();
|
String pageNO = pageInfoNode.element(QTConstants.PAGENO).getText();
|
String rowCount = pageInfoNode.element(QTConstants.ROWCOUNT).getText();
|
if(pageNO != null && !pageNO.equals("")){
|
pageInfo.setPageNO(Integer.parseInt(pageNO));
|
}
|
if(rowCount != null && !rowCount.equals("")){
|
pageInfo.setRowCount(Integer.parseInt(rowCount));
|
}
|
qt.setPageInfo(pageInfo);
|
}
|
//设置orderInfoList
|
Element orderInfosNode = qtNode.element(QTConstants.ORDERINFOS);
|
if(orderInfosNode != null && orderInfosNode.elements(QTConstants.ORDERINFO) != null){
|
List<OrderInfo> orderInfoList = new ArrayList<OrderInfo>();
|
List<Element> orderInfoNodes = orderInfosNode.elements(QTConstants.ORDERINFO);
|
for(Iterator<Element> ite = orderInfoNodes.iterator(); ite.hasNext();){
|
Element orderInfoNode = ite.next();
|
if(orderInfoNode.element(QTConstants.ORDERFIELD) != null && orderInfoNode.element(QTConstants.ORDERMODE) != null
|
&& orderInfoNode.element(QTConstants.LEVEL) != null){
|
OrderInfo obj = new OrderInfo();
|
obj.setOrderField(orderInfoNode.elementText((QTConstants.ORDERFIELD)));
|
obj.setOrderMode(orderInfoNode.elementText((QTConstants.ORDERMODE)));
|
if(orderInfoNode.elementText((QTConstants.LEVEL)) != null && !orderInfoNode.elementText((QTConstants.LEVEL)).equals("")){
|
obj.setLevel(Integer.valueOf(orderInfoNode.elementText((QTConstants.LEVEL))));
|
}
|
orderInfoList.add(obj);
|
}
|
}
|
qt.setOrderInfoList(orderInfoList);
|
}
|
Element conditionNode = qtNode.element(QTConstants.CONDITION);
|
//设置condition
|
if(conditionNode != null && !conditionNode.attributeValue(QTConstants.ROOTCINAME).equals(QTConstants.BLANK)){
|
Condition condition = new Condition();
|
qt.setCondition(condition);
|
condition.setRootCIName(conditionNode.attributeValue(QTConstants.ROOTCINAME));
|
HashMap<String, ConditionItem> cIMap = new HashMap<String, ConditionItem>();
|
condition.setCIMap(cIMap);
|
List<Element> ciNodes = conditionNode.elements(QTConstants.CONDITIONITEM);
|
for(Iterator<Element> ite = ciNodes.iterator(); ite.hasNext();){
|
Element ciNode = ite.next();
|
//设置conditionItem
|
ConditionItem conditionItem = new ConditionItem();
|
conditionItem.setId(ciNode.attributeValue(QTConstants.ID));
|
conditionItem.setLeafFlag(Boolean.valueOf(ciNode.elementText(QTConstants.LEAFFLAG)));
|
|
//设置conditionItem的leafInfo
|
Element ldNode = ciNode.element(QTConstants.LEAFINFO);
|
if(ldNode != null && ldNode.element(QTConstants.CLAUSE) != null){
|
LeafInfo leafData = new LeafInfo();
|
conditionItem.setLeafInfo(leafData);
|
leafData.setClause(ldNode.elementText(QTConstants.CLAUSE));
|
String operator = ldNode.elementText(QTConstants.OPERATOR);
|
/**
|
* 因<, <= 在xml中不能正确存储, 故将查询模板的<, <=存为LT, LTE;
|
* 从xml读取operator为LT, LTE时, 再转换成查询模板的<, <=.
|
* 将>, >= 做相同处理.
|
*/
|
if(operator.equals(Operator.LTTEXT)){
|
operator = Operator.LT;
|
}else if(operator.equals(Operator.LTETEXT)){
|
operator = Operator.LTE;
|
}else if(operator.equals(Operator.GTTEXT)){
|
operator = Operator.GT;
|
}else if(operator.equals(Operator.GTETEXT)){
|
operator = Operator.GTE;
|
}
|
leafData.setOperator(operator);
|
//设置conditionItem的leafData的LDValue
|
Element valueNode = ldNode.element(QTConstants.VALUE);
|
LeafValue ldValue = new LeafValue();
|
leafData.setValue(ldValue);
|
ldValue.setOrdinaryValue(valueNode.elementText(QTConstants.ORDINARYVALUE));
|
String qtName = valueNode.elementText(QTConstants.REFQT);
|
if(qtName != null && !qtName.equals(QTConstants.BLANK)){
|
ldValue.setQueryTemplate(getQTByDoc(doc, qtName));
|
}
|
}
|
|
//设置conditionItem的childrenInfo
|
Element cdNode = ciNode.element(QTConstants.CHILDRENINFO);
|
if(cdNode != null){
|
ChildrenInfo cdData = new ChildrenInfo();
|
conditionItem.setChildrenInfo(cdData);
|
cdData.setLeftCIName(cdNode.elementText((QTConstants.LEFT)));
|
cdData.setRightCIName(cdNode.elementText((QTConstants.RIGHT)));
|
cdData.setConnector(cdNode.elementText((QTConstants.CONNECTOR)));
|
}
|
|
cIMap.put(conditionItem.getId(), conditionItem);
|
}
|
}
|
}
|
}
|
return qt;
|
}
|
|
/**
|
* Array ----> ArrayList
|
* @param array
|
* @return
|
*/
|
// public static List<String> arrayToList(String[] array){
|
// List<String> list = new ArrayList<String>();
|
// for(int i = 0; i < array.length; i++){
|
// list.add(array[i]);
|
// }
|
// return list;
|
// }
|
|
/**
|
* convert array to String append with ','.
|
* @param array
|
* @return
|
*/
|
// public static String arrayToString(String[] array){
|
// String str = QTConstants.BLANK;
|
// if(array == null){
|
// return str;
|
// }
|
// for(int i = 0; i < array.length; i++){
|
// str += array[i];
|
// if(i < array.length - 1){
|
// str += ",";
|
// }
|
// }
|
// return str;
|
// }
|
|
/**
|
* 检查查询模板是否合法, 合法返回OK, 非法返回详细信息
|
* 1. 检查查询条件的值数据类型是否正确
|
* @param qt
|
* @return
|
*/
|
public static String checkQT(QueryTemplate qt){
|
String ok = "OK";
|
if(qt == null){
|
return ok;
|
}
|
Condition condition = qt.getCondition();
|
if(condition == null){
|
return ok;
|
}
|
Map<String, ConditionItem> ciMap = condition.getCIMap();
|
if(ciMap == null){
|
return ok;
|
}
|
//1.检查查询条件的值数据类型是否正确
|
Iterator<String> iterator = ciMap.keySet().iterator();
|
while(iterator.hasNext()){
|
String ciName = iterator.next();
|
ConditionItem ci = ciMap.get(ciName);
|
if(ci.isLeaf()){
|
LeafInfo leafInfo = ci.getLeafInfo();
|
String attName = leafInfo.getClause();
|
if(attName.contains(".")){
|
attName = attName.substring(attName.lastIndexOf(".") + 1, attName.length());
|
}
|
QueryTemplate refQT = leafInfo.getValue().getQueryTemplate();
|
String value = leafInfo.getValue().getOrdinaryValue();
|
if(value != null){
|
//#---#预置参数
|
if(!value.startsWith("#") || !value.endsWith("#")){
|
String dataType = getAbItemDataType(attName);
|
boolean flag = checkDataType(dataType, value);
|
if(!flag){
|
return attName + "数据类型应为: " + dataType;
|
}
|
}
|
}else if(refQT != null){
|
checkQT(refQT);
|
}
|
|
}
|
}
|
return ok;
|
}
|
|
/**
|
* 记录树的结构
|
* @return
|
*/
|
public static Document parseTreeToDoc(JTree tree){
|
if(tree == null){
|
return null;
|
}
|
Document doc = DocumentHelper.createDocument();
|
Element root = doc.addElement("root");
|
DefaultMutableTreeNode rootNode = (DefaultMutableTreeNode) tree.getModel().getRoot();
|
root.setText((String)rootNode.getUserObject());
|
Enumeration<DefaultMutableTreeNode> children = rootNode.children();
|
while(children.hasMoreElements()){
|
DefaultMutableTreeNode childNode = children.nextElement();
|
Element child = root.addElement("child");
|
child.setText((String)childNode.getUserObject());
|
if(childNode.children().hasMoreElements()){
|
addElement(child, childNode);
|
}
|
}
|
|
return doc;
|
}
|
|
/**
|
* 将树的节点迭代增加到doc
|
* @param element
|
* @param node
|
*/
|
public static void addElement(Element element, DefaultMutableTreeNode node){
|
Enumeration<DefaultMutableTreeNode> children = node.children();
|
while(children.hasMoreElements()){
|
DefaultMutableTreeNode childNode = children.nextElement();
|
Element child = element.addElement("child");
|
child.setText((String)childNode.getUserObject());
|
if(childNode.children().hasMoreElements()){
|
addElement(child, childNode);
|
}
|
}
|
}
|
|
/**
|
* 将doc转化成树
|
* @param doc
|
* @return
|
*/
|
public static JTree parseDocToTree(Document doc){
|
if(doc == null){
|
return null;
|
}
|
|
Element root = doc.getRootElement();
|
DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode(root.getText().trim());
|
JTree tree = new JTree(rootNode);;
|
List<Element> children = root.elements();
|
for(Iterator<Element> i = children.iterator(); i.hasNext();){
|
Element child = i.next();
|
DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child.getText().trim());
|
rootNode.add(childNode);
|
if(child.elements().size() > 0){
|
addDefaultMutableTreeNode(childNode, child);
|
}
|
}
|
return tree;
|
}
|
|
/**
|
* 将doc的element迭代增加到treeNode
|
* @param node
|
* @param element
|
*/
|
public static void addDefaultMutableTreeNode(DefaultMutableTreeNode node, Element element){
|
List<Element> children = element.elements();
|
for(Iterator<Element> i = children.iterator(); i.hasNext();){
|
Element child = i.next();
|
DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child.getText().trim());
|
node.add(childNode);
|
if(child.elements().size() > 0){
|
addDefaultMutableTreeNode(childNode, child);
|
}
|
}
|
}
|
|
/**
|
* 将查询模板中查询条件的值参数, 替换为map中给定的值
|
* @param qt
|
* @param map
|
* @throws VCIError
|
*/
|
public static QueryTemplate replaceQTValues(QueryTemplate qt, Map<String, String> map) throws VCIError{
|
try{
|
if(qt == null || map == null){
|
return qt;
|
}
|
Condition condition = qt.getCondition();
|
if(condition == null){
|
return qt;
|
}
|
Map<String, ConditionItem> ciMap = condition.getCIMap();
|
if(ciMap == null){
|
return qt;
|
}
|
for(Iterator<String> i = ciMap.keySet().iterator(); i.hasNext();){
|
String ciId = i.next();
|
ConditionItem ci = ciMap.get(ciId);
|
//当ConditionItem是叶子结点, 并且值参数在map中时, 替换。
|
if(ci.isLeaf()){
|
LeafInfo lInfo = ci.getLeafInfo();
|
String value = lInfo.getValue().getOrdinaryValue();
|
if(value != null && !value.equals("")){
|
if(map.containsKey(value)){
|
String value_ = map.get(value);
|
lInfo.getValue().setOrdinaryValue(value_);
|
//替换自定义查询(非嵌套)in (select oid from ff where #val1# #val2# )
|
}else if(value.contains("#")){
|
while(value.contains("#")){
|
int start = value.indexOf('#');
|
int end = value.indexOf('#', start + 1);
|
String key = value.substring(start + 1, end);
|
String val = map.get(key);
|
value = value.replace('#' + key + '#', val == null ? "null" : val);
|
}
|
lInfo.getValue().setOrdinaryValue(value);
|
}
|
// add by xchao 2017.12.14 begin
|
// replaceMap 处理增强
|
// 当查询模板中有类似如： oid in (select oid from platformbtm_xxx where oid not in('${oid}'))
|
// 如果此时replaceMap中只有 key=${oid}，value=xxx 时，也能正常解析
|
// 此时解析出的条件就是 oid in (select oid from platformbtm_xxx where oid not in('xxx'))
|
// value = lInfo.getValue().getOrdinaryValue();
|
// Iterator<Entry<String, String>> entrys = map.entrySet().iterator();
|
// while(entrys.hasNext()){
|
// Entry<String, String> entry = entrys.next();
|
// String key = entry.getKey();
|
// String kval = entry.getValue();
|
// value = value.replace(key, kval);
|
// }
|
// lInfo.getValue().setOrdinaryValue(value);
|
// add by xchao 2017.12.14 end
|
}else{
|
QueryTemplate refQT = lInfo.getValue().getQueryTemplate();
|
QueryTemplate refQT_ = replaceQTValues(refQT, map);
|
lInfo.getValue().setQueryTemplate(refQT_);
|
}
|
}
|
}
|
return qt;
|
}catch(Throwable e){
|
e.printStackTrace();
|
throw new VCIError("P0010QT-00008", new String[]{e.getMessage()});
|
}
|
}
|
|
/**
|
* 获取属性的数据类型, 属性: 业务类型和链接类型的系统属性, 属性池属性
|
* @param abUpperName
|
* @return
|
*/
|
public static String getAbItemDataType(String abName){
|
String dataType = "VTString";
|
if(abName == null || abName.equals("")){
|
return dataType;
|
}
|
if(abName.contains(".")){
|
abName = abName.substring(abName.lastIndexOf(".") + 1);
|
}
|
// String abUpperName = abName.toUpperCase();
|
// //系统属性
|
// if(abUpperName.equals("OID") || abUpperName.equals("REVISIONOID") || abUpperName.equals("NAMEOID") || abUpperName.equals("BTMNAME")
|
// || abUpperName.equals("CREATOR") || abUpperName.equals("LASTMODIFIER") || abUpperName.equals("REVISIONRULE")
|
// || abUpperName.equals("VERSIONRULE") || abUpperName.equals("REVISIONVALUE") || abUpperName.equals("VERSIONVALUE")
|
// || abUpperName.equals("LCTID") || abUpperName.equals("LCSTATUS")
|
// || abUpperName.equals("ID") || abUpperName.equals("NAME") || abUpperName.equals("DESCRIPTION")
|
// || abUpperName.equals("OWNER") || abUpperName.equals("CHECKINBY")
|
// || abUpperName.equals("CHECKOUTBY") || abUpperName.equals("COPYFROMVERSION")
|
// || abUpperName.equals("ISLASTR") || abUpperName.equals("ISFIRSTR")
|
// || abUpperName.equals("ISLASTV") || abUpperName.equals("ISFIRSTV")
|
// || abUpperName.equals("F_OID") || abUpperName.equals("F_REVISIONOID") || abUpperName.equals("F_NAMEOID")
|
// || abUpperName.equals("F_BTMNAME") || abUpperName.equals("T_OID") || abUpperName.equals("T_REVISIONOID")
|
// || abUpperName.equals("T_NAMEOID") || abUpperName.equals("T_BTMNAME") || abUpperName.equals("F_OID")
|
// || abUpperName.equals("F_BTWNAME") || abUpperName.equals("T_BTWNAME")){
|
// dataType = "VTString";
|
// }else if(abUpperName.equals("REVISIONSEQ") || abUpperName.equals("VERSIONSEQ")){
|
// dataType = "VTInteger";
|
// }else if(abUpperName.equals("CREATETIME") || abUpperName.equals("LASTMODIFYTIME")
|
// || abUpperName.equals("TS") || abUpperName.equals("CHECKINTIME") || abUpperName.equals("CHECKOUTTIME")){
|
// dataType = "VTDateTime";
|
// //属性池中属性
|
// }else{
|
// dataType = ApProvider.getInstance().getAbItemDataType(abName);
|
// }
|
|
try {
|
dataType = ServiceProvider.getOMDService().getAttributeService().getAttribItemDataType(abName);
|
} catch (VCIError e) {
|
// TODO Auto-generated catch block
|
e.printStackTrace();
|
}
|
|
return dataType;
|
}
|
|
/**
|
* 把key, Value 封装成查询模板的Condition
|
* @param map
|
* @return
|
*/
|
public static Condition getCondition(Map<String, String> map){
|
Condition cond = new Condition();
|
Map<String, ConditionItem> ciMap = new HashMap<String, ConditionItem>();
|
Iterator<String> ite = map.keySet().iterator();
|
List<ConditionItem> list = new ArrayList<ConditionItem>();
|
int idFlag = 1;
|
while(ite.hasNext()){
|
String key = ite.next();
|
String value = map.get(key);
|
if(value == null || value.equals("")){
|
continue;
|
}
|
List<ConditionItem> list_ = getCIList(key, value, idFlag);
|
if(list.size() > 0){
|
ConditionItem lCI = list.get(list.size() - 1);
|
ConditionItem rCI = list_.get(list_.size() - 1);
|
list.addAll(list_);
|
idFlag = idFlag + list_.size();
|
ConditionItem pCI = new ConditionItem();
|
pCI.setId("ci" + idFlag);
|
pCI.setLeafFlag(false);
|
pCI.setLeafInfo(null);
|
ChildrenInfo cInfo = new ChildrenInfo();
|
cInfo.setLeftCIName(lCI.getId());
|
cInfo.setConnector(Connector.AND);
|
cInfo.setRightCIName(rCI.getId());
|
pCI.setChildrenInfo(cInfo);
|
list.add(pCI);
|
idFlag++;
|
}else{
|
list.addAll(list_);
|
idFlag = idFlag + list_.size();
|
}
|
}
|
|
for(int i = 0; i < list.size(); i++){
|
ConditionItem ci = list.get(i);
|
ciMap.put(ci.getId(), ci);
|
}
|
if(list.size() > 0){
|
ConditionItem rootCI = list.get(list.size() - 1);
|
cond.setRootCIName(rootCI.getId());
|
cond.setCIMap(ciMap);
|
return cond;
|
}else{
|
return null;
|
}
|
}
|
|
/**
|
* 根据value中包含的AND/OR解析出conditionItem组
|
* @param key
|
* @param value
|
* @param idFlag
|
* @return
|
*/
|
public static List<ConditionItem> getCIList(String key, String value, int idFlag){
|
List<ConditionItem> list = new ArrayList<ConditionItem>();
|
String connector = Connector.AND;
|
while(value.length() > 0){
|
int indexAnd = value.indexOf("\\AND");
|
int indexOr = value.indexOf("\\OR");
|
ConditionItem ci = new ConditionItem();
|
if(indexAnd > 0 || indexOr > 0){
|
String nextConnector = Connector.AND;
|
String value_ = null;
|
if((indexAnd > 0 && indexAnd < indexOr) || indexOr < 0){
|
value_ = value.substring(0, indexAnd);
|
nextConnector = Connector.AND;
|
value = value.substring(indexAnd + 4);
|
}else{
|
value_ = value.substring(0, indexOr);
|
nextConnector = Connector.OR;
|
value = value.substring(indexOr + 3);
|
}
|
ci = getConditionItem(key, value_, idFlag);
|
if(list.size() > 0){
|
ConditionItem lCI = list.get(list.size() - 1);
|
list.add(ci);
|
idFlag++;
|
ConditionItem pCI = new ConditionItem();
|
pCI.setId("ci" + idFlag);
|
pCI.setLeafFlag(false);
|
pCI.setLeafInfo(null);
|
ChildrenInfo cInfo = new ChildrenInfo();
|
cInfo.setLeftCIName(lCI.getId());
|
cInfo.setConnector(connector);
|
cInfo.setRightCIName(ci.getId());
|
pCI.setChildrenInfo(cInfo);
|
list.add(pCI);
|
idFlag++;
|
}else{
|
list.add(ci);
|
idFlag++;
|
}
|
connector = nextConnector;
|
}else{
|
ci = getConditionItem(key, value, idFlag);
|
if(list.size() > 0){
|
ConditionItem lCI = list.get(list.size() - 1);
|
list.add(ci);
|
idFlag++;
|
ConditionItem pCI = new ConditionItem();
|
pCI.setId("ci" + idFlag);
|
pCI.setLeafFlag(false);
|
pCI.setLeafInfo(null);
|
ChildrenInfo cInfo = new ChildrenInfo();
|
cInfo.setLeftCIName(lCI.getId());
|
cInfo.setConnector(connector);
|
cInfo.setRightCIName(ci.getId());
|
pCI.setChildrenInfo(cInfo);
|
list.add(pCI);
|
idFlag++;
|
}else{
|
list.add(ci);
|
idFlag++;
|
}
|
value = "";
|
}
|
}
|
return list;
|
}
|
|
/**
|
* 将原子value（不包含and/or）解析成单个ConditionItem
|
* @param key
|
* @param value
|
* @param idFlag
|
* @return
|
*/
|
private static ConditionItem getConditionItem(String key, String value, int idFlag){
|
ConditionItem ci = new ConditionItem();
|
ci.setId("ci" + idFlag);
|
ci.setChildrenInfo(null);
|
ci.setLeafFlag(true);
|
LeafInfo lInfo = new LeafInfo();
|
String operator = null;
|
|
if(value.startsWith("\\NOTLIKE")){
|
operator = Operator.NOTLIKE;
|
value = value.substring(8);
|
}else if (value.startsWith(Operator.STAR) || value.endsWith(Operator.STAR)) {
|
operator = Operator.LIKE;
|
}else if (value.startsWith(Operator.UNEQUAL)) {
|
operator = Operator.UNEQUAL;
|
value = value.substring(2);
|
}else if(value.startsWith(Operator.GT)){ //add by caill 2016.4.7 为操作添加“大于”的判断 并在此判断中添加“大于等于”的判断
|
operator = Operator.GT;
|
if(value.startsWith(Operator.GTE)){
|
operator = Operator.GTE;
|
value = value.substring(2);
|
}else{
|
value = value.substring(1);
|
}
|
|
}else if(value.startsWith(Operator.LT)){ //add by caill 2016.4.7 为操作添加“小于”的判断 并在此判断中添加“小于等于”的判断
|
operator = Operator.LT;
|
if(value.startsWith(Operator.LTE)){
|
operator = Operator.LTE;
|
value = value.substring(2);
|
}else{
|
value = value.substring(1);
|
}
|
}/*else if(value.startsWith(Operator.LTE)){
|
operator = Operator.LTE;
|
value = value.substring(2);
|
}else if(value.startsWith(Operator.GTE)){
|
operator = Operator.GTE;
|
value = value.substring(2);
|
}*/else if(value.startsWith("\\IN")){
|
operator = Operator.IN;
|
value = value.substring(3);
|
}else if(value.startsWith("\\NOTIN")){
|
operator = Operator.NOTIN;
|
value = value.substring(6);
|
}else {
|
operator = Operator.EQUAL;
|
}
|
lInfo.setOperator(operator);
|
if(key.toUpperCase().contains("T_OID.") || key.toUpperCase().contains("F_OID.")){
|
//去掉T_OID.或者F_OID.
|
String clause_ = key.substring(6);
|
//属性为参照属性
|
if(clause_.contains(".")){
|
int fpIndex = clause_.indexOf(".");
|
String refAbName = key.substring(0, fpIndex + 6);
|
key = key.substring(fpIndex + 6 + 1);
|
lInfo.setClause(refAbName);
|
//去掉T_OID.或者F_OID.
|
refAbName = refAbName.substring(6);
|
lInfo.setOperator(Operator.IN);
|
QueryTemplate qt = getRefQT(refAbName, key, operator, value);
|
LeafValue lValue = new LeafValue();
|
lValue.setQueryTemplate(qt);
|
lInfo.setValue(lValue);
|
//属性为非参照属性
|
}else{
|
lInfo.setClause(key);
|
LeafValue lValue = new LeafValue();
|
lInfo.setValue(lValue);
|
lValue.setOrdinaryValue(value);
|
}
|
}else{
|
//属性为参照属性
|
if(key.contains(".")){
|
int fpIndex = key.indexOf(".");
|
String refAbName = key.substring(0, fpIndex);
|
key = key.substring(fpIndex + 1);
|
lInfo.setClause(refAbName);
|
lInfo.setOperator(Operator.IN);
|
QueryTemplate qt = getRefQT(refAbName, key, operator, value);
|
LeafValue lValue = new LeafValue();
|
lValue.setQueryTemplate(qt);
|
lInfo.setValue(lValue);
|
//属性为非参照属性
|
}else{
|
lInfo.setClause(key);
|
LeafValue lValue = new LeafValue();
|
lInfo.setValue(lValue);
|
lValue.setOrdinaryValue(value);
|
}
|
}
|
ci.setLeafInfo(lInfo);
|
return ci;
|
}
|
|
/**
|
* 获取参照的查询模板
|
* @param refAbName: 参照属性名
|
* @param clause: 属性参照的业务类型中的属性
|
* @param operator
|
* @param ordinaryValue
|
* @return
|
*/
|
private static QueryTemplate getRefQT(String refAbName, String clause,
|
String operator, String ordinaryValue) {
|
QueryTemplate qt = new QueryTemplate();
|
try {
|
List<String> clauseList = new ArrayList<String>();
|
clauseList.add("OID");
|
qt.setClauseList(clauseList);
|
AttribItem refAb;
|
refAb = ServiceProvider.getOMDService().getAttributeService().getAttribItemByName(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);
|
} catch (VCIError e) {
|
// TODO Auto-generated catch block
|
e.printStackTrace();
|
}
|
return qt;
|
}
|
|
/**
|
*
|
* @param direction
|
* @param oid
|
* @param btmType
|
* @param map
|
* @return
|
*/
|
public static Condition getConditionForLink(String direction, String oid, String btmType, Map<String, String> map){
|
Condition cond = new Condition();
|
cond.setRootCIName("ci3");
|
Map<String, ConditionItem> ciMap = new HashMap<String, ConditionItem>();
|
if(direction.equals(QTConstants.DIRECTION_POSITIVE)){
|
ConditionItem ci1 = new ConditionItem();
|
ci1.setId("ci1");
|
ci1.setChildrenInfo(null);
|
ci1.setLeafFlag(true);
|
LeafInfo lInfo = new LeafInfo();
|
lInfo.setClause("f_oid");
|
lInfo.setOperator(Operator.EQUAL);
|
LeafValue lValue = new LeafValue();
|
lValue.setOrdinaryValue(oid);
|
lInfo.setValue(lValue);
|
ci1.setLeafInfo(lInfo);
|
ciMap.put(ci1.getId(), ci1);
|
|
ConditionItem ci2 = new ConditionItem();
|
ci2.setId("ci2");
|
ci2.setChildrenInfo(null);
|
ci2.setLeafFlag(true);
|
LeafInfo lInfo2 = new LeafInfo();
|
lInfo2.setClause("t_nameOId");
|
lInfo2.setOperator(Operator.IN);
|
LeafValue lValue2 = new LeafValue();
|
//参照查询模板
|
QueryTemplate refQT = new QueryTemplate();
|
lValue2.setQueryTemplate(refQT);
|
refQT.setId("refQT");
|
refQT.setBtmType(btmType);
|
refQT.setType(QTConstants.TYPE_BTM);
|
List<String> list = new ArrayList<String>();
|
list.add("nameOId");
|
refQT.setClauseList(list);
|
Condition cond2 = getCondition(map);
|
refQT.setCondition(cond2);
|
lInfo2.setValue(lValue2);
|
ci2.setLeafInfo(lInfo2);
|
ciMap.put(ci2.getId(), ci2);
|
|
ConditionItem ci3 = new ConditionItem();
|
ci3.setId("ci3");
|
ci3.setLeafFlag(false);
|
ci3.setLeafInfo(null);
|
ChildrenInfo cInfo = new ChildrenInfo();
|
ci3.setChildrenInfo(cInfo);
|
cInfo.setLeftCIName(ci1.getId());
|
cInfo.setConnector(Connector.AND);
|
cInfo.setRightCIName(ci2.getId());
|
ciMap.put(ci3.getId(), ci3);
|
}else if(direction.equals(QTConstants.DIRECTION_OPPOSITE)){
|
ConditionItem ci1 = new ConditionItem();
|
ci1.setId("ci1");
|
ci1.setChildrenInfo(null);
|
ci1.setLeafFlag(true);
|
LeafInfo lInfo = new LeafInfo();
|
lInfo.setClause("t_oid");
|
lInfo.setOperator(Operator.EQUAL);
|
LeafValue lValue = new LeafValue();
|
lValue.setOrdinaryValue(oid);
|
lInfo.setValue(lValue);
|
ci1.setLeafInfo(lInfo);
|
ciMap.put(ci1.getId(), ci1);
|
|
ConditionItem ci2 = new ConditionItem();
|
ci2.setId("ci2");
|
ci2.setChildrenInfo(null);
|
ci2.setLeafFlag(true);
|
LeafInfo lInfo2 = new LeafInfo();
|
lInfo2.setClause("f_oid");
|
lInfo2.setOperator(Operator.IN);
|
LeafValue lValue2 = new LeafValue();
|
//参照查询模板
|
QueryTemplate refQT = new QueryTemplate();
|
lValue2.setQueryTemplate(refQT);
|
refQT.setId("refQT");
|
refQT.setBtmType(btmType);
|
refQT.setType(QTConstants.TYPE_BTM);
|
List<String> list = new ArrayList<String>();
|
list.add("oid");
|
refQT.setClauseList(list);
|
Condition cond2 = getCondition(map);
|
refQT.setCondition(cond2);
|
lInfo2.setValue(lValue2);
|
ci2.setLeafInfo(lInfo2);
|
ciMap.put(ci2.getId(), ci2);
|
|
ConditionItem ci3 = new ConditionItem();
|
ci3.setId("ci3");
|
ci3.setLeafFlag(false);
|
ci3.setLeafInfo(null);
|
ChildrenInfo cInfo = new ChildrenInfo();
|
ci3.setChildrenInfo(cInfo);
|
cInfo.setLeftCIName(ci1.getId());
|
cInfo.setConnector(Connector.AND);
|
cInfo.setRightCIName(ci2.getId());
|
ciMap.put(ci3.getId(), ci3);
|
}
|
cond.setCIMap(ciMap);
|
return cond;
|
}
|
|
/**
|
* 合并Condition
|
* 1.将con2中conditionItem的ID和非叶子结点的左右id都加上con1.size
|
* 2.con1->con<-con2
|
* @param con1
|
* @param con2
|
* @param AND/OR
|
*/
|
public static Condition mergeCondition(Condition con1, Condition con2, String connector){
|
if(connector == null){
|
return null;
|
}
|
if(!connector.equalsIgnoreCase(Connector.AND) &&
|
!connector.equalsIgnoreCase(Connector.OR)){
|
return null;
|
}
|
if(con1 == null || con1.getCIMap() == null || con1.getCIMap().keySet().size() == 0){
|
return con2;
|
}
|
if(con2 == null || con2.getCIMap() == null || con2.getCIMap().keySet().size() == 0){
|
return con1;
|
}
|
Condition con = new Condition();
|
Map<String, ConditionItem> ciMap = con1.getCIMap();
|
int size = ciMap.keySet().size();
|
Map<String, ConditionItem> ciMap2 = con2.getCIMap();
|
for(Iterator<String> i = ciMap2.keySet().iterator(); i.hasNext();){
|
String ciId = i.next();
|
ConditionItem ci = ciMap2.get(ciId);
|
int id = Integer.valueOf(ciId.substring(2)) + size;
|
ci.setId("ci" + id);
|
|
if(!ci.isLeaf()){
|
ChildrenInfo cInfo = ci.getChildrenInfo();
|
String lCI = cInfo.getLeftCIName();
|
id = Integer.valueOf(lCI.substring(2)) + size;
|
cInfo.setLeftCIName("ci" + id);
|
String rCI = cInfo.getRightCIName();
|
id = Integer.valueOf(rCI.substring(2)) + size;
|
cInfo.setRightCIName("ci" + id);
|
}
|
|
ciMap.put(ci.getId(), ci);
|
}
|
|
ConditionItem rootCI = new ConditionItem();
|
rootCI.setId("ci" + (ciMap.keySet().size() + 1));
|
rootCI.setLeafFlag(false);
|
|
ChildrenInfo cInfo_ = new ChildrenInfo();
|
cInfo_.setLeftCIName(con1.getRootCIName());
|
String rightCI = con2.getRootCIName();
|
int id_ = Integer.valueOf(rightCI.substring(2)) + size;
|
cInfo_.setRightCIName("ci" + id_);
|
cInfo_.setConnector(connector);
|
rootCI.setChildrenInfo(cInfo_);
|
|
ciMap.put(rootCI.getId(), rootCI);
|
|
con.setCIMap(ciMap);
|
con.setRootCIName(rootCI.getId());
|
return con;
|
}
|
|
/**
|
* 为每一个子节点的ConditinItem中LeafInfo的Clause加上str前缀
|
* F_OID./T_OID.
|
* @param con
|
* @param str
|
* @return
|
*/
|
public static Condition conditionWrapper(Condition con, String str){
|
Map<String, ConditionItem> ciMap = con.getCIMap();
|
for(Iterator<String> i = ciMap.keySet().iterator(); i.hasNext();){
|
String ciId = i.next();
|
ConditionItem ci = ciMap.get(ciId);
|
if(ci.isLeaf()){
|
LeafInfo lInfo = ci.getLeafInfo();
|
String clause = str + lInfo.getClause();
|
lInfo.setClause(clause);
|
}
|
}
|
return con;
|
}
|
|
/**
|
* 克隆list
|
* Object cloneable
|
* @param list
|
* @return
|
*/
|
public static List<OrderInfo> cloneOrderInfoList(List<OrderInfo> list){
|
List<OrderInfo> clone = new ArrayList<OrderInfo>();
|
if(list == null){
|
return clone;
|
}
|
for(OrderInfo o : list){
|
clone.add(o.clone());
|
}
|
return clone;
|
}
|
|
// /**
|
// * 获取链接类型TO端业务类型视图名
|
// * @param ltName
|
// * @return
|
// */
|
// public static String getToViewName(String ltName){
|
// return ltName + _TV;
|
// }
|
//
|
// /**
|
// * 获取链接类型From端业务类型视图名
|
// * @param ltName
|
// * @return
|
// */
|
// public static String getFromViewName(String ltName){
|
// return ltName + _FV;
|
// }
|
//
|
// /**
|
// * 获取业务类型视图名
|
// * @param ltName
|
// * @return
|
// */
|
// public static String getBtViewName(String btName){
|
// return btName + _V;
|
// }
|
|
/**
|
* 获取创建链接类型TO端业务类型视图的sql
|
* @param ltName
|
* @return
|
*/
|
// public static String getBTSViewSql(String[] btNames, String viewName){
|
// if(btNames.length < 1){
|
// return "";
|
// }
|
// StringBuilder stb = new StringBuilder("create or replace view ");
|
// try {
|
// Set<String> allAttrName = getUserAttrNameSet(btNames);
|
// Map<String, StringBuilder> sqlMap = getBTSqlMap(allAttrName, btNames);
|
// stb.append(viewName);
|
// stb.append(" as ");
|
// for(String btName : sqlMap.keySet()){
|
// stb.append(sqlMap.get(btName));
|
// stb.append(" union all ");
|
// }
|
// } catch (Throwable e) {
|
// e.printStackTrace();
|
// }
|
// return stb.substring(0, stb.lastIndexOf(" union all "));
|
// }
|
|
/**
|
* 获取业务类型属性总集合
|
* @param btNames
|
* @return
|
*/
|
private static Set<String> getUserAttrNameSet(String[] btNames){
|
Set<String> set = new LinkedHashSet<String>();
|
try{
|
for(String btName : btNames){
|
String[] abNames = ServiceProvider.getOMDService().getBTMService().getBtmApNameArray(btName);
|
for(String abName : abNames){
|
set.add(abName);
|
}
|
}
|
} catch (Throwable e) {
|
e.printStackTrace();
|
}
|
return set;
|
}
|
|
/**
|
* 获取各个业务类型查询属性总集合的sql
|
* 当业务业务类型中不包含某个属性attrA时, '' as attrA
|
* @param allAttrName
|
* @param btNames
|
* @return
|
*/
|
// private static Map<String, StringBuilder> getBTSqlMap(Set<String> allAttrName,
|
// String[] btNames) {
|
// //记录业务类型和与其对应的属性列表
|
// Map<String, List<String>> btAttrMap = new HashMap<String, List<String>>();
|
// //记录业务类型和与其对应的查询sql
|
// Map<String, StringBuilder> btSqlMap = new HashMap<String, StringBuilder>();
|
// //modify by weidy@2021-11-15，在沈飞的发现一个现象是，拆分了的视图可能某个字段全部为null，这样多个视图链接到一起的时候，会出现类型不一致问题
|
// String[] sysAbItems = OmdTools.getBtSysANames();
|
// String querySysAttrSql = "select " + arrayToString(sysAbItems);
|
// for(String btName : btNames){
|
// try {
|
// String[] abNames;
|
// abNames = ServiceProvider.getOMDService().getBTMService().getBtmApNameArray(btName);
|
// btAttrMap.put(btName, arrayToList(abNames));
|
// btSqlMap.put(btName, new StringBuilder(querySysAttrSql));
|
// } catch (VCIError e) {
|
// // TODO Auto-generated catch block
|
// e.printStackTrace();
|
// }
|
//
|
// }
|
//
|
// Map<String, String> mapAttrNull = new HashMap<String, String>();
|
//
|
// for(String attrName : allAttrName){
|
// for(String btName : btNames){
|
// btSqlMap.get(btName).append(",");
|
// if(btAttrMap.get(btName).contains(attrName)){
|
// btSqlMap.get(btName).append(attrName);
|
// }else{
|
// String attrNull = "";
|
//
|
// if (mapAttrNull.containsKey(attrName)) {
|
// attrNull = mapAttrNull.get(attrName);
|
// } else {
|
// attrNull = CreateAttrNull(attrName);
|
// mapAttrNull.put(attrName, attrNull);
|
// }
|
// btSqlMap.get(btName).append(attrNull);
|
// }
|
// }
|
// }
|
//
|
// for(String btName : btNames){
|
// btSqlMap.get(btName).append(" from " + OmdTools.getBTTableName(btName));
|
// }
|
// return btSqlMap;
|
// }
|
|
/**
|
* 创建null AS 指定类型属性
|
* @param attrName
|
* @return
|
*/
|
// private static String CreateAttrNull(String attrName) {
|
// try {
|
//
|
// AttPoolServicePrx attrService = ServiceProvider.getOMDService().getAttributeService();
|
//
|
// AttribItem ai = attrService.getAttribItemByName(attrName);
|
//
|
// String vtType = ai.vtDataType;
|
// int length = 50;
|
// String lengthStr = getOtherValueByType(ai.other, "length");
|
//
|
// if ((lengthStr != null) && (!lengthStr.equals(""))) {
|
// length = Integer.valueOf(lengthStr).intValue();
|
// }
|
//
|
// String sqlType = "";
|
//
|
// if (VTDataType.VTSTRING.equalsIgnoreCase(vtType)) {
|
// sqlType = "VARCHAR2(" + length + ")";
|
// } else if (VTDataType.VTLONG.equalsIgnoreCase(vtType) || VTDataType.VTINTEGER.equalsIgnoreCase(vtType)) {
|
// sqlType = "NUMBER";
|
// } else if (VTDataType.VTDOUBLE.equalsIgnoreCase(vtType)) {
|
// sqlType = "NUMBER";
|
// } else if (VTDataType.VTBOOLEAN.equalsIgnoreCase(vtType)) {
|
// sqlType = "VARCHAR2(8)";
|
// } else if (VTDataType.VTIMAGE.equalsIgnoreCase(vtType)) {
|
// sqlType = "VARCHAR2(255)";
|
// } else if (VTDataType.VTDATE.equalsIgnoreCase(vtType)) {
|
// sqlType = "DATE";
|
// } else if (VTDataType.VTDATETIME.equalsIgnoreCase(vtType) || VTDataType.VTTIME.equalsIgnoreCase(vtType)) {
|
// sqlType = "TIMESTAMP";
|
// } else if (VTDataType.VTFILEPATH.equalsIgnoreCase(vtType) || VTDataType.VTNOTE.equalsIgnoreCase(vtType)) {
|
// sqlType = "VARCHAR2(255)";
|
// } else if (VTDataType.VTCLOB.equalsIgnoreCase(vtType)) {
|
// sqlType = "CLOB";
|
// } else {
|
// sqlType = "VARCHAR2(" + length + ")";
|
// }
|
//
|
// // btSqlMap.get(btName).append("cast(null as " + sqlType + " ) as " + attrName);
|
// String attrNull = "cast(null as " + sqlType + " ) as " + attrName;
|
//
|
// return attrNull;
|
// } catch (Throwable e) {
|
// e.printStackTrace();
|
// }
|
//
|
// return "";
|
// }
|
|
public static String getOtherValueByType(String other, String type) {
|
String[] otherArray = other.split(";");
|
for (int i = 0; i < otherArray.length; i++) {
|
String otherValue = otherArray[i];
|
if (otherValue.contains(type)) {
|
return otherValue.substring(otherValue.indexOf("=") + 2, otherValue.length());
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 视图cols
|
* viewName.col as col2
|
* @param ltName
|
* @return
|
*/
|
// public static List<String> getViewColsWithAlias(String[] btNames, String viewName) {
|
// List<String> cols = new ArrayList<String>();
|
// String[] sysAbItems = OmdTools.getBtSysANames();
|
// for(String sysAbItem : sysAbItems){
|
// cols.add(viewName + "." + sysAbItem + " AS " + sysAbItem + "2");
|
// }
|
// Set<String> userAttrNameSet = getUserAttrNameSet(btNames);
|
// for(String userAttrName : userAttrNameSet){
|
// cols.add(viewName + "." + userAttrName + " AS " + userAttrName + "2");
|
// }
|
// return cols;
|
// }
|
//
|
|
/**
|
* 获取查询条件的 值
|
* @param con
|
* @param key
|
* @return
|
*/
|
// public static String getConditionItemVlaue(Condition con, String key){
|
// if(con == null){
|
// return null;
|
// }
|
// Map<String, ConditionItem> ciMap = con.getCIMap();
|
// for(String ciId : ciMap.keySet()){
|
// ConditionItem ci = ciMap.get(ciId);
|
// if(ci.isLeaf()){
|
// LeafInfo leafInfo = ci.getLeafInfo();
|
// String clause = leafInfo.getClause();
|
// if(clause.equalsIgnoreCase(key)){
|
// return leafInfo.getValue().getOrdinaryValue();
|
// }
|
// }
|
// }
|
// return null;
|
// }
|
|
/**
|
* 根据leafInfo获取属性名和条件值,
|
* 当有参照时, 加上参照路径
|
* @param leafInfo
|
* @return
|
*/
|
public static Map<String, String> getClauseAndValue(LeafInfo leafInfo){
|
Map<String, String> map = new HashMap<String, String>();
|
String attName = leafInfo.getClause();
|
QueryTemplate refQt = leafInfo.getValue().getQueryTemplate();
|
//add by zhangweiwei 2014/12/09 start
|
String value = null;
|
if(refQt != null){
|
List<String> clauselist = refQt.getClauseList();
|
String attr = clauselist.get(0);
|
value = refQt.getId()+";"+attr;
|
}else{
|
value = leafInfo.getValue().getOrdinaryValue();
|
}
|
map.put("value", value);
|
if(refQt != null&&refQt.getId().startsWith("qt_")){
|
while(refQt != null){
|
Condition cond = refQt.getCondition();
|
if(cond != null){
|
ConditionItem ci = cond.getCIMap().get(cond.getRootCIName());
|
leafInfo = ci.getLeafInfo();
|
attName += "." + leafInfo.getClause();
|
refQt = leafInfo.getValue().getQueryTemplate();
|
}else{
|
break;
|
}
|
}
|
}
|
map.put("clause", attName);
|
//add by zhangweiwei 2014/12/09 end
|
return map;
|
}
|
|
/**
|
* 为提高使用效率, 将KV[][]转化成List
|
* @param array2D
|
* @return
|
*/
|
public static List<Map<String, String>> parseKVArray2D(KV[][] array2D){
|
List<Map<String, String>> list = new ArrayList<Map<String,String>>(array2D.length);
|
for(KV[] array : array2D){
|
Map<String, String> map = new HashMap<String, String>(array.length);
|
for(KV kv : array){
|
map.put(kv.key, kv.value);
|
}
|
list.add(map);
|
}
|
return list;
|
}
|
|
|
/**
|
* 检查属性类型与属性值是否匹配
|
* @param vtType
|
* @param value
|
* @return
|
*/
|
private static boolean checkDataType(String vtType, String value){
|
|
if(vtType.equals(VTDataType.VTSTRING)){
|
try{
|
String.valueOf(value);
|
}catch(Exception e){
|
return false;
|
}
|
}else if(vtType.equals(VTDataType.VTINTEGER)){
|
try{
|
Integer.valueOf(value);
|
}catch(Exception e){
|
return false;
|
}
|
}else if(vtType.equals(VTDataType.VTLONG)){
|
try{
|
Long.valueOf(value);
|
}catch(Exception e){
|
return false;
|
}
|
}else if(vtType.equals(VTDataType.VTDOUBLE)){
|
try{
|
Double.valueOf(value);
|
}catch(Exception e){
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
}
|
