RecordCmp0.java

package com.csc.library.session;

import java.io.File;
import java.lang.reflect.Method;
import java.rmi.RemoteException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Vector;

import com.csc.entity.DataBMPBean;
import com.csc.entity.DataBMPKey;
import com.csc.library.database.ChildManager;
import com.csc.library.database.DataSet;
import com.csc.library.database.DeleteRecord;
import com.csc.library.database.FieldManager;
import com.csc.library.database.MyHashMap;
import com.csc.library.database.MyRecord;
import com.csc.library.database.PropertyRec;
import com.csc.library.database.Relation;
import com.csc.library.database.StaticProperties;
import com.csc.library.database.SystemCode;
import com.csc.library.service.GenProcessQuque;
import com.csc.library.utilities.Base64Decoder;
import com.csc.library.utilities.Base64Encoder;
import com.csc.library.utilities.CscCalendar;
import com.csc.library.utilities.MyLog;
import com.csc.library.utilities.RelationProperties;
import com.csc.library.utilities.UProfile;
import com.csc.library.download.FileDownloadUtils2; //require project CscFileUtils

public class RecordCmp0 extends MyRecord implements DbRecord, Cloneable {
	/**
	 * 
	 * Save Status
	 * ---------------------------------------------------------------------- 
	 *			 1 = insert 
	 * 			-1 = can't insert 
	 * 			 2 = save 
	 * 			-2 = can't update 
	 * 			 3 = normal 
	 * 			 4 = delete
	 * 			-4 = can't delete 
	 * 			 5 = search found data 
	 * 			-5 = search not found data 
	 * 			-99 =duplicate data 
	 * 			-88,-3[multientry] = key is null 
	 * 			-31 = (FK Integrity)Can't delete!! 
	 * 			-21 = can't change password, because old password invalid
	 * ----------------------------------------------------------------------
	 */
	// private String fieldList1;
	protected boolean isDup = false;

	protected Object[] obk;

//	protected HashMap oldData = new HashMap();

	private CscCalendar now = new CscCalendar();

	private boolean confirm = false;

	private String messageError = "";

	private String messageWarning = "";

	private boolean encrypt = true;

	private boolean referOn = false;

	private String fieldName, oValue, newValue, keyGroup;

	private HashMap vUpdateData = new HashMap();

	protected int saveStatus = 3;

	private String fieldNotSave = "";

	private String keyLink = "";

	protected boolean wfOn = true;

	private boolean saveState = false;

	private DbRecord dbEventLog = null;
	
	private boolean transfer= true;
	
	private boolean wfTransfer= false;

	private String wfRefDoc= "";
	
	private boolean alterWfTransfer=false;

	// private HashMap referTable = new HashMap();
	public RecordCmp0() {
		super("", "");
	}

	private String[][] sysCode = { { "", "" } };

	/**
	 * 
	 * @param a =
	 *                  Name of table in DBMS
	 * @param b =
	 *                  Description of DBMS
	 */
	public RecordCmp0(String a, String b) {
		super(a, b);
	}

	/**
	 * 
	 * @param field =
	 *                  Name of field in DBMS
	 * @param data =
	 *                  Value of field in DBMS
	 */
	public boolean set(String field, String data) {
		return super.set(field, data);
	}

	public boolean set(String tableName, String field, String data) {
		try {
			if (tableName.equalsIgnoreCase(this.getTableName())) {
				return this.set(field, data);
			} else {
				DbRecord rec = (DbRecord) this.getChild(tableName);
				return rec.set(field, data);
			}
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
			return false;
		}
	}

	public void setDatabaseName(String databaseName) {
		this.databaseName = databaseName;
	}

	public void setUserId(String uid) {
		this.uid = uid;
	}

	protected void addKey(boolean search) {

		try {
			this.pK.setKey(this);
		} catch (Exception ex) {
			MyLog.error(this, this.getUProfile(), ex);
		}
	}

	public int search(String key) {
		DbInquiry di = new InitialInquiry(this.userPro).getDbInquiry();
		FieldManager fm = this.getField(key);
		Vector v1 = this.getAllKey();
		String keyList = "";
		boolean first = true;
		for (int i = 0; i < v1.size(); i++) {
			if (!first) {
				keyList += "," + (String) v1.elementAt(i);
			} else
				keyList += (String) v1.elementAt(i);
			first = false;
		}
		try {
			di.initMyTable(this.getTableName(), "", "");
			String fType = fm.getType();
			if (fType.equalsIgnoreCase("Integer")
					|| fType.equalsIgnoreCase("Double")
					|| fType.equalsIgnoreCase("BigDecimal"))
				di.setFilter(key + "=" + fm.getValue() + "");
			else
				di.setFilter(key + "='" + fm.getValue() + "'");
			di.setColumn(keyList);
			di.refresh();
			di.next();
			Vector v = di.getCurrentDbRecord().getAllKey();
			for (int i = 0; i < v.size(); i++) {
				this.set((String) v.elementAt(i), di.getString((String) v.elementAt(i)));
			}
			di.closeConnection();
			return this.search();
		} catch (RemoteException e) {
			try {
				MyLog.error(this, this.getUProfile(), e);
				di.closeConnection();
			} catch (Exception ex) {
				MyLog.error(this, this.getUProfile(), ex);
			}
			return 0;
		}
	}

	public int search() {
		this.setCompany();
		String data = "";
		try {
			this.referLangOff();
			this.pRemote.setDbRecord(this);
			this.foundData = pRemote.findByPrimaryKey();
			this.isDup = foundData;
			if (foundData) {
				this.saveStatus = 5;
				this.refreshChild();
				if (this.referLang) {
					this.referLangOn();
				} else {
					this.referLangOff();
				}
			} else {
				this.clearChild();
				this.clearDataExceptKeyField();
				this.saveStatus = -5;
				return 0;
			}
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), StaticProperties.messagePools
					.getMessage("MSG0009", this.getUProfile().get("lang")));
			this.saveStatus = -5;
			return 0;
		}
		return 1;
	}

	
	/**
	 * 
	 * @param field =
	 *                  Name of field in table
	 * @return data in field
	 */
	public String getString(String field) {
		String data = "";
		try {
			data = super.getString(field);
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), StaticProperties.messagePools
					.getMessage("MSG0005", this.getUProfile().get("lang"))
					+ this.getActualName() + "." + field);
		}
		return data.trim();
	}

	public String getRunNo() {
		if(this.isDup)
			return this.getOriginalValue("runno");
		else
			return this.getString("runno");
	}

	private String getKeyFilter() {
		String filter = ""; 
		Vector v = this.getAllKey();
		FieldManager fm;
		String fieldName, value, fType, temp;
		boolean first = true;
		for (int i = 0; i < v.size(); i++) {
			temp = "";
			fieldName = (String) v.elementAt(i);
			fm = this.getField(fieldName);
			value = fm.getValue();
			fType = fm.getType();
			if (fType.equalsIgnoreCase("Integer")
					|| fType.equalsIgnoreCase("Double")
					|| fType.equalsIgnoreCase("BigDecimal")) {
				temp = fieldName + "=" + value;
			} else if (fType.equalsIgnoreCase("Date")) {
				CscCalendar cs = new CscCalendar(value);
				temp = fieldName + "='" + cs.getYYYYMMDD() + "'";
			} else
				temp = fieldName + "='" + value + "'";
			if (!first) {
				temp = " AND " + temp;
			}
			filter += temp;
			first = false;
		}
		return filter;
	}

	/**
	 * <p>
	 * Save data to EntityBean from jsp entry.
	 * </p>
	 */
