Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/web/service/impl/OsQueryTemplateImpl.java

@@ -1,13 +1,15 @@
package com.vci.web.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.vci.client.common.oq.OQTool;
import com.vci.common.qt.object.QTConstants;
import com.vci.common.qt.object.QueryTemplate;
import com.vci.common.qt.object.*;
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.qtm.QTD;
import com.vci.corba.omd.qtm.QTInfo;
import com.vci.dto.QTInfoDTO;
import com.vci.omd.objects.OtherInfo;
import com.vci.starter.web.pagemodel.BaseResult;
import com.vci.starter.web.util.*;
import com.vci.web.service.*;
@@ -18,6 +20,7 @@
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 java.util.*;
@@ -36,6 +39,18 @@
     */
    @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 = "或者";

    /**
     * 查询模板的列表
@@ -156,12 +171,68 @@
            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 查询模板名字
@@ -174,6 +245,559 @@
    }

    /**
     * 链接类型查询模板保存
     * @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("保存查询模板失败");
        }
    }

    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();

    }
    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);

//            OQTool.parseTreeToDoc(seniorTree);
        }
        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
     */