package com.vci.client.bof;

import org.apache.commons.lang3.StringUtils;
import org.omg.CORBA.StringHolder;

import com.vci.corba.omd.atm.AttribItem;
import com.vci.corba.omd.btm.BtmItem;
import com.vci.corba.omd.data.AttributeValue;
import com.vci.corba.omd.data.BusinessObject;
import com.vci.corba.omd.data.LinkObject;
import com.vci.corba.omd.lcm.LifeCycle;
import com.vci.corba.omd.lcm.TransitionVO;
import com.vci.corba.omd.lcm.TransitionVOEvent;
import com.vci.corba.omd.vrm.VersionRule;
import com.vci.client.LogonApplication;
import com.vci.client.common.objects.UserObject;
import com.vci.client.omd.provider.BtmProvider;
import com.vci.client.omd.provider.LifeCycleProvider;
import com.vci.client.omd.provider.VersionRuleProvider;
import com.vci.client.ui.exception.ClientExceptionHandler;
import com.vci.common.annotaion.MethodTypeAnnotation;
import com.vci.common.utility.ObjectUtility;
import com.vci.corba.bofactory.BOFactoryService.BatchCreateBusinessObjectWithLinkTSResult;
import com.vci.corba.bofactory.BOFactoryService.CreateBusinessObjectWithLinkTSResult;
import com.vci.corba.common.VCIError;
import com.vci.mw.ClientContextVariable;
import com.vci.mw.LaunchModeEnum;
import com.vci.corba.common.data.VCIInvocationInfo;
import com.vci.corba.framework.data.UserInfo;

public class ClientBusinessObjectOperation implements ClientBOOperationInterface{
	
	/**
	 * 构建新的BO对象
	 * @throws VCIError 
	 */
	public ClientBusinessObject createBusinessObject(String boName) throws VCIError {
		//modify by weidy@2018-04-13
		//因为LogonApplication获取用户名是针对C/S的，现在很多B/S的环境也调用了这个方法，这样就会造成用户1的操作会记录成用户B
	    return createBusinessObject(boName,getUserName());
	}
	
	//modify by weidy@2018-04-13
			//因为LogonApplication获取用户名是针对C/S的，现在很多B/S的环境也调用了这个方法，这样就会造成用户1的操作会记录成用户B
	private String getUserName() {
		String username = "";
		if(ClientContextVariable.getClientLanuchMode().equals(LaunchModeEnum.WebApp)){
			VCIInvocationInfo vcii = ClientContextVariable.getVCIInvocationInfoForSessionContext();
			if(vcii!=null){
				username = vcii.userName;
			}
		}
		if(StringUtils.isEmpty(username)){
			username = LogonApplication.getUserEntityObject().getUserName();
		}
		return username;
	}
	
	/**
	 * 构建初始的业务对象
	 * 
	 * @param boName,业务类型名称
	 * @param userName,创建者
	 * @return 构建的初始业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject createBusinessObject(String boName, String userName) throws VCIError {
		BtmItem item = this.getTypeInfo(boName);
		ClientBusinessObject bo = new ClientBusinessObject();
		bo.setOid(ObjectUtility.getNewObjectID36());
		bo.setRevisionid(ObjectUtility.getNewObjectID36());
		bo.setNameoid(ObjectUtility.getNewObjectID36());
		bo.setBtmName(boName);
		bo.setIsLastR(true);
		bo.setIsFirstR(true);
		bo.setIsFirstV(true);
		bo.setIsLastV(true);
		
		bo.setCreator(userName);
		bo.setCreateTime(System.currentTimeMillis());
		bo.setLastModifier(userName);
		bo.setLastModifyTime(System.currentTimeMillis());
		bo.setRevisionRule(item.revRuleName);
		bo.setVersionRule(String.valueOf(item.verRuleName));
		
		RevisionValueObject revisonObj = getRevisionSeqVal(item.revLevel, item.revRuleName, item.revInput);
		VersionValueObject versionObj = getVersionValue(item.verRuleName);
		bo.setRevisionSeq(revisonObj.getRevisionSeq());
		bo.setRevisionValue(revisonObj.getRevisionVal());
		bo.setVersionSeq(versionObj.getVersionSeq());
		bo.setVersionValue(versionObj.getVersionVal());
		
		
		bo.setLctId(item.lifeCycle);
		bo.setLcStatus(getLcFirstStatus(item.lifeCycle));
		bo.setId("");
		bo.setName("");
		bo.setDescription("");
		bo.setOwner(userName);
//		bo.setCheckinBy(userName);
		bo.setCopyFromVersion("");
		initTypeAttributeValue(bo);
		return bo;
	}
	
	public ClientBusinessObject cloneBusinessObject(ClientBusinessObject fromBo) throws VCIError {
		return cloneBusinessObject(fromBo, getUserName());
	}
	
	/**
	 * 克隆业务对象
	 * 
	 * @param fromBo, 源业务对象
	 * @param userName, 创建者
	 * @return 克隆后的业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject cloneBusinessObject(ClientBusinessObject fromBo, String userName) throws VCIError {
		BtmItem item = this.getTypeInfo(fromBo.getBtmName());
/*		if (item.revLevel == 0) {
			throw ExceptionLocalHandler.getInstance().getClientString(new VCIError("P0010SOF-00016", new String[0]), "PLMBOFactory");
		}*/
		ClientBusinessObject toBo = new ClientBusinessObject();
		toBo.setOid(ObjectUtility.getNewObjectID36());
		toBo.setRevisionid(ObjectUtility.getNewObjectID36());
		toBo.setNameoid(ObjectUtility.getNewObjectID36());
		toBo.setBtmName(fromBo.getBtmName());
		toBo.setIsLastR(true);
		toBo.setIsFirstR(true);
		toBo.setIsFirstV(true);
		toBo.setIsLastV(true);
		
		toBo.setCreator(userName);
		toBo.setCreateTime(System.currentTimeMillis());
		toBo.setLastModifier(userName);
		toBo.setLastModifyTime(System.currentTimeMillis());
		toBo.setRevisionRule(item.revRuleName);
		toBo.setVersionRule(String.valueOf(item.verRuleName));
		
		RevisionValueObject revisonObj = getRevisionSeqVal(item.revLevel, item.revRuleName, item.revInput);
		VersionValueObject versionObj = getVersionValue(item.verRuleName);
		toBo.setRevisionSeq(revisonObj.getRevisionSeq());
		toBo.setRevisionValue(revisonObj.getRevisionVal());
		toBo.setVersionSeq(versionObj.getVersionSeq());
		toBo.setVersionValue(versionObj.getVersionVal());
		
