package nc.ui.bd.ref;
/**
* 表参照－其他参照基类。 创建日期：(2001-8-23 20:26:54) 模型里未处理栏目
*
* @author：张扬
*
*/
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.EventListenerList;
import nc.bs.framework.common.InvocationInfoProxy;
import nc.bs.framework.common.RuntimeEnv;
import nc.bs.logging.Logger;
import nc.jdbc.framework.misc.LRUMap;
import nc.ui.bd.BDGLOrgBookAccessor;
import nc.ui.bd.mmpub.DataDictionaryReader;
import nc.ui.uap.bd.def.DefFieldInfo;
import nc.ui.uap.bd.def.UFRefDefTanslateUtil;
import nc.vo.bd.access.BdinfoVO;
import nc.vo.bd.ref.DocSealWherePartMng;
import nc.vo.bd.ref.IFilterStrategy;
import nc.vo.bd.ref.RefColumnDispConvertVO;
import nc.vo.bd.ref.RefQueryResultVO;
import nc.vo.bd.ref.RefQueryVO;
import nc.vo.bd.ref.RefVO_mlang;
import nc.vo.bd.ref.RefcolumnVO;
import nc.vo.bd.ref.ReftableVO;
import nc.vo.bd.refdatatemp.RefdatatempVO;
import nc.vo.jcom.lang.StringUtil;
import nc.vo.logging.Debug;
import nc.vo.ml.NCLangRes4VoTransl;
import nc.vo.pub.BusinessException;
import nc.vo.pub.formulaset.FormulaParseFather;
import nc.vo.pub.lang.UFBoolean;
import nc.vo.sm.nodepower.OrgnizeTypeVO;
public abstract class AbstractRefModel implements IRefModel {
private String para1 = null;
private String para2 = null;
private String para3 = null;
protected IRefModelHandler modelHandler;
private ArrayList hiddenFieldList = new ArrayList();
// V55需求，是否大小写敏感
private boolean isCaseSensitve = false;
//
private Vector vecAllColumnNames = null;
private RefQueryVO queryVO = new RefQueryVO();
/**
* AbstractRefModel 构造子注解。
*/
public AbstractRefModel() {
super();
try {
Class c;
// 加载服务器类。
if (RuntimeEnv.getInstance().isRunningInServer())
c = Class.forName("nc.ui.bd.ref.impl.RefModelHandlerForServer");
// 加载客户端类
else {
// Server server = (Server)
// NCLocator.getInstance().lookup(Server.class.getName());
// Container container = server.getContainer("uap");
// if(container == null)
// throw new ServletException("无法找到模块uap");
// ClassLoader cl = container.getClassLoader();
c = Class.forName("nc.ui.bd.ref.RefModelHandlerForClient");
}
Constructor cs = c
.getConstructor(new Class[] { AbstractRefModel.class });
modelHandler = (IRefModelHandler) cs.newInstance(this);
} catch (Exception e) {
Logger.error(e);
}
}
private String[] m_strFieldCode = null; // 业务表的字段名
private String[] m_strFieldName = null; // 业务表的字段中文名
// 业务表字段类型
private int[] m_intFieldType = null;
private String m_strPkFieldCode = null;
private String m_strTableName = null; // 业务表名
private java.lang.String m_strBlurValue = null;
private String m_strRefTitle = null;
protected Vector m_vecData = null;
private int m_iDefaultFieldCount = 2;
private String m_strOrderPart = null;
protected java.lang.String m_strPk_corp = null;
protected String m_strRefCodeField = null;
protected String m_strRefNameField = null;
protected Vector m_vecSelectedData = null;
private String m_strStrPatch = "";
private String m_strWherePart = null;
private boolean m_bCacheEnabled = true;
private Hashtable m_htCodeIndex = null;
private String m_orgTypeCode = OrgnizeTypeVO.COMPANY_TYPE;
// 当前参照所在界面的功能节点号
private String m_fun_code = null;
// 参照增加按钮打开节点的功能节点编码
private String m_fun_code_DocOpen = null;
// 主体账簿主键
private String m_pk_glOrgBook = null;
// 增加从临时表取数的方式 2004-06-10
private boolean isFromTempTable = false;
// 是否包含模糊匹配Sql
private boolean isIncludeBlurPart = true;
// sxj 返回值是否包含下级节点
private boolean isIncludeSub = false;
private boolean isPKMatch = false;
// 树表和树型参照可以带一个表型参照，用来匹配助记码等。
private AbstractRefModel m_defGridmodel = null;
// sxj 2003-10-31
// 匹配数据时，如果匹配不上，是否刷新数据再匹配一次
private boolean m_isRefreshMatch = true;
// sxj 2004-03-17
// 是否显示封存数据
private boolean m_isSealedDataShow = false;
// 增加用户可以自定义setPk匹配的列。 2004-09-23
private String m_matchField = null;
// 数据匹配
private HashMap m_matchHM = new HashMap();
// 支持助记码2003-02-19
// 支持助记码组 2004-01-12
private String[] m_mnecodes = null;
// sxj 2003-11-14
private String querySql = null;
// 高级过滤类名
private String refFilterDlgClaseName = null;
private String refQueryDlgClaseName = null;
// sxj
private Object userPara = null;
protected static final String LARGE_NODE_NAME = "客商基本档案:客商档案:客户档案:供应商档案:客商辅助核算:客户辅助核算:供应商辅助核算:客商档案包含冻结:客户档案包含冻结:供应商档案包含冻结:存货基本档案:存货档案:存货辅助核算:物料档案";
// 参照setpk匹配数据时，是否包含参照WherePart的开关
private boolean isMatchPkWithWherePart = false;
// 参照的编辑状态,该状态和界面的可编辑性一致
private boolean m_isRefEnable = true;
// 参照对公式解析的支持
// 格式举例 formula[0][0] ="字段";formula[0][1]="公式内容"
private String[][] formulas = null;
// 树表参照查询是否启用(不是高级查询)
boolean isLocQueryEnable = true;
// 是否允许选择非末级
private boolean m_bNotLeafSelectedEnabled = true;
// isUseDataPower 2002-09-09
private boolean m_bUserDataPower = true;
// 动态列接口名字
private String m_dynamicColClassName = null;
// sxj 2003-04-10
// 提供按给定的Pks进行过滤
private int m_filterStrategy = IFilterStrategy.INSECTION;
private HashMap m_hmFilterPks = new HashMap();
private String[] m_filterPks = null;
// htDispConvert2002-08-30
private Hashtable m_htDispConvertor = null;
// sxj 2003-10-28 动态列启用开关
private boolean m_isDynamicCol = false;
private int[] m_iShownColumns = null;
// 支持助记码多条记录的匹配2003-02-21
private boolean m_mnecodeInput = false;
private String[] m_strBlurFields = null;
private java.lang.String m_strDataSource = null;
// 动态列名称
private String[] m_strDynamicFieldNames = null;
private java.lang.String m_strGroupPart = null;
private String[] m_strHiddenFieldCode = null;
private java.lang.String m_strOriginWherePart;
// 新增参照ID(这里是名称)
protected String m_strRefNodeName = null;
// 用户调用动态列接口时，要使用到的参数。
private Object m_userParameter = null;
//
// private Vector m_vecUnMatchData = null;
private String refTempDataWherePart = null;
// 模糊匹配时，默认把code+助记码列（数组）作为匹配的列。该参数决定是否只用助记码列来匹配
private boolean isOnlyMneFields = false;
// 增补的wherePart
private String m_addWherePart = null;
// 处理特殊列显示转换
private Object[][] m_columnDispConverter = null;
// 用户
private String m_pk_user = null;
FormulaHandler formulaHandler = null;
DefFieldsHandler defFieldHandler = null;
private EventListenerList eListenerList = new EventListenerList();
private Map eventListMap = new HashMap();
private transient ChangeEvent changeEvent = null;
// 是否只显示集团数据
private boolean isGroupAssignData = false;
// 参照数据缓存Key前缀字符串
private String refDataCachekeyPreStr = "REFDATACACHE";
private DDReaderVO ddReaderVO = null;
// 对于自定义参照数据权限的支持.数据权限优先按资源ID查询。
private int resourceID = -1;
private String sealedWherePart = null;
// 该条件会根据环境变量变化，同时在setpk时不带此条件
private String envWherePart = null;
private BdinfoVO bdinfoVO = null;
// 是否已初始化BDInfoVO
private boolean isInitBDinfoVO = false;
// 是否要改变关联表的顺序（为缓存）
private boolean isChangeTableSeq = true;
// 维护按钮是否可用
private boolean isMaintainButtonEnabled = true;
// 数据权限资源字段
private String dataPowerResourceColumn = null;
// 记录详细信息显示组件
private String refCardInfoComponentImplClass = null;
// 参照显示字段
private String refShowNameField = null;
// 自定义项字段,必须是表名.字段名
private String[] defFields = null;
// 对齐方式Map
private Map<String, Integer> alignMap = null;
// 界面控制自定义组件名称,该实现类必须继承JComponent，且包含AbstractRefMOdel的构造子
private String uiControlComponentClassName = null;
// 参照维护接口类，since v5.5 支持自定义档案维护界面
private String refDocEditClassName = null;
private class DDReaderVO {
String tableName = null;
String[] fieldNames = null;
/**
* @return 返回 fieldNames。
*/
public String[] getFieldNames() {
return fieldNames;
}
/**
* @param fieldNames
* 要设置的 fieldNames。
*/
public void setFieldNames(String[] fieldNames) {
this.fieldNames = fieldNames;
}
/**
* @return 返回 tableName。
*/
public String getTableName() {
return tableName;
}
/**
* @param tableName
* 要设置的 tableName。
*/
public void setTableName(String tableName) {
this.tableName = tableName;
}
}
/**
* @return 返回 m_columnDispConverterClass。
*/
public Object[][] getColumnDispConverter() {
return m_columnDispConverter;
}
/**
* @param dispConverterClass
* 要设置的 m_columnDispConverterClass。
*/
public void setColumnDispConverter(Object[][] dispConverter) {
m_columnDispConverter = dispConverter;
}
/**
* 增加where子句 创建日期：(2001-8-16 12:42:02)
*
* @param newWherePart
* java.lang.String
*/
public void addWherePart(String newWherePart) {
// 从原始Where增加
// m_strWherePart = getOriginWherePart();
// if (m_strWherePart == null || m_strWherePart.trim().length() == 0) {
// m_strWherePart = " ( 11 = 11 )";
// }
// if (newWherePart != null && newWherePart.trim().length() > 0) {
// m_strWherePart = "( " + m_strWherePart + " )";
// m_strWherePart += " " + newWherePart + " ";
// }
// setAddWherePart(newWherePart);
m_addWherePart = newWherePart;
// clearData();
resetSelectedData_WhenDataChanged();
}
/**
* 创建日期：(2004-9-23 9:03:51)
*
* @param newM_matchField
* java.lang.String 自定义的列。用SetPk方法设的值在该列中匹配。 不建议使用。
*/
public void setMatchField(java.lang.String newM_matchField) {
m_matchField = newM_matchField;
}
/**
* 此处插入方法说明。
*
* /** 清除数据及缓存。 创建日期：(2001-8-23 21:01:00)
*/
public void clearData() {
clearModelData();
clearCacheData();
}
/**
* 删除参照缓存数据
*/
public void clearCacheData() {
modelHandler.clearCacheData();
}
protected void clearModelData() {
m_vecData = null;
setSelectedData(null);
}
protected void clearDataPowerCache() {
modelHandler.clearDataPowerCache();
}
/**
* 将一行数据转化为VO,如不使用VO可以虚实现。 创建日期：(2001-8-13 16:34:11)
*
* @return nc.vo.pub.ValueObject
* @param vData
* java.util.Vector
*/
public nc.vo.pub.ValueObject convertToVO(java.util.Vector vData) {
return null;
}
/**
* 将多行数据转化为VO数组。 创建日期：(2001-8-13 16:34:11)
*
* @return nc.vo.pub.ValueObject[]
* @param vData
* java.util.Vector
*/
public nc.vo.pub.ValueObject[] convertToVOs(java.util.Vector vData) {
if (vData == null || vData.size() == 0)
return null;
nc.vo.pub.ValueObject[] vos = new nc.vo.pub.ValueObject[vData.size()];
for (int i = 0; i < vData.size(); i++) {
Vector vRecord = (Vector) vData.elementAt(i);
vos[i] = convertToVO(vRecord);
}
return vos;
}
/**
* 模糊字段值。 创建日期：(2001-8-17 11:17:42)
*
* @return java.lang.String
*/
public String getBlurValue() {
return m_strBlurValue;
}
/**
* 获取缓存或数据库表中的参照数据－－二维Vector。
* <p>
* <strong>最后修改人：sxj</strong>
* <p>
* <strong>最后修改日期：2006-7-12</strong>
* <p>
*
* @param
* @return Vector
* @exception BusinessException
* @since NC5.0
*/
public final Vector getRefData() {
return modelHandler.getRefData();
}
/**
* 获取参照数据－－二维Vector。 自定义参照可以覆盖
*
* @return java.util.Vector
*/
public java.util.Vector getData() {
String sql = getRefSql();
Vector v = null;
if (isCacheEnabled()) {
/** 从缓存读数据 */
v = modelHandler.getFromCache(getRefDataCacheKey(),
getRefCacheSqlKey());
}
if (v == null) {
// 从数据库读--也可以在此定制数据
try {
if (isFromTempTable()) {
v = modelHandler.queryRefDataFromTemplateTable(sql);
} else {
// 同时读取参照栏目数据
v = getQueryResultVO();
}
} catch (Exception e) {
Debug.debug(e.getMessage(), e);
}
}
putToCache(v);
m_vecData = v;
return m_vecData;
}
public void putToCache(Vector v) {
if (v != null && isCacheEnabled()) {
/** 加入到缓存中 */
modelHandler.putToCache(getRefDataCacheKey(), getRefCacheSqlKey(),
v);
}
}
public Vector getConvertedData1(boolean isDataFromCache, Vector v,
boolean isDefConverted) {
return getConvertedData(isDataFromCache, v, isDefConverted);
}
/**
* <p>
* <strong>最后修改人：sxj</strong>
* <p>
* <strong>最后修改日期：2006-7-12</strong>
* <p>
*
* @param
* @return void
* @exception BusinessException
* @since NC5.0
*/
protected Vector getConvertedData(boolean isDataFromCache, Vector v,
boolean isDefConverted) {
if (v == null) {
return v;
}
Vector vecData = v;
// 与总账协商的结果,按传入Pks过滤
if (vecData != null && vecData.size() > 0) {
vecData = getFilterPKsVector(vecData, getFilterStrategy());
}
// 多语言处理
// 缓存中的数据已经处理过了.
if (!isDataFromCache) {
setMlangValues(vecData, getRefVO_mlang());
if (getFormulas() != null) {
getFormulaHandler().setFormulaValues(vecData, getFormulas());
}
// 统计型自定义项pk-->name
if (isDefConverted) {
getDefFieldHandler().setDefFieldValues(vecData);
}
}
// 特殊处理结束
// try to convert
handleDispConvertor(vecData);
// end converts
// 处理特殊显示列。
if (getColumnDispConverter() != null) {
setColDispValues(vecData, getColumnDispConverter());
}
return vecData;
}
/**
* 枚举类型显示值的转换
* <p>
* <strong>最后修改人：sxj</strong>
* <p>
* <strong>最后修改日期：2006-3-9</strong>
* <p>
*
* @param
* @return void
* @exception
* @since NC5.0
*/
private void handleDispConvertor(Vector v) {
if (getDispConvertor() != null) {
Hashtable convert = getDispConvertor();
Enumeration e = convert.keys();
while (e.hasMoreElements()) {
String convertColumn = (String) e.nextElement();
Hashtable conv = (Hashtable) convert.get(convertColumn);
Integer Idx = (Integer) getHtCodeIndex().get(convertColumn);
if (Idx == null || Idx.intValue() < 0)
continue;
int idx = Idx.intValue();
if (v != null) {
int rows = v.size();
for (int i = 0; i < rows; i++) {
Vector vRow = (Vector) v.elementAt(i);
if (vRow != null) {
Object oldValue = vRow.elementAt(idx);
if (oldValue == null)
continue;
Object newValue = conv.get(oldValue.toString());
if (newValue != null) {
vRow.setElementAt(newValue, idx);
// 如果需求，可以转换为原值，目前先保持翻译后的值
// Object obj =
// getRefValueVO(vRow.elementAt(idx),
// newValue);
// vRow.setElementAt(obj, idx);
}
}
}
}
}
}
}
/**
* 默认显示字段中的显示字段数----表示显示前几个字段
*/
public int getDefaultFieldCount() {
return m_iDefaultFieldCount;
}
/**
* 得到一个字段在所有字段中的下标。 创建日期：(2001-8-16 15:39:23)
*
* @return int
* @param fieldList
* java.lang.String[]
* @param field
* java.lang.String
*/
public int getFieldIndex(String field) {
if (field == null || field.trim().length() == 0
|| getHtCodeIndex() == null || getHtCodeIndex().size() == 0)
return -1;
Object o = getHtCodeIndex().get(field.trim());
if (o == null) {
// 加入动态列
int index = m_htCodeIndex.size();
if (isDynamicCol() && getDynamicFieldNames() != null) {
for (int i = 0; i < getDynamicFieldNames().length; i++) {
m_htCodeIndex.put(getDynamicFieldNames()[i].trim(),
new Integer(index + i));
}
}
o = getHtCodeIndex().get(field.trim());
}
return (o == null) ? -1 : ((Integer) o).intValue();
}
/**
* 此处插入方法说明。 创建日期：(01-6-17 18:35:14)
*
* @return java.util.Hashtable
*/
public Hashtable getHtCodeIndex() {
if (m_htCodeIndex == null || m_htCodeIndex.size() == 0) {
m_htCodeIndex = new Hashtable();
if (getFieldCode() != null)
for (int i = 0; i < getFieldCode().length; i++) {
m_htCodeIndex.put(getFieldCode()[i].trim(), new Integer(i));
}
if (getHiddenFieldCode() != null) {
int index = 0;
if (getFieldCode() != null) {
index = getFieldCode().length;
}
for (int i = 0; i < getHiddenFieldCode().length; i++) {
if (getHiddenFieldCode()[i] != null) {
m_htCodeIndex.put(getHiddenFieldCode()[i].trim(),
new Integer(index + i));
} else {
System.out
.println("Waring: The RefModel has some errors.");
}
}
}
}
return m_htCodeIndex;
}
/**
* Order子句。
*
* @return java.lang.String
*/
public String getOrderPart() {
if (m_strOrderPart == null && getFieldCode() != null
&& getFieldCode().length > 0)
m_strOrderPart = getFieldCode()[0];
return m_strOrderPart;
}
/**
* 得到公司主键－－默认参照使用。 创建日期：(2001-8-17 11:17:03)
*
* @return java.lang.String
*/
public String getPk_corp() {
if (m_strPk_corp == null) {
m_strPk_corp = modelHandler.getPk_corp();
}
return m_strPk_corp;
}
/**
* 返回值－－主键字段
*
* @return java.lang.String
*/
public String getPkValue() {
String strValue = null;
Object objValue = getValue(getPkFieldCode());
if (objValue != null) {
strValue = objValue.toString();
}
return strValue;
}
/**
* 返回值数组－－主键字段
*
* @return java.lang.String
*/
public java.lang.String[] getPkValues() {
Object[] oDatas = getValues(getPkFieldCode());
String[] sDatas = objs2Strs(oDatas);
return sDatas;
}
/**
* 参照编码字段。 创建日期：(2001-8-13 16:19:24)
*
* @return java.lang.String
*/
public String getRefCodeField() {
if (m_strRefCodeField == null && getFieldCode() != null
&& getFieldCode().length > 0)
m_strRefCodeField = getFieldCode()[0];
return m_strRefCodeField;
}
/**
* 返回值－－编码字段 创建日期：(2001-8-13 16:19:24)
*
* @return java.lang.String
*/
public String getRefCodeValue() {
String strValue = null;
String[] strValues = getRefCodeValues();
if (strValues != null && strValues.length > 0) {
strValue = strValues[0];
}
return strValue;
}
/**
* 返回值数组－－编码字段 创建日期：(2001-8-13 16:19:24)
*
* @return java.lang.String[]
*/
public java.lang.String[] getRefCodeValues() {
Object[] oDatas = getValues(getRefCodeField());
String[] sDatas = objs2Strs(oDatas);
return sDatas;
}
protected String[] objs2Strs(Object[] oDatas) {
if (oDatas == null)
return null;
String[] sDatas = new String[oDatas.length];
for (int i = 0; i < oDatas.length; i++) {
if (oDatas[i] == null)
sDatas[i] = null;
else
sDatas[i] = oDatas[i].toString().trim();
}
return sDatas;
}
/**
* 参照名称字段。 创建日期：(2001-8-13 16:19:24)
*
* @return java.lang.String
*/
public String getRefNameField() {
if (m_strRefNameField == null && getFieldCode() != null
&& getFieldCode().length > 1)
m_strRefNameField = getFieldCode()[1];
return m_strRefNameField;
}
/**
* 返回值－名称字段 创建日期：(2001-8-13 16:19:24)
*
* @return java.lang.String
*/
public java.lang.String getRefNameValue() {
String strValue = null;
String[] strValues = getRefNameValues();
if (strValues != null && strValues.length > 0) {
strValue = strValues[0];
}
return strValue;
}
/**
* 返回值－名称字段 创建日期：(2001-8-13 16:19:24)
*
* @return java.lang.String[]
*/
public java.lang.String[] getRefNameValues() {
// 名称列，取翻译后的值
Object[] oDatas = getValues(getRefNameField(), getSelectedData(), false);
String[] sDatas = objs2Strs(oDatas);
return sDatas;
}
public java.lang.String[] getRefShowNameValues() {
// 名称列，取翻译后的值
Object[] oDatas = getValues(getRefShowNameField(), getSelectedData(),
false);
return objs2Strs(oDatas);
}
/**
* 此处插入方法说明。 创建日期：(2001-8-15 17:30:17)
*
* @return java.lang.String
*/
public String getRefSql() {
return getSql(getStrPatch(), getFieldCode(), getHiddenFieldCode(),
getTableName(), getWherePart(), getGroupPart(), getOrderPart());
}
/**
* 返回选择数据－－二维数组。 创建日期：(2001-8-23 19:10:29)
*
* @return java.util.Vector
*/
public java.util.Vector getSelectedData() {
return m_vecSelectedData;
}
/**
* DISTINCT子句
*
* @return java.lang.String
*/
public String getStrPatch() {
return m_strStrPatch;
}
/**
* 返回值－根据参数字段 创建日期：(2001-8-13 16:19:24)
*
* @return java.lang.Object
*/
public Object getValue(String field) {
Object[] values = getValues(field);
Object value = null;
if (values != null && values.length > 0) {
value = values[0];
}
return value;
}
/**
* 返回值数组－根据参数字段 创建日期：(2001-8-13 16:19:24)
*
* @return java.lang.Object[]
*/
public java.lang.Object[] getValues(String field) {
return getValues(field, true);
}
/**
* 取参照选中记录给定列的值
*
* <p>
* <strong>最后修改人：sxj</strong>
* <p>
* <strong>最后修改日期：2006-11-16</strong>
* <p>
*
* @param field
* 列
* @param 是否是原值。列可能已被翻译（例如定义了公式，定义了多语翻译，定义了枚举类型的对应值）
*
* @return java.lang.Object[]
* @exception BusinessException
* @since NC5.0
*/
public java.lang.Object[] getValues(String field, boolean isOriginValue) {
return getValues(field, getSelectedData(), isOriginValue);
}
/**
*
*/
public java.lang.Object[] getValues(String field, Vector datas) {
return getValues(field, datas, true);
}
protected java.lang.Object[] getValues(String field, Vector datas,
boolean isOriginValue) {
int col = getFieldIndex(field);
if (datas == null || datas.size() == 0)
return null;
if (col < 0) {
throw new RuntimeException("参照中没有该属性");
}
Vector vRecord = null;
Object[] oData = new Object[datas.size()];
for (int i = 0; i < datas.size(); i++) {
vRecord = (Vector) datas.elementAt(i);
if (vRecord == null || vRecord.size() == 0 || col >= vRecord.size())
oData[i] = null;
else {
oData[i] = getValueOfRefvalueVO(vRecord.elementAt(col),
isOriginValue);
}
}
return oData;
}
private Object getValueOfRefvalueVO(Object obj, boolean isOriginValue) {
Object value = obj;
if (obj instanceof RefValueVO && isOriginValue) {
value = ((RefValueVO) obj).getOriginValue();
}
/**
* V55 数据库中查出的原始类型为BigDecimal，为NC处理简便，参照对外统一转换为UFDouble
*
*/
value = RefPubUtil.bigDecimal2UFDouble(value);
return value;
}
/**
* 获取已经读出的参照数据－－二维Vector。 创建日期：(2001-8-23 18:39:24)
*
* @return java.util.Vector
*/
public java.util.Vector getVecData() {
return m_vecData;
}
/**
* 此处插入方法说明。 创建日期：(2001-8-25 12:06:11)
*
* @return nc.vo.pub.ValueObject
*/
public nc.vo.pub.ValueObject getVO() {
if (getSelectedData() != null && getSelectedData().size() > 0)
return convertToVO(((Vector) getSelectedData().elementAt(0)));
else
return null;
}
/**
* 此处插入方法说明。 创建日期：(2001-8-25 12:06:11)
*
* @return nc.vo.pub.ValueObject
*/
public nc.vo.pub.ValueObject[] getVOs() {
return convertToVOs(getSelectedData());
}
/**
* getWherePart 方法注解。
*/
public String getWherePart() {
return m_strWherePart;
}
/**
* 此处插入方法说明。 创建日期：(2001-8-23 21:03:06)
*
* @return boolean
*/
public boolean isCacheEnabled() {
return m_bCacheEnabled;
}
/**
* 匹配界面输入数据－－选择数据也改变了。 创建日期：(2001-8-23 18:39:24)
*
* @return java.util.Vector
*/
public Vector matchBlurData(String strBlurValue) {
Vector v = null;
if (strBlurValue != null && strBlurValue.trim().length() > 0) {
v = matchData(getBlurFields(), new String[] { strBlurValue });
// 如果是模糊查询的结果或者是编码等多条匹配，处理叶子节点是否可以选中
// 用于树形参照通过模糊匹配变成表型，过滤掉非叶子节点
if (!isNotLeafSelectedEnabled()
&& (!isNull(strBlurValue) || isMnecodeInput())) {
v = filterNotLeafNode(v);
}
}
// 清空已选择数据
setSelectedData(v);
return v;
}
private boolean isNull(String str) {
return str == null || str.trim().length() == 0;
}
/**
* 获取匹配数据 匹配成功 数据－>m_vecSelectedData 匹配不成功 null－>m_vecSelectedData
* 创建日期：(2001-8-23 18:39:24)
*
* @return java.util.Vector sxj 修改如果value= null or value.length()=0
* 不做匹配,提高效率，防止重复reloadData()
*/
public Vector matchData(String field, String value) {
return matchData(new String[] { field }, new String[] { value });
}
/**
* 匹配主键数据－－选择数据也改变了。 创建日期：(2001-8-23 18:39:24)
*
* @return java.util.Vector sxj 2004-06-08 如果是用Pk 进行匹配，则在最大集内进行匹配。 根据
* getMatchField()提供的列进行匹配
*/
public Vector matchPkData(String strPkValue) {
if (strPkValue == null || strPkValue.trim().length() == 0) {
setSelectedData(null);
return null;
}
return matchPkData(new String[] { strPkValue });
}
/**
* 重新载入数据。 1.使用缓存手动调用如刷新按钮。 创建日期：(2001-8-23 21:14:19)
*
* @return java.util.Vector
*/
public java.util.Vector reloadData() {
reloadData1();
return getRefData();
}
// 重载数据前的处理
public void reloadData1() {
// 刷新前已选择的数据
String[] selectedPKs = getPkValues();
clearData();
// 清数据权限缓存
clearDataPowerCache();
modelHandler.getLRUMap().clear();
// 刷新后重新匹配数据。
if (selectedPKs != null && selectedPKs.length > 0) {
matchPkData(selectedPKs);
}
modelHandler.fireDBCache();
}
/**
* 设置模糊值。 创建日期：(2001-8-17 12:57:37)
*/
public void setBlurValue(String strBlurValue) {
m_strBlurValue = strBlurValue;
}
/**
* 此处插入方法说明。 创建日期：(2001-8-23 21:03:06)
*/
public void setCacheEnabled(boolean cacheEnabled) {
m_bCacheEnabled = cacheEnabled;
}
/**
* 此处插入方法说明。 创建日期：(2001-8-24 10:32:33)
*
* @param vData
* java.util.Vector
*/
public void setData(Vector vData) {
m_vecData = vData;
// 默认参照支持自定义数据
if (isCacheEnabled()) {
String sql = getRefSql();
modelHandler.putToCache(getRefDataCacheKey(), sql, vData);
}
}
/**
* 默认显示字段中的显示字段数----表示显示前几个字段
*/
public void setDefaultFieldCount(int iDefaultFieldCount) {
m_iDefaultFieldCount = iDefaultFieldCount;
}
/**
* Order子句。
*/
public void setOrderPart(String strOrderPart) {
m_strOrderPart = strOrderPart;
}
/**
* 设置公司主键－－默认参照使用。 自定义参照不支持动态改变环境变量动态改变WherePart
*
* @return java.lang.String
*/
public void setPk_corp(String strPk_corp) {
if (strPk_corp == null) {
return;
}
// 切换公司，主体账簿主键也会改变（对于会计科目参照等主体账簿）
m_pk_glOrgBook = null;
// 自定义参照，用字符串替换算法来动态改变Wherepart,对于系统默认参照
setPk_corpForDefRef(strPk_corp, m_strPk_corp);
m_strPk_corp = strPk_corp;
// 系统默认参照
// 重置WherePart,也可能有其他信息也要改变，
resetWherePart();
}
/**
* <p>
* <strong>最后修改人：sxj</strong>
* <p>
* <strong>最后修改日期：2006-6-16</strong>
* <p>
*
* @param
* @return void
* @exception BusinessException
* @since NC5.0
*/
private void resetWherePart() {
setRefNodeName(getRefNodeName());
// 可能有业务组添加的WherePart
String wherePart = getWherePart();
// 如果WherePart中不包含业务组添加的WherePart，再给添加上
if (getAddWherePart() != null && wherePart != null
&& wherePart.indexOf(getAddWherePart()) < 0) {
addWherePart(getAddWherePart());
}
}
/**
* 设置公司主键同时重置参照默认配置条件
*
* @deprecated
*/
public void setPk_corpAndRefreshRefNodeName(String strPk_corp) {
setPk_corp(strPk_corp);
}
/*
* 自定义参照动态改变公司主键后，要重新设置WherePart
*/
private void setPk_corpForDefRef(String pk_corp, String pk_corpOld) {
if (pk_corpOld != null && pk_corp != null
&& (!pk_corpOld.equals(pk_corp))) {
String wherePartOld = getWherePart();
String wherePart = "";
if (wherePartOld != null) {
int index = wherePartOld.indexOf("'" + pk_corpOld + "'");
if (index > 0) {
wherePart = wherePartOld.replaceFirst("'" + pk_corpOld
+ "'", "'" + pk_corp + "'");
setWherePart(wherePart);
}
}
}
}
/**
* 设置参照编码字段。 创建日期：(2001-8-13 16:19:24)
*/
public void setRefCodeField(String strRefCodeField) {
m_strRefCodeField = strRefCodeField;
}
/**
* 设置参照名称字段。 创建日期：(2001-8-13 16:19:24)
*/
public void setRefNameField(String strRefNameField) {
m_strRefNameField = strRefNameField;
}
/**
* 此处插入方法说明。 创建日期：(2001-8-25 18:58:00)
*
* @param vecSelectedData
* java.util.Vector
*/
public void setSelectedData(Vector vecSelectedData) {
m_vecSelectedData = vecSelectedData;
}
public void setSelectedDataAndConvertData(Vector vecSelectedData) {
if (vecSelectedData == null) {
setSelectedData(vecSelectedData);
return;
}
Vector matchVec = getConvertedData(false, vecSelectedData, false);
setSelectedData(matchVec);
putLruMap(matchVec);
}
/**
* 此处插入方法说明。 创建日期：(01-6-19 21:15:22)
*
* @param newStrPatch
* java.lang.String
*/
public void setStrPatch(java.lang.String newStrPatch) {
m_strStrPatch = newStrPatch;
}
/**
* 此处插入方法说明。 创建日期：(2001-8-16 12:42:02)
*
* @param newWherePart
* java.lang.String
*/
public void setWherePart(String newWherePart) {
if (newWherePart != null) {
newWherePart = newWherePart.trim();
int index = newWherePart.toLowerCase().indexOf("where ");
if (index == 0)
newWherePart = newWherePart.substring(index + 5, newWherePart
.length());
}
m_strWherePart = newWherePart;
// 同时修改原始where
m_strOriginWherePart = m_strWherePart;
resetSelectedData_WhenDataChanged();
}
/**
* 当Where 条件改变后，清空m_vecData，重新匹配已经设置的pks.
*/
private void resetSelectedData_WhenDataChanged() {
String[] selectedPKs = getPkValues();
// 清数据。
clearModelData();
if (selectedPKs != null && selectedPKs.length > 0) {
matchPkData(selectedPKs);
}
Vector selectedData = getSelectedData();
setSelectedData(selectedData);
// 通知UIRefPane,刷新界面
fireChange();
}
/**
* java.util.Vector 过滤非末级节点
*/
protected Vector filterNotLeafNode(Vector vec) {
return vec;
}
/**
* 模糊字段名。 创建日期：(01-4-4 0:57:23)
*
* @return java.lang.String
*/
public String[] getBlurFields() {
if (m_strBlurFields == null || m_strBlurFields.length == 0) {
if (isOnlyMneFields()) {
return m_strBlurFields = getMnecodes();
} else if (getFieldCode() != null) {
ArrayList al = new ArrayList();
int len = getFieldCode().length;
al.add(getFieldCode()[0]);
if (len >= 2) {
al.add(getFieldCode()[1]);
}
if (getMnecodes() != null) {
for (int i = 0; i < getMnecodes().length; i++) {
if (al.contains(getMnecodes()[i])) {
continue;
}
al.add(getMnecodes()[i]);
}
}
m_strBlurFields = new String[al.size()];
al.toArray(m_strBlurFields);
}
}
return m_strBlurFields;
}
/**
* 此处插入方法说明。 创建日期：(2001-11-9 8:54:00)
*
* @return java.lang.String
*/
public java.lang.String getDataSource() {
return m_strDataSource;
}
/**
* 用于参照内容转换的影射表 如attrib1属性1－上海 2－南京3－北京 Hashtable conv=new Hashtable();
* Hashtable contents=new Hashtable(); contents.put("1","上海");
* contents.put("2","南京"); contents.put("3","北京");
* conv.put("attrib1",contents); return conv; 童志杰2002-08-30
*/
public java.util.Hashtable getDispConvertor() {
if (getDdReaderVO() != null && m_htDispConvertor == null) {
m_htDispConvertor = getDDReaderMap(getDdReaderVO().getTableName(),
getDdReaderVO().getFieldNames());
}
return m_htDispConvertor;
}
/**
* 此处插入方法说明。 创建日期：(2003-10-28 19:40:50)
*
* @return java.lang.String
*/
public java.lang.String getDynamicColClassName() {
return m_dynamicColClassName;
}
/**
* 此处插入方法说明。 创建日期：(2003-10-30 8:34:51)
*
* @return java.lang.String[]
*/
public java.lang.String[] getDynamicFieldNames() {
return m_strDynamicFieldNames;
}
/**
* 此处插入方法说明。 创建日期：(01-4-3 20:08:40)
*
* @return java.util.Hashtable
* @param tableName
* java.lang.String
*/
public Map getFieldCNName() {
return modelHandler.getFieldCNName();
}
/**
* 此处插入方法说明。 创建日期：(2003-4-10 18:42:56) 取过滤后的数据集. vecData 当前结果集
*/
public Vector getFilterPKsVector(Vector vecData, int filterStrategy) {
Vector filterVector = null;
int pkIndex = getFieldIndex(getPkFieldCode());
if (vecData != null) {
// 没有过滤的PKs
if (getFilterPks() == null) {
return vecData;
}
filterVector = new Vector();
for (int i = 0; i < vecData.size(); i++) {
Object vecpk = ((Vector) vecData.elementAt(i))
.elementAt(pkIndex);
switch (filterStrategy) {
case IFilterStrategy.INSECTION: {
if (m_hmFilterPks.size() == 0) {
return null;
}
if (m_hmFilterPks.get(vecpk.toString()) != null) {
filterVector.add(vecData.elementAt(i));
}
break;
}
case IFilterStrategy.REFDATACOLLECT_MINUS_INSECTION: {
if (m_hmFilterPks.size() == 0) {
return vecData;
}
if (m_hmFilterPks.get(vecpk.toString()) == null) {
filterVector.add(vecData.elementAt(i));
}
break;
}
default:
}
}
}
return filterVector;
}
/**
* 此处插入方法说明。 创建日期：(2001-11-8 13:31:41)
*
* @return java.lang.String
*/
public java.lang.String getGroupPart() {
return m_strGroupPart;
}
/**
* 不显示字段列表
*
* @return java.lang.String
*/
public java.lang.String[] getHiddenFieldCode() {
return m_strHiddenFieldCode;
}
/**
* 此处插入方法说明。 创建日期：(2001-11-9 9:38:40)
*
* @return java.lang.String
*/
public java.lang.String getOriginWherePart() {
return m_strOriginWherePart;
}
/**
* 此处插入方法说明。 创建日期：(2001-11-8 10:36:45)
*
* @return java.lang.String
*/
public java.lang.String getRefNodeName() {
return m_strRefNodeName == null ? getClass().getName()
: m_strRefNodeName;
}
/**
* 此处插入方法说明。 创建日期：(2001-8-29 10:08:50)
*
* @return int[]
*/
public int[] getShownColumns() {
if ((m_iShownColumns == null || m_iShownColumns.length == 0)
&& getDefaultFieldCount() > 0) {
m_iShownColumns = new int[getDefaultFieldCount()];
for (int i = 0; i < getDefaultFieldCount(); i++) {
m_iShownColumns[i] = i;
}
}
return m_iShownColumns;
}
/**
* 此处插入方法说明。 创建日期：(02-7-4 18:40:10)
*
* @return java.util.Vector
*/
// public java.util.Vector getUnMatchData() {
// if (m_vecUnMatchData == null)
// m_vecUnMatchData = new Vector();
// return m_vecUnMatchData;
// }
/**
* 此处插入方法说明。 创建日期：(2003-10-28 19:54:29)
*
* @return java.lang.Object
*/
public java.lang.Object getUserParameter() {
return m_userParameter;
}
/**
* 此处插入方法说明。 创建日期：(2003-10-28 19:38:34)
*
* @return boolean
*/
public boolean isDynamicCol() {
return m_isDynamicCol;
}
/**
* 此处插入方法说明。 创建日期：(2003-2-21 16:27:33)
*
* @return boolean
*/
public boolean isMnecodeInput() {
return m_mnecodeInput;
}
/**
* 此处插入方法说明。 创建日期：(2003-4-10 20:39:56)
*
* @return boolean
*/
public boolean isNotLeafSelectedEnabled() {
return m_bNotLeafSelectedEnabled;
}
/**
* 是否允许使用数据权限
*
* @return boolean
*/
public boolean isUseDataPower() {
return m_bUserDataPower;
}
/**
* 设置模糊字段。 创建日期：(2001-8-17 12:57:37)
*/
public void setBlurFields(String[] strBlurFields) {
m_strBlurFields = strBlurFields;
}
/**
* 此处插入方法说明。 创建日期：(2001-11-9 8:54:00)
*
* @param newDataSource
* java.lang.String
*/
public void setDataSource(java.lang.String newDataSource) {
m_strDataSource = newDataSource;
}
/**
* 用于参照内容转换的影射表 如attrib1属性1－上海 2－南京3－北京 Hashtable conv=new Hashtable();
* Hashtable contents=new Hashtable(); contents.put("1","上海");
* contents.put("2","南京"); contents.put("3","北京");
* conv.put("attrib1",contents); return conv; 童志杰2002-08-30
*/
public void setDispConvertor(java.util.Hashtable newDispConvertor) {
m_htDispConvertor = newDispConvertor;
}
/**
* 此处插入方法说明。 创建日期：(2003-10-28 19:40:50)
*
* @param newColClassName
* java.lang.String
*/
public void setDynamicColClassName(java.lang.String newColClassName) {
m_dynamicColClassName = newColClassName;
}
/**
* 此处插入方法说明。 创建日期：(2003-10-30 8:34:51)
*
* @param newDynamicFieldNames
* java.lang.String[]
*/
public void setDynamicFieldNames(java.lang.String[] newDynamicFieldNames) {
m_strDynamicFieldNames = newDynamicFieldNames;
}
/**
* 此处插入方法说明。 创建日期：(2003-4-10 18:32:43)
*
* @param newM_filterPks
* java.lang.String[]
*
* 设置过滤的Pks
*/
public void setFilterPks(java.lang.String[] newM_filterPks) {
setFilterPks(newM_filterPks, IFilterStrategy.INSECTION);
}
/**
* 此处插入方法说明。 创建日期：(2005-9-02 18:32:43)
*
* @param newM_filterPks
* java.lang.String[]
*
*
* 设置过滤的Pks
*/
public void setFilterPks(java.lang.String[] newM_filterPks,
int filterStrategy) {
m_filterPks = newM_filterPks;
// 过滤策略
m_filterStrategy = filterStrategy;
m_hmFilterPks.clear();
if (m_filterPks != null && m_filterPks.length > 0) {
for (int i = 0; i < m_filterPks.length; i++) {
m_hmFilterPks.put(m_filterPks[i], m_filterPks[i]);
}
}
}
/**
* 此处插入方法说明。 创建日期：(2001-11-8 13:31:41)
*
* @param newGroupPart
* java.lang.String
*/
public void setGroupPart(java.lang.String newGroupPart) {
m_strGroupPart = newGroupPart;
}
/**
* 此处插入方法说明。 创建日期：(01-6-25 10:53:54)
*
* @param newHiddenFieldCode
* java.lang.String[]
*/
public void setHiddenFieldCode(java.lang.String[] newHiddenFieldCode) {
getHtCodeIndex().clear();
hiddenFieldList.clear();
hiddenFieldList.addAll(Arrays.asList(newHiddenFieldCode));
m_strHiddenFieldCode = newHiddenFieldCode;
}
/**
* 此处插入方法说明。 创建日期：(01-6-17 18:35:14)
*
* @return java.util.Hashtable
*/
public void setHtCodeIndex(Hashtable ht) {
m_htCodeIndex = ht;
}
/**
* 此处插入方法说明。 创建日期：(2003-10-28 19:38:34)
*
* @param newDynamicCol
* boolean
*/
public void setIsDynamicCol(boolean newDynamicCol) {
m_isDynamicCol = newDynamicCol;
}
/**
* 此处插入方法说明。 创建日期：(2003-2-21 16:27:33)
*
* @param newM_mnecodeInput
* boolean
*/
public void setMnecodeInput(boolean newM_mnecodeInput) {
m_mnecodeInput = newM_mnecodeInput;
}
/**
* 此处插入方法说明。 创建日期：(2003-4-10 20:39:56)
*
* @param newM_bNotLeafSelectedEnabled
* boolean
*/
public void setNotLeafSelectedEnabled(boolean newM_bNotLeafSelectedEnabled) {
m_bNotLeafSelectedEnabled = newM_bNotLeafSelectedEnabled;
}
/**
* 此处插入方法说明。 创建日期：(2001-11-8 10:36:45)
*
* @param newRefNodeName
* java.lang.String
*/
public void setRefNodeName(java.lang.String newRefNodeName) {
m_strRefNodeName = newRefNodeName;
}
/**
* v5 不建议使用 替换方式，请分步调用 1、setRefNodeName(refnodename); 2、setPk_corp(pk_corp);
*
* @deprecated
*/
public void setRefNodeName(java.lang.String newRefNodeName, String pk_corp) {
m_strPk_corp = pk_corp;
m_strRefNodeName = newRefNodeName;
}
/**
* 为了适配三种DefaultModel添加的方法，在DefaultModel里被覆盖 对于自定义model不能直接调用该方法，请覆盖它
*/
public void setRefTitle(java.lang.String newRefTitle) {
m_strRefTitle = newRefTitle;
}
/**
* 此处插入方法说明。 创建日期：(2001-8-29 10:08:50)
*
* @return int[]
*/
public void setShownColumns(int[] iShownColumns) {
m_iShownColumns = iShownColumns;
return;
}
/**
* 为了适配三种DefaultModel添加的方法，在DefaultModel里被覆盖 对于自定义model不能直接调用该方法，请覆盖它
*/
public void setTableName(java.lang.String newTableName) {
m_strTableName = newTableName;
}
/**
* 设置是否使用数据权限。 创建日期：(2001-8-23 21:03:06)
*/
public void setUseDataPower(boolean useDataPower) {
m_bUserDataPower = useDataPower;
}
/**
* 此处插入方法说明。 创建日期：(2003-10-28 19:54:29)
*
* @param newParameter
* java.lang.Object
*/
public void setUserParameter(java.lang.Object newParameter) {
m_userParameter = newParameter;
}
/**
* 根据记录位置，列名称插入列值
*/
public void setValue(int recordIndex, String field, Object value) {
Vector vecData = getSelectedData();
if (vecData == null || recordIndex >= vecData.size()) {
return;
}
Vector vRecord = (Vector) vecData.get(recordIndex);
int col = getFieldIndex(field);
//
if (isDynamicCol()) {
if (vRecord == null || vRecord.size() == 0 || col < 0)
return;
if (value != null) {
if (col >= vRecord.size()) {
vRecord.add(value);
} else {
vRecord.setElementAt(value, col);
}
return;
}
}
if (vRecord == null || vRecord.size() == 0 || col < 0
|| col >= vRecord.size())
return;
if (value != null) {
vRecord.setElementAt(value, col);
}
}
/**
* 自定义参照，可以添加封存条件
*/
public void addSealedWherePart(String refNodeName, String sealedWherePart) {
DocSealWherePartMng.addSealedWherePart(refNodeName, sealedWherePart);
}
/**
* sxj 2004-5-26 新增 改变WherePart时是否清除数据
*/
public void addWherePart(String newWherePart, boolean isRrefreshData) {
addWherePart(newWherePart);
if (isRrefreshData) {
clearModelData();
}
}
/**
* 此处插入方法说明。 创建日期：(2004-6-1 10:21:59)
*
* @return java.lang.String
*/
public java.lang.String getFilterDlgClaseName() {
return refFilterDlgClaseName;
}
/**
* 此处插入方法说明。 创建日期：(2004-9-23 9:03:51)
*
* @return java.lang.String
*/
public java.lang.String getMatchField() {
if (m_matchField == null) {
return getPkFieldCode();
}
return m_matchField;
}
/**
* 此处插入方法说明。 创建日期：(2004-11-10 10:31:47)
*
* @return java.util.HashMap
*/
private java.util.HashMap getMatchHM() {
return m_matchHM;
}
/**
* 此处插入方法说明。 创建日期：(2003-2-19 9:24:17)
*
* @return java.lang.String
*/
public java.lang.String[] getMnecodes() {
return m_mnecodes;
}
/**
* 此处插入方法说明。 创建日期：(2004-4-16 10:31:17)
*
* @return java.lang.Object
*/
public java.lang.Object getPara() {
return userPara;
}
/**
* 此处插入方法说明。 创建日期：(2003-11-14 15:42:52)
*
* @return java.lang.String
*/
public java.lang.String getQuerySql() {
return querySql;
}
/**
* 此处插入方法说明。 创建日期：(2003-11-15 10:51:44)
*
* @return java.lang.String
*/
public java.lang.String getRefQueryDlgClaseName() {
return refQueryDlgClaseName;
}
/**
* 此处插入方法说明。 创建日期：(2004-4-14 16:01:25)
*
* @return java.lang.String
*/
public java.lang.String getTempDataWherePart() {
return refTempDataWherePart;
}
/**
* 此处插入方法说明。 创建日期：(2004-6-10 12:09:05)
*
* @return boolean
*/
public boolean isFromTempTable() {
return isFromTempTable;
}
/**
* 此处插入方法说明。 创建日期：(2004-4-14 16:13:36)
*
* @return boolean
*/
public boolean isIncludeSub() {
return isIncludeSub;
}
/**
* 此处插入方法说明。 创建日期：(2003-10-31 15:57:17)
*
* @return boolean
*/
public boolean isRefreshMatch() {
return m_isRefreshMatch;
}
/**
* 此处插入方法说明。 创建日期：(2004-3-17 12:53:23)
*
* @return boolean
*/
public boolean isSealedDataShow() {
return m_isSealedDataShow;
}
/**
* 获取匹配数据 匹配成功 数据－>m_vecSelectedData 匹配不成功 null－>m_vecSelectedData
* 创建日期：(2001-8-23 18:39:24)
*
* @return java.util.Vector sxj 修改如果value= null or value.length()=0
* 不做匹配,提高效率，防止重复reloadData() sxj 2004-11-11 add
*/
public Vector matchData(String field, String[] values) {
return matchData(new String[] { field }, values);
}
/**
* 匹配主键数据－－选择数据也改变了。 创建日期：(2001-8-23 18:39:24)
*
* @return java.util.Vector sxj 2004-06-08 如果是用Pk 进行匹配，则在最大集内进行匹配。 根据
* getMatchField()提供的列进行匹配
*/
public Vector matchPkData(String[] strPkValues) {
if (strPkValues == null) {
return null;
}
Vector v = null;
String matchsql = null;
matchsql = getMatchSql(strPkValues);
Vector matchVec = getMatchVectorFromLRU(strPkValues);
if (matchVec != null) {
// setSelectedDataAndConvertData(matchVec);
setSelectedData(matchVec);
return matchVec;
}
try {
if (isNonSqlMatch(matchsql)) {
v = matchData(getMatchField(), strPkValues);
} else {
if (isFromTempTable()) {
v = modelHandler.queryRefDataFromTemplateTable(matchsql);
} else {
v = modelHandler.matchPK(getDataSource(), matchsql);
}
}
} catch (Exception e) {
Debug.error(e.getMessage(), e);
}
// putLruMap(strPkValues, v);
setSelectedDataAndConvertData(v);
return getSelectedData();
}
public Vector getMatchVectorFromLRU(String[] strPkValues) {
if (isCacheEnabled()) {
LRUMap<String, Vector> lruMap = modelHandler.getLRUMap();
String lruKey = getLRUKey(strPkValues);
Vector matchVec = lruMap.get(lruKey);
return matchVec;
}
return null;
}
private void putLruMap(Vector vecData) {
if (isCacheEnabled()) {
String[] pkValues = getPkValues();
if (pkValues == null) {
return;
}
LRUMap<String, Vector> lruMap = modelHandler.getLRUMap();
String lruKey = getLRUKey(pkValues);
lruMap.put(lruKey, vecData);
}
}
private String getLRUKey(String[] strPkValues) {
StringBuffer sb = new StringBuffer();
String dsName = getDataSource();
if (dsName == null) {
dsName = InvocationInfoProxy.getInstance().getUserDataSource();
}
sb.append(dsName).append(getRefNodeName()).append(
getMatchSql(strPkValues));
if (strPkValues != null && strPkValues.length > 0) {
for (int i = 0; i < strPkValues.length; i++) {
sb.append(strPkValues[i]);
}
}
return sb.toString();
}
/**
*
*/
public boolean isNonSqlMatch(String matchsql) {
return modelHandler.isNonSqlMatch(matchsql);
}
public String getMatchSql(String[] strPkValues) {
setPKMatch(true);
boolean originSealedDataShow = isSealedDataShow();
boolean originUseDataPower = isUseDataPower();
if (!isRefEnable()) {
// 如果参照不可编辑，不启用数据权限控制;包含封存数据 ---〉V5新需求
setUseDataPower(false);
setSealedDataShow(true);
}
String matchsql;
// pk匹配时，带distinct,防止关联表出现重复数据的问题。
String strPatch = IRefConst.DISTINCT;
String strWherePart = null;
String[] fieldCodes = getFieldCode();
if (fieldCodes != null && fieldCodes.length > 0) {
if (fieldCodes[0] != null
&& strPatch.indexOf(fieldCodes[0].toLowerCase()) >= 0) {
strPatch = "";
}
}
if (isMatchPkWithWherePart()) {
strWherePart = getWherePart();
}
if (isLargeDataRef() && canUseDB())
matchsql = getSpecialMatchSql(new String[] { getMatchField() },
strPkValues, strPatch, getFieldCode(),
getHiddenFieldCode(), getTableName(), strWherePart,
getOrderPart());
// 批处理Sql
else
matchsql = getSql_Match(new String[] { getMatchField() },
strPkValues, strPatch, getFieldCode(),
getHiddenFieldCode(), getTableName(), strWherePart,
getOrderPart());// 批处理Sql
setPKMatch(false);
setSealedDataShow(originSealedDataShow);
setUseDataPower(originUseDataPower);
return matchsql;
}
/**
* 此处插入方法说明。 创建日期：(2004-6-1 10:21:59)
*
* @param newFilterDlgClaseName
* java.lang.String
*/
public void setFilterDlgClaseName(java.lang.String newFilterDlgClaseName) {
refFilterDlgClaseName = newFilterDlgClaseName;
}
/**
* 此处插入方法说明。 创建日期：(2004-6-10 12:09:05)
*
* @param newFromTempTable
* boolean
*/
public void setFromTempTable(boolean newFromTempTable) {
isFromTempTable = newFromTempTable;
}
/**
* 此处插入方法说明。 创建日期：(2004-4-14 16:13:36)
*
* @param newIncludeSub
* boolean
*/
public void setIncludeSub(boolean newIncludeSub) {
isIncludeSub = newIncludeSub;
}
/**
* 此处插入方法说明。 创建日期：(2003-10-31 15:57:17)
*
* @param newRefreshMatch
* boolean
*/
public void setIsRefreshMatch(boolean newRefreshMatch) {
m_isRefreshMatch = newRefreshMatch;
}
/**
* 此处插入方法说明。 创建日期：(2003-2-19 9:24:17)
*
* @param newM_mnecode
* java.lang.String
*/
public void setMnecode(java.lang.String[] newM_mnecodes) {
m_mnecodes = newM_mnecodes;
}
/**
* 此处插入方法说明。 创建日期：(2004-4-16 10:31:17)
*
* @param newPara
* java.lang.Object
*/
public void setPara(java.lang.Object newPara) {
userPara = newPara;
}
/**
* sxj 2004-5-26 新增 改变WherePart时是否清除数据
*/
public void setPara(java.lang.Object newPara, boolean isRrefreshData) {
setPara(newPara);
if (isRrefreshData) {
clearModelData();
}
}
/**
* sxj 2004-5-26 新增 改变WherePart时是否清除数据
*/
public void setPk_corp(String strPk_corp, boolean isRrefreshData) {
setPk_corp(strPk_corp);
if (isRrefreshData) {
clearModelData();
}
}
/**
* 只修改变量的值，不同步WherePart中的值。
*/
public void setPk_corpValue(String strPk_corp) {
m_strPk_corp = strPk_corp;
}
/**
* 此处插入方法说明。 创建日期：(2003-11-14 15:42:52)
*
* @param newQuerySql
* java.lang.String
*/
public void setQuerySql(java.lang.String newQuerySql) {
querySql = newQuerySql;
}
/**
* 此处插入方法说明。 创建日期：(2003-11-15 10:51:44)
*
* @param newRefQueryDlgClaseName
* java.lang.String
*/
public void setRefQueryDlgClaseName(java.lang.String newRefQueryDlgClaseName) {
refQueryDlgClaseName = newRefQueryDlgClaseName;
}
/**
* 此处插入方法说明。 创建日期：(2004-3-17 12:53:23)
*
* @param newSealedDataShow
* boolean
*/
public void setSealedDataShow(boolean newSealedDataShow) {
m_isSealedDataShow = newSealedDataShow;
}
/**
* 此处插入方法说明。 创建日期：(2004-4-14 16:01:25)
*
* @param newTempDataWherePart
* java.lang.String
*/
public void setTempDataWherePart(java.lang.String newTempDataWherePart) {
refTempDataWherePart = newTempDataWherePart;
}
/**
* sxj 2004-5-26 新增 改变WherePart时是否清除数据
*/
public void setWherePart(String newWherePart, boolean isRrefreshData) {
setWherePart(newWherePart);
if (isRrefreshData) {
clearModelData();
}
}
/**
* 此处插入方法描述。 创建日期：(2004-6-3 16:56:59)
*
* @author：毛士福
* @return nc.ui.bd.ref.AbstractRefModel
* @deprecated since v5.0
*/
public AbstractRefModel getM_defGridmodel() {
return m_defGridmodel;
}
/**
* @return 返回 m_pk_org。
*/
public String getPk_GlOrgBook() {
return m_pk_glOrgBook;
}
/**
* @return 返回 m_orgTypeCode。
*/
public String getOrgTypeCode() {
return m_orgTypeCode;
}
/**
* 本方法不支持自定义参照，动态改变主体账簿后，WherePart的动态改变。
*
* @param orgTypeCode
* 要设置的 m_orgTypeCode。
* @param pk_org
* 要设置的 m_pk_org。 多账簿、多会计主体设置接口 主要功能：
* 提供给总账按主体账簿方式设置，其他业务组调用可能会产生问题。
*/
public void setPk_GlOrgBook(String orgTypeCode, String pk_GlOrgBook) {
// 档案的真正类型
String pk = pk_GlOrgBook;
String type = orgTypeCode;
BdinfoVO infoVO = getBdinfoVO();
if (infoVO != null) {
pk = BDGLOrgBookAccessor.getAccuratePK(infoVO.getOrgtypecode(),
orgTypeCode, pk_GlOrgBook);
type = infoVO.getOrgtypecode();
}
setOrgTypeCodeAndPK(type, pk);
// 重新设置条件.
resetWherePart();
}
/*
* 设置档案类型等属性。
*/
public void setOrgTypeCodeAndPK(String orgTypeCode, String pk) {
// 如果是公司类型
if (OrgnizeTypeVO.COMPANY_TYPE.equals(orgTypeCode)) {
setPk_corp(pk);
m_orgTypeCode = null;
m_pk_glOrgBook = null;
} else if (OrgnizeTypeVO.ZHUZHANG_TYPE.equals(orgTypeCode)) {
m_orgTypeCode = orgTypeCode;
m_pk_glOrgBook = pk;
}
}
/**
* @param newM_defGridmodel
* nc.ui.bd.ref.AbstractRefModel
* @deprecated since v5.0
*/
public void setM_defGridmodel(AbstractRefModel newM_defGridmodel) {
m_defGridmodel = newM_defGridmodel;
}
/*
*
*/
public String getDataPowerSubSql(String strTableName,
String strTableShowName) {
String tableName = strTableName;
if (strTableName != null) {
tableName = strTableName.trim();
}
String powerSql = modelHandler.getDataPowerSubSql(tableName,
strTableShowName, this);
return powerSql;
}
protected String getDataPowerSqlKey(String strTableName,
String strTableShowName) {
String pk_org = null;
if (getPk_GlOrgBook() != null) {
pk_org = getPk_GlOrgBook();
} else {
pk_org = getPk_corp();
}
String tableName = strTableName;
if (strTableName != null) {
tableName = strTableName.trim();
}
String dataPowerKey = tableName + "_" + strTableShowName + pk_org;
return dataPowerKey;
}
/**
* @return 返回 m_fun_code。
*/
public String getFun_code() {
return m_fun_code;
}
/**
* @param m_fun_code
* 要设置的 m_fun_code。
*/
public void setFun_code(String m_fun_code) {
boolean isEqual = modelHandler.equals(this.m_fun_code, m_fun_code);
this.m_fun_code = m_fun_code;
// 同时要重新初始化参照的设置
if (!isEqual) {
setRefNodeName(getRefNodeName());
}
}
/**
* 为多语言添加此方法, 请覆盖此方法返回要翻译字段数组。
*/
protected RefVO_mlang[] getRefVO_mlang() {
return null;
}
/**
* * 为多语言添加此方法, 并提供默认实现.
*
* vecData：参照中的数据（全集），请用参数传入的vecData,不要用getData()方法得到，否则会死循环。
* vecData中的数据为每一行Record，每一个Record也是一个Vector.
*
* 返回值为Vector，它的数据为翻译后的Object[],注意放置Object[]的顺序一定和refVO_mlangs的顺序一致。
*
* 创建日期：(2005-3-30 16:19:24)
*
* @return Vector
*/
private Vector getValues_mlang(Vector vecData, RefVO_mlang[] refVO_mlangs) {
// 要翻译的列
Vector datas = new Vector();
if (vecData != null && vecData.size() > 0) {
int recordAccout = vecData.size(); // 行记录数。
if (refVO_mlangs != null) {
for (int i = 0; i < refVO_mlangs.length; i++) {
RefVO_mlang refVO_mlang = refVO_mlangs[i];
String resid = "";
String[] resIDFieldNames = refVO_mlangs[i]
.getResIDFieldNames();
Object[] oData_mlang = new Object[recordAccout];
for (int j = 0; j < recordAccout; j++) {
Vector record = (Vector) vecData.get(j); // 行记录
resid = "";
if (resIDFieldNames != null) {
resid += refVO_mlang.getPreStr();
for (int k = 0; k < resIDFieldNames.length; k++) {
Object oValue = record
.get(getFieldIndex(resIDFieldNames[k]));
if (oValue != null) {
resid += oValue.toString();
}
}
}
// 根据资源ID取翻译后的数据
String str_multiLang = NCLangRes4VoTransl
.getNCLangRes().getStrByID(
refVO_mlang.getDirName(), resid);
// 根据资源没有找到,返回原来的值.
if (resid.equals(str_multiLang)) {
str_multiLang = record.get(
getFieldIndex(refVO_mlang.getFieldName()))
.toString();
}
oData_mlang[j] = str_multiLang;
}
datas.add(oData_mlang);
}
}
}
return datas;
}
/**
* 为多语言添加此方法, 设置翻译后的值到参照数据中. 设置特定列的值 创建日期：(2005-3-30 16:19:24)
*
*/
private void setMlangValues(Vector vecData, RefVO_mlang[] refVO_mlangs) {
if (vecData == null || vecData.size() == 0 || refVO_mlangs == null) {
return;
}
Vector vec_malng = getValues_mlang(vecData, refVO_mlangs);
if (vec_malng == null || vec_malng.size() != refVO_mlangs.length) {
return;
}
String[] fieldNames = new String[refVO_mlangs.length];
for (int i = 0; i < refVO_mlangs.length; i++) {
fieldNames[i] = refVO_mlangs[i].getFieldName();
}
setValuesByFieldName(vecData, vec_malng, fieldNames);
}
class DefFieldsHandler {
/**
* 设有公式的参照，按公式取值。 创建日期：(2005-3-30 16:19:24)
*
*/
void setDefFieldValues(Vector vecData) {
String[] defFields = getShowDefFields();
if (vecData == null || vecData.size() == 0 || defFields == null
|| defFields.length == 0) {
return;
}
Vector<Object[]> rawData = new Vector<Object[]>();
Vector convertedData = null;
DefFieldInfo defFieldInfo = new DefFieldInfo(defFields);
for (int i = 0; i < defFields.length; i++) {
rawData.add(getValues(defFields[i], vecData));
}
try {
convertedData = UFRefDefTanslateUtil.getDefValues(defFieldInfo,
rawData, Integer.valueOf(getOrgTypeCode()).intValue(),
getPk_corp());
} catch (Exception e) {
Logger.error(e.getMessage(), e);
}
if (convertedData == null) {
return;
}
setValuesByFieldName(vecData, convertedData, defFields);
}
}
class FormulaHandler {
private FormulaParseFather parse = null;
/**
* 设有公式的参照，按公式取值。 创建日期：(2005-3-30 16:19:24)
*
*/
void setFormulaValues(Vector vecData, String[][] formulas) {
if (vecData == null || vecData.size() == 0 || formulas == null) {
return;
}
String[][] showFormulas = getShowFieldFormulas(formulas);
if (showFormulas == null) {
return;
}
Object[][] datas = getValues_formulas(vecData, showFormulas);
if (datas == null || datas.length != showFormulas.length) {
return;
}
Vector v = new Vector();
String[] fieldNames = new String[datas.length];
for (int i = 0; i < datas.length; i++) {
v.add(datas[i]);
fieldNames[i] = (String) showFormulas[i][0];
}
setValuesByFieldName(vecData, v, fieldNames);
}
private String[][] getShowFieldFormulas(String[][] formulas) {
List<String[]> list = new ArrayList<String[]>();
for (int i = 0; i < formulas.length; i++) {
String formulaField = formulas[i][0];
if (isShowField(formulaField)) {
list.add(formulas[i]);
}
}
String[][] showFormulas = null;
if (list.size() > 0) {
showFormulas = new String[list.size()][];
list.toArray(showFormulas);
}
return showFormulas;
}
private Object[][] getValues_formulas(Vector vecData,
String[][] formulas) {
// 要翻译的列
Object[][] datas = null;
int flen = formulas.length;
if (vecData != null && vecData.size() > 0 && flen > 0) {
int recordAccout = vecData.size(); // 行记录数。
datas = new Object[flen][recordAccout];
ArrayList list = new ArrayList();
String formulaField = null;
String strFormula = null;
for (int i = 0; i < flen; i++) {
list.clear();
formulaField = formulas[i][0];
strFormula = formulas[i][1];
for (int j = 0; j < recordAccout; j++) {
Vector record = (Vector) vecData.get(j);
list.add(getFormulaValue(record, formulaField));
}
datas[i] = getFormulaValues(formulaField, strFormula, list);
}
}
return datas;
}
/**
* <p>
* <strong>最后修改人：sxj</strong>
* <p>
* <strong>最后修改日期：2006-9-19</strong>
* <p>
*
* @param
* @return String
* @exception BusinessException
* @since NC5.0
*/
private String getFormulaValue(Vector record, String formulaField) {
int fieldIndex = getFieldIndex(formulaField);
if (fieldIndex == -1) {
return null;
}
Object obj = record.get(fieldIndex);
String value = null;
if (obj instanceof RefValueVO && obj != null) {
Object originValue = ((RefValueVO) obj).getOriginValue();
value = originValue == null ? null : originValue.toString();
} else {
if (obj != null) {
value = obj.toString();
}
}
return value;
}
private Object[] getFormulaValues(String fieldName, String formulas,
List givenvalues) {
FormulaParseFather parse = getParse();
// String express = formula;
String[] expresses = StringUtil.toArray(formulas, ";");
parse.setExpressArray(expresses);
parse.addVariable(fieldName, givenvalues);
Object[][] values = parse.getValueOArray();
return values[values.length - 1];
}
/**
* @return 返回 parse。
*/
private FormulaParseFather getParse() {
if (parse == null) {
parse = new nc.ui.pub.formulaparse.FormulaParse();
}
return parse;
}
}
/*
* _ add by hetian 2005-04-11 ______________________________________
*/
/**
* 判断该参照是否是大数据表
*
* @return
*/
public boolean isLargeDataRef() {
if (m_strRefNodeName == null || m_strRefNodeName.equals(""))
return false;
if (LARGE_NODE_NAME.indexOf(m_strRefNodeName) >= 0
&& isChangeTableSeq()) {
return true;
}
return false;
}
/**
* 改变主表
*
* @param table
* @return
*/
public String changeBaseTable(String table) {
if (table == null || table.indexOf("join") < 0)
return table;
StringTokenizer token = new StringTokenizer(table);
String firstTable = "";
String secondTable = "";
String lastElement = "";
String joinStr = "";
String onStr = "";
boolean isJoin = false;
boolean isOn = false;
int index = 0;
while (token.hasMoreTokens()) {
String element = token.nextToken();
if (lastElement.equalsIgnoreCase("join")) {
secondTable = element;
isJoin = false;
}
if (element.equalsIgnoreCase("on")) {
isOn = true;
}
if (isJoin) {
joinStr += new StringBuffer().append(" ").append(element)
.append(" ").toString();
}
if (isOn) {
onStr += new StringBuffer().append(" ").append(element).append(
" ").toString();
}
if (index == 0) {
firstTable = new StringBuffer().append(element).append(" ")
.toString();
isJoin = true;
}
lastElement = element;
index++;
}
return secondTable + joinStr + firstTable + onStr;
}
/**
* 得到匹配语句
*
* @return
*/
public String getSpecialMatchSql(String[] fieldNames, String values[],
String strPatch, String[] strFieldCode, String[] hiddenFields,
String strTableName, String strWherePart, String strOrderField) {
if (strTableName == null || strTableName.trim().length() == 0)
return null;
if (!isPKMatch()) {
strTableName = changeBaseTable(strTableName);
}
if (strOrderField != null) {
strOrderField = filterColumn(strOrderField);
}
return getSql_Match(fieldNames, values, strPatch, strFieldCode,
hiddenFields, strTableName, strWherePart, strOrderField);
}
/**
* 构造基本 SQL
*/
public String buildBaseSql(String patch, String[] columns,
String[] hiddenColumns, String tableName, String whereCondition) {
StringBuffer whereClause = new StringBuffer();
StringBuffer sql = new StringBuffer("select ").append(patch)
.append(" ");
int columnCount = columns == null ? 0 : columns.length;
addQueryColumn(columnCount, sql, columns, hiddenColumns);
// 加入FROM子句
sql.append(" from ").append(tableName);
// 加入WHERE子句
if (whereCondition != null && whereCondition.trim().length() != 0) {
whereClause.append(" where (").append(whereCondition).append(" )");
} else
whereClause.append(" where 11=11 ");
appendAddWherePartCondition(whereClause);
addDataPowerCondition(getTableName(), whereClause);
addSealCondition(whereClause);
addEnvWherePart(whereClause);
sql.append(" ").append(whereClause.toString());
return sql.toString();
}
protected void addDataPowerCondition(String tableName,
StringBuffer whereClause) {
if (isUseDataPower()) {
String powerSql = getDataPowerSubSql(tableName, getDataPowerName());
if (powerSql != null)
whereClause.append(" and (").append(
getDataPowerResourceColumn()).append(" in (").append(
powerSql).append("))");
}
}
public String getDataPowerResourceColumn() {
if (dataPowerResourceColumn == null) {
return getPkFieldCode();
}
return dataPowerResourceColumn;
}
private void appendAddWherePartCondition(StringBuffer whereClause) {
if (getAddWherePart() == null) {
return;
}
if (isPKMatch() && !isMatchPkWithWherePart()) {
return;
}
whereClause.append(" ").append(getAddWherePart());
}
/**
* 给数据权限重定向的机会，子类覆盖。 特殊情况下使用，例如会计科目多版本
*/
protected String getDataPowerName() {
return getRefNodeName();
}
/**
* 添加列条件
*
* @param iSelectFieldCount
* @param strSql
* @param strFieldCode
* @param hiddenFields
*/
public void addQueryColumn(int iSelectFieldCount, StringBuffer strSql,
String[] strFieldCode, String[] hiddenFields) {
for (int i = 0; i < iSelectFieldCount; i++) {
strSql.append(strFieldCode[i]);
if (i < iSelectFieldCount - 1)
strSql.append(",");
}
// 加入隐藏字段
if (hiddenFields != null && hiddenFields.length > 0) {
for (int k = 0; k < hiddenFields.length; k++) {
if (hiddenFields[k] != null
&& hiddenFields[k].trim().length() > 0) {
strSql.append(",");
strSql.append(hiddenFields[k]);
}
}
}
}
/**
* 添加封存条件
*
* @param whereClause
*/
public void addSealCondition(StringBuffer whereClause) {
// 封存数据不显示，添加Where条件
if (!isSealedDataShow()) {
String wherePart = getSealedWherePart();
if (wherePart != null) {
whereClause.append(" and (").append(wherePart).append(") ");
}
}
}
/**
* 查询参照封存条件。
*
* @param refNodeName
* @return refNodeName对应参照的过滤封存数据的SQL where条件
*/
public String getSealedWherePart() {
if (sealedWherePart != null) {
return sealedWherePart;
}
sealedWherePart = DocSealWherePartMng
.getSealedWherePart(getRefNodeName());
if (sealedWherePart == null) {
sealedWherePart = DocSealWherePartMng
.getSealedWherePart(getTableName());
}
return sealedWherePart;
}
/**
* 设置封存条件
*
* @param sealedWherePart
* 要设置的 sealedWherePart。
*/
public void setSealedWherePart(String sealedWherePart) {
this.sealedWherePart = sealedWherePart;
}
/**
* 过滤表名
*
* @param column
* @return
*/
public String filterColumn(String column) {
return column.substring(column.indexOf(".") + 1, column.length());
}
/**
* 构造SQL语句
*
* @author 张扬 贺扬修改
*/
protected String getSql(String strPatch, String[] strFieldCode,
String[] hiddenFields, String strTableName, String strWherePart,
String strGroupField, String strOrderField) {
if (strTableName == null || strTableName.trim().length() == 0) {
return null;
}
String basSQL = buildBaseSql(strPatch, strFieldCode, hiddenFields,
strTableName, strWherePart);
StringBuffer sqlBuffer = new StringBuffer(basSQL);
if (getQuerySql() != null) {
addQueryCondition(sqlBuffer);
}
if (getBlurValue() != null && isIncludeBlurPart()) {
String blurSql = addBlurWherePart();
sqlBuffer.append(blurSql);
}
//
// 加入Group子句
if (strGroupField != null) {
sqlBuffer.append(" group by ").append(strGroupField).toString();
}
// 加入ORDER子句
if (strOrderField != null && strOrderField.trim().length() != 0) {
sqlBuffer.append(" order by ").append(strOrderField).toString();
}
return sqlBuffer.toString();
}
protected void addQueryCondition(StringBuffer sqlBuffer) {
sqlBuffer.append(" and (").append(getPkFieldCode()).append(" in (")
.append(getQuerySql()).append("))").toString();
}
/**
* @param sqlBuffer
*/
public String addBlurWherePart() {
return modelHandler.addBlurWherePart();
}
/**
*/
protected String getSql_Match(String[] fieldNames, String[] values,
String strPatch, String[] strFieldCode, String[] hiddenFields,
String strTableName, String strWherePart, String strOrderField) {
if (strTableName == null || strTableName.trim().length() == 0)
return null;
String basSQL = null;
basSQL = buildBaseSql(strPatch, strFieldCode, hiddenFields,
strTableName, strWherePart);
StringBuffer buffer = new StringBuffer(basSQL);
buffer.append(" and (");
if (isPKMatch()) {
buffer.append(getWherePartByFieldsAndValues(fieldNames, values));
} else {
String[] toLowCasefieldNames = new String[fieldNames.length];
String[] toLowCaseValues = new String[values.length];
for (int i = 0; i < toLowCasefieldNames.length; i++) {
toLowCasefieldNames[i] = RefPubUtil.toLowerDBFunctionWrapper(
this, fieldNames[i]);
}
for (int i = 0; i < toLowCaseValues.length; i++) {
toLowCaseValues[i] = RefPubUtil.toLowerCaseStr(this, values[i]);
}
buffer.append(getWherePartByFieldsAndValues(toLowCasefieldNames,
toLowCaseValues));
}
buffer.append(") ");
// 加入ORDER子句
if (strOrderField != null) {
buffer.append(" order by ").append(strOrderField).toString();
}
return buffer.toString();
}
/*
*
* 在java.util.Hashtable getDispConvertor()中初始化
*
*/
public Hashtable getConvertHT(String tableName, String[] fieldNames) {
// 只设置一个标识
setDdReaderVO(tableName, fieldNames);
// 读取值域
return null;
}
/**
* <p>
* <strong>最后修改人：sxj</strong>
* <p>
* <strong>最后修改日期：2006-7-20</strong>
* <p>
*
* @param
* @return Hashtable
* @exception BusinessException
* @since NC5.0
*/
private Hashtable getDDReaderMap(String tableName, String[] fieldNames) {
DataDictionaryReader ddReader = new DataDictionaryReader(tableName);
Hashtable convert = new Hashtable();
for (int i = 0; i < fieldNames.length; i++) {
// 如果列名已经包含表名,去掉表名.值域列没有表名
String newfieldName = fieldNames[i];
if (newfieldName.indexOf(".") > 0) {
newfieldName = newfieldName.substring(
newfieldName.indexOf(".") + 1, newfieldName.length());
}
String[] keys = ddReader.getQzsm(newfieldName);
Hashtable contents = new Hashtable();
for (int j = 0; j < keys.length; j++) {
if (keys[j] != null) {
contents.put(ddReader
.getNumberByQzsm(newfieldName, keys[j]).toString(),
keys[j]);
}
}
convert.put(fieldNames[i], contents);
}
return convert;
}
/**
* @return 返回 isMatchPkWithWherePart。
*
*/
public boolean isMatchPkWithWherePart() {
return isMatchPkWithWherePart;
}
/**
* @param isMatchPkWithWherePart
* 要设置的 isMatchPkWithWherePart。
*/
public void setMatchPkWithWherePart(boolean isMatchPkWithWherePart) {
this.isMatchPkWithWherePart = isMatchPkWithWherePart;
}
/**
* @return 返回 m_isRefEnable。
*/
public boolean isRefEnable() {
return m_isRefEnable;
}
/**
* 参照是否可编辑 规则： 1、如果参照可以编辑 在matchPK时，包含数据权限和不包含封存数据 2、如果参照不能编辑
* 在matchPK时，不包含数据权限和包含封存数据
* 3、对于规则1，如果isUseDataPower()=false,就不包含数据权限；如果isSealedDataShow=true,就包含封存数据
*/
public void setisRefEnable(boolean refEnable) {
m_isRefEnable = refEnable;
}
/**
* @return 返回 formulas。
*/
public String[][] getFormulas() {
return formulas;
}
/**
* @param formulas
* 要设置的 formulas。
*/
public void setFormulas(String[][] formulas) {
this.formulas = formulas;
}
/**
* @return 返回 isLocQueryEnable。
*/
public boolean isLocQueryEnable() {
return isLocQueryEnable;
}
/**
* @param isLocQueryEnable
* 要设置的 isLocQueryEnable。
*/
public void setLocQueryEnable(boolean isLocQueryEnable) {
this.isLocQueryEnable = isLocQueryEnable;
}
/**
* @return 返回 m_hmFilterPks。
*/
public HashMap getHmFilterPks() {
return m_hmFilterPks;
}
/**
* @return 返回 m_filterStrategy。
*/
public int getFilterStrategy() {
return m_filterStrategy;
}
/**
* @return 返回 m_filterPks。
*/
public String[] getFilterPks() {
return m_filterPks;
}
/**
* 获取匹配数据 匹配成功 数据－>m_vecSelectedData 匹配不成功 null－>m_vecSelectedData
* 创建日期：(2001-8-23 18:39:24)
*
* @return java.util.Vector sxj 修改如果value= null or value.length()=0
* 不做匹配,提高效率，防止重复reloadData() sxj 2004-11-11 add
*/
public Vector matchData(String[] fields, String[] values) {
Vector vMatchData = getMatchedRecords(fields, values);
// 使用缓存，并且匹配不到数据，刷新数据再执行一次
if (isCacheEnabled() && vMatchData == null && isRefreshMatch()) {
clearData();
vMatchData = getMatchedRecords(fields, values);
}
// boolean isDefConverted = true;
// if (vMatchData == null || vMatchData.size() == 1) {
// isDefConverted = false;
// }
// if (vMatchData != null) {
// vMatchData = getConvertedData(false, vMatchData, isDefConverted);
// }
setSelectedData(vMatchData);
return vMatchData;
}
/**
* 此处插入方法说明。 创建日期：(2005-10-21 14:43:00)
*
* @param fieldNames
* java.lang.String[]
* @param values
* java.lang.String
*/
protected Vector getMatchedRecords(String[] fieldNames, String[] values) {
Vector vMatchedRecords = null;
// sxj
if (values == null || values.length == 0) {
return vMatchedRecords;
}
//
if (fieldNames == null || fieldNames.length == 0) {
return vMatchedRecords;
}
// 要比较的值放到HashMap
getMatchHM().clear();
for (int i = 0; i < values.length; i++) {
if (values[i] != null) {
getMatchHM().put(RefPubUtil.toLowerCaseStr(this, values[i]),
RefPubUtil.toLowerCaseStr(this, values[i]));
}
}
vMatchedRecords = new Vector();
// 在全集中匹配数据
setIncludeBlurPart(false);
// 重新载入数据
Vector data = null;
data = getRefData();
if (data != null) {
for (int i = 0; i < data.size(); i++) {
Vector vRecord = (Vector) data.elementAt(i);
if (vRecord != null)
for (int j = 0; j < fieldNames.length; j++) {
int col = getFieldIndex(fieldNames[j]);
if (col < 0 || col >= vRecord.size()) {
continue;
}
if (vRecord.elementAt(col) != null
&& getMatchHM().get(
RefPubUtil.toLowerCaseStr(this, vRecord
.elementAt(col).toString()
.trim())) != null) {
vMatchedRecords.addElement(vRecord);
break;
}
}
}
}
if (vMatchedRecords != null && vMatchedRecords.size() == 0)
vMatchedRecords = null;
setIncludeBlurPart(true); // 恢复原状态
return vMatchedRecords;
}
/**
* 此处插入方法说明。 创建日期：(2005-10-21 17:12:01)
*
* @return boolean
*/
public boolean isOnlyMneFields() {
return isOnlyMneFields;
}
/**
* 此处插入方法说明。 创建日期：(2005-10-21 17:12:01)
*
* @param newIsOnlyMneFields
* boolean
*/
public void setOnlyMneFields(boolean newIsOnlyMneFields) {
isOnlyMneFields = newIsOnlyMneFields;
}
/**
* 此处插入方法说明。 创建日期：(2003-2-19 9:24:17)
*
* @return java.lang.String
*/
public java.lang.String getWherePartByFieldsAndValues(String[] fields,
String[] values) {
String wherePart = "";
StringBuffer sb = new StringBuffer();
if (fields != null && values != null) {
int length = fields.length;
for (int i = 0; i < length; i++) {
if (values.length == 1) {
// =
sb.append(fields[i]).append("='").append(values[0]).append(
"' ");
} else {
// in
sb.append(RefPubUtil.getInSubSql(fields[i], values));
}
if (i == length - 1) {
continue;
}
sb.append(" or ");
}
} else {
return null;
}
wherePart = sb.toString();
return wherePart;
}
/**
* @return Returns the m_addWherePart.
*/
public String getAddWherePart() {
return m_addWherePart;
}
public void saveTempData(Object[] retPKs) {
// 保存Pk 到临时表
if (retPKs == null || retPKs.length == 0) {
setTempDataWherePart(null);
return;
}
String pk_ts = null;
RefdatatempVO[] vos = new RefdatatempVO[retPKs.length];
for (int i = 0; i < retPKs.length; i++) {
vos[i] = new RefdatatempVO();
vos[i].setPk_selecteddata(retPKs[i].toString());
vos[i].setPk_corp(getPk_corp());
vos[i].setCuserid(getPk_user());
vos[i].setRefnodename(getRefNodeName());
vos[i].setPk_ts("temp");
}
try {
pk_ts = modelHandler.saveRefDataTempVOs(vos);
} catch (Exception e) {
Debug.error(e.getMessage(), e);
}
String selSql = "select pk_selecteddata from bd_refdatatemp ";
// 设置临时表取树WherePart
String wherePart = selSql + " where pk_corp='" + getPk_corp()
+ "' and cuserid = '" + getPk_user() + "' "
+ " and refnodename='" + getRefNodeName() + "' and pk_ts = '"
+ pk_ts + "'";
setTempDataWherePart(wherePart);
}
/**
* 设有公式的参照，按公式取值。 创建日期：(2005-3-30 16:19:24)
*
*/
public void setColDispValues(Vector vecData, Object[][] dispConverter) {
if (vecData == null || vecData.size() == 0 || dispConverter == null) {
return;
}
// 列显示转换器循环
for (int i = 0; i < dispConverter.length; i++) {
// 列显示转化配置ＶＯ
RefColumnDispConvertVO convertVO = (RefColumnDispConvertVO) dispConverter[i][0];
if (convertVO == null) {
continue;
}
// 实现类名称
String className = dispConverter[i][1].toString();
// 给列显示转化配置ＶＯ设置数据主键值
// convertVO.setPks(pks);
convertVO.setRefData(vecData);
// 处理列显示转换
m_vecData = modelHandler.setColDispValue(vecData, convertVO,
className);
}
}
/*
*
*/
public ReftableVO getRefTableVO(String pk_corp) {
return modelHandler.getRefTableVO(pk_corp);
}
/*
* 栏目信息数据放到缓存.
*/
public void setReftableVO2Cache(ReftableVO vo, String pk_org) {
modelHandler.setReftableVO2Cache(vo, pk_org);
}
public String getReftableVOCacheKey(String pk_org) {
String refNodeName = getRefNodeName();
// if (OrgnizeTypeVO.ZHUZHANG_TYPE.equals(getOrgTypeCode())){
// pk_org = getPk_GlOrgBook();
// }else{
// pk_org = getPk_corp();
// }
// 目前还是按当前登录公司来保存栏目信息,以后有需求可以加入对主体账簿的支持
String key = refNodeName + pk_org;
return key;
}
/*
* 查询参照数据以及参照栏目信息数据 1、栏目数据直接放入缓存. 2、参照数据返回
*/
public Vector getQueryResultVO() {
boolean isQueryRefColumn = !modelHandler
.isReftableVOCached(getPk_corp());
RefQueryVO queryVO = getRefQueryVO();
// 目前还是按当前登录公司来保存栏目信息,以后有需求可以加入对主体账簿的支持
queryVO.setPk_org(getPk_corp());
RefQueryResultVO resultVO = null;
resultVO = modelHandler.queryRefdataByQueryVO(queryVO);
if (resultVO == null) {
return null;
}
Vector v = resultVO.getRefData();
if (isQueryRefColumn) {
setReftableVO2Cache(resultVO.getRefTableVO(), getPk_corp());
}
return v;
}
protected RefQueryVO getRefQueryVO() {
boolean isQueryRefColumn = !modelHandler
.isReftableVOCached(getPk_corp());
queryVO.setDataSourceName(getDataSource());
queryVO.setRefNodeName(getRefNodeName());
queryVO.setQuerySql(getRefSql());
queryVO.setObj(getPara());
queryVO.setQueryRefColumn(isQueryRefColumn);
return queryVO;
}
/**
* 参照标题 创建日期：(01-4-4 0:57:23)
*
* @return java.lang.String
*/
public String getRefTitle() {
if (m_strRefTitle != null) {
return m_strRefTitle;
}
m_strRefTitle = modelHandler.getRefNodeName_mLang(getRefNodeName());
if (m_strRefTitle == null) {
m_strRefTitle = getRefNodeName();
}
return m_strRefTitle;
}
/**
* @param m_pk_user
* 要设置的 m_pk_user。
*/
public void setPk_user(String m_pk_user) {
this.m_pk_user = m_pk_user;
}
/*
* 给名称字段赋值
*/
public void resetFieldName() {
if (getFieldCode() != null && getTableName() != null
&& (getFieldName() == null || getFieldName().length == 0)) {
String[] name = new String[getFieldCode().length];
for (int i = 0; i < getFieldCode().length; i++) {
String fieldCode = modelHandler
.getFieldCodeWithTableName(getFieldCode()[i]);
String resid = modelHandler.getResID(fieldCode);
name[i] = modelHandler.getRefMultiLangStr(resid, fieldCode);
}
setFieldName(name);
}
}
/**
* @return 返回 formulaHandler。
*/
private FormulaHandler getFormulaHandler() {
if (formulaHandler == null) {
formulaHandler = new FormulaHandler();
}
return formulaHandler;
}
private DefFieldsHandler getDefFieldHandler() {
if (defFieldHandler == null) {
defFieldHandler = new DefFieldsHandler();
}
return defFieldHandler;
}
/**
* 设置自定义数据到指定vecData中的field列。 创建日期：(2005-3-30 16:19:24)
*
* @return java.lang.Object[]
*/
private void setValuesByFieldName(Vector vecData, Vector newVecData,
String[] fieldNames) {
int col = -1;
for (int i = 0; i < fieldNames.length; i++) {
col = getFieldIndex(fieldNames[i]);
Object[] values = (Object[]) newVecData.get(i);
if (values == null) {
continue;
}
for (int j = 0; j < values.length; j++) {
Vector vRecord = (Vector) vecData.get(j);
if (vRecord == null || vRecord.size() == 0 || col < 0
|| col >= vRecord.size()) {
continue;
}
Object obj = getRefValueVO(vRecord.elementAt(col), values[j]);
vRecord.setElementAt(obj, col);
}
}
}
/**
* <p>
* <strong>最后修改人：sxj</strong>
* <p>
* <strong>最后修改日期：2006-5-17</strong>
* <p>
*
* @param
* @return void
* @exception BusinessException
* @since NC5.0
*/
private RefValueVO getRefValueVO(Object originValue, Object newValue) {
if (originValue instanceof RefValueVO) {
return (RefValueVO) originValue;
}
RefValueVO valueVO = new RefValueVO();
valueVO.setOriginValue(originValue);
valueVO.setNewValue(newValue);
return valueVO;
}
/**
* @return 返回 m_pk_user。
*/
public String getPk_user() {
if (m_pk_user == null) {
m_pk_user = modelHandler.getPk_user();
}
return m_pk_user;
}
/**
* 只添加不重复的监听类。
* <p>
* <strong>最后修改人：sxj</strong>
* <p>
* <strong>最后修改日期：2006-8-10</strong>
* <p>
*
* @param
* @return void
* @exception BusinessException
* @since NC5.0
*/
public void addChangeListener(ChangeListener l) {
if (eventListMap.get(l) == null) {
eListenerList.add(ChangeListener.class, l);
eventListMap.put(l, l);
}
}
public void removeChangeListener(ChangeListener l) {
eListenerList.add(ChangeListener.class, l);
eventListMap.remove(l);
}
public ChangeListener[] getChangeListeners() {
return (ChangeListener[]) eListenerList
.getListeners(ChangeListener.class);
}
public void fireChange() {
Object[] listeners = eListenerList.getListenerList();
for (int i = listeners.length - 2; i >= 0; i -= 2) {
if (listeners[i] == ChangeListener.class) {
if (changeEvent == null) {
changeEvent = new ChangeEvent(this);
}
((ChangeListener) listeners[i + 1]).stateChanged(changeEvent);
}
}
}
/**
* 显示字段列表 创建日期：(01-4-4 0:57:23)
*
* @return java.lang.String
*/
public java.lang.String[] getFieldCode() {
return m_strFieldCode;
}
/**
* 显示字段中文名 创建日期：(01-4-4 0:57:23)
*
* @return java.lang.String
*/
public java.lang.String[] getFieldName() {
return m_strFieldName;
}
/**
* 此处插入方法说明。 创建日期：(2001-8-31 18:59:51)
*
* @return java.lang.String
*/
public String getGroupCode() {
return IRefConst.GROUPCORP;
}
/**
* 主键字段名
*
* @return java.lang.String
*/
public String getPkFieldCode() {
return m_strPkFieldCode;
}
/**
* 参照标题 创建日期：(01-4-4 0:57:23)
*
* @return java.lang.String
*/
/**
* 参照数据库表或者视图名 创建日期：(01-4-4 0:57:23)
*
* @return java.lang.String
*/
public String getTableName() {
return m_strTableName;
}
/**
* 此处插入方法说明。 创建日期：(01-3-22 13:22:29)
*
* @param newFieldCode
* java.lang.String[]
*/
public void setFieldCode(java.lang.String[] newFieldCode) {
getHtCodeIndex().clear();
m_strFieldCode = newFieldCode;
}
/**
* 此处插入方法说明。 创建日期：(01-3-22 13:22:29)
*
* @param newFieldName
* java.lang.String[]
*/
public void setFieldName(java.lang.String[] newFieldName) {
m_strFieldName = newFieldName;
}
/**
* 主键字段名
*/
public void setPkFieldCode(String strPkFieldCode) {
m_strPkFieldCode = strPkFieldCode;
}
/**
* @return 返回 m_fun_code_DocOpen。
*/
public String getFun_code_DocOpen() {
return m_fun_code_DocOpen;
}
/**
* @param docOpen
* 要设置的 m_fun_code_DocOpen。
*/
public void setFun_code_DocOpen(String docOpen) {
m_fun_code_DocOpen = docOpen;
}
/**
* @return 返回 m_intFieldType。
*/
public int[] getIntFieldType() {
return m_intFieldType;
}
/**
* @param fieldType
* 要设置的 m_intFieldType。
*/
public void setIntFieldType(int[] fieldType) {
m_intFieldType = fieldType;
}
/**
* @return 返回 isGroupAssignData。
*/
public boolean isGroupAssignData() {
return isGroupAssignData;
}
/**
* @param isGroupAssignData
* 要设置的 isGroupAssignData。
*/
public void setGroupAssignData(boolean isGroupAssignData) {
this.isGroupAssignData = isGroupAssignData;
}
public String getRefDataCacheKey() {
String key = refDataCachekeyPreStr
+ getDataPowerSqlKey(getTableName(), getRefNodeName());
return key;
}
public String getFieldShowName(String fieldCode) {
int index = getFieldIndex(fieldCode);
if (index < 0 || index > getFieldName().length - 1) {
return null;
} else {
return getFieldName()[index];
}
}
/**
* @return 返回 ddReaderVO。
*/
private DDReaderVO getDdReaderVO() {
return ddReaderVO;
}
/**
* @param ddReaderVO
* 要设置的 ddReaderVO。
*/
public void setDdReaderVO(String tableName, String[] fieldnames) {
if (ddReaderVO == null) {
ddReaderVO = new DDReaderVO();
}
ddReaderVO.setTableName(tableName);
ddReaderVO.setFieldNames(fieldnames);
}
/**
* @return 返回 resourceID。
*/
public int getResourceID() {
return resourceID;
}
/**
* @param resourceID
* 要设置的 resourceID。
*/
public void setResourceID(int resourceID) {
this.resourceID = resourceID;
}
/**
* @return 返回 isPKMatch。
*/
public boolean isPKMatch() {
return isPKMatch;
}
/**
* @param isPKMatch
* 要设置的 isPKMatch。
*/
public void setPKMatch(boolean isPKMatch) {
this.isPKMatch = isPKMatch;
}
/**
* @return 返回 isIncludeBlurPart。
*/
public boolean isIncludeBlurPart() {
return isIncludeBlurPart;
}
/**
* @param isIncludeBlurPart
* 要设置的 isIncludeBlurPart。
*/
public void setIncludeBlurPart(boolean isIncludeBlurPart) {
this.isIncludeBlurPart = isIncludeBlurPart;
}
/**
* @return 返回 envWherePart。
*/
private String getEnvWherePart() {
return envWherePart;
}
/**
* 设置条件时，要利用参照的环境变量的方法去拼条件，否则无法根据环境变量的变化而变化。 例如：
*
* @param envWherePart
* 要设置的 envWherePart。
*/
public void setEnvWherePart(String envWherePart) {
this.envWherePart = envWherePart;
}
/**
*
*/
private void addEnvWherePart(StringBuffer whereClause) {
// setpk ,不包含此条件
if (isPKMatch()) {
return;
}
String wherePart = getEnvWherePart();
if (wherePart != null) {
whereClause.append(" and (").append(wherePart).append(") ");
}
}
/**
* @return 返回 bdinfoVO。
*/
public BdinfoVO getBdinfoVO() {
if (bdinfoVO == null && !isInitBDinfoVO) {
bdinfoVO = modelHandler.getBdInfoVObyName(getRefNodeName());
isInitBDinfoVO = true;
}
return bdinfoVO;
}
/**
* @param bdinfoVO
* 要设置的 bdinfoVO。
*/
public void setBdinfoVO(BdinfoVO bdinfoVO) {
this.bdinfoVO = bdinfoVO;
isInitBDinfoVO = true;
}
/**
* @return Returns the isChangeTableSeq.
*/
public boolean isChangeTableSeq() {
return isChangeTableSeq;
}
/**
* @param isChangeTableSeq
* The isChangeTableSeq to set.
*/
public void setChangeTableSeq(boolean isChangeTableSeq) {
this.isChangeTableSeq = isChangeTableSeq;
}
/**
* @return 返回 isMaintainButtonEnabled。
*/
public boolean isMaintainButtonEnabled() {
return isMaintainButtonEnabled;
}
/**
* @param isMaintainButtonEnabled
* 要设置的 isMaintainButtonEnabled。
*/
public void setMaintainButtonEnabled(boolean isMaintainButtonEnabled) {
this.isMaintainButtonEnabled = isMaintainButtonEnabled;
}
/**
* @param dataPowerPK_column
* 要设置的 dataPowerPK_column。
*/
public void setDataPowerResourceColumn(String dataPowerResourceColumn) {
this.dataPowerResourceColumn = dataPowerResourceColumn;
}
/**
* @return 返回 refCardInfoComponentImplClass。
*/
public String getRefCardInfoComponentImplClass() {
return refCardInfoComponentImplClass;
}
/**
* @param refCardInfoComponentImplClass
* 要设置的 refCardInfoComponentImplClass。
*/
public void setRefCardInfoComponentImplClass(
String refCardInfoComponentImplClass) {
this.refCardInfoComponentImplClass = refCardInfoComponentImplClass;
}
public String getRefShowNameField() {
return refShowNameField == null ? getRefNameField() : refShowNameField;
}
public void setRefShowNameField(String refShowNameField) {
this.refShowNameField = refShowNameField;
}
// 初始化自定义项字段
// defFields.length==0表示初始化过了。
public String[] getDefFields() {
return defFields;
}
/**
* 栏目显示的自定义项
*
* @return
*/
public String[] getShowDefFields() {
String[] defFieldNames = null;
if (getDefFields() == null || getDefFields().length == 0) {
return defFieldNames;
}
Map<String, RefcolumnVO> map = modelHandler.getRefColumnVOsMap();
List<String> list = new ArrayList<String>();
for (int i = 0; i < getDefFields().length; i++) {
if (map.get(getDefFields()[i]) != null
&& map.get(getDefFields()[i]).getIscolumnshow()
.booleanValue()) {
list.add(getDefFields()[i]);
}
}
if (list.size() > 0) {
String[] fieldNames = new String[list.size()];
list.toArray(fieldNames);
defFieldNames = fieldNames;
}
return defFieldNames;
}
public void setDefFields(String[] defFields) {
this.defFields = defFields;
}
public Map<String, Integer> getAlignMap() {
return alignMap;
}
private void setAlignMap(Map<String, Integer> alignMap) {
this.alignMap = alignMap;
}
/**
* 栏目对齐方式
*
* @param fieldName
* 栏目名称 要对齐的列（列名要和fieldCodes中的一致）
* @param alignment
* 对齐方式 常量见SwingConstants，例如 SwingConstants.RIGHT
*/
public void addFieldAlignment(String fieldName, int alignment) {
if (getAlignMap() == null) {
setAlignMap(new HashMap<String, Integer>());
}
getAlignMap().put(fieldName, new Integer(alignment));
}
public boolean canUseDB() {
return modelHandler.canUseDB();
}
public Vector getCacheValue(String sql) {
return modelHandler.getCacheValue(sql);
}
public Vector queryMain(String dsName, String sql) {
return modelHandler.queryMain(dsName, sql);
}
public void removeCacheValue(String sql) {
modelHandler.removeCache(sql);
}
public void setCacheValue(String sql, Vector value) {
modelHandler.setCacheValue(sql, value);
}
public String getCodeRuleFromPara(String orgTypeCode, String pk_GlOrgBook,
String codingRule, UFBoolean boolean1) {
return modelHandler.getCodeRuleFromPara(orgTypeCode, pk_GlOrgBook,
codingRule, boolean1);
}
public String getCodeRuleFromPara(String codingRule) {
return modelHandler.getCodeRuleFromPara(codingRule);
}
public String getNumberCodingRule(String codingRule) {
return modelHandler.getNumberCodingRule(codingRule);
}
public String[] getDefFields(String[] fieldCode) {
return modelHandler.getDefFields(fieldCode);
}
public String getPara1() {
return para1;
}
public void setPara1(String para1) {
this.para1 = para1;
}
public String getPara2() {
return para2;
}
public void setPara2(String para2) {
this.para2 = para2;
}
public String getPara3() {
return para3;
}
public void setPara3(String para3) {
this.para3 = para3;
}
protected IRefModelHandler getModelHandler() {
return modelHandler;
}
public String getUiControlComponentClassName() {
return uiControlComponentClassName;
}
public void setUiControlComponentClassName(
String uiControlComponentClassName) {
this.uiControlComponentClassName = uiControlComponentClassName;
}
/**
* 界面控制组件变化时调用该方法，在子类实现具体业务逻辑。
*
* @param eventData
* 暂时返回发生变化的组件名称
*/
public void UiControlClassValueChanged(UIControlClassEvent event) {
}
public String getRefDocEditClassName() {
return refDocEditClassName;
}
public void setRefDocEditClassName(String refDocEditClassName) {
this.refDocEditClassName = refDocEditClassName;
}
public boolean isShowField(String fieldName) {
boolean isShowField = false;
int[] showColumns = getShownColumns();
int index = getFieldIndex(fieldName);
for (int i = 0; i < showColumns.length; i++) {
if (showColumns[i] == index) {
isShowField = true;
break;
}
}
return isShowField;
}
public String[] getShowFields() {
String[] showFields = new String[getShownColumns().length];
int fieldCodeLength = getFieldCode().length;
for (int i = 0; i < showFields.length; i++) {
int index = getShownColumns()[i];
if (index < fieldCodeLength) {
showFields[i] = getFieldCode()[index];
} else {
Logger.debug("参照栏目信息有误，请点击参照栏目中的重置按钮。该参照为：" + getRefNodeName());
}
}
return showFields;
}
public boolean isHiddenField(String fieldCode) {
return hiddenFieldList.contains(fieldCode);
}
// 输入时是否大小写敏感
public boolean isCaseSensitve() {
return isCaseSensitve;
}
public void setCaseSensive(boolean isCaseSensitve) {
this.isCaseSensitve = isCaseSensitve;
}
public Vector getAllColumnNames() {
if (vecAllColumnNames != null) {
return vecAllColumnNames;
}
vecAllColumnNames = new Vector();
if (getFieldCode() != null && getFieldCode().length > 0) {
if (getFieldName() == null || getFieldName().length == 0) {
for (int i = 0; i < getFieldCode().length; i++) {
vecAllColumnNames.addElement(getFieldCode()[i]);
}
} else {
if (getFieldName().length >= getFieldCode().length) {
for (int i = 0; i < getFieldCode().length; i++) {
vecAllColumnNames.addElement(getFieldName()[i]);
}
} else {
for (int i = 0; i < getFieldName().length; i++) {
vecAllColumnNames.addElement(getFieldName()[i]);
}
for (int i = getFieldName().length; i < getFieldCode().length; i++) {
vecAllColumnNames.addElement(getFieldCode()[i]);
}
}
}
}
if (getHiddenFieldCode() != null)
for (int i = 0; i < getHiddenFieldCode().length; i++) {
vecAllColumnNames.addElement(getHiddenFieldCode()[i]);
}
// 加入动态列
if (isDynamicCol()) {
String[] dynamicColNames = getDynamicFieldNames();
if (getDynamicFieldNames() != null) {
for (int i = 0; i < dynamicColNames.length; i++) {
// 加入到显示的列名中
vecAllColumnNames.addElement(dynamicColNames[i]);
}
}
}
return vecAllColumnNames;
}
protected String getRefCacheSqlKey() {
return getRefSql() == null ? getClass().getName() : getRefSql();
}
}