//	public synchronized int insert() {
	public int insert() {
		int returnValue = 0;
		// savestatus not clear in memory
		this.saveStatus = 2;
		if (this.checkReferenceKey()) {
			try {
				if (this.keyOK()) {
					StaticProperties.myConnection.beginTransaction(
							this.userPro, this);
					int save = 0;
					this.setAutonumField();
					this.setDataToHisField();
//					this.searchForSave();
					this.isDuplicate();
					if (!this.isDup) {
						this.saveStatus = this.createData();
						StaticProperties.myConnection.endTransaction(
								this.userPro, this);
					} else {
						this.saveStatus = -99;
					}
				} else {
					StaticProperties.myConnection.rollback(this.userPro, this);
					this.saveStatus = -88;
					MyLog.error(this, this.getUProfile(),
							StaticProperties.messagePools.getMessage("MSG0001",
									this.getUProfile().get("lang"))
									+ this.getKeyEmptyList());
				}
			} catch (Exception e) {
				try {
					MyLog.error(this, this.getUProfile(), e);
					StaticProperties.myConnection.rollback(this.userPro, this);
				} catch (SQLException e1) {
					MyLog.error(this, this.getUProfile(), e1);
				}
			}
		} else {
			this.saveStatus = -1;
			try {
				StaticProperties.myConnection.rollback(this.userPro, this);
			} catch (SQLException e1) {
				MyLog.error(this, this.getUProfile(), e1);
			}
		}
		return this.saveStatus;
	}

	private void saveChild() throws Exception {
		DbTable dt;
		DbRecord db;
		Object obj;
		Relation relation;
		int save =0;
		for (Enumeration enums = this.childTable.keys(); enums.hasMoreElements();) {
			obj = this.childTable.get((String) enums.nextElement());
			if (obj instanceof DbTable) {
				dt = (DbTable) obj;
				relation = this.getRelation(dt.getActualName());
				dt.setParentDb(this);
				dt.setRelationLink(relation.parentField, relation.childField);
				dt.setKeyGroup(this.getKeyRefer());
				dt.setParam(this.param);
				this.refreshConditionChild(dt.getTableName());
				save = dt.save();
			} else if (obj instanceof DbRecord) {
				db = (DbRecord) obj;
				this.refreshConditionChild(db.getTableName());
				if(db.isSave())
					save = db.save();
			} 
			if (save < 0) {
				this.saveStatus = save;
				return;
			} 
		}
	}

	/**
	 * <p>
	 * Set key confirm for update old record.
	 * <p>
	 * 
	 * @param confirm
	 */
	public void setConfirm(boolean confirm) {
		this.confirm = confirm;
	}

	/**
	 * @return confirm
	 */
	public boolean getConfirm() {
		return this.confirm;
	}

	/**
	 * 
	 * @return value if save ok return 1
	 */
	public int save(String keyGroup) {
		this.keyGroup = keyGroup;
		return this.save();
	}

	private void setAutonumField() {
		FieldManager fm = null;
		String fieldName = "";		
			for (int num = 0; num < AutoNumField.size(); num++) {
				fieldName = (String) AutoNumField.get(num);
				if(!fieldName.equalsIgnoreCase("RUNNO")){				
					fm = this.getField(fieldName);
					if (fm.getString().equalsIgnoreCase("0")) {				
							fm.set(fm.insAutoNumber());
				}
			}
		}
	}

