PLTWEB.git - Gitblit

package plm.portal.utility;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
 
import org.dom4j.DocumentException;
 
import com.vci.base.server.utility.ObjectUtility;
import com.vci.corba.common.VCIError;
 
import plm.bs.bom.common.BusinessObject;
import plm.bs.bom.common.LinkObject;
import plm.bs.bom.common.constants.ObjectTool;
import plm.bs.omd.linktype.client.LinkTypeStart;
import plm.bs.omd.statepool.client.StatePoolStart;
import plm.corba.attribpool.AttribItem;
import plm.corba.btm.BtmAndApName;
import plm.corba.enumManager.EnumChild;
import plm.corba.enumManager.EnumItem;
import plm.corba.enumManager.EnumItemFilter;
import plm.corba.linkTypeManager.LinkType;
import plm.corba.refquery.RefPath;
import plm.corba.statePoolManager.StatePool;
import plm.oq.objectQuery.common.OrderInfo;
import plm.oq.objectQuery.common.PageInfo;
import plm.portal.custom.ICustomDefine;
import plm.portal.utility.DataModelProcessor;
import plm.portal.utility.PRMItem;
import plm.uif.engine.common.CBOHelper;
import plm.vo.omd.attribpool.ui.APClient;
import plm.vo.omd.btm.ui.BtmClient;
import plm.vo.omd.enumManager.ui.EnumClient;
 
public class TableDataUtil {
    
    public final String LCSTATUS = "lcstatus";
    private HashMap<String, HashMap<String, String>> typeAttrEnumValueToNameMap = new HashMap<String,HashMap<String,String>>();
    private HashMap<String, HashMap<String, String>> typeAttrEnumNameToValueMap = new HashMap<String,HashMap<String,String>>();
    
    /**
     * 查询业务对象的详细信息
     * @param qtName， 查询模版
     * @param replaceMap， 替换map
     * @param conditionMap， 附加条件
     * @param pageInfo， 翻页信息
     * @param orderInfos， 排序信息
     * @param showType， 显示类型
     * @param queryColumnsMap， 查询列, key为查询列名，value为显示名称
     * @param customMap， 自定义列
     * @return
     * @throws VCIError
     * @throws DocumentException
     */
    public List<Map<String, String>> getObjectDataList(String qtName, Map<String, String> replaceMap, 
            Map<String, String> conditionMap, PageInfo pageInfo, List<OrderInfo> orderInfos, String showType,
            Map<String, String> queryColumnsMap, Map<String, PRMItem> customMap, Map<String, PRMItem> fileMap) throws VCIError, DocumentException {
        DataModelProcessor processor = new DataModelProcessor();
        BusinessObject[] objs = processor.getBusinessObjectByQueryTemplate(
                qtName, replaceMap, conditionMap, pageInfo, orderInfos);
        List<Map<String, String>> datas = getObjectDataSecondList(processor, objs, showType, queryColumnsMap);
        if (customMap != null && customMap.size() > 0) {
            getCustomValue(customMap, datas);
        }
        if (fileMap != null && fileMap.size() > 0) {
            getFileColValue(fileMap, datas);
        }
        return datas;
    }
    