		toBo.setLctId(fromBo.getLctId());
		toBo.setLcStatus(getLcFirstStatus(item.lifeCycle));
		toBo.setId(fromBo.getId());
		toBo.setName(fromBo.getName());
		toBo.setDescription(fromBo.getDescription());
		toBo.setOwner(userName);
//		toBo.setCheckinBy(userName);
		toBo.setCopyFromVersion("");
		initRevisionTypeAttributeValue(fromBo, toBo);
		return toBo;
	}
	
	/**
	 * 克隆对象
	 * 
	 * @param fromBo，被克隆对象
	 * @param btmItem，被克隆对象对应的业务类型详细信息
	 * @param attrItems，被克隆对象对应的属性集合详细信息
	 * @param isNew，true代表被克隆的对象为未升版本版次的对象，false代表被克隆对象已经升过版本或者版次
	 * @param userName，克隆用户，为空时去被克隆对象的创建者信息
	 * @return
	 * @throws VCIError
	 */
	public ClientBusinessObject cloneBusinessObject(ClientBusinessObject fromBo, BtmItem btmItem, AttribItem[] attrItems, boolean isNew, String userName) throws VCIError {
		if (isNew || userName == null || userName.trim().equals("")) {
			userName = fromBo.getCreator();
		}
		
		ClientBusinessObject toBo = new ClientBusinessObject();
		toBo.setOid(ObjectUtility.getNewObjectID36());
		toBo.setRevisionid(ObjectUtility.getNewObjectID36());
		toBo.setNameoid(ObjectUtility.getNewObjectID36());
		toBo.setBtmName(fromBo.getBtmName());
		toBo.setIsLastR(true);
		toBo.setIsFirstR(true);
		toBo.setIsFirstV(true);
		toBo.setIsLastV(true);
		
		toBo.setCreator(userName);
		toBo.setCreateTime(System.currentTimeMillis());
		toBo.setLastModifier(userName);
		toBo.setLastModifyTime(System.currentTimeMillis());
		toBo.setRevisionRule(btmItem.revRuleName);
		toBo.setVersionRule(String.valueOf(btmItem.verRuleName));
		
		if (isNew) {
			toBo.setRevisionSeq(fromBo.getRevisionSeq());
			toBo.setRevisionValue(fromBo.getRevisionValue());
			toBo.setVersionSeq(fromBo.getVersionSeq());
			toBo.setVersionValue(fromBo.getVersionValue());
		} else {
			RevisionValueObject revisonObj = getRevisionSeqVal(btmItem.revLevel, btmItem.revRuleName, btmItem.revInput);
			VersionValueObject versionObj = getVersionValue(btmItem.verRuleName);
			toBo.setRevisionSeq(revisonObj.getRevisionSeq());
			toBo.setRevisionValue(revisonObj.getRevisionVal());
			toBo.setVersionSeq(versionObj.getVersionSeq());
			toBo.setVersionValue(versionObj.getVersionVal());
		}
		
		toBo.setLctId(fromBo.getLctId());
		if (isNew) {
			toBo.setLcStatus(fromBo.getLcStatus());
		} else {
			toBo.setLcStatus(getLcFirstStatus(btmItem.lifeCycle));
		}
		toBo.setId(fromBo.getId());
		toBo.setName(fromBo.getName());
		toBo.setDescription(fromBo.getDescription());
		toBo.setOwner(userName);
//		toBo.setCheckinBy(userName);
		toBo.setCopyFromVersion("");
		initRevisionTypeAttributeValue(fromBo, toBo, attrItems, isNew);
		
		return toBo;
	}
	
	/**
	 * 获取初始的版本信息
	 * @param revLevel， 版本类型
	 * @param revRuleName，版本规则名称
	 * @return
	 * @throws VCIError 
	 */
	private RevisionValueObject getRevisionSeqVal(int revLevel, String revRuleName, boolean revInput) throws VCIError {
		RevisionValueObject obj = new RevisionValueObject();
		obj.setRevisionSeq((short)1);
		if (revInput) {
			obj.setRevisionVal("");
			return obj;
		}
		if (revLevel == 0) {
			obj.setRevisionVal("-");
		} else {
			obj.setRevisionVal(getFirstRevision(revRuleName));
		}
		
		return obj;
	}
	
	/**
	 * 获取去初始版本
	 * @param verRuleName
	 * @return
	 */
	private VersionValueObject getVersionValue(int verRuleName) {
		VersionValueObject obj = new VersionValueObject();
		obj.setVersionSeq((short)1);
		if (verRuleName == 0) {
			obj.setVersionVal("1");
		} else if (verRuleName == 1){
			obj.setVersionVal("a");
		} else if (verRuleName == 2) {
			obj.setVersionVal("0");
		}
		
		return obj;
	}
	
	/**
	 * 根据BO名称获取对象详细信息
	 * @param boName
	 * @return
	 * @throws VCIError 
	 */
	private BtmItem getTypeInfo(String boName) throws VCIError {
		BtmItem item = null;
		try {
			item = BtmProvider.getInstance().getBtmItemByName(boName);
		} catch (Exception e) {
			e.printStackTrace();
			throw new VCIError();
		} catch (Throwable e) {
			e.printStackTrace();
			throw new VCIError();
		}
		return item;
	}
	
	/**
	 * 根据生命周期名称获取第一个生命周期节点
	 * @param lifeCycleName
	 * @return
	 * @throws VCIError 
	 */
	private String getLcFirstStatus(String lifeCycleName) throws VCIError {
		try {
			LifeCycle[] lifeCycls = LifeCycleProvider.getInstance().getLifeCyles();
			
			for (LifeCycle lifeCycle : lifeCycls) {
				if (lifeCycle.name.equals(lifeCycleName)) {
					return lifeCycle.startState;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw new VCIError();
		} catch (Throwable e) {
			e.printStackTrace();
			throw new VCIError();
		}
		return "";
	}
	
	/**
	 * 获取第一个版本值
	 * @param revRuleName
	 * @return
	 * @throws VCIError 
	 */
	private String getFirstRevision(String revRuleName) throws VCIError {
		try {
			VersionRule[] vrs = VersionRuleProvider.getInstance().getVersionRules();
			for (VersionRule vr : vrs) {
				if (vr.name.equals(revRuleName)) {
					return vr.initialValue;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw new VCIError();
		} catch (Throwable e) {
			e.printStackTrace();
			throw new VCIError();
		}
		return "";
	}
	
	/**
	 * 设置BO对象的初始属性值
	 * @param bo
	 * @throws VCIError 
	 */
	private void initTypeAttributeValue(ClientBusinessObject bo) throws VCIError {
		try {
			AttribItem[] items = BtmProvider.getInstance().getBtAbItems(bo.getBtmName());
			for (AttribItem item : items) {
				bo.setAttributeValue(item.name, item.defValue);		
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw new VCIError();
		} catch (Throwable e) {
			e.printStackTrace();
			throw new VCIError();
		}
	}
	
	/**
	 * 初始升版本BO对象属性值
	 * @param fromBo
	 * @param toBo
	 * @throws VCIError 
	 */
	private void initRevisionTypeAttributeValue(ClientBusinessObject fromBo, ClientBusinessObject toBo) throws VCIError {
		BtmProvider provide = BtmProvider.getInstance();
		AttribItem[] items = provide.getBtAbItems(toBo.getBtmName());
		for (AttribItem item : items) {
			toBo.setAttributeValue(item.name, fromBo.getAttributeValue(item.name));		
		}
	}
	
//	/**
//	 * 复制对象属性
//	 * @param fromBo
//	 * @param toBo
//	 * @param items
//	 * @throws VCIError
//	 */
//	private void initRevisionTypeAttributeValue(ClientBusinessObject fromBo, ClientBusinessObject toBo, AttribItem[] items) throws VCIError {
//		for (AttribItem item : items) {
//			toBo.setAttributeValue(item.name, fromBo.getAttributeValue(item.name));		
//		}
//	}
	
	/**
	 * 复制对象属性
	 * @param fromBo
	 * @param toBo
	 * @param items
	 * @throws VCIError
	 */
	private void initRevisionTypeAttributeValue(ClientBusinessObject fromBo, ClientBusinessObject toBo, AttribItem[] items, boolean isNew) throws VCIError {
		if(isNew){
			AttributeValue[] vals = fromBo.getBusinessObject().newAttrValList;
			AttributeValue[] valsCopy = new AttributeValue[vals.length];
			for (int i = 0; i < valsCopy.length; i++) {
				valsCopy[i] = new AttributeValue(vals[i].attrName, vals[i].attrVal);
			}
			toBo.getBusinessObject().newAttrValList = valsCopy;
		} else {
			for (AttribItem item : items) {
				toBo.setAttributeValue(item.name, fromBo.getAttributeValue(item.name));		
			}
		}
	}
	
	/**
	 * 获取对象的初始生版对象
	 * 
	 * @param fromBo, 生版前对象
	 * @param revisionVal, 生版后对象的版本，为空时系统根据版本规则自动生成
	 * @param lifecycleStatus，可以生版的生命周期状态
	 * @return 生版后的业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject reviseBusinessObject(ClientBusinessObject fromBo, String revisionVal, String[] lifecycleStatus) throws VCIError {
		BtmItem item = this.getTypeInfo(fromBo.getBtmName());
		if (item.revLevel == 0) {
			throw ClientExceptionHandler.getInstance().getClientString(new VCIError("P0010SOF-00016", new String[0]), "PLMBOFactory");
		}
		if (lifecycleStatus != null && lifecycleStatus.length != 0) {
			boolean isExist = false;
			for (int i = 0; i < lifecycleStatus.length; i++) {
				if (fromBo.getLcStatus().equals(lifecycleStatus[i])) {
					isExist = true;
					break;
				}
			}
			if (!isExist) {
				throw ClientExceptionHandler.getInstance().getClientString(new VCIError("P0010SOF-00022", new String[0]), "PLMBOFactory");
			}
		}
		return reviseBusinessObject(fromBo, revisionVal);
	}
	
	public ClientBusinessObject reviseBusinessObject(ClientBusinessObject fromBo, String revisionVal) throws VCIError {
		return reviseBusinessObject(fromBo, revisionVal, getUserName());
	}
	
	/**
	 * 获取升版本初始对象
	 * @param fromBo, 生版前业务对象
	 * @param revisionVal, 生版后对象的版本，为空时系统根据版本规则自动生成
	 * @return 生版后的业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject reviseBusinessObject(ClientBusinessObject fromBo, String revisionVal, String userName) throws VCIError {
		BtmItem item = this.getTypeInfo(fromBo.getBtmName());
		if (item.revLevel == 0) {
			throw ClientExceptionHandler.getInstance().getClientString(new VCIError("P0010SOF-00016", new String[0]), "PLMBOFactory");
		}
		ClientBusinessObject toBo = new ClientBusinessObject();
		toBo.setOid(ObjectUtility.getNewObjectID36());
		toBo.setRevisionid(ObjectUtility.getNewObjectID36());
		toBo.setNameoid(fromBo.getNameoid());
		toBo.setBtmName(fromBo.getBtmName());
		toBo.setIsLastR(true);
		toBo.setIsFirstR(false);
		toBo.setIsFirstV(true);
		toBo.setIsLastV(true);
		
		toBo.setCreator(userName);
		toBo.setCreateTime(System.currentTimeMillis());
		toBo.setLastModifier(userName);
		toBo.setLastModifyTime(System.currentTimeMillis());
		toBo.setRevisionRule(item.revRuleName);
		toBo.setVersionRule(String.valueOf(item.verRuleName));
		RevisionValueObject rvObj = getNextRevision(fromBo.getBtmName(), fromBo.getNameoid(), item.revRuleName, item.revInput, revisionVal);
		toBo.setRevisionSeq(rvObj.getRevisionSeq());
		toBo.setRevisionValue(rvObj.getRevisionVal());
		
		VersionValueObject versionObj = getVersionValue(item.verRuleName);
		toBo.setVersionSeq(versionObj.getVersionSeq());
		toBo.setVersionValue(versionObj.getVersionVal());
		
		toBo.setLctId(fromBo.getLctId());
		toBo.setLcStatus(getLcFirstStatus(item.lifeCycle));
		toBo.setId(fromBo.getId());
		toBo.setName(fromBo.getName());
		toBo.setDescription(fromBo.getDescription());
		toBo.setOwner(userName);
//		toBo.setCheckinBy(userName);
		toBo.setCopyFromVersion(fromBo.getOid());
		initRevisionTypeAttributeValue(fromBo, toBo);
		return toBo;
	}
	
	/**
	 * 获取下一个版本号
	 * @param boName
	 * @param nameOid
	 * @param revRuleName
	 * @param revInput
	 * @param revisionVal
	 * @return
	 * @throws VCIError
	 */
	private RevisionValueObject getNextRevision(String btName, String nameOid, String revRuleName, boolean revInput, String revisionVal) throws VCIError {
		RevisionValueDelegate delegate = new RevisionValueDelegate();
		//String tableName = this.getTableName(boName);
		RevisionValueObject object = delegate.getNextRevisionValueObject(btName, nameOid, revRuleName, revInput, revisionVal);
		return object;
	}
	
	/**
	 * 不同过查询数据库，直接计算获取下一个版本号
	 * @param revisionVal
	 * @param revisionSeq
	 * @param revisionRule
	 * @return
	 * @throws VCIError
	 */
	public RevisionValueObject getNextRevision(String revisionVal, int revisionSeq, String revisionRule) throws VCIError {
		RevisionValueDelegate delegate = new RevisionValueDelegate();
		RevisionValueObject object = delegate.getNextRevisionValue(revisionVal, (short)revisionSeq, revisionRule);
		return object;
	}
	
	/**
	 * 根据类型获取对应的表名称
	 * @param btmName
	 * @return
	 */
//	private String getTableName(String btmName) {
//		return OmdTools.getBTTableName(btmName);
//	}
	
	public ClientBusinessObject createBusinessObjectVersion(ClientBusinessObject fromBo) throws VCIError {
		return createBusinessObjectVersion(fromBo, getUserName());
	}
	
	/**
	 * 获取新版次初始对象
	 * 
	 * @param fromBo, 生版次前的业务对象
	 * @param userName, 创建者名
	 * @return 生版次后的业务对象
	 * @throws VCIError
	 */
    public ClientBusinessObject createBusinessObjectVersion(ClientBusinessObject fromBo, String userName) throws VCIError {
		BtmItem item = this.getTypeInfo(fromBo.getBtmName());
		if (item.revLevel != 2) {
			throw ClientExceptionHandler.getInstance().getClientString(new VCIError("P0010SOF-00016", new String[0]), "PLMBOFactory");
		}
		ClientBusinessObject toBo = new ClientBusinessObject();
		toBo.setOid(ObjectUtility.getNewObjectID36());
		toBo.setRevisionid(fromBo.getRevisionid());
		toBo.setNameoid(fromBo.getNameoid());
		toBo.setBtmName(fromBo.getBtmName());
		toBo.setIsLastR(fromBo.getIsLastR());
		toBo.setIsFirstR(fromBo.getIsFirstR());
		toBo.setIsFirstV(false);
		toBo.setIsLastV(true);
		
		toBo.setCreator(userName);
		toBo.setCreateTime(System.currentTimeMillis());
		toBo.setLastModifier(userName);
		toBo.setLastModifyTime(System.currentTimeMillis());
		toBo.setRevisionRule(item.revRuleName);
		toBo.setVersionRule(String.valueOf(item.verRuleName));
		toBo.setRevisionSeq(fromBo.getRevisionSeq());
		toBo.setRevisionValue(fromBo.getRevisionValue());
		
		VersionValueObject vvObj = getNextVersion(fromBo.getBtmName(), fromBo.getNameoid(), fromBo.getRevisionid(), item.verRuleName);
		toBo.setVersionSeq(vvObj.getVersionSeq());
		toBo.setVersionValue(vvObj.getVersionVal());
		
		toBo.setLctId(fromBo.getLctId());
		toBo.setLcStatus(fromBo.getLcStatus());
		toBo.setId(fromBo.getId());
		toBo.setName(fromBo.getName());
		toBo.setDescription(fromBo.getDescription());
		toBo.setOwner(userName);
//		toBo.setCheckinBy(userName);
		toBo.setCopyFromVersion(fromBo.getOid());
		initRevisionTypeAttributeValue(fromBo, toBo);
		return toBo;
	}
	
    /**
     * 获取下一个版次
     * @param boName
     * @param nameOid
     * @param revisionOid
     * @param versionType
     * @return
     * @throws VCIError
     */
	private VersionValueObject getNextVersion(String btName, String nameOid, String revisionOid, int versionType) throws VCIError {
		VersionValueDelegate delegate = new VersionValueDelegate();
		//String tableName = this.getTableName(boName);
		VersionValueObject object = delegate.getNextVersionValue(btName, nameOid, revisionOid, versionType);
		return object;
	}
	
	/**
	 * 读取对象的详细信息
	 * @param list
	 * @return
	 * @throws VCIError
	 */
	public ClientBusinessObject readBusinessObjectById(String oid, String boName) throws VCIError{
		ClientBusinessObject cbo = new ClientBusinessObject();
		BusinessObject businessObject = BOFactoryClient.getBOFactoryService().readBusinessObject(oid, boName);
		cbo.setBusinessObject(businessObject);
		return cbo;
	}
	
	/**
	 * 获取最新版本最新版次的业务对象
	 * 
	 * @param nameoid, 业务对象的主oid
	 * @param boName, 业务对象的类型名称
	 * @return 符合要求的最新版本最新版次业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject[] getLastRevisionBusinessObject(String nameoid, String boName) throws VCIError{
		BusinessObject[] businessObjects = BOFactoryClient.getBOFactoryService().getLastRevisionBusinessObject(nameoid, boName);
		int len = businessObjects.length;
		ClientBusinessObject[] cbos = new ClientBusinessObject[len];
		for (int i = 0; i < len; i++) {
			cbos[i] = new ClientBusinessObject();
			cbos[i].setBusinessObject(businessObjects[i]);
		}
		
		return cbos;
	}
	
	/**
	 * 批量根据ID读取对象的详细信息
	 * @param oids, 需要查询的对象oid
	 * @param boName, 需要查询对象的业务类型名称
	 * @return 符合要求的业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject[] readBusinessObjectById(String[] oids, String boName) throws VCIError {
		BusinessObject[] bos = BOFactoryClient.getBOFactoryService().getBatchBusinessObject(oids, boName);
		ClientBusinessObject[] cbos = new ClientBusinessObject[bos.length];
		for (int i = 0; i < cbos.length; i++) {
			ClientBusinessObject cbo = new ClientBusinessObject();
			cbo.setBusinessObject(bos[i]);
			cbos[i] = cbo;
		}
		
		return cbos;
	}
	
	/**
	 * 根据业务类型名称获取初始化的对象
	 * @param btmName
	 * @return
	 * @throws VCIError
	 */
	public ClientBusinessObject initBusinessObject(String btmName) throws VCIError {
		BusinessObject businessObject = BOFactoryClient.getBOFactoryService().initBusinessObject(btmName);
		ClientBusinessObject cbo = new ClientBusinessObject();
		cbo.setBusinessObject(businessObject);
		
		return cbo;
	}
	
	/**
	 * 对业务对象进行升版本或者升版本操作，同时复制所有link
	 * @param cbo，生版对象
	 * @param clos，生版需要更改的链接对象
	 * @param isRev， true代表升版本，false代表生版次
	 * @param isSave，true代表保存，false代表不保存
	 * @param isFromLinkCopy, 作为from端的link复制
	 * @param isToLinkCopy，作为to端的link复制
	 * @return 生版后的业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject revisionBusinessObject(ClientBusinessObject cbo, 
			ClientLinkObject[] clos, boolean isRev, boolean isSave, boolean isFromLinkCopy, boolean isToLinkCopy) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		LinkObject[] los = new LinkObject[clos.length];
		for (int i = 0; i < clos.length; i++) {
			clos[i].dealLinkObjectNullValue();
			los[i] = clos[i].getLinkObject();
		}
		BusinessObject businessObject = BOFactoryClient.getBOFactoryService().revisionBusinessObject(
				cbo.getBusinessObject(), los, isRev, isSave, isFromLinkCopy, isToLinkCopy);
		
		ClientBusinessObject revBo = new ClientBusinessObject();
		revBo.setBusinessObject(businessObject);
		
		return revBo;
	}
	
	/**
	 * 对业务对象进行升版本或者升版本操作,同时复制指定的link
	 * @param cbo，生版对象
	 * @param linkTypes，复制的link名称
	 * @param isRev， true代表升版本，false代表生版次
	 * @param isSave，true代表保存，false代表不保存
	 * @param isFromLinkCopy, 作为from端的link复制
	 * @param isToLinkCopy，作为to端的link复制
	 * @return 生版后的业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject revisionBusinessObject(ClientBusinessObject cbo, 
			String[] linkTypes, boolean isRev, boolean isSave, boolean isFromLinkCopy, boolean isToLinkCopy) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		
		BusinessObject businessObject = BOFactoryClient.getBOFactoryService().revisionBusinessObjectWithLink(
				cbo.getBusinessObject(), linkTypes, isRev, isSave, isFromLinkCopy, isToLinkCopy);
		
		ClientBusinessObject revBo = new ClientBusinessObject();
		revBo.setBusinessObject(businessObject);
		
		return revBo;
	}
	
	/**
	 * 保存单个BO对象
	 * @param cbo, 需要保存的业务对象
	 * @return 保存返回后的业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject saveCreateBuinessObject(ClientBusinessObject cbo) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		BusinessObject businessObject = BOFactoryClient.getBOFactoryService().createBusinessObject(cbo.getBusinessObject(), false, false);
		cbo.setBusinessObject(businessObject);
		return cbo;
	}
	
	/**
	 * 批量保存BO对象
	 * @param cbos, 需要保存的业务对象数组
	 * @return 保存成功后的对象数组
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public ClientBusinessObject[] batchSaveCreateBuinessObject(ClientBusinessObject[] cbos) throws VCIError {
		int len = cbos.length;
		if (len < 1) {
			return null;
		}
		BusinessObject[] bos = new BusinessObject[len];
		for (int i = 0; i < len; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		BusinessObject[] businessObjects = BOFactoryClient.getBOFactoryService().batchCreateBusinessObject(bos, false, false);
		for (int i = 0; i < len; i++) {
			cbos[i].setBusinessObject(businessObjects[i]);
		}
		return cbos;
	}
	
	/**
	 * 保存升版本后的对象
	 * @param cbo, 生版后的业务对象
	 * @return 保存成功的业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject saveRevisionBuinessObject(ClientBusinessObject cbo) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		BusinessObject businessObject = BOFactoryClient.getBOFactoryService().createBusinessObject(cbo.getBusinessObject(), true, false);
		cbo.setBusinessObject(businessObject);
		return cbo;
	}
	
	/**
	 * 批量保存升版本后的对象
	 * @param cbos, 升版本后的业务对象
	 * @return 保存成功后的业务对象
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public ClientBusinessObject[] batchSaveRevisionBuinessObject(ClientBusinessObject[] cbos) throws VCIError {
		int len = cbos.length;
		if (len < 1) {
			return null;
		}
		BusinessObject[] bos = new BusinessObject[len];
		for (int i = 0; i < len; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		BusinessObject[] businessObjects = BOFactoryClient.getBOFactoryService().batchCreateBusinessObject(bos, true, false);
		for (int i = 0; i < len; i++) {
			cbos[i].setBusinessObject(businessObjects[i]);
		}
		return cbos;
	}
	
	/**
	 * 保存升版次后的对象
	 * @param cbo, 升版次的业务对象
	 * @return 保存成功后的业务对象
	 * @throws VCIError
	 */
	public ClientBusinessObject saveVersionBuinessObject(ClientBusinessObject cbo) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		BusinessObject businessObject = BOFactoryClient.getBOFactoryService().createBusinessObject(cbo.getBusinessObject(), false, true);
		cbo.setBusinessObject(businessObject);
		return cbo;
	}
	
	/**
	 * 批量保存升版次对象
	 * @param cbos, 升版次的业务对象属性
	 * @return 保存成功后的业务对象
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public ClientBusinessObject[] batchSaveVersionBuinessObject(ClientBusinessObject[] cbos) throws VCIError {
		int len = cbos.length;
		if (len < 1) {
			return null;
		}
		BusinessObject[] bos = new BusinessObject[len];
		for (int i = 0; i < len; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		BusinessObject[] businessObjects = BOFactoryClient.getBOFactoryService().batchCreateBusinessObject(bos, false, true);
		for (int i = 0; i < len; i++) {
			cbos[i].setBusinessObject(businessObjects[i]);
		}
		return cbos;
	}
	
	/**
	 * 保存对象以及对象关联的链接
	 * 
	 * @param cbos, 需要保存的业务对象
	 * @param clo, 需要保存的链接对象
	 * @return 保存成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean saveCreateBuinessObject(ClientBusinessObject[] cbos, ClientLinkObject clo) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		
		clo.dealLinkObjectNullValue();
		
		boolean rs = BOFactoryClient.getBOFactoryService().createBusinessObjectWithLink(bos, clo.getLinkObject());
		return rs;
	}
	
	/**
	 * 保存对象以及对象关联的链接，并更新传入对象的ts
	 * @param cbos, 需要保存的业务对象
	 * @param clo, 需要保存的链接对象
	 * @return 保存成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean saveCreateBuinessObjectTS(ClientBusinessObject[] cbos, ClientLinkObject clo) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		
		clo.dealLinkObjectNullValue();
		
		StringHolder ts = new StringHolder();
		ts.value = "";
		
		CreateBusinessObjectWithLinkTSResult res = BOFactoryClient.getBOFactoryService().createBusinessObjectWithLinkTS(bos, clo.getLinkObject());
		//boolean rs = BOFactoryClient.getBOFactoryService().createBusinessObjectWithLinkTS(bos, clo.getLinkObject(), ts);
		for (int i = 0; i < cbos.length; i++) {
			bos[i].ts = res.ts;
			cbos[i].setBusinessObject(bos[i]);
		}
		return res.returnValue;
	}
	
	/**
	 * 批量保存BO对象以及LO对象
	 * @param cbos, 需要保存的业务对象数组
	 * @param clos, 需要保存的链接对象数组
	 * @return 保存成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchSaveCreateBuinessObject(ClientBusinessObject[] cbos, ClientLinkObject[] clos) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		
		LinkObject[] los = new LinkObject[clos.length];
		for (int i = 0; i < clos.length; i++) {
			clos[i].dealLinkObjectNullValue();
			los[i] = clos[i].getLinkObject();
		}

		long start = System.currentTimeMillis();
		System.out.println(System.currentTimeMillis());
		boolean rs = BOFactoryClient.getBOFactoryService().batchCreateBusinessObjectWithLink(bos, los);
		long end = System.currentTimeMillis();
		System.out.println(System.currentTimeMillis());
		System.out.println("server duration time: " + (end - start));
		return rs;
	}
	
	/**
	 * 批量存储业务对象和链接对象，不对链接对象进行检查，不对业务对象进行日志记录
	 * @param cbos
	 * @param clos
	 * @return
	 * @throws VCIError
	 */
	public boolean batchSaveCreateBuinessObjectWithNoCheckNoLog(ClientBusinessObject[] cbos, ClientLinkObject[] clos) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		
		LinkObject[] los = new LinkObject[clos.length];
		for (int i = 0; i < clos.length; i++) {
			clos[i].dealLinkObjectNullValue();
			los[i] = clos[i].getLinkObject();
		}
		
		boolean rs = BOFactoryClient.getBOFactoryService().batchCreateBOWithLinkNoCheckNoLog(bos, los);
		return rs;
	}
	
	
	/**
	 * 批量创建业务对象、链接对象，同时支持批量删除业务对象、链接对象
	 * @param createCbos, 需要保存的业务对象数组
	 * @param createClos, 需要保存的链接对象数组
	 * @param deleteCbos, 需要删除的业务对象数组
	 * @param deleteClos, 需要删除的链接对象数组
	 * @return  执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchCreateDeleteBOLO(ClientBusinessObject[] createCbos, ClientLinkObject[] createClos, 
			ClientBusinessObject[] deleteCbos, ClientLinkObject[] deleteClos) throws VCIError {
		BusinessObject[] createBOs = new BusinessObject[createCbos.length];
		for (int i = 0; i < createCbos.length; i++) {
			createCbos[i].dealBusinessObjectNullValue();
			createBOs[i] = createCbos[i].getBusinessObject();
		}
		
		LinkObject[] createLOs = new LinkObject[createClos.length];
		for (int i = 0; i < createClos.length; i++) {
			createClos[i].dealLinkObjectNullValue();
			createLOs[i] = createClos[i].getLinkObject();
		}
		
		BusinessObject[] deleteBOs = new BusinessObject[deleteCbos.length];
		for (int i = 0; i < deleteCbos.length; i++) {
			deleteCbos[i].dealBusinessObjectNullValue();
			deleteBOs[i] = deleteCbos[i].getBusinessObject();
		}
		
		LinkObject[] deleteLOs = new LinkObject[deleteClos.length];
		for (int i = 0; i < deleteClos.length; i++) {
			deleteClos[i].dealLinkObjectNullValue();
			deleteLOs[i] = deleteClos[i].getLinkObject();
		}
		

		boolean rs = BOFactoryClient.getBOFactoryService().batchCreateDeleteBOLO(createBOs, createLOs, deleteBOs, deleteLOs);
		return rs;
	}
	
	/**
	 * 批量创建、修改、删除业务对象和链接对象
	 * @param createCbos, 需要创建的业务对象数组
	 * @param createClos, 需要删除的链接对象数组
	 * @param updateCbos, 需要更新的业务对象数组
	 * @param updateClos, 需要更新的链接对象数组
	 * @param deleteCbos, 需要删除的业务对象数组
	 * @param deleteClos, 需要删除的链接对象数组
	 * @return  执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean batchCUDBOLO(ClientBusinessObject[] createCbos, ClientLinkObject[] createClos, 
			ClientBusinessObject[] updateCbos, ClientLinkObject[] updateClos,
			ClientBusinessObject[] deleteCbos, ClientLinkObject[] deleteClos) throws VCIError {
		BusinessObject[] createBOs = new BusinessObject[createCbos.length];
		for (int i = 0; i < createCbos.length; i++) {
			createCbos[i].dealBusinessObjectNullValue();
			createBOs[i] = createCbos[i].getBusinessObject();
		}
		
		LinkObject[] createLOs = new LinkObject[createClos.length];
		for (int i = 0; i < createClos.length; i++) {
			createClos[i].dealLinkObjectNullValue();
			createLOs[i] = createClos[i].getLinkObject();
		}
		
		BusinessObject[] upateBOs = new BusinessObject[updateCbos.length];
		for (int i = 0; i < updateCbos.length; i++) {
			updateCbos[i].dealBusinessObjectNullValue();
			upateBOs[i] = updateCbos[i].getBusinessObject();
		}
		
		LinkObject[] updateLOs = new LinkObject[updateClos.length];
		for (int i = 0; i < updateClos.length; i++) {
			updateClos[i].dealLinkObjectNullValue();
			updateLOs[i] = updateClos[i].getLinkObject();
		}
		
		BusinessObject[] deleteBOs = new BusinessObject[deleteCbos.length];
		for (int i = 0; i < deleteCbos.length; i++) {
			deleteCbos[i].dealBusinessObjectNullValue();
			deleteBOs[i] = deleteCbos[i].getBusinessObject();
		}
		
		LinkObject[] deleteLOs = new LinkObject[deleteClos.length];
		for (int i = 0; i < deleteClos.length; i++) {
			deleteClos[i].dealLinkObjectNullValue();
			deleteLOs[i] = deleteClos[i].getLinkObject();
		}
		
		boolean rs = BOFactoryClient.getBOFactoryService().batchCUDBOLO(createBOs, createLOs, upateBOs, updateLOs, deleteBOs, deleteLOs);
		return rs;
	}
	
	/**
	 * 批量保存BO对象以及LO对象,并更新bo的ts
	 * @param cbos, 需要创建的业务对象数组
	 * @param clos, 需要创建的链接对象数组
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchSaveCreateBuinessObjectTS(ClientBusinessObject[] cbos, ClientLinkObject[] clos) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		
		LinkObject[] los = new LinkObject[clos.length];
		for (int i = 0; i < clos.length; i++) {
			clos[i].dealLinkObjectNullValue();
			los[i] = clos[i].getLinkObject();
		}
		//LongHolder ts = new LongHolder();
		//ts.value = "";
		long ts = System.currentTimeMillis();
		long start = System.currentTimeMillis();
		System.out.println(System.currentTimeMillis());
		BatchCreateBusinessObjectWithLinkTSResult result = BOFactoryClient.getBOFactoryService().batchCreateBusinessObjectWithLinkTS(bos, los);
		long end = System.currentTimeMillis();
		System.out.println(System.currentTimeMillis());
		System.out.println("server duration time: " + (end - start));
		for (int i = 0; i < cbos.length; i++) {
			bos[i].ts = ts;
			cbos[i].setBusinessObject(bos[i]);
		}
		return result.returnValue;
	}
	
	/**
	 * 更改BO对象的属性信息
	 * @param cbo, 需要更改的业务对象
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean updateBuinessObject(ClientBusinessObject cbo) throws VCIError {
//		if (!cbo.getCheckoutBy().equals(LogonApplication.getUserEntityObject().getUserName())) {
//			throw new VCIError("P0010SOF-00020", new String[0]);
//		}
		cbo.dealBusinessObjectNullValue();


		return BOFactoryClient.getBOFactoryService().updateBusinessObjectOut(cbo.getBusinessObject());
	}
	
	/**
	 * 批量更新BO对象属性
	 * @param cbos,需要更改的业务对象数组
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchUpdateBuinessObject(ClientBusinessObject[] cbos) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		

//		for (int i = 0; i < cbos.length; i++) {
//			cbos[i].dealBusinessObjectNullValue();
//			bos[i] = cbos[i].getBusinessObject();
//		}
		return BOFactoryClient.getBOFactoryService().batchUpdateBusinessObject(bos);
	}
	
	/**
	 * 删除当前版次业务对象
	 * @param cbo,需要删除的业务对象
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean deleteBuinessObject(ClientBusinessObject cbo) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		return BOFactoryClient.getBOFactoryService().deleteBusinessObject(cbo.getBusinessObject(), 1);
	}
	
	/**
	 * 批量删除当前版次对象
	 * @param cbos,需要删除的业务对象数组
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchDeleteBuinessObject(ClientBusinessObject[] cbos) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		return BOFactoryClient.getBOFactoryService().batchDeleteBusinessObject(bos, 1);
	}
	
	/**
	 * 删除当前版本的对象信息
	 * @param cbo, 需要删除的对象
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean deleteBuinessObjectRevision(ClientBusinessObject cbo) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		return BOFactoryClient.getBOFactoryService().deleteBusinessObject(cbo.getBusinessObject(), 2);
	}
	
	/**
	 * 批量删除当前版本对象
	 * @param cbos, 需要删除的对象数组
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchDeleteBuinessObjectRevision(ClientBusinessObject[] cbos) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		return BOFactoryClient.getBOFactoryService().batchDeleteBusinessObject(bos, 2);
	}
	
	/**
	 * 删除主对象信息
	 * @param cbo, 需要删除的业务对象
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean deleteBuinessObjectMaster(ClientBusinessObject cbo) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		return BOFactoryClient.getBOFactoryService().deleteBusinessObject(cbo.getBusinessObject(), 3);
	}
	
	/**
	 * 批量删除主对象
	 * @param cbos, 需要删除的业务对象数组
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchDeleteBuinessObjectMaster(ClientBusinessObject[] cbos) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		return BOFactoryClient.getBOFactoryService().batchDeleteBusinessObject(bos, 3);
	}
	
	/**
	 * 检入对象
	 * @param cbo, 需要检入的业务对象
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean checkinBusinessObject(ClientBusinessObject cbo) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		return BOFactoryClient.getBOFactoryService().checkInBusinessObject(cbo.getBusinessObject());
	}
	
	/**
	 * 批量检入对象
	 * @param cbos, 需要检入的业务对象数组
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchCheckinBusinessObject(ClientBusinessObject[] cbos) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		return BOFactoryClient.getBOFactoryService().batchCheckInBusinessObject(bos);
	}
	
	/**
	 * 检出对象	
	 * @param cbo, 需要检出的业务对象
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean checkoutBusinessObject(ClientBusinessObject cbo) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		return BOFactoryClient.getBOFactoryService().checkoutBusinessObject(cbo.getBusinessObject());
	}
	
	/**
	 * 批量检出对象
	 * @param cbos,需要检出的业务对象数组
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchCheckoutBusinessObject(ClientBusinessObject[] cbos) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		return BOFactoryClient.getBOFactoryService().batchCheckoutBusinessObject(bos);
	}
	
	/**
	 * 跃迁对象
	 * @param cbos,需要跃迁的业务对象
	 * @param vo, 跃迁对象的状态信息
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean transferBusinessObject(ClientBusinessObject cbo, TransitionVO vo) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		if (vo.transitionVOEvents == null) {
			vo.transitionVOEvents = new TransitionVOEvent[0];
		}
		

		return BOFactoryClient.getBOFactoryService().transferBusinessObject(cbo.getBusinessObject(), vo);
	}
	
	/**
	 * 跃迁对象，并根据发布状态更改对象是否为最新发布版本的对象
	 * @param cbo, 需要跃迁的业务对象
	 * @param vo, 跃迁的对象状态信息
	 * @param releaseStatus, 发布状态
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean transferBusinessObject(ClientBusinessObject cbo, TransitionVO vo, String releaseStatus) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		if (vo.transitionVOEvents == null) {
			vo.transitionVOEvents = new TransitionVOEvent[0];
		}
		if (releaseStatus == null) {
			releaseStatus = "";
		}
		
		return BOFactoryClient.getBOFactoryService().transferBusinessObjectAndRelease(cbo.getBusinessObject(), vo, releaseStatus);
	}
	
	/**
	 * 批量跃迁对象，并根据发布状态更改对象是否为最新发布版本的对象
	 * @param cbos, 需要跃迁的对象数组
	 * @param vos, 需要跃迁的对象状态信息数组
	 * @param releaseStatus， 发布状态数组
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean batchTransferBusinessObject(ClientBusinessObject[] cbos, TransitionVO[] vos, String[] releaseStatus) throws VCIError {
		if (cbos.length != vos.length ||  cbos.length != releaseStatus.length) {
			return false;
		}
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		for (int i = 0; i < vos.length; i++) {
			if (vos[i].transitionVOEvents == null) {
				vos[i].transitionVOEvents = new TransitionVOEvent[0];
			}
		}
		for (int i = 0; i < releaseStatus.length; i++) {
			if (releaseStatus[i] == null) {
				releaseStatus[i] = "";
			}
		}
		
		return BOFactoryClient.getBOFactoryService().batchTransferBusinessObjectAndRelease(bos, vos, releaseStatus);
	}
	
	/**
	 * 取消迁出BO对象
	 * @param cbo, 需要撤销迁出的跃迁对象
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean undoCheckOutBusinessObject(ClientBusinessObject cbo) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		return BOFactoryClient.getBOFactoryService().unCheckOutBusinessObject(cbo.getBusinessObject());
	}
	
	/**
	 * 批量撤销迁出对象
	 * @param cbos, 需要撤销迁出的跃迁对象数组
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchUndoCheckOutBusinessObject(ClientBusinessObject[] cbos) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		return BOFactoryClient.getBOFactoryService().batchUnCheckOutBusinessObject(bos);
	}
	
	/**
	 * 更改所有者
	 * @param cbos, 业务对象
	 * @param userObject, 用户信息
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	public boolean changeBusinessObjectOwner(ClientBusinessObject cbo, UserObject userObject) throws VCIError {
		cbo.dealBusinessObjectNullValue();
		UserInfo userInfo = changeUserObjectToUserInfo(userObject);
		return BOFactoryClient.getBOFactoryService().changeBusinessObjectOwner(cbo.getBusinessObject(), userInfo);
	}
	
	/**
	 * 批量更改所有者
	 * @param cbos,业务对象数组
	 * @param userObjects,用户信息数组
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchChangeBusinessObjectOwner(ClientBusinessObject[] cbos, UserObject[] userObjects) throws VCIError {
		BusinessObject[] bos = new BusinessObject[cbos.length];
		for (int i = 0; i < cbos.length; i++) {
			cbos[i].dealBusinessObjectNullValue();
			bos[i] = cbos[i].getBusinessObject();
		}
		UserInfo[] userInfos = new UserInfo[userObjects.length];
		for (int i = 0; i < userObjects.length; i++) {
			userInfos[i] = changeUserObjectToUserInfo(userObjects[i]);
		}
		
		return BOFactoryClient.getBOFactoryService().batchChangeBusinessObjectOwner(bos, userInfos);
	}
	
	/**
	 * 批量升版本
	 * @param oids, 生版对象的oid
	 * @param btmName, 生版对象对应的业务类型名称
	 * @return 执行成功返回true，保存失败返回false
	 * @throws VCIError
	 */
	@MethodTypeAnnotation(getMethodType="batch")
	public boolean batchRevisonBusinessObject(String[] oids, String btmName) throws VCIError {
		return BOFactoryClient.getBOFactoryService().batchRevisonBusinessObject(oids, btmName);
	}
	
	public UserInfo changeUserObjectToUserInfo(UserObject user) {
		UserInfo userInfo = new UserInfo();
		userInfo.id = user.getId() == null ? "" : user.getId();
		userInfo.userName = user.getUserName() == null ? "" : user.getUserName();
		userInfo.pwd = user.getPwd() == null ? "" : user.getPwd();
		userInfo.trueName = user.getTrueName() == null ? "" : user.getTrueName();
		userInfo.email = user.getEmail() == null ? "" : user.getEmail();
		userInfo.desc = user.getDesc() == null ? "" : user.getDesc();
		userInfo.userType = user.getUserType();
		userInfo.status = user.getStatus();
		userInfo.createTime = user.getCreateTime();
		userInfo.createUser = user.getCreateUser() == null ? "" : user.getCreateUser();
		userInfo.updateTime = user.getUpdateTime();
		userInfo.updateUser = user.getUpdateUser() == null ? "" : user.getUpdateUser();
		userInfo.pwdUpdateTime = user.getPwdUpdateTime();
		userInfo.grantor = user.getGrantor() == null ? "" : user.getGrantor();
		userInfo.secretGrade = user.getSecretGrade() == null ? "" : user.getSecretGrade();
		userInfo.isDeptLeader = user.getIsDeptLeader() == null ? "0" : user.getIsDeptLeader();
		return userInfo;
	}
	
	public String[] getClassficationValue(String sql, AttributeValue[] attrVals) throws VCIError {
		for (int i = 0; i < attrVals.length; i++) {
			if (attrVals[i].attrVal == null) {
				attrVals[i].attrVal = "";
			}
		}
		return BOFactoryClient.getBOFactoryService().getClssficationValue(sql, attrVals);
	}
	
	public String[][] getSqlQueryResult(String sql, AttributeValue[] attrVals) throws VCIError {
		for (int i = 0; i < attrVals.length; i++) {
			if (attrVals[i].attrVal == null) {
				attrVals[i].attrVal = "";
			}
		}
		return BOFactoryClient.getBOFactoryService().getSqlQueryResult(sql, attrVals);
	}
	
	public String[][] getCustomSqlValue(String[] sqls) throws VCIError {
		if (sqls == null || sqls.length == 0) {
			return new String[0][0];
		}
		return BOFactoryClient.getBOFactoryService().getCustomSqlValue(sqls);
	}
	
	public boolean executeUpdateSql(String sql) throws VCIError {
		if (sql == null || sql.equals("")) {
			return false;
		}
		return BOFactoryClient.getBOFactoryService().executeUpdateSql(sql);
	}
	
	public boolean executeUpdateSqls(String[] sqls) throws VCIError {
		if (sqls == null || sqls.length == 0) {
			return true;
		}
		
		for (int i = 0; i < sqls.length; i++) {
			if (sqls[i] == null) {
				sqls[i] = "";
			}
		}
		
		return BOFactoryClient.getBOFactoryService().executeUpdateSqls(sqls);
	}
}