//	public synchronized int save() {
	public int save() {
		MyLog.info(this, this.getUProfile(),"**********************SAVE IN RecordCMP*********************");
		this.saveState = true;
		this.saveStatus = 3;
		// this.setFieldConfigForSaveORUpdate();
		this.pRemote.setDbRecord(this);
		try {
			if (this.pRemote.checkDataBeforeSave()) {
				if (this.checkReferenceKey()) {
					try {
						this.setDataToHisField();
						if (this.keyOK()) {
							StaticProperties.myConnection.beginTransaction(this.userPro, this);
							this.referLangOff();
							this.setAutonumField();
							this.isDuplicate();
							this.saveStatus = this.createData();
							StaticProperties.myConnection.endTransaction(this.userPro, this);
							if (this.referLang) {
								this.referLangOn();
							} else {
								this.referLangOff();
							}
						} else {
							StaticProperties.myConnection.rollback(this.userPro, this);
							this.saveStatus = -88;
							MyLog.error(this, this.getUProfile(),StaticProperties.messagePools.getAllMessage("MSG0001", this.getUProfile().get("lang"))+ this.getKeyEmptyList());
						}
					} catch (Exception e) {
						this.saveState = false;
						try {
							MyLog.error(this, this.getUProfile(), e);
							StaticProperties.myConnection.rollback(this.userPro, this);
						} catch (SQLException e1) {
							MyLog.error(this, this.getUProfile(), e1);
						}
					}
				} else {
					this.saveStatus = -1;
					try {
						StaticProperties.myConnection.rollback(this.userPro,this);
					} catch (SQLException e1) {
						MyLog.error(this, this.getUProfile(), e1);
					}
				}
			} else {
				MyLog.error(this, this.getUProfile(), "�բ����ū�ӫ�͹! "+ this.getConditionAND());
			}
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
		}
		this.saveState = false;
		return this.saveStatus;
	}

	public String getKeyGroup() {
		String result = "";
		if (this.keyGroup != null && !this.keyGroup.equalsIgnoreCase(""))
			result = this.keyGroup;
		else
			result = this.getKeyRefer();
		return result;
	}

	protected String getCurentTime() {
		return new CscCalendar().getTimestamp().toString();
	}

	protected String getUser() {
		return this.userPro.getUserId();
	}

	protected String getCompanyId() {
		return this.userPro.get("companyid");
	}

	protected String getScreenName() {
		return (String) this.param.get("__screen");
	}

	protected String getFieldName() {
		return this.fieldName;
	}

	protected String getOldValue() {
		return this.oValue;
	}

	public String getOriginalValue(String fieldName) {
		try {
			return this.pRemote.getString(fieldName);
		} catch (RemoteException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return "";
	}

	
	protected String getNewValue() {
		return this.newValue;
	}

	public String getTableName() {
		return this.tableName;
	}

	protected String getKeyRefer() {
		String result = "";
		result = "runno=" + this.getRunNo();
		return result;
	}

	private int createData() throws Exception {
		this.pRemote.setDbRecord(this);		
		this.stampTimeChange();
		if (this.isDup == false) {
			MyLog.debug(this, this.getUProfile(),"New key process save record");
			if (this.preInsertTrigger()) {
				this.saveStatus = 1;
				this.setCreateBy();
				this.saveRecord();
				this.saveChild();
				this.postInsertTrigger();
			} else {
				StaticProperties.myConnection.rollback(this.userPro, this);
				this.saveStatus = -1;
			}
		} else {
			MyLog.debug(this, this.getUProfile(),
					"Key aready exist update record");
			if (this.preUpdateTrigger()) {
				this.saveStatus = 2;
				this.setEditBy();
				this.updateRecord();
				this.keepDataForUpdate();
				this.saveChild();
				this.postUpdateTrigger();
			} else {
				StaticProperties.myConnection.rollback(this.userPro, this);
				this.saveStatus = -2;
			}
		}
		return this.saveStatus;
	}

	public boolean checkReferenceKey() {
		boolean ok = true;
		String mess = "";
		Relation relation;
		try {
			if (this.getUProfile().containsKey("processID")) {
				return true;
			}
			for (Enumeration enumeration = this.childTable.keys(); enumeration
					.hasMoreElements();) {
				String chName = (String) enumeration.nextElement();
				ChildManager ch = (ChildManager) this.childTable.get(chName);
				if (!(ch instanceof DbTable)) {
					relation = this.getRelation(chName);
					if (relation.isNeedCheck(this)) {
						ch.setParent((DbRecord) this);
						this.refreshChild(chName);
						if (!ch.foundData()) {
							ok = false;
							mess += "-------------------------------------------------\n"
									+ ch.getActualName()
									+ ":"
									+ ch.getDescription()
									+ "\n"
									+ relation
											.GenFieldDescription((DbRecord) this);
						}
					}
				}
			}
		} catch (Exception e) {
			MyLog.error(this, e);
		}
		if (!ok) {
			// MyLog.error(this, "Could not save data because reference key not
			// perfect! \r\n"+mess);
			MyLog.error(this,this.getUProfile(),StaticProperties.messagePools.getAllMessage("MSG0002", this.getUProfile().get("lang"))+ mess);
		}

		return ok;
	}

	public void setTransferRecord(DbRecord dbrec){
		transfer=false;
		if (this.isReferOn()) {
			try {
					Vector referFieldList = (Vector) this.referField.get(dbrec.getTableName());
					if (referFieldList != null) {
						Iterator itField = referFieldList.iterator();
						while (itField.hasNext()) {
							String tmp = (String) itField.next();
							int i = tmp.indexOf("$");
							String pfname = tmp.substring(0, i);
							String cfname = tmp.substring(i + 1, tmp.length());
							this.set(pfname, dbrec.getString(cfname));
						}
					}
			} catch (Exception e) {
				transfer=true;
				MyLog.error(this,this.getUProfile(),e);
			}
		}
	}
	
	
	private void setDataToHisField() {
		if (this.isReferOn()&&transfer) {
			try {
				Iterator it = this.referField.keySet().iterator();
				DbRecord dr;
				while (it.hasNext()) {
					String key = (String) it.next();
					Vector referFieldList = (Vector) this.referField.get(key);
					if (referFieldList != null) {
						if (this.getChild(key) == null) {
							dr =new InitialRecord(this.userPro).getDbRecord(key);
							dr.setColumn(this.subField(referFieldList));
							dr.isSave(false); //ա save child 
							this.putChild(dr);
						} else {
								dr = (DbRecord) this.getChild(key);								
						}
						this.refreshChild(key);
						
						Iterator itField = referFieldList.iterator();
						while (itField.hasNext()) {
							String tmp = (String) itField.next();
							int i = tmp.indexOf("$");
							String pfname = tmp.substring(0, i);
							String cfname = tmp.substring(i + 1, tmp.length());
							this.set(pfname, dr.getString(cfname));
						}
					}
				}
			} catch (Exception e) {
				MyLog.error(this,this.getUProfile(),e);
			}
		}
	}

	private Vector subField(Vector vfieldList) {
		Vector data = new Vector();
		Iterator itField = vfieldList.iterator();
		while (itField.hasNext()) {
			String temp = (String) itField.next();
			data.addElement(temp
					.substring(temp.indexOf("$") + 1, temp.length()));
		}
		return data;
	}


	protected void saveRecord() throws Exception {
		try {
			MyLog.info(this, this.getUProfile(), "Save table : "+ this.getTableName() + " key :" + this.getAllKey());
			if (this.isSave && this.saveStatus>0) {
				this.initWFTransfer();
				if(this.pRemote.create()){
					this.processworkflow();
				}else{
					this.saveStatus = -1;
				}
			}
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(),StaticProperties.messagePools.getAllMessage("MSG0003", this.getUProfile().get("lang"))+ e);
			// this.saveStatus=98;
			this.saveStatus = -1;
		}
	}

	protected void updateRecord() throws SQLException {
		try {
			if (this.isSave && this.saveStatus>0) {
				this.removeFile(true);
				this.initWFTransfer();
				MyLog.debug(this, this.getUProfile(),"#################### UPDATE RECORD IN RECORD CMP ############");
				if(pRemote.update(false)){
					this.processworkflow();
				}else{
					this.saveStatus = -2;
				}
			}
		} catch (Exception e) {
			StaticProperties.myConnection.rollback(this.userPro, this);
			MyLog.error(this, this.getUProfile(), e);
			this.saveStatus = -2;
		}
	}
	
	protected void keepDataForUpdate() {
		try {
			for (int i = 0; i < this.aField.size(); i++) {
				String field = this.aField.get(i).toString();
				FieldManager fn = this.getField(field);
				fn.setOriginal(fn.getSaveString());
			}
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
		}
	}

	public boolean setColumn(Vector fieldList) {
		super.setColumn(fieldList);
		this.addKey(false);
//		this.pRemote.setDataBMPKey(this.pK);
		this.pRemote.setDbRecord(this);
		return true;
	}
	
	public int searchForSave() {
		return this.isDuplicate();
	}
	
	public int isDuplicate() {
		String data = "";
		this.setCompany();
		try {
//			this.pRemote.setDbRecord(this);
			this.isDup = pRemote.isDuplicate();
		} catch (Exception e) {
			this.isDup = false;
			return 0;
		}
		return 1;
	}

	/*
	 * ...................................................................................................................................................................................
	 * Update For Relation Level
	 * ...................................................................................................................................................................................
	 */
	private boolean deleteAllchild() {
		Hashtable re = this.getRelationInfo();
		Enumeration em = re.keys();
		Vector chNew = new Vector();
		try {
			while (em.hasMoreElements()) {
				Relation relation = (Relation) re.get(em.nextElement());
				String dLevel = relation.getDeleteLevel();
				String mdelete = relation.getModuleDelete();
				if (dLevel.equals("1")) {
					Vector cList = relation.getVFieldListParent();
					Vector pList = relation.getVFieldtListChild();
					MyLog.info(this, "Ch tableName " + relation.tableName);
					String filter = "";
					for (int i = 0; i < cList.size(); i++) {
						String chField = (String) cList.elementAt(i);
						String value = this.getString((String) pList
								.elementAt(i));
						if (filter.length() == 0)
							filter += chField + "='" + value + "'";
						else
							filter += " AND " + chField + "='" + value + "'";
					}
					UProfile uf = (UProfile) this.userPro.clone();
					if (!mdelete.trim().equals(""))
						uf.set("appname", mdelete);
					new DeleteRecord(uf, relation.tableName, filter).process();
				}
			}
			return true;
		} catch (Exception ex) {
			MyLog.error(this, this.getUProfile(), ex);
			return false;
		}
	}

	public boolean chkDependTable(String mode) {
		boolean out = true;
		String fieldList = "";
		if (this.isDepend) {
			if (mode.equals("delete")) {
				Hashtable re = this.getRelationInfo();
				Enumeration em = re.keys();
				while (em.hasMoreElements()) {
					Relation relation = (Relation) re.get(em.nextElement());
					String dpLevel = relation.getDependLevel();
					fieldList = "";
					if (dpLevel.equals("true")
							&& (!relation.getMode().equals("-1"))) {
						// query for check data
						String tableName = relation.getRTableName();
						Vector vecPField = relation.getVFieldtListChild();
						Vector vecCField = relation.getVFieldListParent();
						String filter = "";
						for (int i = 0; i < vecPField.size(); i++) {
							String pfield = (String) vecPField.get(i);
							String cfield = (String) vecCField.get(i);

							if (filter.length() > 0)
								filter += " and ";

							if (fieldList.length() > 0)
								fieldList += ",";
							fieldList += cfield;
							String ftype = "";
							try {
								ftype = this.getField(pfield).getType();
							} catch (Exception ex) {
								MyLog.error(this, this.getUProfile(),StaticProperties.messagePools.getMessage("MSG0005", this	.getUProfile().get("lang"))+ pfield);
							}
							if (ftype.equalsIgnoreCase("integer")
									|| ftype.equalsIgnoreCase("double")
									|| ftype.equalsIgnoreCase("float")
									|| ftype.equalsIgnoreCase("long"))
								filter += cfield + "=" + this.getString(pfield);
							else
								filter += cfield + "='"
										+ this.getString(pfield) + "'";
						}
						String sql = "select count(1) numrows from "
								+ tableName + " where " + filter;
						boolean found = false;
						try {
							found = this.selectDB(sql, tableName);
						} catch (Exception e) {
							found = true;
						}
						if (!found) {
							out = true;
						} else {
							MyLog.error(this, this.getUProfile(),StaticProperties.messagePools.getMessage(	"MSG0006", this.getUProfile().get("lang"))+ tableName);
							out = false;
							break;
						}
					}
				}
			}
		}
		return out;
	}

	public boolean chkDependTableAllRelation(String mode) {
		boolean out = true;
		String fieldList = "";
		if (this.isDepend) {
			if (mode.equals("delete")) {
				HashMap chRelation = StaticProperties.relationPools
						.getRelation(this.getActualName().toUpperCase());
				if (chRelation != null) {
					Iterator it = chRelation.keySet().iterator();
					RelationProperties relation;
					String childName = "";
					while (it.hasNext()) {
						childName = (String) it.next();
						if (!childName.equals("KEYLIST")) {
							relation = (RelationProperties) chRelation
									.get(childName);

							String dpLevel = relation.getDependLevel();
							fieldList = "";
							if (dpLevel.equals("true")
									&& (!relation.getMode().equals("-1"))) {
								// query for check data
								String tableName = relation.getRtablename();
								if(tableName.trim().length()==0)
									tableName=childName;
								// Vector vecPField =
								// relation.getVFieldtListChild();
								Vector vecCField = relation.getChildList();
								String filter = "";
								String arrField[];
								for (int i = 0; i < vecCField.size(); i++) {
									String cfield = (String) vecCField.get(i);
									arrField = cfield.split(",");

									if (filter.length() > 0)
										filter += " and ";

									if (fieldList.length() > 0)
										fieldList += ",";
									fieldList += arrField[1];
									String ftype = "";
									try {
										ftype = this.getField(arrField[0])
												.getType();
									} catch (Exception ex) {
										MyLog.error(this,this.getUProfile(),StaticProperties.messagePools.getMessage("MSG0005",this.getUProfile().get("lang"))+ arrField[0]+" table = "+tableName);
									}
									if (ftype.equalsIgnoreCase("integer")
											|| ftype.equalsIgnoreCase("double")
											|| ftype.equalsIgnoreCase("float")
											|| ftype.equalsIgnoreCase("long"))
										filter += arrField[1] + "="
												+ this.getString(arrField[0]);
									else
										filter += arrField[1] + "='"
												+ this.getString(arrField[0])
												+ "'";
								}
								String sql = "select count(1) numrows from "
										+ tableName + " where " + filter;
								try {
									boolean found = this.selectDB(sql,tableName);
									if (!found) {
										out = true;
									} else {
										MyLog.error(this,this.getUProfile(),StaticProperties.messagePools.getMessage("MSG0006",	this.getUProfile().get("lang"))+ tableName);
										out = false;
										break;
									}
								} catch (Exception ex) {
									MyLog.error(this, this.getUProfile(), ex);
									out = false;
									break;
								}
							}
						}
					}
				}
			}
		}
		return out;
	}

