NC常用的参照类型有三种:列表型、树型、树表型。对应于这三种常用类型的参照,Model提供了三个抽象类:
- 列表参照: AbstractRefModel
- 树型参照: AbstractRefTreeModel
- 树表型参照:AbstractRefGridTreeModel
不同类型的参照对应的参照类须继承上述的相应基类。
如新建一个代码参照类,继承AbstractRefModel类,以下是 “仓库” 自定义参照代码案例
package nc.ui.bd.ref.model;
import nc.itf.bd.pub.IBDResourceIDConst;
import nc.ui.bd.ref.AbstractRefModel;
import nc.ui.bd.ref.IRefDocEdit;
import nc.ui.bd.ref.IRefMaintenanceHandler;
import nc.vo.bd.stordoc.StordocVO;
/**
* 仓库,不根据库存组织联动查询
*/
public class StorDocReportRefModel extends AbstractRefModel {
public StorDocReportRefModel() {
reset();
}
@Override
public void reset() {
setFieldCode(new String[] { StordocVO.CODE, StordocVO.NAME, StordocVO.STORADDR, StordocVO.MEMO, StordocVO.PRINCIPALCODE });
setFieldName(new String[] { nc.vo.ml.NCLangRes4VoTransl.getNCLangRes().getStrByID("common", "UC000-0000162")/*
* @res "仓库编码"
*/, nc.vo.ml.NCLangRes4VoTransl.getNCLangRes().getStrByID("common", "UC000-0000157") /*
* @res "仓库名称"
*/,
nc.vo.ml.NCLangRes4VoTransl.getNCLangRes().getStrByID("10140warh", "110140warh0001")
/* @res "仓库地址" */, "备注", "负责人" });
setHiddenFieldCode(new String[] { StordocVO.PK_STORDOC });
setTableName("bd_stordoc");
setPkFieldCode(StordocVO.PK_STORDOC);
setRefCodeField(StordocVO.CODE);
setRefNameField(StordocVO.NAME);
setFormulas(new String[][] { { StordocVO.STORADDR, "formataddress(" + StordocVO.STORADDR + ");" } });
// 使用启用条件
setAddEnableStateWherePart(true);
// 数据权限
setResourceID(IBDResourceIDConst.STORDOC);
// 维护
setRefMaintenanceHandler(new IRefMaintenanceHandler() {
@Override
public String[] getFucCodes() {
return new String[] { "10140WARH" };
}
@Override
public IRefDocEdit getRefDocEdit() {
return null;
}
});
resetFieldName();
}
/**
* 参照标题 创建日期:(01-4-4 0:57:23)
*
* @return java.lang.String
*/
public String getRefTitle() {
return "报表查询条件参照-仓库";
}
/**
* 设置不显示参照
*/
public String[] getHiddenFieldCode() {
return new String[] { StordocVO.PK_STORDOC };
}
/**
* 设置参照表名
*/
public String getTableName() {
return "bd_stordoc";
}
/**
* 设置参照查询规则
*
*/
public String getWherePart(){
return " isnull(dr, 0) = 0 ";
}
public boolean isMatchPkWithWherePart() {
return true;
}
/**
* 获取主键字段,必要
*/
public String getPkFieldCode() {
return StordocVO.PK_STORDOC;
}
}
在编写参照类后,还需要在参照表bd_refinfo中插入参照信息
insert into bd_refinfo (CODE, DR, ISNEEDPARA, ISSPECIALREF, LAYER, METADATANAMESPACE, METADATATYPENAME, MODULENAME, NAME, PARA1, PARA2, PARA3, PK_COUNTRY, PK_INDUSTRY, PK_REFINFO, REFCLASS, REFSYSTEM, REFTYPE, RESERV1, RESERV2, RESERV3, RESID, RESIDPATH, TS, WHEREPART)
values ('report_stordoc', 0, null, null, null, 'uapbd', 'stordoc', 'uapbd', '报表查询条件-仓库', null, null, null, null, null, '0001Z01000010001STOR', 'nc.ui.bd.ref.model.StorDocReportRefModel', null, 0, null, null, null, 'UC000-0000153', 'common', '2021-04-07 12:02:30', null);
commit;
至此,参照开发完成,在单据模板中可以使用该参照了,这以采购入库单的仓库为例,如下图:
设置完后可以打开参照,查出数据,则证明代码没错了
自定义参照也可以用于自由报表的查询条件,如下图:
选择仓库查询条件进行属性设置
然后在弹框中选择数据来源页签,在数据来源的下拉中选择参照,把是否系统定义的√去掉,如下图:
在参照名称中输入自己自定义的参照类:nc.ui.bd.ref.model.StorDocReportRefModel,返回类型选择主键参照,点击应用再点击确定就可以了
(注意:返回类型和显示名称需要根据自己定义的参照情况来选择,我这里是选择主键参照)
如图:
以上操作完成后,点击仓库参照,即可看到自定义参照的数据,如下图:
AbstractRefModel 基类源码:
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.ui.pub.beans.ValueChangedEvent;
import nc.vo.bd.ref.IFilterStrategy;
import nc.vo.bd.ref.RefBlurQueryVO;
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.jcom.lang.StringUtil;
import nc.vo.logging.Debug;
import nc.vo.ml.MultiLangContext;
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;
import org.apache.commons.lang.StringUtils;
import uap.iweb.ref.controller.RefClientPageInfo;
public abstract class AbstractRefModel implements IRefModel {
protected IRefModelHandler modelHandler;
private IRefMaintenanceHandler refMaintenanceHandler;
// 是否增加档案启用过滤条件开关
private boolean isAddEnableStateWherePart = false;
private boolean isAddEnvWherePart = true;
private String dataPowerColumn = null;
// 版本CheckBox名称
private String versionDataLabelName = null;
private boolean isBlur = false;
private boolean isFilterByLucene = false;
private boolean isSupportPY = false;//过滤是否支持拼音,默认为不支持
//AbstractRefModel增加一下参数值扩展,用于从报表传递业务人员场景,人员参照这样可以根据场景拼跨组织条件
//2015-5-5 金基勇部门请求增加
private Map<String,String> keyValueExtendMap = new HashMap<String,String>();
public Map<String, String> getKeyValueExtendMap() {
return keyValueExtendMap;
}
/**
* AbstractRefModel 构造子注解。
*/
public AbstractRefModel() {
super();
try {
Class c;
// 加载服务器类。
if (RuntimeEnv.getInstance().isRunningInServer())
c = Class.forName("nc.ui.bd.ref.impl.RefModelHandlerForServer");
// 加载客户端类
else {
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 para1 = null;
private String para2 = null;
private String para3 = null;
private ArrayList hiddenFieldList = new ArrayList();
// V55需求,是否大小写敏感
private boolean isCaseSensitve = false;//v63默认为不区分大小写,杨小强
//
private Vector vecAllColumnNames = null;
private String pk_org = null;
// V6权限资源主键
private String powerResourceID = null;
// v6权限操作标示
private String powerOperator = null;
private String[] filterRefNodeNames = null;
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 String m_blurQueryTableName = null;//全文检索模糊匹配表名
private java.lang.String m_strBlurValue = null;
private String m_strRefTitle = null;
protected Vector m_vecData = null;
protected Vector<Object> m_vecDataWeb = null;
protected Object[] pksWeb = 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 boolean m_queryFromServer = false;//为导入功能加的接口,改入时设置为true,查询数据走后台
private Hashtable m_htCodeIndex = null;
private String m_orgTypeCode = OrgnizeTypeVO.COMPANY_TYPE;
// 当前参照所在界面的功能节点号
private String m_fun_code = null;
// 增加从临时表取数的方式 2004-06-10
private boolean isFromTempTable = false;
// 是否包含模糊匹配Sql
private boolean isIncludeBlurPart = true;
// sxj 返回值是否包含下级节点
private boolean isIncludeSub = false;
private boolean isPKMatch = false;
// sxj 2003-10-31
// 匹配数据时,如果匹配不上,是否刷新数据再匹配一次
private boolean m_isRefreshMatch = true;
// 是否显示停用数据
private boolean m_isDisabledDataShow = 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;
// 参照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 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 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;
// 参照数据缓存Key前缀字符串
private String refDataCachekeyPreStr = "REFDATACACHE";
private DDReaderVO ddReaderVO = null;
// 对于自定义参照数据权限的支持.数据权限优先按资源ID查询。
private String resourceID = null;
private String classResouceID = null;
public String getClassResouceID() {
return classResouceID;
}
public void setClassResouceID(String classResouceID) {
this.classResouceID = classResouceID;
}
// 停用数据条件
private String disabledDataWherePart = null;
// 该条件会根据环境变量变化,同时在setpk时不带此条件
private String envWherePart = null;
// 是否要改变关联表的顺序(为缓存)
private boolean isChangeTableSeq = true;
// 维护按钮是否可用
private boolean isMaintainButtonEnabled = true;
// 记录详细信息显示组件
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;
// 集团
private String pk_group = null;
// 是否多语种名称参照
private boolean isMutilLangNameRef = true;
private Map<String, AbstractRefModel> filterRefMap = null;
// 历史版本数据
private boolean isHistoryVersionDataShow = false;
private boolean isHistoryVersionRef = false;
//搜索全部:全包含的开关,如果为false,则使用左包含
private boolean isAllMatching = true;
private RefQueryVO queryVO = new RefQueryVO();
// 手工输入时要加入的过滤条件,该条件只对用Sql语句匹配数据的参照,例如树表型参照。
// v60新增,只要是物料档案多版本参照,在手工输入时只选中最新版本。
private String inputMatchWherePart = null;
// 权限动作编码
private String dataPowerOperation_code = IRefConst.DATAPOWEROPERATION_CODE;
// 快捷输入开关
private boolean isShortCutInput = true;
public boolean isShortCutInput() {
return isShortCutInput;
}
public void setShortCutInput(boolean isShortCutInput) {
this.isShortCutInput = isShortCutInput;
}
public String getDataPowerOperation_code() {
return dataPowerOperation_code;
}
public void setDataPowerOperation_code(String dataPowerOperation_code) {
if (dataPowerOperation_code == null) {
this.dataPowerOperation_code = IRefConst.DATAPOWEROPERATION_CODE;
} else {
this.dataPowerOperation_code = dataPowerOperation_code;
}
}
public String getInputMatchWherePart() {
return inputMatchWherePart;
}
public void setInputMatchWherePart(String inputMatchWherePart) {
this.inputMatchWherePart = inputMatchWherePart;
}
public void setFilterRefMap(Map<String, AbstractRefModel> filterRefMap) {
this.filterRefMap = filterRefMap;
}
public Map<String, AbstractRefModel> getFilterRefMap() {
return filterRefMap;
}
public AbstractRefModel getFilterRefModel(String refNodeName) {
if (getFilterRefMap() == null) {
return null;
}
return getFilterRefMap().get(refNodeName);
}
public boolean isMutilLangNameRef() {
return isMutilLangNameRef;
}
public void setMutilLangNameRef(boolean isMutilLangNameRef) {
this.isMutilLangNameRef = isMutilLangNameRef;
}
// yxq--------------------模全文检索的模糊匹配功能--------------------------------------------------------
public Vector getRefdataByBlurValue(int maxReturnRows){
RefQueryVO queryVO = getRefQueryVO();
if (getBlurValue() != null) {
RefBlurQueryVO blurQueryVO = new RefBlurQueryVO();
blurQueryVO.setBlurFields(getSearchFields());
blurQueryVO.setBlurValue(getBlurValue());
blurQueryVO.setMaxReturnRows(maxReturnRows);
blurQueryVO.setPkField(getPkFieldCode());
blurQueryVO.setRefNodeName(getRefNodeName());
if (getBlurQueryTableName() != null)
blurQueryVO.setTableName(getBlurQueryTableName());
else
blurQueryVO.setTableName(getTableName());
//blurQueryVO.setFuzzuMatchConfig(getFuzzyMatchConfig());
queryVO.setBlurQueryVO(blurQueryVO);
//搜索一般是按name进行,这里改变一下order by 的属性,用Name列来排序
String orderPart = getOrderPart();
if(isMutilLangNameRef()&& getLangStrSuffix()!=null){
setOrderPart(getCompositeOrderColumn(getRefNameField()));
}else{
setOrderPart(getRefNameField());
}
//走全文检索,不用自己拼模糊匹配条件
if (this instanceof AbstractRefGridTreeBigDataModel){
setIncludeBlurPart(false);
//把分类条件去掉
((AbstractRefGridTreeBigDataModel)this).setClassJoinValue(IRefConst.QUERY);
}
queryVO.setQuerySql(getRefSql());
//恢复默认搜索列
setOrderPart(orderPart);
}
// 目前还是按当前登录公司来保存栏目信息,以后有需求可以加入对主体账簿的支持
queryVO.setPk_org(getPk_corp());
RefQueryResultVO resultVO = null;
StringBuffer strBuffer = new StringBuffer("前台开始全文检索模糊查找字符:").append(/*-=notranslate=-*/
queryVO.getBlurQueryVO().getBlurValue()).append("---------------\n");
long beginTimeMillis = System.currentTimeMillis();
resultVO = modelHandler.queryBlurRefdataByQueryVO(queryVO);
long endTimeMillis = System.currentTimeMillis();
strBuffer.append("前台发起的纯调用后台查询总耗时:").append(endTimeMillis - beginTimeMillis);/*-=notranslate=-*/
Logger.debug(strBuffer.toString());
queryVO.setBlurQueryVO(null);
if (resultVO == null) {
return null;
}
Vector v = resultVO.getRefData();
v = RefPubUtil.getFilterPKsVector(v, this);
v = getConvertedData1(false, v, false);
return v;
}
//过滤时走全文检索返回匹配到的记录的pks
public Vector getMatchPksByFilter(Vector tablePKs){
RefQueryVO queryVO = getRefQueryVO();
if (getBlurValue() != null) {
RefBlurQueryVO blurQueryVO = new RefBlurQueryVO();
blurQueryVO.setBlurFields(getSearchFields());
blurQueryVO.setBlurValue(getBlurValue());
blurQueryVO.setPkField(getPkFieldCode());
blurQueryVO.setRefNodeName(getRefNodeName());
blurQueryVO.setFilter(true);
blurQueryVO.setTablePKs(tablePKs);
if (getBlurQueryTableName() != null)
blurQueryVO.setTableName(getBlurQueryTableName());
else
blurQueryVO.setTableName(getTableName());
queryVO.setBlurQueryVO(blurQueryVO);
//搜索一般是按name进行,这里改变一下order by 的属性,用Name列来排序
String orderPart = getOrderPart();
if(isMutilLangNameRef()&& getLangStrSuffix()!=null){
setOrderPart(getCompositeOrderColumn(getRefNameField()));
}else{
setOrderPart(getRefNameField());
}
//把分类条件去掉
if(this instanceof AbstractRefGridTreeBigDataModel){
((AbstractRefGridTreeBigDataModel)this).setClassJoinValue(IRefConst.QUERY);
}
queryVO.setQuerySql(getRefSql());
//恢复默认搜索列
setOrderPart(orderPart);
}
// 目前还是按当前登录公司来保存栏目信息,以后有需求可以加入对主体账簿的支持
queryVO.setPk_org(getPk_corp());
RefQueryResultVO resultVO = null;
StringBuffer strBuffer = new StringBuffer("前台过滤开始全文检索模糊匹配字符:").append(/*-=notranslate=-*/
queryVO.getBlurQueryVO().getBlurValue()).append("---------------\n");
long beginTimeMillis = System.currentTimeMillis();
resultVO = modelHandler.queryBlurRefdataByQueryVO(queryVO);
long endTimeMillis = System.currentTimeMillis();
strBuffer.append("前台过滤发起的纯调用后台查询总耗时:").append(endTimeMillis - beginTimeMillis);/*-=notranslate=-*/
Logger.debug(strBuffer.toString());
queryVO.setBlurQueryVO(null);
if (resultVO == null) {
return null;
}
Vector v = resultVO.getRefData();
//v = getConvertedData1(false, v, false);
return v;
}
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) {
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);
}
}
if (v != null && isCacheEnabled()) {
/** 加入到缓存中 */
modelHandler.putToCache(getRefDataCacheKey(), getRefCacheSqlKey(), v);
}
m_vecData = v;
return m_vecData;
}
@SuppressWarnings("unchecked")
public java.util.Vector<Object> getDataForWeb(RefClientPageInfo refClientPageInfo) {
String sql = getRefSql();
Vector<Object> v = null;
if (isCacheEnabled() && refClientPageInfo.getCurrPageIndex()!= -1) {
/** 从缓存读数据 */
Map<String, Vector<Object>> keyCache = IRefCache.getCache(getRefDataCacheKey());
if(null!=keyCache){
v = keyCache.get(getRefCacheSqlKey());
}
}
if (v == null) {
// 从数据库读--也可以在此定制数据
try {
// if (isFromTempTable()) {
// v = modelHandler.queryRefDataFromTemplateTable(sql);
// } else {
// // 同时读取参照栏目数据
// v = getQueryResultVO();
// }
v = getData();
//关联列编码值转换后-存放新值 RefValueVO
v = getConvertedData(false, v, false);
} catch (Exception e) {
Debug.debug(e.getMessage(), e);
}
refClientPageInfo.setCurrPageIndex(0);
if (v == null) {
refClientPageInfo.setPageCount(0);
return null;
}
}
if (v != null && isCacheEnabled()) {
/** 加入到缓存中 */
try {
IRefCache.putToCache(getRefDataCacheKey(), getRefCacheSqlKey(), v);
} catch (Exception e) {
Debug.debug(e.getMessage(), e);
}
}
//增加PK过滤
v = RefPubUtil.getFilterPKsVector(v, this);
int currPage = refClientPageInfo.getCurrPageIndex();
int pageSize = refClientPageInfo.getPageSize();
pageSize = pageSize == -1 ? v.size() : pageSize;
refClientPageInfo.setPageCount(pageSize < 1 ? 1 : v.size()/pageSize + 1);
this.pksWeb = null;
m_vecDataWeb = new Vector<Object>();
if (v.size() > 0) {
for (int index = currPage * pageSize; (index < (currPage+1) * pageSize && index < v.size()); index++) {
Object o = v.get(index);
m_vecDataWeb.add(o);
}
this.pksWeb = getValues(getPkFieldCode(), m_vecDataWeb, true);
}
return m_vecDataWeb;
}
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 = RefPubUtil.getFilterPKsVector(vecData, this);
//
// }
// 多语言处理
// 缓存中的数据已经处理过了.
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(),Integer.valueOf(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(), Integer.valueOf(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(),
Integer.valueOf(index + i));
} else {
Logger.debug("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)
return m_strPk_corp;
return modelHandler.getPk_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() {
// todo
String sql = null;
if (isLargeDataRef() && canUseDB())
sql = getSpecialSql(getStrPatch(), getFieldCode(),
getHiddenFieldCode(), getTableName(), getWherePart(),
getGroupPart(), getOrderPart());
else
sql = getSql(getStrPatch(), getFieldCode(), getHiddenFieldCode(),
getTableName(), getWherePart(), getGroupPart(),
getOrderPart());
return sql;
}
/**
* 返回选择数据--二维数组。 创建日期:(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("This Attribute is not in the Ref ");
}
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()
&& (!RefPubUtil.isNull(strBlurValue) || isMnecodeInput())) {
v = filterNotLeafNode(v);
}
}
// 清空已选择数据
setSelectedData(v);
return v;
}
/**
* 获取匹配数据 匹配成功 数据->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 });
}
public Vector matchBlurDataForWeb(String strBlurValue) {
Vector v = null;
if (strBlurValue != null && strBlurValue.trim().length() > 0) {
v = matchDataForWeb(getBlurFields(), new String[] { strBlurValue });
// 如果是模糊查询的结果或者是编码等多条匹配,处理叶子节点是否可以选中
// 用于树形参照通过模糊匹配变成表型,过滤掉非叶子节点
if (!isNotLeafSelectedEnabled()
&& (!RefPubUtil.isNull(strBlurValue) || isMnecodeInput())) {
v = filterNotLeafNode(v);
}
}
// 清空已选择数据
setSelectedData(v);
return v;
}
/**
* 匹配主键数据--选择数据也改变了。 创建日期:(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();
modelHandler.fireDBCache();
// 刷新后重新匹配数据。
if (selectedPKs != null && selectedPKs.length > 0) {
matchPkData(selectedPKs);
fireChange();
}
}
/**
* 设置模糊值。 创建日期:(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
* @deprecated since V6 请用 setPk_org(String pk_org)
*/
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();
}
/**
* 设置参照编码字段。 创建日期:(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) {
setWherePart(newWherePart, true);
}
public void setWherePart(String newWherePart, boolean isResetSelectedData) {
if (newWherePart != null) {
newWherePart = newWherePart.trim();
int index = newWherePart.toLowerCase().indexOf("where ");
if (index == 0)
newWherePart = newWherePart.substring(index + 5, newWherePart
.length());
}
if (m_strWherePart != null && newWherePart != null
&& m_strWherePart.equalsIgnoreCase(newWherePart))// 如果值相等就不做resetSelectedData_WhenDataChanged
return;
m_strWherePart = newWherePart;
// 同时修改原始where
m_strOriginWherePart = m_strWherePart;
if (isResetSelectedData)
resetSelectedData_WhenDataChanged();
}
/**
* 当Where 条件改变后,清空m_vecData,重新匹配已经设置的pks.
*/
private void resetSelectedData_WhenDataChanged() {
String[] selectedPKs = getPkValues();
// 清数据。
// clearModelData();
clearData();
if (selectedPKs != null && selectedPKs.length > 0) {
matchPkData(selectedPKs);
}
Vector selectedData = getSelectedData();
setSelectedData(selectedData);
// 通知UIRefPane,刷新界面
fireChange();
}
/**
* java.util.Vector 过滤非末级节点
*/
public 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(getRefCodeField());
if (len >= 2) {
al.add(getRefNameField());
if (isMutilLangNameRef() && getLangStrSuffix() != null) {
al.add(getRefNameField() + getLangStrSuffix());
}
}
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;
}
protected String[] getSearchFields() {
return getBlurFields();//全文检索指定搜索的字段,这里是默认实现。对于大数据量参照,可以重写该方法。
}
/**
* 此处插入方法说明。 创建日期:(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();
}
/**
* 此处插入方法说明。 创建日期:(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;
}
/**
* 此处插入方法说明。 创建日期:(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) {
if (Arrays.equals(newM_filterPks,m_filterPks)){
return;
}
m_filterPks = newM_filterPks;
// 过滤策略
m_filterStrategy = filterStrategy;
String[] selectedPKs = getPkValues();
clearData();
RefRecentRecordsUtil.clear(this);
if (isCacheEnabled() && selectedPKs != null) {
String lruKey = getLRUKey(selectedPKs);
modelHandler.getLRUMap().put(lruKey, null);
}
if (selectedPKs != null && selectedPKs.length > 0) {
matchPkData(selectedPKs);
}
Vector selectedData = getSelectedData();
setSelectedData(selectedData);
// 通知UIRefPane,刷新界面
fireChange();
}
/**
* 此处插入方法说明。 创建日期:(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;
}
public void setRefNodeName(String refNodeName, String pk_corp) {
m_strRefNodeName = refNodeName;
m_strPk_corp = pk_corp;
}
/**
* 为了适配三种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);
}
}
/**
* 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
* @deprecated
*/
public boolean isSealedDataShow() {
return m_isDisabledDataShow;
}
public boolean isDisabledDataShow() {
return m_isDisabledDataShow;
}
/**
* 获取匹配数据 匹配成功 数据->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) {
Vector v = null;
String matchsql = null;
matchsql = getMatchSql(strPkValues);
Vector matchVec = getMatchVectorFromLRU(strPkValues);
if (matchVec != null) {
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);
}
setSelectedDataAndConvertData(v);
return getSelectedData();
}
/**
*
*/
public boolean isNonSqlMatch(String matchsql) {
return modelHandler.isNonSqlMatch(matchsql);
}
public String getMatchSql(String[] strPkValues) {
setPKMatch(true);
boolean originUseDataPower = isUseDataPower();
// boolean originAddEnableStateWherePart = isAddEnableStateWherePart();
boolean originDisabledDataShow = isDisabledDataShow();
if (!isRefEnable()) {
// 如果参照不可编辑,不启用数据权限控制;包含封存数据 ---〉V5新需求
setUseDataPower(false);
setDisabledDataShow(true,false);
}
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);
setDisabledDataShow(originDisabledDataShow,false);
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();
// }
}
/**
* 此处插入方法说明。 创建日期:(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
* @deprecated
*/
public void setSealedDataShow(boolean newSealedDataShow) {
this.m_isDisabledDataShow = newSealedDataShow;
}
public void setDisabledDataShow(boolean isDisabledDataShow) {
setDisabledDataShow(isDisabledDataShow,true);
}
private void setDisabledDataShow(boolean isDisabledDataShow,boolean fireChange) {
this.m_isDisabledDataShow = isDisabledDataShow;
if(fireChange){
fireChange();
}
}
/**
* 此处插入方法说明。 创建日期:(2004-4-14 16:01:25)
*
* @param newTempDataWherePart
* java.lang.String
*/
public void setTempDataWherePart(java.lang.String newTempDataWherePart) {
refTempDataWherePart = newTempDataWherePart;
}
/**
* @return 返回 m_orgTypeCode。
*/
public String getOrgTypeCode() {
return m_orgTypeCode;
}
/*
*
*/
public String getDataPowerSubSql(String strTableName,
String dataPowerField, String resourceID) {
String tableName = strTableName;
if (strTableName != null) {
tableName = strTableName.trim();
}
String powerSql = modelHandler.getDataPowerSubSql(tableName,
dataPowerField, this, resourceID);
return powerSql;
}
protected String getDataPowerSqlKey(String strTableName,
String dataPowerField) {
// String pk_org = null;
String tableName = strTableName;
if (strTableName != null) {
tableName = strTableName.trim();
}
String dataPowerKey = tableName + "_" + dataPowerField
+ getDataPowerOperation_code() + getPk_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
*/
protected 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 obj = record
.get(getFieldIndex(resIDFieldNames[k]));
if (obj == null) {
break;
}
resid += obj.toString();
}
}
Object oStr = record.get(getFieldIndex(refVO_mlang
.getFieldName()));
String dirName = refVO_mlang.getDirName();
if (refVO_mlang.getDirFieldName() != null) {
Object oDirFieldName = record
.get(getFieldIndex(refVO_mlang
.getDirFieldName()));
if (oDirFieldName != null) {
dirName = oDirFieldName.toString();
}
}
String value = (oStr == null ? null : oStr.toString());
// 根据资源ID取翻译后的数据
String str_multiLang = NCLangRes4VoTransl
.getNCLangRes()
.getString(dirName, value, resid);
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 convertedData = null;
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 (IRefConst.LARGE_NODE_NAME.indexOf(m_strRefNodeName) > 0
// && isChangeTableSeq()) {
// return true;
// }
if (IRefConst.LARGE_NODE_NAME.indexOf(m_strRefNodeName) >= 0) {
return true;
}
return false;
}
/**
* 改变主表
*
* @param table
* @return
*/
public String changeBaseTable(String table) {
//v6.5 大数据量参照从后台取数据,不需要再改变表名了。
return 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 getSpecialSql(String strPatch, String[] strFieldCode,
String[] hiddenFields, String strTableName, String strWherePart,
String group, String order) {
if (strTableName == null || strTableName.trim().length() == 0)
return null;
strTableName = changeBaseTable(strTableName);
String basSQL = buildBaseSql(strPatch, strFieldCode, hiddenFields,
strTableName, strWherePart);
StringBuffer buffer = new StringBuffer(basSQL);
if (getQuerySql() != null) {
addQueryCondition(buffer);
}
// 把or改成union
addSpecialBlurCriteria(buffer, basSQL);
if (group != null) {
buffer.append(" group by ").append(filterColumn(group));
}
// 加入ORDER子句
if (order != null && order.trim().length() != 0) {
buffer.append("order by ").append(filterColumn(order));
}
return buffer.toString();
}
private void addSpecialBlurCriteria(StringBuffer buffer, String basSQL) {
if (getBlurValue() != null && isIncludeBlurPart()) {
if (getBlurValue().indexOf('*') != -1
|| getBlurValue().indexOf('%') != -1
|| getBlurValue().indexOf('?') != -1) {
String[] blurfields = getBlurFields();
buffer.append(" and (");
buffer.append("( ").append(blurfields[0]).append(" like '")
.append(
getBlurValue().replace('*', '%').replace('?',
'_')
+ "' )");
for (int j = 1; j < blurfields.length; j++) {
buffer.append(" or ( ").append(blurfields[j]).append(
" like '").append(
getBlurValue().replace('*', '%').replace('?', '_')
+ "' )");
}
buffer.append(")");
} else {
if (isMnecodeInput() && getMnecodes() != null) {
buffer.append(" and ( ").append(getRefCodeField()).append(
" = '").append(getBlurValue()).append("' ");
for (int i = 0; i < getMnecodes().length; i++) {
buffer.append(" union ");
buffer.append(basSQL);
buffer.append(" and ").append(getMnecodes()[i]).append(
"='").append(getBlurValue()).append("' ");
}
}
}
}
}
/**
* 得到匹配语句
*
* @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);
addDisabledDataWherePart(whereClause);
addEnvWherePart(whereClause);
sql.append(" ").append(whereClause.toString());
return sql.toString();
}
public String buildBaseSql_common(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);
addDisabledDataWherePart(whereClause);
addEnvWherePart(whereClause);
sql.append(" ").append(whereClause.toString());
return sql.toString();
}
protected void addDataPowerCondition(String tableName,
StringBuffer whereClause) {
if (isUseDataPower()) {
String powerSql = getDataPowerSubSql(tableName,
getDataPowerColumn(), getResourceID());
if (powerSql != null) {
whereClause.append(" and (").append(powerSql).append(")");
}
}
}
private void appendAddWherePartCondition(StringBuffer whereClause) {
if (getAddWherePart() == null) {
return;
}
if (isPKMatch() && !isMatchPkWithWherePart()) {
return;
}
whereClause.append(" ").append(getAddWherePart());
}
/**
* 添加列条件
*
* @param iSelectFieldCount
* @param strSql
* @param strFieldCode
* @param hiddenFields
*/
public void addQueryColumn(int iSelectFieldCount, StringBuffer strSql,
String[] strFieldCode, String[] hiddenFields) {
int nameFieldIndex = getFieldIndex(getRefNameField());
for (int i = 0; i < iSelectFieldCount; i++) {
if (isMutilLangNameRef() && i == nameFieldIndex && !strFieldCode[nameFieldIndex].equalsIgnoreCase("null")
&& strFieldCode[nameFieldIndex].equalsIgnoreCase(getRefNameField())) {
strSql.append(getLangNameColume(getRefNameField()));
}else {
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
*/
private void addDisabledDataWherePart(StringBuffer whereClause) {
if (isAddEnableStateWherePart()) {
String wherePart = getDisableDataWherePart(isDisabledDataShow());
if (wherePart != null) {
whereClause.append(" and (").append(wherePart).append(") ");
}
}
}
/**
* 是否显示停用的数据
*
* @param isEnable
* @return
*/
protected String getDisableDataWherePart(boolean isDisableDataShow) {
if (isDisableDataShow) {
return "(enablestate = 1 or enablestate = 2 or enablestate = 3)";
} else {
return "enablestate = 2";
}
}
/**
* @deprecated
*/
public String getDisabledDataWherePart() {
return disabledDataWherePart;
}
/**
* 设置停用条件
*
* @deprecated
*/
public void setDisabledDataWherePart(String disabledDataWherePart) {
this.disabledDataWherePart = disabledDataWherePart;
}
/**
* 过滤表名
*
* @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();
}
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 null;
}
/**
* @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_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()
&& values != null) {
clearData();
modelHandler.fireDBCache();
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;
}
public Vector matchDataForWeb(String[] fields, String[] values) {
Vector vMatchData = getMatchedRecordsForWeb(fields, values);
// 使用缓存,并且匹配不到数据,刷新数据再执行一次
if (isCacheEnabled() && vMatchData == null && isRefreshMatch()
&& values != null) {
clearData();
modelHandler.fireDBCache();
vMatchData = getMatchedRecordsForWeb(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 14:43:00)
*
* @param fieldNames
* java.lang.String[]
* @param values
* java.lang.String
*/
protected Vector getMatchedRecordsForWeb(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();
//关联列编码值转换后-存放新值 RefValueVO
data = getConvertedData(false, data, false);
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[] tempValues = null;;
if (values != null) {
tempValues = values.clone();
for (int i = 0; i < tempValues.length; i++) {
String tempStr = tempValues[i];
tempValues[i] = tempStr.replaceAll("'", "''");
}
}
return modelHandler.getWherePartByFieldsAndValues(fields, tempValues);
}
/**
* @return Returns the m_addWherePart.
*/
public String getAddWherePart() {
return m_addWherePart;
}
/**
* 设有公式的参照,按公式取值。 创建日期:(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++) {
// 列显示转化配置VO
RefColumnDispConvertVO convertVO = (RefColumnDispConvertVO) dispConverter[i][0];
if (convertVO == null) {
continue;
}
// 实现类名称
String className = dispConverter[i][1].toString();
// 给列显示转化配置VO设置数据主键值
// 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();
// 目前还是按当前登录公司来保存栏目信息,以后有需求可以加入对主体账簿的支持
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;
}
/**
* 参照标题 创建日期:(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) {
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)
return m_pk_user;
return modelHandler.getPk_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_intFieldType。
*/
public int[] getIntFieldType() {
return m_intFieldType;
}
/**
* @param fieldType
* 要设置的 m_intFieldType。
*/
public void setIntFieldType(int[] fieldType) {
m_intFieldType = fieldType;
}
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 String getResourceID() {
return resourceID;
}
/**
* @param resourceID
* 要设置的 resourceID。
*/
public void setResourceID(String 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。
*/
protected String getEnvWherePart() {
return envWherePart;
}
/**
* 设置条件时,要利用参照的环境变量的方法去拼条件,否则无法根据环境变量的变化而变化。 例如:
*
* @param envWherePart
* 要设置的 envWherePart。
*/
public void setEnvWherePart(String envWherePart) {
this.envWherePart = envWherePart;
}
/**
*
*/
private void addEnvWherePart(StringBuffer whereClause) {
if (!isAddEnvWherePart()) {
return;
}
// setpk ,不包含此条件
if (isPKMatch() && !isMatchPkWithWherePart()) {
return;
}
String wherePart = getEnvWherePart();
if (wherePart != null && wherePart.trim().length() > 0) {
whereClause.append(" and (").append(wherePart).append(") ");
}
}
/**
* @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;
}
/**
* @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, Integer.valueOf(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 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 fieldCodeLen = getFieldCode().length;
for (int i = 0; i < showFields.length; i++) {
// 容错
if (getShownColumns()[i] < fieldCodeLen) {
showFields[i] = getFieldCode()[getShownColumns()[i]];
}
}
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;
}
public String getPk_org() {
// return pk_org == null ? IOrgConst.GLOBEORG : pk_org;
return pk_org == null ? InvocationInfoProxy.getInstance().getGroupId()
: pk_org;
}
public void setPk_org(String pk_org) {
if (getPk_org() != null && pk_org != null && getPk_org().equalsIgnoreCase(pk_org)) {
return;
}
this.pk_org = pk_org;
// 系统默认参照
// 重置WherePart,也可能有其他信息也要改变,
// resetWherePart();
reset();
setRefNodeName(getRefNodeName());
resetSelectedData_WhenDataChanged();
}
public String getPowerOperator() {
return powerOperator;
}
public void setPowerOperator(String powerOperator) {
this.powerOperator = powerOperator;
}
public String getPowerResourceID() {
return powerResourceID;
}
public void setPowerResourceID(String powerResourceID) {
this.powerResourceID = powerResourceID;
}
public String[] getFilterRefNodeNames() {
return filterRefNodeNames;
}
public void setFilterRefNodeName(String[] filterRefNodeNames) {
this.filterRefNodeNames = filterRefNodeNames;
}
/**
* 过滤参照值变化事件,子类要覆盖该方法。
*
* @param event
*/
public void filterValueChanged(ValueChangedEvent changedValue) {
}
public String getPk_group() {
if (pk_group != null)
return pk_group;
return modelHandler.getPk_group();
}
public void setPk_group(String pk_group) {
this.pk_group = pk_group;
}
/**
* 请子类覆盖此方法以完成参照初始化工作 当环境变量改变后,需要重新初始化,已获得正确的环境变量条件
* 替代以前默认的初始化方法setRefNodeName();
*
* since V60
*/
public void reset() {
}
protected String getLangStrSuffix() {
String suffix = null;
int langSeq = MultiLangContext.getInstance().getCurrentLangSeq()
.intValue();
if (langSeq != 1) {
suffix = String.valueOf(langSeq);
}
return suffix;
}
public String getLangNameColume(String nameField) {
if (getLangStrSuffix() == null) {
return nameField;
}
String currLangName = nameField + getLangStrSuffix();
StringBuffer sb = new StringBuffer();
sb.append(" case when isnull(").append(currLangName).append(
",'~')='~' then ").append(nameField).append(" else ").append(
currLangName).append(" end as "+getCompositeOrderColumn(nameField));
return sb.toString();
}
public String getLangNameOrderColume(String nameField) {
return getCompositeOrderColumn(nameField) ;
}
protected String getCompositeOrderColumn(String nameField){
String strName = nameField;
if (nameField.indexOf(".")>0){
strName= nameField.replaceAll("\\.","");
}
String name = strName + RefQueryVO.multiname+" ";
if (name.length()>30){
name = name.substring(name.length()-30, name.length());
}
return name;
}
// 增加过滤参照的过滤条件
// since v60
public void addFilterRefWherePart(String refNodeName, String wherePart) {
if (getFilterRefModel(refNodeName) != null) {
getFilterRefModel(refNodeName).addWherePart(wherePart);
}
}
public boolean isHistoryVersionDataShow() {
return isHistoryVersionDataShow;
}
public void setHistoryVersionDataShow(boolean isHistoryVersionDataShow) {
this.isHistoryVersionDataShow = isHistoryVersionDataShow;
}
protected RefQueryVO getRefQueryVO() {
boolean isQueryRefColumn = !modelHandler
.isReftableVOCached(getPk_corp());
queryVO.setDataSourceName(getDataSource());
queryVO.setRefNodeName(getRefNodeName());
// //搜索一般是按name进行,这里改变一下order by 的属性,用Name列来排序
// String orderPart = getOrderPart();
// setOrderPart(getLangNameColume(getRefNameField()));
queryVO.setQuerySql(getRefSql());
//恢复默认搜索列
// setOrderPart(orderPart);
queryVO.setObj(getPara());
queryVO.setQueryRefColumn(isQueryRefColumn);
return queryVO;
}
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 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);
}
}
protected String getRefCacheSqlKey() {
String sql = getRefSql();
return sql == null ? getClass().getName() : sql;
}
public IRefMaintenanceHandler getRefMaintenanceHandler() {
return refMaintenanceHandler;
}
public void setRefMaintenanceHandler(
IRefMaintenanceHandler refMaintenanceHandler) {
this.refMaintenanceHandler = refMaintenanceHandler;
}
public boolean isAddEnableStateWherePart() {
return isAddEnableStateWherePart;
}
public void setAddEnableStateWherePart(boolean isAddEnableStateWherePart) {
this.isAddEnableStateWherePart = isAddEnableStateWherePart;
}
public boolean isAddEnvWherePart() {
return isAddEnvWherePart;
}
public void setAddEnvWherePart(boolean isAddEnvWherePart) {
this.isAddEnvWherePart = isAddEnvWherePart;
}
public String getDataPowerColumn() {
if (dataPowerColumn == null) {
return getPkFieldCode();
}
return dataPowerColumn;
}
public void setDataPowerColumn(String dataPowerColumn) {
this.dataPowerColumn = dataPowerColumn;
}
public boolean isHistoryVersionRef() {
return isHistoryVersionRef;
}
public void setHistoryVersionRef(boolean isHistoryVersionRef) {
this.isHistoryVersionRef = isHistoryVersionRef;
}
public String getVersionDataLabelName() {
return versionDataLabelName;
}
public void setVersionDataLabelName(String versionDataLabelName) {
this.versionDataLabelName = versionDataLabelName;
}
// for query templet
public String getPKFieldRefSql() {
// todo
return getPKFieldRefSql("", new String[] { getPkFieldCode() }, null,
getTableName(), getWherePart(), null, null);
}
// for query templet
private String getPKFieldRefSql(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);
}
return sqlBuffer.toString();
}
public void setBlurQueryTableName(String m_blurQueryTableName) {
this.m_blurQueryTableName = m_blurQueryTableName;
}
public String getBlurQueryTableName() {
return m_blurQueryTableName;
}
public void setBlur(boolean isBlur) {
this.isBlur = isBlur;
}
public boolean isBlur() {
return isBlur;
}
public void setAllMatching(boolean isAllMatching) {
this.isAllMatching = isAllMatching;
}
public boolean isAllMatching() {
return isAllMatching;
}
public void setQueryFromServer(boolean queryFromServer) {
this.m_queryFromServer = queryFromServer;
}
public boolean isQueryFromServer() {
return m_queryFromServer;
}
public void setFilterByLucene(boolean isFilterByLucene) {
this.isFilterByLucene = isFilterByLucene;
}
public boolean isFilterByLucene() {
return isFilterByLucene;
}
public void setSupportPY(boolean isSupportPY) {
this.isSupportPY = isSupportPY;
}
public boolean isSupportPY() {
return isSupportPY;
}
public String getPksWeb() {
return StringUtils.join(pksWeb, ",");
}
}
获取参照的sql 在基类 如 “nc.ui.bd.ref.AbstractRefModel ” 的方法 “getRefSql()” 获取。
构造基本 SQL,在“nc.ui.bd.ref.AbstractRefModel”类的方法“buildBaseSql()”获取。