    /**
     * 获取业务对象二次查询的结果
     * @param processor
     * @param objs， 业务对象
     * @param showType， 显示类型
     * @param formColumnsMap,key为内部主键，value为显示名称（在此过程中暂不使用，可以传入空值）
     */
    private List<Map<String, String>> getObjectDataSecondList(
            DataModelProcessor processor,
            BusinessObject[] objs, String showType,
            Map<String, String> queryColumnsMap){
        @SuppressWarnings("unchecked")
        Map<String, String>[] res = new LinkedHashMap[0];
        res = CBOHelper.getBOValueMap(objs);
        Map<String, List<String>>  referenceKeyMap = processor.getReferenceCol(queryColumnsMap);
        if (referenceKeyMap != null && referenceKeyMap.size() > 0) {
            Iterator<String> referenceKey = referenceKeyMap.keySet().iterator();
            List<String> referenceList = new LinkedList<String>();
            while (referenceKey.hasNext()) {
                referenceList.add(referenceKey.next());
            }
            Map<String, Map<String, String>> rowRefMap = new LinkedHashMap<String, Map<String, String>>();
            Map<String, Boolean> emptyCheckMap = new LinkedHashMap<String, Boolean>();
            for (BusinessObject obj : objs) {
                String boOid = obj.oid;
                Map<String, String> refMap = new LinkedHashMap<String, String>();
                for (int j = 0; j < referenceList.size(); j++) {
                    String refKey = referenceList.get(j);
                    String refVal = ObjectTool.getBOAttributeValue(obj, refKey);
                    if (refVal == null) {
                        refVal = "";
                        emptyCheckMap.put(refVal, true);
                    } else {
                        emptyCheckMap.put(refKey, false);
                    }
                    refMap.put(refKey, refVal);
                }
                rowRefMap.put(boOid, refMap);
            }
            
            Map<String, String> emptyMap = new HashMap<String, String>();
            Iterator<String> emptyCheckItor = emptyCheckMap.keySet().iterator();
            List<String> delKeyList = new ArrayList<String>();
            while (emptyCheckItor.hasNext()) {
                String emptyCheckKey = emptyCheckItor.next();
                boolean  emptyCheckVal = emptyCheckMap.get(emptyCheckKey);
                if (!emptyCheckVal) {
                    continue;
                }
                List<String> list  = referenceKeyMap.get(emptyCheckKey);
                emptyMap.put(emptyCheckKey, "");
                for (int j = 0; j < list.size(); j++) {
                    emptyMap.put(list.get(j), "");
                }
                referenceKeyMap.remove(emptyCheckKey);
                delKeyList.add(emptyCheckKey);
            }
            if (delKeyList.size() > 0) {
                Iterator<String> itor = rowRefMap.keySet().iterator();
                while (itor.hasNext()) {
                    Map<String, String> crowMap = rowRefMap.get(itor.next());
                    for (int i = 0; i < delKeyList.size(); i++) {
                        crowMap.remove(delKeyList.get(i));
                    }
                }
            }
            
            Map<String, String> secQueryMap = processor.getQueryBusinessObjectCondition(showType, rowRefMap, referenceKeyMap);
            RefPath[] refPaths = processor.queryReference(secQueryMap, showType);
            connectSecondQueryResult(res, refPaths, secQueryMap, referenceKeyMap);
        }
        
        List<Map<String, String>> listRes = new LinkedList<Map<String, String>>();
        for (Map<String, String> resMap : res) {
            listRes.add(resMap);
        }
        return listRes;
    }
    
    /**
     * 将二次查询结果拼接到一次查询结果中
     * @param res
     * @param refPaths
     * @param secQueryMap
     * @param referenceKeyMap
     */
    private void connectSecondQueryResult(Map<String, String>[] res, RefPath[] refPaths, Map<String, String> secQueryMap, Map<String, List<String>>  referenceKeyMap) {
        if (refPaths != null) {
            int colNum = secQueryMap.size();
            for (int i = 0; i < res.length; i++) {
                Map<String, String> rowVal = res[i];
                for (int j = 0; j < colNum; j++) {
                    String key = secQueryMap.keySet().toArray(new String[colNum])[j];
                    if (referenceKeyMap.containsKey(key)) {
                        continue;
                    }
                    if (refPaths[j].values.length <= i) {
                        continue;
                    }
                    String cVal = refPaths[j].values[i].value;
                    rowVal.put(secQueryMap.keySet().toArray(new String[colNum])[j], cVal);
                }
            }
        }
    }
    
    /**
     * 获取自定义列的值
     * @param customMap, 自定义查询列
     * @param datas, 查询结果
     * @throws VCIError
     */
    private void getCustomValue(Map<String, PRMItem> customMap, List<Map<String, String>> datas) throws VCIError {
        Iterator<String> itor = customMap.keySet().iterator();
        while (itor.hasNext()) {
            String key = itor.next();
            PRMItem prm = customMap.get(key);
            String customCls = prm.getItemCustomClass();
            if(customCls == null || "".equals(customCls)){
                continue;
            }
            executeSetCustomValue(customCls, key, customMap, datas);
        }
    }
    
