package com.vci.server.query.delegate;
|
|
import java.sql.SQLException;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
|
import org.apache.commons.lang3.ArrayUtils;
|
|
import com.vci.corba.omd.atm.AttribItem;
|
import com.vci.corba.omd.btm.BtmItem;
|
import com.vci.corba.omd.ltm.LinkType;
|
import com.vci.corba.query.data.RefPath;
|
import com.vci.corba.query.data.RefValue;
|
import com.vci.omd.objects.OtherInfo;
|
import com.vci.server.base.utility.ServerServiceProvider;
|
import com.vci.server.cache.OMCacheProvider;
|
import com.vci.server.query.refquery.objects.FromItem;
|
import com.vci.server.query.refquery.objects.MetaData;
|
import com.vci.server.query.refquery.objects.PLMRefPathInfo;
|
import com.vci.server.query.refquery.objects.PLMRefQueryPath;
|
import com.vci.server.query.refquery.utils.PLMRefSQLHelper;
|
import com.vci.server.query.refquery.utils.RefQueryUtils;
|
import com.vci.common.exception.VciExceptionTool;
|
import com.vci.common.log.ServerWithLog4j;
|
import com.vci.corba.common.VCIError;
|
|
public class RefQueryDelegate {
|
public static final String Other_Key = "btm";
|
public static final String Root_key = "A_1_OID";
|
public static final String ToOid = "t_oid";
|
public static final String FromOid = "f_oid";
|
|
|
/**
|
* 依据数据库最大的限制OID的数目做分割查询
|
*
|
* @param RefPath
|
* [] 参照路径数组
|
* @return RefPath [] 参照路径数组
|
* @throws Exception
|
* */
|
public RefPath[] limitNumQuery(RefPath[] paths, int limit)
|
throws Throwable {
|
List<RefPath> results = new ArrayList<RefPath>();
|
// parse path
|
PLMRefQueryPath[] refPaths = toQueryPath(paths);
|
// to mode(a subtree of type tree )
|
Map<String, List<PLMRefQueryPath>> queryConditions = toQuerymode(refPaths);
|
results = queryEachMode(queryConditions, limit);
|
return results.toArray(new RefPath[results.size()]);
|
}
|
|
public RefPath[] limitNumQuery(RefPath[] paths, String toType, int limit)
|
throws Throwable {
|
// 结果集合
|
List<RefPath> results = new ArrayList<RefPath>();
|
// 生成查询路径 parse path
|
PLMRefQueryPath[] refPaths = toQueryPath(paths, toType);
|
// 分割查询模式 to mode(a subtree of type tree )
|
Map<String, List<PLMRefQueryPath>> queryConditions = toQuerymode(refPaths);
|
// 查询每一个模式
|
results = queryEachMode(queryConditions, limit);
|
// 返回结果集合
|
return results.toArray(new RefPath[results.size()]);
|
}
|
|
public RefPath[] limitNumQuery(RefPath[] paths, String[] toTypes, int limit)
|
throws Throwable {
|
|
// 结果集合
|
List<RefPath> results = new ArrayList<RefPath>();
|
// 查询每一个模式
|
results = mulTypeQueury(paths, toTypes, limit);
|
// 返回结果集合
|
return results.toArray(new RefPath[results.size()]);
|
}
|
|
private List<RefPath> mulTypeQueury(RefPath[] paths, String[] toTypes, int limit) throws Throwable {
|
RefValue[] rvs = paths[0].values;
|
HashMap<String, List<RefValue>> map = new LinkedHashMap<String, List<RefValue>>();
|
HashMap<String, List<Integer>> seqMap = new LinkedHashMap<String, List<Integer>>();
|
|
for (int i = 0; i < rvs.length; i++) {
|
String type = toTypes[i];
|
List<RefValue> list = map.get(type);
|
if (list == null) {
|
list = new ArrayList<RefValue>();
|
map.put(type, list);
|
}
|
list.add(rvs[i]);
|
List<Integer> seqList = seqMap.get(type);
|
if (seqList == null) {
|
seqList = new ArrayList<Integer>();
|
seqMap.put(type, seqList);
|
}
|
seqList.add(i);
|
}
|
Iterator<String> itor = map.keySet().iterator();
|
int count = 0;
|
List<List<RefPath>> returnList = new ArrayList<List<RefPath>>();
|
Map<Integer, Integer> posMap = new LinkedHashMap<Integer, Integer>();
|
Map<ArrayList<RefValue>, String> queryMap = new LinkedHashMap<ArrayList<RefValue>, String>();
|
while (itor.hasNext()) {
|
String cType = itor.next();
|
List<RefValue> cList = map.get(cType);
|
List<Integer> cSeqList = seqMap.get(cType);
|
ArrayList<RefValue> midList = new ArrayList<RefValue>();
|
for (int i = 0; i < cList.size(); i++) {
|
midList.add(cList.get(i));
|
posMap.put(count, cSeqList.get(i));
|
if (count + 1 % limit == 0) {
|
queryMap.put(midList, cType);
|
returnList.add(multiTypeQuery(queryMap, paths));
|
queryMap = new HashMap<ArrayList<RefValue>, String>();
|
midList = new ArrayList<RefValue>();
|
}
|
count++;
|
}
|
queryMap.put(midList, cType);
|
midList = new ArrayList<RefValue>();
|
}
|
if (queryMap.size() > 0) {
|
returnList.add(multiTypeQuery(queryMap, paths));
|
}
|
List<RefPath> wrsList = null;
|
for (int i = 0; i < returnList.size(); i++) {
|
List<RefPath> rsList = returnList.get(i);
|
if (i == 0) {
|
wrsList = rsList;
|
continue;
|
}
|
for (int j = 0; j < rsList.size(); j++) {
|
ArrayUtils.addAll(wrsList.get(i).values, rsList.get(i).values);
|
}
|
}
|
for (int i = 0; i < wrsList.size(); i++) {
|
RefValue[] values = wrsList.get(i).values;
|
RefValue[] newValues = new RefValue[values.length];
|
for (int j = 0; j < values.length; j++) {
|
newValues[posMap.get(j)] = values[j];
|
newValues[posMap.get(j)].row = posMap.get(j);
|
}
|
wrsList.get(i).values = newValues;
|
}
|
|
return wrsList;
|
}
|
|
public List<RefPath> multiTypeQuery(Map<ArrayList<RefValue>, String> queryMap, RefPath[] paths) throws Throwable {
|
List<RefPath> list = null;
|
Iterator<ArrayList<RefValue>> itor = queryMap.keySet().iterator();
|
String allSql = "";
|
boolean isFirst = true;
|
|
PLMRefQueryPath[] crefPaths = null;
|
while (itor.hasNext()) {
|
ArrayList<RefValue> next = itor.next();
|
String type = queryMap.get(next);
|
RefPath[] cpaths = new RefPath[paths.length];
|
for (int i = 0; i < paths.length; i++) {
|
RefPath cPath = new RefPath();
|
cPath.path = paths[i].path;
|
cPath.values = copyRefValues(next.toArray(new RefValue[next.size()]));
|
cpaths[i] = cPath;
|
}
|
PLMRefQueryPath[] refPaths = toQueryPath(cpaths, type);
|
String sql = PLMRefSQLHelper.generateSQL(refPaths);
|
if (isFirst) {
|
allSql = sql;
|
crefPaths = refPaths;
|
isFirst = false;
|
} else {
|
allSql += " union " + sql;
|
for (int i = 0; i < crefPaths.length; i++) {
|
RefValue[] rfs1 = crefPaths[i].getPath().values;
|
RefValue[] rfs2 = refPaths[i].getPath().values;
|
RefValue[] trfs = new RefValue[rfs1.length + rfs2.length];
|
System.arraycopy(rfs1, 0, trfs, 0, rfs1.length);
|
System.arraycopy(rfs2, 0, trfs, rfs1.length, rfs2.length);
|
crefPaths[i].getPath().values = trfs;
|
}
|
}
|
}
|
list = getMultiQueryResult(crefPaths, allSql);
|
return list;
|
}
|
|
private RefValue[] copyRefValues(RefValue[] refValues) {
|
RefValue[] copyRefValues = new RefValue[refValues.length];
|
for (int i = 0; i < refValues.length; i++) {
|
RefValue copyRefValue = new RefValue();
|
copyRefValue.row = refValues[i].row;
|
copyRefValue.value = refValues[i].value;
|
copyRefValues[i] = copyRefValue;
|
}
|
|
return copyRefValues;
|
}
|
|
private List<RefPath> getMultiQueryResult(PLMRefQueryPath[] refpaths, String sql)
|
throws SQLException {
|
// reference SQL
|
String[] cnames = PLMRefSQLHelper.generateResultSetMetaData(refpaths);
|
// reference data
|
Map<String, Object> datas = RefQueryUtils.executeQuery(sql, cnames);
|
//如果没有查到，判断是否为业务类型，判读是否有继承关系的属性。如果有继承的业务对象，则继续查找。
|
try {
|
if(datas == null || datas.isEmpty()){
|
datas = queryAllChildBtmData(refpaths, cnames);
|
}
|
} catch (Exception e) {
|
//子查询时出现异常
|
e.printStackTrace();
|
}
|
|
List<RefPath> returnRefPaths = new ArrayList<RefPath>();
|
|
for (PLMRefQueryPath o : refpaths) {
|
// root node
|
if (o.getSelectKey() == null) {
|
returnRefPaths.add(o.getPath());
|
continue;
|
}
|
// 查询数据库，数据不存在
|
List<Object> values = (List<Object>) datas.get(o.getSelectKey()
|
.toUpperCase());
|
|
RefValue[] refValues = (RefValue[]) o.getPath().values;
|
|
for (int i = 0; i < refValues.length; i++) {
|
if (values == null || values.size() == 0) {
|
// 非主键
|
if (!o.getSelectKey().toUpperCase().equals(Root_key)) {
|
refValues[i].value = "";
|
continue;
|
}
|
}
|
int real = mapToDbIndex(refValues[i].value, datas);
|
if (real == -1) {
|
// 非主键
|
if (!o.getSelectKey().toUpperCase().equals(Root_key)) {
|
refValues[i].value = "";
|
}
|
} else {
|
refValues[i].value = values.get(real) instanceof String ? (String) values
|
.get(real) : String.valueOf(values.get(real));
|
}
|
}
|
returnRefPaths.add(o.getPath());
|
}
|
return returnRefPaths;
|
}
|
|
/**
|
* 将二次查询的属性进行分组
|
* eg. gpr.usepart.id
|
* gpr.usepart.code
|
* gpr.usepart.name
|
* gpr.useppart.id
|
* gpr.useppart.code
|
* gpr.useppart.name
|
* @param refPaths
|
* @return Map<usepart, List<PLMRefQueryPath>>
|
* <useppart,List<PLMRefQueryPath>>
|
*/
|
private Map<String, List<PLMRefQueryPath>> toQuerymode(
|
PLMRefQueryPath[] refPaths) {
|
Map<String, List<PLMRefQueryPath>> queryItems = new HashMap<String, List<PLMRefQueryPath>>();
|
for (int i = 0; i < refPaths.length; i++) {
|
MetaData firstLevelO = refPaths[i].getLevel(1);
|
if (queryItems.get(firstLevelO.getAttributeDef().name) == null) {
|
List<PLMRefQueryPath> levelRefPaths = new ArrayList<PLMRefQueryPath>();
|
levelRefPaths.add(refPaths[i]);
|
queryItems.put(firstLevelO.getAttributeDef().name,
|
levelRefPaths);
|
} else {
|
|
List<PLMRefQueryPath> levelRefPaths = queryItems
|
.get(firstLevelO.getAttributeDef().name);
|
levelRefPaths.add(refPaths[i]);
|
}
|
}
|
return queryItems;
|
|
}
|
|
private List<RefPath> queryEachMode(
|
Map<String, List<PLMRefQueryPath>> queryConditions, int limit)
|
throws VCIError {
|
List<RefPath> results = new ArrayList<RefPath>();
|
// query each of mode
|
Iterator<Entry<String, List<PLMRefQueryPath>>> itrator = queryConditions
|
.entrySet().iterator();
|
while (itrator.hasNext()) {
|
List<PLMRefQueryPath> refPathLists = itrator.next().getValue();
|
try {
|
// 限制数目是1000
|
int maxNum = 0;
|
// 所有的Id
|
if (refPathLists != null && refPathLists.size() != 0) {
|
maxNum = refPathLists.get(0).getPath().values.length;
|
}
|
if (maxNum < limit) {
|
results.addAll(query(refPathLists));
|
results.toArray(new RefPath[results.size()]);
|
} else {
|
results.addAll(splitValuesQuery(maxNum, refPathLists, limit));
|
}
|
} catch (SQLException e) {
|
ServerWithLog4j.logger.error(e.getMessage(), e);
|
throw new VCIError(RefQueryDelegate.class.getName(), new String[]{VciExceptionTool.getExceptionStr(e), VciExceptionTool.getExceptionDetail(e)});
|
|
}
|
|
}
|
return results;
|
}
|
|
private List<RefPath> splitValuesQuery(int maxNum,
|
List<PLMRefQueryPath> refPathLists, int limit) throws SQLException {
|
List<RefPath> results = new ArrayList<RefPath>();
|
// 保存一份数据
|
RefValue[] valuesCopy = new RefValue[maxNum];
|
RefValue[] valuesNew = new RefValue[maxNum];
|
System.arraycopy(refPathLists.get(0).getPath().values, 0, valuesNew, 0,
|
maxNum);
|
getCopy(maxNum, valuesCopy, valuesNew);
|
// 分批次查询
|
Map<RefPath, List<RefValue>> rsMaps = new HashMap<RefPath, List<RefValue>>();
|
for (int i = 0; i < (maxNum / limit) + 1; i++) {
|
int length = (maxNum - ((i) * (limit - 1)));
|
if (length < (limit - 1)) {
|
// 重新赋值
|
for (int j = 0; j < refPathLists.size(); j++) {
|
refPathLists.get(j).getPath().values = getEachSplitValueCopy(
|
length, (limit - 1), i, valuesNew);
|
}
|
} else {
|
// 重新赋值
|
for (int j = 0; j < refPathLists.size(); j++) {
|
refPathLists.get(j).getPath().values = getEachSplitValueCopy(
|
(limit - 1), (limit - 1), i, valuesNew);
|
}
|
}
|
// 执行查询
|
query(refPathLists);
|
// 分段查询结束
|
getEachSplitResult(refPathLists, rsMaps);
|
}// end for
|
// 全部查询结束
|
for (int n = 0; n < refPathLists.size(); n++) {
|
RefPath key = refPathLists.get(n).getPath();
|
// 非主键
|
if (refPathLists.get(n).getLevel() != 1) {
|
key.values = rsMaps.get(key).toArray(new RefValue[maxNum]);
|
} else {
|
refPathLists.get(n).getPath().values = valuesCopy;
|
}
|
// 返回结果
|
results.add(refPathLists.get(n).getPath());
|
}
|
return results;
|
}
|
|
@SuppressWarnings("unchecked")
|
private List<RefPath> query(List<PLMRefQueryPath> refPathLists)
|
throws SQLException {
|
PLMRefQueryPath[] refpaths = refPathLists
|
.toArray(new PLMRefQueryPath[refPathLists.size()]);
|
// reference SQL
|
String sql = PLMRefSQLHelper.generateSQL(refpaths);
|
String[] cnames = PLMRefSQLHelper.generateResultSetMetaData(refpaths);
|
// reference data
|
Map<String, Object> datas = RefQueryUtils.executeQuery(sql, cnames);
|
//如果没有查到，判断是否为业务类型，判读是否有继承关系的属性。如果有继承的业务对象，则继续查找。
|
try {
|
if(datas == null || datas.isEmpty()){
|
datas = queryAllChildBtmData(refpaths, cnames);
|
}
|
} catch (Exception e) {
|
//子查询时出现异常
|
e.printStackTrace();
|
}
|
|
List<RefPath> returnRefPaths = new ArrayList<RefPath>();
|
|
for (PLMRefQueryPath o : refpaths) {
|
// root node
|
if (o.getSelectKey() == null) {
|
returnRefPaths.add(o.getPath());
|
continue;
|
}
|
// 查询数据库，数据不存在
|
List<Object> values = (List<Object>) datas.get(o.getSelectKey()
|
.toUpperCase());
|
|
RefValue[] refValues = (RefValue[]) o.getPath().values;
|
|
for (int i = 0; i < refValues.length; i++) {
|
if (values == null || values.size() == 0) {
|
// 非主键
|
if (!o.getSelectKey().toUpperCase().equals(Root_key)) {
|
refValues[i].value = "";
|
continue;
|
}
|
}
|
int real = mapToDbIndex(refValues[i].value, datas);
|
if (real == -1) {
|
// 非主键
|
if (!o.getSelectKey().toUpperCase().equals(Root_key)) {
|
refValues[i].value = "";
|
}
|
} else {
|
refValues[i].value = values.get(real) instanceof String ? (String) values
|
.get(real) : String.valueOf(values.get(real));
|
}
|
}
|
returnRefPaths.add(o.getPath());
|
}
|
return returnRefPaths;
|
}
|
|
/**
|
* 获得传入数组的备份
|
* */
|
private RefValue[] getCopy(int maxNum, RefValue[] valuesCopy,
|
RefValue[] valuesNew) {
|
int b = 0;
|
for (RefValue v : valuesNew) {
|
RefValue temp = new RefValue();
|
temp.row = v.row;
|
temp.value = v.value;
|
valuesCopy[b] = temp;
|
++b;
|
}
|
return valuesCopy;
|
}
|
|
/**
|
* 分割后，每一个批次的result
|
* */
|
private Map<RefPath, List<RefValue>> getEachSplitResult(
|
List<PLMRefQueryPath> refPathLists,
|
Map<RefPath, List<RefValue>> rsMaps) {
|
for (int n = 0; n < refPathLists.size(); n++) {
|
RefPath key = refPathLists.get(n).getPath();
|
if (rsMaps.get(key) == null) {
|
List<RefValue> valueObjects = new ArrayList<RefValue>();
|
valueObjects.addAll(Arrays.asList(key.values));
|
rsMaps.put(key, valueObjects);
|
} else {
|
rsMaps.get(key).addAll(Arrays.asList(key.values));
|
}
|
}
|
return rsMaps;
|
}
|
|
/**
|
* 分割后，每一个批次的Value
|
* */
|
private RefValue[] getEachSplitValueCopy(int length, int limit, int batch,
|
RefValue[] valuesNew) {
|
RefValue[] eachbatch = new RefValue[(length)];
|
for (int c = 0; c < (length); c++) {
|
RefValue temp = new RefValue();
|
temp.row = valuesNew[batch * (limit - 1) + c].row;
|
temp.value = valuesNew[batch * (limit - 1) + c].value;
|
eachbatch[c] = temp;
|
}
|
return eachbatch;
|
}
|
|
@SuppressWarnings("unchecked")
|
private int mapToDbIndex(String oid, Map<String, Object> dbdatas) {
|
List<Object> dbvalues = (List<Object>) dbdatas.get(Root_key);
|
return dbvalues.indexOf(oid);
|
}
|
|
private PLMRefPathInfo generatePathInfo(RefPath path,
|
Map<String, String> toFromTypes) throws Throwable {
|
// 根类型的所有的属性信息
|
AttribItem[] leveloneattrs = getAllAttributeByTypeName(path.path
|
.split("\\.")[0]);
|
PLMRefPathInfo pathInfo = new PLMRefPathInfo();
|
List<MetaData> metas = new ArrayList<MetaData>();
|
String[] cascade = path.path.split("\\.");
|
|
for (int i = 0; i < cascade.length; i++) {
|
if (i == 0 || (i > 1 && i == cascade.length - 1)) {
|
continue;
|
}
|
AttribItem currentAttribute = null;
|
if (i == 1) {
|
for (AttribItem a : leveloneattrs) {
|
if (a.name.equals(cascade[i])) {
|
currentAttribute = a;
|
break;
|
}
|
}
|
}
|
if (i > 1) {
|
currentAttribute = getCurrentAttribute(cascade[i]);
|
}
|
// 查询类型
|
getCurrentType(currentAttribute, null, path, toFromTypes, i, metas);
|
// generateMetaData(metas, currentAttribute, currentType, i);
|
}
|
pathInfo.setMd(metas.toArray(new MetaData[metas.size()]));
|
return pathInfo;
|
}
|
|
private void generateMetaData(List<MetaData> metas, AttribItem currentAttr,
|
Object type, int level, OtherInfo info) {
|
MetaData meta = new MetaData();
|
meta.setAttribItem(currentAttr);
|
if (type instanceof BtmItem) {
|
meta.setRefType((BtmItem) type);
|
meta.setType(true);
|
} else {
|
if (info != null) {
|
meta.setQueryEnum(info.getRefFlag());
|
}
|
meta.setRefLink((LinkType) type);
|
meta.setType(false);
|
}
|
meta.setLevel(level);
|
metas.add(meta);
|
}
|
|
/**
|
* 生成查询路径
|
*
|
* @param RefPath
|
* 参照的路径信息 ，String 链接的to端类型
|
* */
|
|
private PLMRefPathInfo generatePathInfo(RefPath path, String toType,
|
Map<String, String> toFromTypes) throws Throwable {
|
PLMRefPathInfo pathInfo = new PLMRefPathInfo();
|
List<MetaData> metas = new ArrayList<MetaData>();
|
String[] cascade = path.path.split("\\.");
|
for (int i = 0; i < cascade.length; i++) {
|
if (i == 0 || (i > 1 && i == cascade.length - 1)) {
|
continue;
|
}
|
AttribItem currentAttr = null;
|
// 得到属性定义信息
|
currentAttr = getCurrentAttribute(cascade[i]);
|
getCurrentType(currentAttr, toType, path, toFromTypes, i, metas);
|
// generateMetaData(metas, currentAttr, type, i);
|
}
|
pathInfo.setMd(metas.toArray(new MetaData[metas.size()]));
|
return pathInfo;
|
}
|
|
/**
|
* 生成查询路径集合
|
*
|
* @param RefPath
|
* [] 参照的路径信息 ，String 链接的to端类型
|
* */
|
private PLMRefQueryPath[] toQueryPath(RefPath[] paths, String toType)
|
throws Throwable {
|
List<PLMRefQueryPath> refPaths = new ArrayList<PLMRefQueryPath>();
|
// 收集to\from端类型
|
Map<String, String> toFromTypes = new HashMap<String, String>();
|
for (RefPath path : paths) {
|
int level = path.path.split("\\.").length;
|
PLMRefQueryPath refPath = new PLMRefQueryPath();
|
refPath.setPath(path);
|
refPath.setLevel(level - 1);
|
PLMRefPathInfo info = generatePathInfo(path, toType, toFromTypes);
|
refPath.setPathInfo(info);
|
refPaths.add(refPath);
|
}
|
return refPaths.toArray(new PLMRefQueryPath[refPaths.size()]);
|
|
}
|
|
// private PLMRefQueryPath[] toQueryPath(RefPath[] paths, String[] toTypes)
|
// throws Throwable {
|
// List<PLMRefQueryPath> refPaths = new ArrayList<PLMRefQueryPath>();
|
// // 收集to\from端类型
|
// Map<String, String> toFromTypes = new HashMap<String, String>();
|
// for (int i = 0; i < paths.length; i++) {
|
// RefPath path = paths[i];
|
// int level = path.path.split("\\.").length;
|
// PLMRefQueryPath refPath = new PLMRefQueryPath();
|
// refPath.setPath(path);
|
// refPath.setLevel(level - 1);
|
// PLMRefPathInfo info = generatePathInfo(path, toTypes[i], toFromTypes);
|
// refPath.setPathInfo(info);
|
// refPaths.add(refPath);
|
// }
|
// return refPaths.toArray(new PLMRefQueryPath[refPaths.size()]);
|
//
|
// }
|
|
private PLMRefQueryPath[] toQueryPath(RefPath[] paths) throws Throwable {
|
List<PLMRefQueryPath> refPaths = new ArrayList<PLMRefQueryPath>();
|
// 收集to\from端类型
|
Map<String, String> toFromTypes = new HashMap<String, String>();
|
for (RefPath path : paths) {
|
int level = path.path.split("\\.").length;
|
PLMRefQueryPath refPath = new PLMRefQueryPath();
|
refPath.setPath(path);
|
refPath.setLevel(level - 1);
|
PLMRefPathInfo info = generatePathInfo(path, toFromTypes);
|
refPath.setPathInfo(info);
|
refPaths.add(refPath);
|
}
|
return refPaths.toArray(new PLMRefQueryPath[refPaths.size()]);
|
|
}
|
|
/**
|
* 查询路径在指定的层次的业务类型定义
|
*
|
* @param AttribItem
|
* 属性定义 ，String 链接的to端类型
|
* */
|
private Object getCurrentType(AttribItem attribute, String toType,
|
RefPath path, Map<String, String> toFromTypes, int level,
|
List<MetaData> metas) throws VCIError {
|
Object retrun = null;
|
BtmItem btmItem = null;
|
LinkType linkItem = null;
|
try {
|
if (attribute.name.toLowerCase().trim().equals(ToOid)
|
|| attribute.name.toLowerCase().trim().equals(FromOid)) {
|
// t_oid or f_oid 处于第一层
|
if (toType != null && !toType.equals("")) {
|
// query reference type
|
//btmItem = ServerServiceProvider.getOMDService().getBTMService().getBtmItemByName(toType);
|
btmItem = OMCacheProvider.getBizType(toType);
|
retrun = btmItem;
|
generateMetaData(metas, attribute, retrun, level, null);
|
} else {
|
// t_oid or f_oid 处于非第一层
|
String key = getIndentifier((level), path);
|
if (toFromTypes.get(key) != null) {
|
//btmItem = ServerServiceProvider.getOMDService().getBTMService().getBtmItemByName(toFromTypes.get(key));
|
btmItem = OMCacheProvider.getBizType(toFromTypes.get(key));
|
retrun = btmItem;
|
generateMetaData(metas, attribute, retrun, level, null);
|
return retrun;
|
}
|
String linkTypeName = path.path.split("\\.")[level - 1];//
|
AttribItem attributeItem = getCurrentAttribute(linkTypeName);
|
OtherInfo info = OtherInfo.getOtherInfoByText(attributeItem.other);
|
String oid = path.values[0].value;
|
|
String typeName = attribute.name.toLowerCase().trim()
|
.equals(FromOid) ? searchType(info.getRefTypeName(),
|
oid, false) : searchType(info.getRefTypeName(), oid,
|
true);
|
//btmItem = ServerServiceProvider.getOMDService().getBTMService().getBtmItemByName(typeName);
|
btmItem = OMCacheProvider.getBizType(typeName);
|
toFromTypes.put(key, typeName);
|
retrun = btmItem;
|
generateMetaData(metas, attribute, retrun, level, info);
|
}
|
} else {
|
// 普通属性：分为业务类型与链接类型
|
// is reference Attribute
|
OtherInfo info = OtherInfo.getOtherInfoByText(attribute.other);
|
// 业务类型
|
if (info.getRefFlag() == 0) {
|
btmItem = ServerServiceProvider.getOMDService().getBTMService().getBtmItemByName(
|
info.getRefTypeName());
|
retrun = btmItem;
|
} else {
|
linkItem = ServerServiceProvider.getOMDService().getLinkTypeService().getLinkType(
|
info.getRefTypeName());
|
retrun = linkItem;
|
}
|
generateMetaData(metas, attribute, retrun, level, null);
|
}
|
} catch (Throwable e) {
|
throw new VCIError("", new String[]{VciExceptionTool.getExceptionStr(e), VciExceptionTool.getExceptionDetail(e)});
|
// TODO: handle exception
|
}
|
return retrun;
|
}
|
|
private String getIndentifier(int i, RefPath path) {
|
String[] s = path.path.split("\\.");
|
String results = "";
|
for (int j = 0; j <= i; j++) {
|
|
results += s[j];
|
results += ".";
|
}
|
return results.substring(0, results.lastIndexOf("."));
|
|
}
|
|
private String searchType(String link, String oid, boolean to)
|
throws SQLException {
|
StringBuilder searchSQL = new StringBuilder();
|
Object o = null;
|
if (to) {
|
searchSQL.append(" select t_btwname from ").append("platformlt_")
|
.append(link).append(" where oid in ('").append(oid)
|
.append("')");
|
|
Map<String, Object> toTypes = RefQueryUtils.executeQuery(
|
searchSQL.toString(), new String[] { "t_btwname" });
|
|
o = toTypes.get("t_btwname");
|
} else {
|
searchSQL.append(" select f_btwname from ").append("platformlt_")
|
.append(link).append(" where oid in ('").append(oid)
|
.append("')");
|
|
Map<String, Object> toTypes = RefQueryUtils.executeQuery(
|
searchSQL.toString(), new String[] { "f_btwname" });
|
o = toTypes.get("f_btwname");
|
}
|
|
return o.toString();
|
}
|
|
/**
|
* 查询路径在指定的层次的属性定义
|
*
|
* @param String
|
* 属性名称
|
* */
|
private AttribItem getCurrentAttribute(String name) throws Throwable {
|
AttribItem currentAttr = null;
|
if (name.toLowerCase().trim().equals(ToOid)
|
|| name.toLowerCase().trim().equals(FromOid)) {
|
AttribItem attribute = new AttribItem();
|
attribute.name = name.toLowerCase().trim().equals(ToOid) ? ToOid
|
: FromOid;
|
currentAttr = attribute;
|
} else {
|
currentAttr = getAttributeByName(name);
|
}
|
return currentAttr;
|
}
|
|
private AttribItem getAttributeByName(String name) throws Throwable {
|
return OMCacheProvider.getAttribute(name);
|
// AttribItem[] arrays = ServerServiceProvider.getOMDService().getAttributeService().getAttribItemsByNames(new String[0]);
|
// for (AttribItem a : arrays) {
|
// if (a.name.equals(name)) {
|
// return a;
|
// }
|
// }
|
// return null;
|
}
|
|
/**
|
* 依据业务类型的名称，获取所有的属性定义信息
|
*
|
* @param String
|
* 业务类型名称
|
* */
|
private AttribItem[] getAllAttributeByTypeName(String typeName)
|
throws Throwable {
|
//BtmItem typeItem = ServerServiceProvider.getOMDService().getBTMService().getBtmItemByName(typeName);
|
BtmItem typeItem = OMCacheProvider.getBizType(typeName);
|
String[] attributeNames = typeItem.apNameArray;
|
List<AttribItem> attributes = new ArrayList<AttribItem>();
|
for (String s : attributeNames) {
|
attributes.add(getAttributeByName(s));
|
}
|
return attributes.toArray(new AttribItem[attributes.size()]);
|
}
|
|
/**
|
* 一次从子业务类型中查找数据
|
* 知道找到为止，如果全不包含返回空Map
|
* @param refpaths
|
* @param cnames
|
* @return
|
*/
|
private Map<String, Object> queryAllChildBtmData(PLMRefQueryPath[] refpaths, String[] cnames){
|
Map<String, Object> datas = new HashMap<String, Object>();
|
try {
|
//得到所有子业务类型
|
List<FromItem> fromItemList = PLMRefSQLHelper.generateFromItemList(refpaths);
|
BtmItem[] bits = getChildBtm(fromItemList);
|
if(bits != null && bits.length > 0){
|
for(BtmItem bit : bits) {
|
//重新设置refPaths和FormItem的信息
|
for(FromItem fi : fromItemList){
|
fi.getMeta().setRefType(bit);
|
}
|
//设置查询语句
|
String sql = PLMRefSQLHelper.generateSQL(refpaths, fromItemList);
|
//执行查询
|
datas = RefQueryUtils.executeQuery(sql, cnames);
|
if(datas == null || !datas.isEmpty()){
|
break;
|
}
|
}
|
}
|
} catch (Exception e) {
|
//System.out.println("二次查询时发生异常！");
|
//e.printStackTrace();
|
ServerWithLog4j.logger.error("二次查询时发生异常！", e);
|
}
|
return datas;
|
}
|
|
/**
|
* 获得所有子业务类型
|
* @return
|
*/
|
/**
|
* 得到业务对象名称
|
* @param fromitems
|
* @return
|
*/
|
private static BtmItem[] getChildBtm(List<FromItem> fromitems) {
|
String btmName = "";
|
for (FromItem item : fromitems) {
|
if (item.getLevel() == 1) {
|
// 判断是业务对象还是link对象
|
if (item.getMeta().isType()) {
|
btmName = item.getMeta().getRefType().name;
|
} else {
|
btmName = item.getMeta().getRefLink().name;
|
}
|
break;
|
}
|
}
|
try {
|
BtmItem[] a1 = ServerServiceProvider.getOMDService().getBTMService().getChildrenBtms(btmName);
|
return a1;
|
} catch (Throwable e) {
|
//System.out.println("查询子对象异常！");
|
//e.printStackTrace();
|
ServerWithLog4j.logger.error("查询子对象异常！", e);
|
return null;
|
}
|
}
|
|
|
}
|