//	public synchronized int delete() {
	public int delete() {
		return delete("delete");
	}

//	public synchronized int deleteForMyTable() {
	public int deleteForMyTable() {
		return delete("save");
	}

	private int delete(String chk) {
		try {
//			this.addKey(true);
			this.pRemote.setDbRecord(this);
			if (this.keyOK()) {
				if (pRemote.findByPrimaryKey()) {
					StaticProperties.myConnection.beginTransaction(
							this.userPro, this);
					if (this.preDeleteTrigger()) {
						if (this.deleteAllchild()) {
							if (this.chkDependTableAllRelation(chk)) {
								this.saveStatus = 4;
								int i = this.realDelete();
								this.postDeleteTrigger();
								this.clearData();
								StaticProperties.myConnection.endTransaction(
										this.userPro, this);
								return i;
							} else {
								StaticProperties.myConnection.rollback(
										this.userPro, this);
								this.saveStatus = -4;
							}
						} else {
							MyLog.error(this, this.getUProfile(),StaticProperties.messagePools.getMessage("MSG0007", this.getUProfile().get("lang")));
							StaticProperties.myConnection.rollback(this.userPro, this);
							this.saveStatus = -4;
						}
					} else {
						MyLog.error(this, this.getUProfile(),StaticProperties.messagePools.getMessage(	"MSG0008", this.getUProfile().get("lang")));
						StaticProperties.myConnection.rollback(this.userPro,	this);
					}
				} else {
					MyLog.error(this, this.getUProfile(),
							StaticProperties.messagePools.getMessage("MSG0009",
									this.getUProfile().get("lang")));
					this.saveStatus = -5;
					StaticProperties.myConnection.rollback(this.userPro, this);
				}
			} else {

				MyLog.error(this, this.getUProfile(),StaticProperties.messagePools.getMessage("MSG0010",this.getUProfile().get("lang")));
				this.saveStatus = -88;
				StaticProperties.myConnection.rollback(this.userPro, this);
			}
		} catch (SQLException e1) {
			MyLog.error(this, this.getUProfile(), e1);
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
		}
		return this.saveStatus;
	}

	private int realDelete() throws Exception {
		this.setDeleteBy();
		if (this.isSave)
			this.deleteRecord();
		this.saveStatus = 4;
		return this.saveStatus;
	}

	protected void deleteRecord() throws Exception {
		this.removeFile(false);
		this.pRemote.remove();
	}

	private void clearData() {
		try {
			for (int i = 0; i < this.aField.size(); i++) {
				String field = this.aField.get(i).toString();
				super.set(field, "");
			}
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
		}
	}

	private void clearDataExceptKeyField() {
		try {
			for (int i = 0; i < this.aField.size(); i++) {
				if (!this.allKey.contains(this.aField.get(i).toString())) {
					String field = this.aField.get(i).toString();
					super.set(field, "");
				}
			}
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
		}
	}

	public void setPKObject() {
		try {
			pK = new DataBMPKey();
		} catch (Exception ex) {
			MyLog.error(this, this.getUProfile(), ex);
		}
	}

	public void setMessageError(String mess) {
		this.messageError = mess;
	}

	public void setMessageWarning(String mess) {
		this.messageWarning = mess;
	}

	public String getMessageError() {
		return this.messageError;
	}

	public String getMessageWarning() {
		return this.messageWarning;
	}

	public ChildManager getParent() {
		return (ChildManager) this.parentTable;
	}
	
	public void setParent(ChildManager ch) {
		try {
			this.parentTable= ch;
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
		}
	}

	private void saveLog(String fieldName, String oldValue, String cuValue) {
		try {
			if (this.getUProfile() != null ) {
				if (this.dbEventLog == null) {
					this.dbEventLog = new InitialRecord(this.getUProfile())
							.getDbRecord("leventlog");
					this.dbEventLog.setColumn("*");
				} else {
					this.dbEventLog.clearField();
				}
				this.dbEventLog.set("companyid", this.getString(this
						.getNameKey(String.valueOf(this.getSizeKey()))));
				this.dbEventLog.set("table_name", this.getTableName());
				this.dbEventLog.set("field_name", fieldName);
				this.dbEventLog.set("refer", this.getRunNo());
				this.dbEventLog.set("old_value", oldValue);
				this.dbEventLog.set("new_value", cuValue);
				this.dbEventLog.set("user_code", this.getUProfile().getEmployee());
				this.dbEventLog.save();
			}
		} catch (Exception ex) {
			MyLog.error(this, this.getUProfile(), ex);
		}
	}

	public void actionLog() {
	}

	protected String decryption(String encryption) {
		try {
			Base64Decoder b = new Base64Decoder(encryption);
			return b.processString();
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
			return null;
		}
	}

	public void actionLog(FieldManager fm) {
		boolean islog;
		islog = fm.isLog();
		if (islog) {
			String cuValue, oldValue, nameField;
			nameField = fm.getName();
			
			oldValue = fm.getOriginalData();
			cuValue = this.getString(nameField);
			if (fm.isModified()) {
				this.saveLog(nameField, oldValue, cuValue);
			}
		
		}
	}

	public void setEncryptOn() {
		this.encrypt = true;
	}

	public void setEncryptOff() {
		this.encrypt = false;
	}

	public String getSystemCode(String table, String field) {
		try {
			ChildManager ch = this.getChild(table);
			DbRecord dbrec = null;
			if (ch instanceof DbRecord) {
				dbrec = (DbRecord) ch;
			} else if (ch instanceof DbInquiry) {
				dbrec = ((DbInquiry) ch).getCurrentDbRecord();
			} else if (ch instanceof DbTable) {
				dbrec = ((DbTable) ch).getCurrentRecordManager();
			}
			MyLog.debug(this, this.getUProfile(), " :::   PROPERTY FIELD : "
					+ dbrec.getField(field).getProperty("validcode"));
			MyLog.debug(this, this.getUProfile(),
					" :::   getSystemCode : Child : " + ch + "  Fieldname : "
							+ field);
			String key = ch.getString(field);
			MyLog.debug(this, this.getUProfile(), "this.getFiled(" + field
					+ ").getProperty(validcode):   " + this.getField(field));
			String validCode = dbrec.getField(field).getProperty("validcode");
			MyLog.debug(this, this.getUProfile(),
					" ::::::::::::::: validcode :  " + validCode);
			String lang = this.userPro.get("lang");
			String value = "", tmpKey = "";
			this.setValidCode(validCode, lang);
			for (int point = 0; point < sysCode.length; point++) {
				tmpKey = sysCode[point][0];
				value = sysCode[point][1];
				if (tmpKey.equals(key))
					return value;
			}
			return "";
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
			return "";
		}
	}

	public String getSystemCode(String field) {
		try {
			String key = this.getString(field);
			String validCode = this.getField(field).getProperty("validcode");
			String lang = this.userPro.get("lang");
			String value = "", tmpKey = "";
			this.setValidCode(validCode, lang);
			for (int point = 0; point < sysCode.length; point++) {
				tmpKey = sysCode[point][0];
				value = sysCode[point][1];
				if (tmpKey.equals(key)) {
					return value;
				}
			}
			return "";
		} catch (Exception ex) {
			MyLog.error(this, this.getUProfile(), ex);
			return "";
		}
	}

	private void setValidCode(String validCode, String lang) {
		if ((validCode != null) && (lang != null)) {
			String[][] sysC = SystemCode.getContent(validCode);
			this.sysCode = new String[sysC.length][2];
			for (int point = 0; point < sysC.length; point++) {
				sysCode[point][0] = new String(sysC[point][0]);
				sysCode[point][1] = new String(sysC[point][1]);
				if (sysC[point][1].indexOf(",") > 0) {
					if (lang.equalsIgnoreCase("eng")) {
						sysCode[point][1] = new String(sysC[point][1]
								.substring(0, sysC[point][1].indexOf(",")));
					} else {
						sysCode[point][1] = new String(sysC[point][1]
								.substring(sysC[point][1].indexOf(",") + 1));
					}
				}
			}

		}
	}

	public int assignField(DataSet rs) {
		String tmpField="";
		this.rReferLangOff();
		int ok = 0;
		try {
			if (rs.isEmpty()) {
				ok = 0;
				this.foundData = false;
			} else {
				FieldManager fm=null;
				for (int i = 0; i < this.aField.size(); i++) {
					tmpField = this.aField.get(i).toString();
					fm=this.getField(tmpField);

					tmpField = fm.getName();
					String value = (String) rs.getString(tmpField);
					String type = fm.getType();
					if (value == null) {
						if (type.equalsIgnoreCase("integer")
								|| type.equalsIgnoreCase("double")
								|| type.equalsIgnoreCase("bigdecimal")
								|| type.equalsIgnoreCase("long")
								|| type.equalsIgnoreCase("float")){
							value = "0";
						}else{
							value = "";
						}

						if(fm.isEncrypt()){
							value=new Base64Encoder(value).processString();
						}					
						
					}
					if (value == null) {
						value = "";
					} else {
						value = this.charCode("point4", value);
					}
					if (fm != null) {
						ok = 1;
						fm.setOriginal(value);
					}
				}
				this.foundData = true;
				this.setLastUpdate();
			}
			if (this.referLang){
				this.rReferLangOn();
			}else{
				this.rReferLangOff();
			}
			return ok;
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
			if (e instanceof NullPointerException){
				if (rs != null){
					MyLog.error(this, this.getUProfile(),"RecordCmp0 assignField() - HaveError");
				}
			}
			return 0;
		}
	}

	public void editCheckOn() {
		editCheck = "true";
	}

	public void editCheckOff() {
		editCheck = "false";
	}

	public String getFieldNotSave() {
		return this.fieldNotSave;
	}

	public String getAutoNumber(String field) {
		DbInquiry di = new InitialInquiry(this.userPro).getDbInquiry();
		try {
			di.initMyTable(this.getTableName(), "", "");
			di.setColumn(field);
			di.setFilter(this.getKeyFilter());
			di.refresh();
			di.next();
			String data = di.getString(field);
			di.closeConnection();
			return data;
		} catch (Exception e) {
			try {
				MyLog.error(this, this.getUProfile(), e);
				di.closeConnection();
			} catch (Exception ex) {
				MyLog.error(this, this.getUProfile(), ex);
			}
			return "";
		}
	}

	private Hashtable getChildClone() {
		Hashtable child = new Hashtable();
		Enumeration em = this.getChildTable().keys();
		while (em.hasMoreElements()) {
			String key = (String) em.nextElement();
			Object ch = this.getChildTable().get(key);
			if (ch instanceof DbRecord) {
				DbRecord db;
				try {
					db = (DbRecord) ((DbRecord) ch).cloneRecord(true);
					child.put(key, db);
				} catch (Exception e) {
					child.put(key, ch);
				}

			} else {
				child.put(key, ch);
			}
		}
		return child;
	}

	public DbRecord cloneRecord(boolean isSave) {
		DbRecord db = null;
		try {
			if (isSave)
				db = new InitialRecord(this.userPro).getDbRecord(this.actualName);
			else
				db = new InitialRecord(this.userPro).getDbRecord(this.actualName, 'i');
			db.loadHelp(true);
			db.setColumn(this.getArrayFieldList());
			for (int i = 0; i < this.aField.size(); i++) {
				String fieldName = this.aField.get(i).toString();
				String data = this.getString(fieldName);
				db.set(fieldName, data);
			}
			db.setRelationInfo(this.getRelationInfo());
			// db.setChildTable(this.getChildTable());
			db.setChildTable(this.getChildClone());
			db.setParam(this.getParam());
		} catch (RemoteException e) {
			MyLog.error(this, this.getUProfile(), e);
		}
		return db;
	}

	/**
	 * Returns the referOn.
	 * 
	 * @return boolean
	 */
	public boolean isReferOn() {
		return referOn;
	}

	/**
	 * Sets the referOn.
	 * 
	 * @param referOn
	 *                  The referOn to set
	 */
	public void setReferOn(boolean referOn) {
		this.referOn = referOn;
	}

	protected boolean preInsertTrigger() throws Exception {
		return true;
	}

	protected boolean preUpdateTrigger() throws Exception {
		return true;
	}

	protected boolean preDeleteTrigger() throws Exception {
		return true;
	}

	protected void postInsertTrigger() throws Exception {
		// processworkflow();
	}

	protected void postUpdateTrigger() throws Exception {
		// processworkflow();
	}

	protected void postDeleteTrigger() throws Exception {
	}

	protected boolean checkChildTable() {
		return true;
	}

	private void processworkflow() throws Exception {
		if (this.wfOn && this.wfActive()) {
			// try {
			UProfile up = this.userPro;
			HashMap paramWorkflow = (HashMap) this.param.clone();
			paramWorkflow.put("uprofile", up);
			paramWorkflow.put("runno", this.getRunNo());
			paramWorkflow.put("up_tname", this.getActualName());
			paramWorkflow.put("up_fname", "wfstatus");
			String  refkey=up.getEmployee()+"$"+this.getString(this.documentno)+"$"+paramWorkflow.get("step_id");
			if (this.wfkey.length() > 0) {
				if (!this.wfkey.equalsIgnoreCase("runno"))
					paramWorkflow.put("wfkey", this.getString(this.wfkey));
				else
					paramWorkflow.put("wfkey", this.getRunNo());
			}
			if (this.documentno != null && !this.documentno.equals("")) {
				paramWorkflow.put("document_no", this.getString(this.documentno));
			}
			
			GenProcessQuque gp=new GenProcessQuque();
			if(!this.isDup){
				gp.createWorkFlowProcess(up, paramWorkflow,"creat Workflow ["+this.getString(this.documentno)+"]", "ҧ͡ ["+this.getString(this.documentno)+"]", "", "",refkey);
			}else{
				gp.createWorkFlowProcess(up, paramWorkflow,"approve Workflow ["+this.getString(this.documentno)+"]", "͹ѵ͡ ["+this.getString(this.documentno)+"]", "", "",refkey);
			}
			
		}
	}

	public void setWFOn() {
		this.wfOn = true;
	}

	public void setWFOff() {
		this.wfOn = false;
	}

	protected void preProcessWf() {
		if (!this.wfActive()) {
			if (this.getField("wf_status") != null) {
				// pae edit ���� WF_STATUS=6 ����ͧ Update Status (������
				// 6=HR Edit)
				if (!this.getString("wf_status").equals("6")) {
					this.set("wf_status", 4);
				}
			}
		}
	}

	public void postInqNext() {
	}

	public int recCount() {
		return 1;
	}

	// select db direct to dataset
	private boolean selectDB(String sql, String tableName) throws Exception {
		boolean result = false;
		DataSet ds = new DataSet(sql, this.getUProfile().getDbName(), tableName);
		try {
			ds.initConnection(this.getUProfile());
			if (ds.hasEror()) {
				MyLog.error(this, this.getUProfile(), " ------ Check DB SQL : "+ sql);
				throw new Exception(ds.msgError());
			} else{
				if(ds.next()){
//					result = !ds.getString("numrows").equals("0");
					result = !ds.getString(0).equals("0");
				}
			}
			ds.closeConnection();
		} catch (SQLException e) {
			MyLog.error(this, this.getUProfile(), sql);
			MyLog.error(this, this.getUProfile(), e);
			result = true;
		} catch (RemoteException e) {
			MyLog.error(this, this.getUProfile(), sql);
			MyLog.error(this, this.getUProfile(), e);
			result = true;
		}
		return result;
	}

	public void afterLoadConfig() {
	}

	private void stampTimeChange() {
		UProfile uf = this.getUProfile();
		String dbName = uf.getDbName();
		String companyid = uf.get("companyid");
		String key = dbName + "-" + companyid + "-" + this.tableName;
		StaticProperties.timeLoadPData.put(key.toLowerCase(), String
				.valueOf(new CscCalendar().getTime()));
	}

	public void searchOriginal() {
		this.setCompany();
		try {
			this.referLangOff();
			this.pRemote.setDbRecord(this);
			pRemote.findByPrimaryKey();
		} catch (Exception e) {
			MyLog.info(this,	this.getUProfile(),"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!Search data not found!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
		}
	}

	public int putChild(ChildManager oChild) {
		int check = super.putChild(oChild);
		try {
			oChild.setParent((ChildManager) this);
		} catch (RemoteException e) {
			MyLog.error(this, this.getUProfile(), e);
		}
		return check;
	}

	public void setAllDeleteLevel(String delete) {
		Hashtable re = this.getRelationInfo();
		Enumeration em = re.keys();
		Vector chNew = new Vector();
		while (em.hasMoreElements()) {
			Relation relation = (Relation) re.get(em.nextElement());
			if (relation.getDeleteLevel().equalsIgnoreCase("99"))
				relation.setDeleteLevel(delete);
		}
	}

	private void setDeleteBy() {
		CscCalendar cs = new CscCalendar();
		this.set("delete_date", cs.getYYYYMMDD());
		this.set("delete_time", cs.getHHMMSS());
		this.set("delete_by", this.userPro.getUserId());
	}

	private void setCreateBy()  {
		try{
			CscCalendar cs = new CscCalendar();
			this.set("create_date", cs.getYYYYMMDD());
			this.set("create_time", cs.getHHMMSS());
			this.set("create_by", this.userPro.get("employeeid"));
			this.set("actorid", this.getUProfile().get("actorid"));
			this.getUProfile().setFieldConfig((DbRecord) this);
			this.set("edit_date", cs.getYYYYMMDD());
			this.set("edit_time", cs.getHHMMSS());
			this.set("edit_by", this.userPro.get("employeeid"));
			FieldManager fm = this.getField("runno");
			fm.set(fm.insAutoNumber());
		}catch(Exception ex){
			MyLog.error(this,this.getUProfile(),ex);
			this.saveStatus = -1;
		}
	}

	private void setEditBy() {
		CscCalendar cs = new CscCalendar();
		this.set("edit_date", cs.getYYYYMMDD());
		this.set("edit_time", cs.getHHMMSS());
		this.set("edit_by", this.userPro.get("employeeid"));
		if(this.getString("wf_ref_doc").length()==0){ /* edit by pas 20111129 ͧҡ wf_ref_doc  field system óշաúѹ֡ҡ˹ҨҤ  isduplicate ӡ setҨҡ database  ֧ӡ setҨҡ premote ᷹*/
			try {
				this.set("wf_ref_doc",pRemote.getString("wf_ref_doc"));
			} catch (Exception e) {
				MyLog.error(this,this.getUProfile(),e);
			}
		}
	}

	public int getConfirmStatus() {
		return this.saveStatus;
	}

	public boolean isSaveState() {
		return this.saveState;
	}

	public MyHashMap getMyHashMap() {
		MyHashMap h = new MyHashMap();
		for (int i = 0; i < this.aField.size(); i++) {
			String temp = this.aField.get(i).toString();
			FieldManager fm = this.getField(temp);
//			FieldManager fm = this.getField(i);			
			h.put(temp, fm.getString());
		}
		return h;
	}

	public DbRecord clone() {
		RecordCmp0 O = null;
		try {
			O = (RecordCmp0) super.clone();
			O.mf = this.mf.clone((DbRecord) this);
			O.pRemote = new DataBMPBean();
			O.pRemote.setDbRecord(O);
			// O.key = this.key.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return (DbRecord) O;
	}

	public DbRecord clone(UProfile upf) {
		RecordCmp0 O = null;
		try {
			O = (RecordCmp0) super.clone();
			if (!this.appname.equalsIgnoreCase(upf.get("appname").toString())
					|| !this.language.equalsIgnoreCase(upf.get("lang")
							.toString())) {
				O.mf.setUProfile(upf);
				O.mf = this.mf.clone((DbRecord) this, upf);
			} else {
				O.mf.setUProfile(upf);
				O.mf = this.mf.clone((DbRecord) this);
			}
			O.pRemote = new DataBMPBean();
			O.pRemote.setDbRecord(O);
			O.pRemote.clearOldWhere();
			O.referLangOff();
			// O.key = this.key.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return (DbRecord) O;
	}

	public PropertyRec clonePropertyRec(UProfile upf) {
		PropertyRec O = null;
		if (!this.appname.equalsIgnoreCase(upf.get("appname").toString())
				|| !this.language.equalsIgnoreCase(upf.get("lang").toString())) {
			O = this.mf.clone((DbRecord) this, upf);
		} else {
			O = this.mf.clone((DbRecord) this);
		}
		return O;
	}

	public void setPropertyRec(PropertyRec pr) {
		this.mf = pr;
	}
	
	public void refresh() {
		this.pRemote.setDbRecord(this);
		super.refresh();
	}

    public void configInq() {
    }  
        
    /**
	 * @author James
	 * źź record  update 
     *  ѧ
	 */
	protected int  removeFile(boolean isUpdate){
		int count=0;
		/*
		String path =	"";
		FieldManager fm = null;
//		InitialEnvironment env = new InitialEnvironment("GLOBAL");
		for (Iterator it = mf.keySet().iterator(); it.hasNext();) {
			try {
				fm = (FieldManager) mf.get(it.next());
				if(("fileupload").equalsIgnoreCase(fm.getComType())) {

//					String upload = fm.getProperty("upload");
//					String folder = fm.getProperty("folder");
					String fValue = fm.getString();
					String oValue = fm.getOldValue();
//					String alternate =  fm.getProperty("alternate");
					String uploadField = fm.getParent().getTableName() +"." +fm.getName();

//					if( upload != null && (!upload.equals("")) ) {
//						path = env.getValue( upload +"-dir");
//						if( folder !=null && (!folder.equals("")) ) {
//							path += folder;
//						}
//					}

					if( isUpdate ) {
						// in case update record
						if( !(oValue.equals("")) && !(oValue.equalsIgnoreCase(fValue)) ) {
							
							// when old_value != "" and old_value != alternate and old_value != new_value
							//FileUploadUtils.deleteFileUpload(uploadField, null, oValue);
//							File file = new File(path, oValue);
//							MyLog.info(this,this.getUProfile(), "Field '" +fm.getName() +"' was update, file has been delete :" +file.getCanonicalPath());
//							if( file.delete() ) {
//								count++;
//							}
						}
					} else {
						// in case delete recore
						if( !fValue.equals("")) {
							
							// when new_value != "" and new_value != alternate
//							File file = new File(path, fValue);
//							MyLog.info(this,this.getUProfile(), "Field '" +fm.getName() +"' was update, file has been delete :" +file.getCanonicalPath());
//							if( file.delete() ) {
//								count++;
//							}
							//FileUploadUtils.deleteFileUpload(uploadField, null, fValue);
						}
					}
				}
			} catch (Exception e){
				MyLog.error(this, this.getUProfile(), e);
			}
		}*/
		return  count;
	}
	
	/**
	 * require project CscFileUtils
	 * @author james
	 */
	public String getViewUrl(String field) {
		String url ="";
		try {
			FieldManager fm = this.getField(field);
			if(("fileupload").equalsIgnoreCase(fm.getComType())){
				
				FileDownloadUtils2 utils = new FileDownloadUtils2();
				utils.setUploadField(fm.getParent().getTableName(), fm.getName() );
				utils.setFilename( this.getString(field) );
				url = utils.getViewUrl();
			}
			return url;

		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
			return "";
		}
	}
	
	/**
	 * require project CscFileUtils
	 * @author james
	 */
	public String getDownloadUrl(String field) {
		String url ="";
		try {
			FieldManager fm = this.getField(field);
			if(("fileupload").equalsIgnoreCase(fm.getComType())){
				
				FileDownloadUtils2 utils = new FileDownloadUtils2();
				utils.setUploadField(fm.getParent().getTableName(), fm.getName() );
				utils.setFilename( this.getString(field) );
				url = utils.getDownloadUrl();
			}
			return url;
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
			return "";
		}
	}
	
	/**
	 * 
	 * require project CscFileUtils
	 * @author james
	 */
	public String getZipUrl(String field){
		String url ="";
		try {
			FieldManager fm = this.getField(field);
			if(("fileupload").equalsIgnoreCase(fm.getComType())){
				
				FileDownloadUtils2 utils = new FileDownloadUtils2();
				utils.setUploadField(fm.getParent().getTableName(), fm.getName() );
				utils.setFilename( this.getString(field) );
				url = utils.getZipdUrl();
			}
			return url;
		} catch (Exception e) {
			MyLog.error(this, this.getUProfile(), e);
			return "";
		}
	}
   
	protected void finalize() throws Throwable {
		//this.closeConnectionChild(this.getChildTable());
	}
	
	/**
	 * @author odragonfireo
	 * @param target = table ͧźͧ initial Record зӡ set ͹
	 * @param filter = ͹䢷ͧ¢ 稨зӡź table source 
	 */
	public void moveToTable(DbRecord target,String filter,boolean sort) {
		int countExp=0;
		try{
		StaticProperties.myConnection.beginTransaction(this.userPro, this);
		if(this.getArrayFieldList().size()==target.getArrayFieldList().size()){
			this.pRemote.setDbRecord(this);		
			countExp+=this.pRemote.moveToTable(target, filter,sort);
			String deleteSql="delete from "+this.getTableName();
			if(filter.trim().length()>0){
				deleteSql+=" where "+filter;
			}
			countExp+=this.pRemote.deleteTable(deleteSql);
		}else{
			MyLog.error(this,this.getUProfile(),"Field not match source["+this.getArrayFieldList().size()+"] but target["+this.getArrayFieldList().size()+"]");
			StaticProperties.myConnection.rollback(this.userPro, this);
		}
		if(countExp==0){
			StaticProperties.myConnection.endTransaction(this.userPro, this);
		}else{
			StaticProperties.myConnection.rollback(this.userPro, this);
		}
	   }catch(Exception ex){
		   try {
			StaticProperties.myConnection.rollback(this.userPro, this);
		} catch (SQLException e) {}
	   }
	}
	
	/**
	 * @author odragonfireo
	 * @param sql = query 㹡¢
	 * @param deleteSql = query ͧźtable 鹷ҧѧҡ¢º
	 */
	public void moveToTable(String sql,String deleteSql) {
		int countExp=0;
		try{
			StaticProperties.myConnection.beginTransaction(this.userPro, this);
			this.pRemote.setDbRecord(this);
			countExp+=this.pRemote.moveToTable(sql);
			countExp+=this.pRemote.deleteTable(deleteSql);
			if(countExp==0){
				StaticProperties.myConnection.endTransaction(this.userPro, this);
			}else{
				StaticProperties.myConnection.rollback(this.userPro, this);
			}
		}catch(Exception ex){
			MyLog.error(this,this.getUProfile(),"Cloud n't moveToTable not match sql["+sql+"] deleteSql["+deleteSql+"]");
			try {
				StaticProperties.myConnection.rollback(this.userPro, this);
			} catch (SQLException e) {}
		}
	}

	public String getObjectTrace() {
		StringBuilder build=new StringBuilder();
		/**
		 * 
		 * comment by pas  
		 * comment ͷͺ memory
		 * 
		 * 		
		build.append("====RecordCmp0.toString()=").append(getClass().getName() + "@" + Integer.toHexString(hashCode()));
		build.append("isDup =").append(isDup).append("\n");
		build.append("obk =").append(obk).append("\n");
		build.append("now =").append(now).append("\n");
		build.append("confirm =").append(confirm).append("\n");
		build.append("messageError =").append(messageError).append("\n");
		build.append("messageWarning =").append(messageWarning).append("\n");
		build.append("encrypt =").append(encrypt).append("\n");
		build.append("referOn =").append(referOn).append("\n");
		build.append("fieldName =").append(fieldName).append("\n");
		build.append("oValue =").append(oValue).append("\n");
		build.append("newValue =").append(newValue).append("\n");
		build.append("keyGroup =").append(keyGroup).append("\n");
		build.append("vUpdateData =").append(vUpdateData).append("\n");
		build.append("saveStatus =").append(saveStatus).append("\n");
		build.append("fieldNotSave =").append(fieldNotSave).append("\n");
		build.append("keyLink =").append(keyLink).append("\n");
		build.append("wfOn =").append(wfOn).append("\n");
		build.append("saveState =").append(saveState).append("\n");
		build.append("dbEventLog =").append(dbEventLog).append("\n");
		build.append("transfer =").append(transfer).append("\n");
		build.append("=====================");
		**/
		return build.toString();
	}

	public void setWFTransferOff() {
		this.wfTransfer=false;
	}

	public void setWFTransferOn(String wf_ref_doc) {
		this.wfTransfer=true;
		this.wfRefDoc=wf_ref_doc;		
	}
	
	public boolean getWFTransfer() {
		return this.wfTransfer;
	}
	
	public String getWFRefDoc() {
		return this.wfRefDoc;
	}
	
	protected void initWFTransfer(){
		if(this.getWFTransfer()&&this.getWFRefDoc().length()>0){	
			this.set("wf_ref_doc",this.getWFRefDoc());
		}
	}
	
	public String getWorkflowURL(){
		String url="#";
		String wf_ref_doc=this.getString("wf_ref_doc");
			if(wf_ref_doc.length()>0){
				String sql="select actor_url from actor_parameter where wf_seq_no in (select runno from workflow_data where doc_no='"+wf_ref_doc+"') order by step_seq_no desc, actor_seq_no desc,step_id";
				DataSet ds=new DataSet(sql,this.getUProfile().getDbName(),"actor_parameter");
				try {
					ds.initConnection(this.getUProfile());
					if(ds.next()){
						url=ds.getString("actor_url");
					}
				} catch (Exception e) {
					MyLog.error(this,this.getUProfile()," Can't getWorkflowURL >> "+e.getMessage());
				}finally{
					if(ds!=null){
						ds.closeConnection();
					}
				}
			}
		return url;
	}
	
}