    /**
     * 执行自定义列类获取具体的值
     * @param customCls， 自定义类
     * @param key， 自定义列主键
     * @param customMap， 自定义列对应的Map
     * @param datas， 数据
     */
    private void executeSetCustomValue(String customCls, String key, Map<String, PRMItem> customMap, List<Map<String, String>> datas){
        try {
            int paramIndex = customCls.indexOf("?");
            String param = "";
            if(paramIndex > 0){
                param = customCls.substring(paramIndex + 1);
                customCls = customCls.substring(0, paramIndex);
            }
            Class<?> cls = Class.forName(customCls);
            ICustomDefine custom = (ICustomDefine)cls.getConstructor().newInstance();
            if(param != null && !"".equals(param)){
                key = key + "?" + param;
            }
            custom.getCustomValue(key, customMap, datas);
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
    private void getFileColValue(Map<String, PRMItem> fileMap, List<Map<String, String>> datas) throws VCIError {
        try {
            Iterator<String> itor = fileMap.keySet().iterator();
            while (itor.hasNext()) {
                String key = itor.next();
                PRMItem prm = fileMap.get(key);
                String customCls = prm.getItemCustomClass();
                if(customCls == null || "".equals(customCls)){
                    customCls = "plm.portal.custom.CustomFileInterceptor";
                }
                executeSetCustomValue(customCls, key, fileMap, datas);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    
    /**
     * 获取链接对象的详细信息
     * @param qtName， 查询模版
     * @param replaceMap， 替换map
     * @param conditionMap， 附加条件
     * @param linkType， 显示类型
     * @param isForward, 方向
     * @param queryColumnsMap， 查询列
     * @param customMap， 自定义列
     * @return
     * @throws VCIError
     * @throws DocumentException
     */
    public List<Map<String, String>> getLinkDataList(String qtName, Map<String, String> replaceMap, Map<String, String> conditionMap, boolean isForward, 
            String linkType, Map<String, String> queryColumnsMap, Map<String, PRMItem> customMap, Map<String, PRMItem> fileMap) throws VCIError, DocumentException {
        DataModelProcessor processor = new DataModelProcessor();
        LinkObject[] los = processor.getLinkObjectByQueryTemplate(qtName, replaceMap, conditionMap);
        List<Map<String, String>> datas = getLinkDataSecondList(processor, los, isForward, linkType, queryColumnsMap);
        if (customMap != null) {
            getCustomValue(customMap, datas);
        }
        if (fileMap != null && fileMap.size() > 0) {
            getFileColValue(fileMap, datas);
        }
        return datas;
    }
    
    /**
     * 返回LO二次查询结果
     * @param processor
     * @param los
     * @param isForward
     * @param linkType
     * @param formColumnsMap
     * @return
     */
    private List<Map<String, String>>  getLinkDataSecondList(
            DataModelProcessor processor,
            LinkObject[] los, boolean isForward, String linkType, 
            Map<String, String> queryColumnsMap){
        @SuppressWarnings("unchecked")
        Map<String, String>[] res = new LinkedHashMap[0];
        Map<String, List<String>>  referenceKeyMap = processor.getReferenceCol(queryColumnsMap);
        
        res = CBOHelper.getLOValueMap(los);
        if (referenceKeyMap.containsKey("t_oid")) {
            Map<String, String> rowRefMap = new LinkedHashMap<String, String>();
            Map<String, String> rowKeyMap = new LinkedHashMap<String, String>();
            String[] cTypes = new String[los.length];
            String cType = los[0].toBTMName;
            boolean isSingleType = true;
            for (int i = 0; i < los.length; i++) {
                String loOid = los[i].toOid;
                String refKey = "t_oid";
                rowRefMap.put(loOid, refKey);
                rowKeyMap.put(new ObjectUtility().getNewObjectID36(), loOid);
                if (!cType.equals(los[i].toBTMName)) {
                    isSingleType = false;
                }
                cTypes[i] = los[i].toBTMName;
            }
            Map<String, String> secQueryMap = processor.getQueryLinkObjectCondition(linkType, rowKeyMap, rowRefMap, referenceKeyMap);
            RefPath[] refPaths;
            if (isSingleType) {
                refPaths = processor.queryReference(secQueryMap, cType);
            } else {
                refPaths = processor.queryReference(secQueryMap, cTypes);
            }
            connectSecondQueryResult(res, refPaths, secQueryMap, referenceKeyMap);
            referenceKeyMap.remove("t_oid");
        }
        if (referenceKeyMap.containsKey("f_oid")) {
            Map<String, String> rowRefMap = new LinkedHashMap<String, String>();
            Map<String, String> rowKeyMap = new LinkedHashMap<String, String>();
            String[] cTypes = new String[los.length];
            String cType = los[0].fromBTMName;
            boolean isSingleType = true;
            for (int i = 0; i < los.length; i++) {
                String loOid = los[i].fromOid;
                String refKey = "f_oid";
                rowRefMap.put(loOid, refKey);
                rowKeyMap.put(new ObjectUtility().getNewObjectID36(), loOid);
                if (!cType.equals(los[i].fromBTMName)) {
                    isSingleType = false;
                }
                cTypes[i] = los[i].fromBTMName;
            }
            Map<String, String> secQueryMap = processor.getQueryLinkObjectCondition(linkType, rowKeyMap, rowRefMap, referenceKeyMap);
            RefPath[] refPaths;
            if (isSingleType) {
                refPaths = processor.queryReference(secQueryMap, cType);
            } else {
                refPaths = processor.queryReference(secQueryMap, cTypes);
            }
            connectSecondQueryResult(res, refPaths, secQueryMap, referenceKeyMap);
            referenceKeyMap.remove("f_oid");
        }
        
        Iterator<String> referenceKey = referenceKeyMap.keySet().iterator();
        List<String> referenceList = new LinkedList<String>();
        while (referenceKey.hasNext()) {
            referenceList.add(referenceKey.next());
        }
        if (referenceList.size() > 0) {
            Map<String, Map<String, String>> rowRefMap = new LinkedHashMap<String, Map<String, String>>();
            for (int i = 0; i < los.length; i++) {
                String boOid = los[i].oid;
                Map<String, String> refMap = new LinkedHashMap<String, String>();
                for (int j = 0; j < referenceList.size(); j++) {
                    String refKey = referenceList.get(j);
                    String refVal = ObjectTool.getLOAttributeValue(los[i], refKey);
                    if (refVal == null) {
                        refVal = "";
                    }
                    refMap.put(refKey, refVal);
                }
                rowRefMap.put(boOid, refMap);
            }
            Map<String, String> secQueryMap = processor.getQueryBusinessObjectCondition(linkType, rowRefMap, referenceKeyMap);
            RefPath[] refPaths = processor.queryReference(secQueryMap, "");
            connectSecondQueryResult(res, refPaths, secQueryMap, referenceKeyMap);
        }
        
        List<Map<String, String>> listRes = new LinkedList<Map<String, String>>();
        for (Map<String, String> resMap : res) {
            listRes.add(resMap);
        }
        return listRes;
    }
    
    /**
     * 国际化生命周期状态
     * @param datas
     */
    public void displayLifeCycleStatus(List<Map<String, String>> datas) {
        Map<String, StatePool> statePoolsMap = getAllStatusInfo();
        for (Map<String, String> data : datas) {
            Iterator<String> itor = data.keySet().iterator();
            while (itor.hasNext()) {
                String key = itor.next();
                if (!key.equalsIgnoreCase(LCSTATUS) && !key.toLowerCase().endsWith("." + LCSTATUS)) {
                    continue;
                }
                String value = data.get(key);
                if (statePoolsMap.containsKey(value)) {
                    data.put(key, statePoolsMap.get(value).tag);
                }
            }
        }
    }
    
    /**
     * 获取所有的生命周期状态
     * @return
     */
    private Map<String, StatePool> getAllStatusInfo() {
        Map<String, StatePool> statePoolsMap = new HashMap<String, StatePool>();
        try {
            StatePool[] statePools = StatePoolStart.getService().getStatePools();
            for(StatePool sp:statePools){
                statePoolsMap.put(sp.name, sp);
            }
        } catch (VCIError e) {
            e.printStackTrace();
        }
        return statePoolsMap;
    }
    
    /**
     * 显示链接类型数据的枚举值
     * @param datas
     * @param linkType
     */
    public void displayLinkObjectEnumValue(List<Map<String, String>> datas, String linkType) {
        String[] linktypes = new String[1];
        linktypes[0] = linkType;
        calcAttrEnumMapForLinkType(linktypes);
        getEnumValue(datas);
    }
    
    /**
     * 显示业务类型数据的枚举值
     * @param datas
     * @param type
     */
    public void displayBusinessObjectEnumValue(List<Map<String, String>> datas, String type) {
        String[] types = new String[1];
        types[0] = type;
        calcAttrEnumMapForBtmType(types);
        getEnumValue(datas);
    }
    
    private void getEnumValue(List<Map<String, String>> datas) {
        for (Map<String, String> data : datas) {
            Iterator<String> itor = data.keySet().iterator();
            while (itor.hasNext()) {
                String key = itor.next();
                String ckey = "";
                if (typeAttrEnumValueToNameMap.containsKey(key)) {
                    ckey = key;
                } else if (key.indexOf(".") > 0){
                    ckey = key.substring(key.lastIndexOf(".") + 1);
                    if (!typeAttrEnumValueToNameMap.containsKey(ckey)) {
                        continue;
                    }
                } else {
                    continue;
                }
                String value = data.get(key);
                HashMap<String, String> enumValue = typeAttrEnumValueToNameMap.get(ckey);
                if (enumValue.containsKey(value)) {
                    value = enumValue.get(value);
                }
                data.put(key, value);
            }
        }
    }
    
    /**
     * 计算指定链接类型 枚举属性的值map
     * @param types 业务类型名称集合
     */
    public void calcAttrEnumMapForLinkType(String[] linkTypes){
        try {
            LinkType[] lts = LinkTypeStart.getService().getLinkTypes();
            for(String type : linkTypes){
                for(LinkType lt : lts){
                    if(type.equals(lt.name)){
                        calcAttrEnumMapCommonLogic(lt.name, lt.attributes);
                        calcAttrEnumMapForBtmType(lt.btmItemsFrom);
                        calcAttrEnumMapForBtmType(lt.btmItemsTo);
                    }
                }
            }
        } catch (VCIError e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 计算指定业务类型 枚举属性的值map
     * @param types 业务类型名称集合
     */
    public void calcAttrEnumMapForBtmType(String[] btmTypes){
        try {
            for(String type : btmTypes){
                BtmAndApName[] baans = BtmClient.getService().getBtmAndApNameArray(type);
                for(BtmAndApName baan : baans) {
                    calcAttrEnumMapCommonLogic(baan.btmName, baan.apName);
                }
            }
        } catch (VCIError e) {
            e.printStackTrace();
        }
    }
    
    private void calcAttrEnumMapCommonLogic(String type, String[] attrNames) throws VCIError{
        AttribItem[] arItems = APClient.getService().getAttribItemsByNames(attrNames);
        for(AttribItem ai : arItems){
            //allowNull = yes;enumName = parttypeenum
            String[] others = ai.other.split(";");
            for(String other : others){
                String[] cvs = other.split("=");
                if(cvs[0].trim().equalsIgnoreCase("enumName")){
                    String enumName = cvs[1].trim();
                    HashMap<String, String> enumValueToName = getEnumValueOrNameMap(enumName, true);
                    HashMap<String, HashMap<String, String>> fieldToEnumValuetoNameMap = new HashMap<String, HashMap<String,String>>();
                    fieldToEnumValuetoNameMap.put(ai.name, enumValueToName);
                    typeAttrEnumValueToNameMap.putAll(fieldToEnumValuetoNameMap);
                    
                    HashMap<String, String> enumNameToValue = getEnumValueOrNameMap(enumName, false);
                    HashMap<String, HashMap<String, String>> fieldToEnumNameToValueMap = new HashMap<String, HashMap<String,String>>();
                    fieldToEnumNameToValueMap.put(ai.name, enumNameToValue);
                    typeAttrEnumNameToValueMap.putAll(fieldToEnumNameToValueMap);
                }
            }
        }
    }
    
    private HashMap<String, EnumItem> enumItemMap = new HashMap<String, EnumItem>();
    private HashMap<String, String> getEnumValueOrNameMap(String enumName, boolean valueToName){
        HashMap<String, String> map = new HashMap<String, String>();
        try {
            if(enumItemMap.size() == 0){
                EnumItemFilter filter = new EnumItemFilter();
                EnumItem[] enumItems = EnumClient.getService().getEmItems(filter, 1, 1);
                for(EnumItem ei : enumItems){
                    enumItemMap.put(ei.name, ei);
                }
            }
            if(enumItemMap.containsKey(enumName)){
                EnumItem ei = enumItemMap.get(enumName);
                for(EnumChild ec : ei.children){
                    if(valueToName){
                        map.put(ec.value, ec.name);
                    } else {
                        map.put(ec.name, ec.value);
                    }
                }
            }
        } catch (VCIError e) {
            e.printStackTrace();
        }
        return map;
    }
}