package test.forgon.disinfectsystem;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertTrue;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.util.JSONStringer;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTransactionalTestNGSpringContextTests;

import test.forgon.constant.Constants;
import test.forgon.disinfectsystem.invoicemanager.service.DataGenerater;

import com.forgon.directory.acegi.tools.AcegiHelper;
import com.forgon.directory.model.BarcodeDevice;
import com.forgon.directory.model.CssdHandleTousses;
import com.forgon.directory.model.CssdServiceDepts;
import com.forgon.directory.model.OrgUnit;
import com.forgon.directory.service.DirectoryHelper;
import com.forgon.directory.service.OrgUnitManager;
import com.forgon.directory.service.SysUserManager;
import com.forgon.directory.vo.LoginUserData;
import com.forgon.disinfectsystem.basedatamanager.container.service.ContainerManager;
import com.forgon.disinfectsystem.basedatamanager.goodsstock.service.GoodsStockManager;
import com.forgon.disinfectsystem.basedatamanager.sterilizer.service.SterilizerManager;
import com.forgon.disinfectsystem.basedatamanager.supplyroomconfig.service.SupplyRoomConfigManager;
import com.forgon.disinfectsystem.basedatamanager.warehouse.service.WareHouseManager;
import com.forgon.disinfectsystem.common.CssdUtils;
import com.forgon.disinfectsystem.diposablegoods.service.DiposableGoodBatchStockManager;
import com.forgon.disinfectsystem.diposablegoods.service.DiposableGoodsManager;
import com.forgon.disinfectsystem.diposablegoods.service.DisposableGoodsBatchManager;
import com.forgon.disinfectsystem.diposablegoods.service.GodownEntryManager;
import com.forgon.disinfectsystem.diposablegoods.service.IdentificationOfDiposableGoodsManager;
import com.forgon.disinfectsystem.entity.assestmanagement.DiposableGoodsInstance;
import com.forgon.disinfectsystem.entity.assestmanagement.DisposableGoods;
import com.forgon.disinfectsystem.entity.assestmanagement.DisposableGoodsBatchStock;
import com.forgon.disinfectsystem.entity.assestmanagement.DisposableGoodsIdentification;
import com.forgon.disinfectsystem.entity.assestmanagement.DisposableGoodsStock;
import com.forgon.disinfectsystem.entity.assestmanagement.GodownEntry;
import com.forgon.disinfectsystem.entity.assestmanagement.GodownEntryItem;
import com.forgon.disinfectsystem.entity.basedatamanager.container.Container;
import com.forgon.disinfectsystem.entity.basedatamanager.expirationdateinfo.ExpirationDateInfo;
import com.forgon.disinfectsystem.entity.basedatamanager.materialdefinition.MaterialDefinition;
import com.forgon.disinfectsystem.entity.basedatamanager.materialinstance.MaterialInstance;
import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer;
import com.forgon.disinfectsystem.entity.basedatamanager.supplyroomconfig.SupplyRoomConfig;
import com.forgon.disinfectsystem.entity.basedatamanager.taskGroup.TaskGroup;
import com.forgon.disinfectsystem.entity.basedatamanager.tousseGroup.TousseGroup;
import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.ComboTousseComposite;
import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.ComboTousseOrgUint;
import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.TousseDefinition;
import com.forgon.disinfectsystem.entity.basedatamanager.toussedefinition.TousseInstance;
import com.forgon.disinfectsystem.entity.basedatamanager.warehouse.WareHouse;
import com.forgon.disinfectsystem.entity.goodsstock.GoodsStock;
import com.forgon.disinfectsystem.entity.invoicemanager.InvoicePlan;
import com.forgon.disinfectsystem.entity.recyclingapplication.RecyclingApplication;
import com.forgon.disinfectsystem.entity.recyclingrecord.RecyclingRecord;
import com.forgon.disinfectsystem.entity.tousseitem.TousseItem;
import com.forgon.disinfectsystem.foreigntousseapplication.service.ForeignTousseApplicationManager;
import com.forgon.disinfectsystem.invoicemanager.service.InvoiceManager;
import com.forgon.disinfectsystem.maintain.basic.service.MaintainManager;
import com.forgon.disinfectsystem.recyclingapplication.service.InvoicePlanManager;
import com.forgon.disinfectsystem.recyclingapplication.service.RecyclingApplicationManager;
import com.forgon.disinfectsystem.recyclingrecord.vo.RecyclingBasketVo;
import com.forgon.disinfectsystem.recyclingrecord.vo.RecyclingClassifiedItemVo;
import com.forgon.disinfectsystem.recyclingrecord.vo.RecyclingItemVo;
import com.forgon.disinfectsystem.returngoodsrecord.service.ReturnGoodsRecordManager;
import com.forgon.disinfectsystem.sterilizationmanager.foreignproxydisinfection.service.ForeignProxyDisinfectionManager;
import com.forgon.disinfectsystem.sterilizationmanager.proxydisinfection.service.ProxyDisinfectionManager;
import com.forgon.disinfectsystem.stockmanage.cssdstock.service.TousseStockManager;
import com.forgon.disinfectsystem.stockmanage.departmentstock.service.DepartmentStockManager;
import com.forgon.disinfectsystem.tousse.materialdefinition.service.MaterialDefinitionManager;
import com.forgon.disinfectsystem.tousse.materialinstance.service.MaterialInstanceManager;
import com.forgon.disinfectsystem.tousse.toussedefinition.service.TousseDefinitionManager;
import com.forgon.disinfectsystem.tousse.toussedefinition.service.TousseInstanceManager;
import com.forgon.disinfectsystem.tousseitem.service.TousseItemManager;
import com.forgon.disinfectsystem.vo.TousseItemVo;
import com.forgon.disinfectsystem.webservice.security.service.WebServiceManager;
import com.forgon.oa.initdata.service.InitializeDataManager;
import com.forgon.oa.web.service.PublicInformationManager;
import com.forgon.runwithtrans.model.RunWithTransNewTask;
import com.forgon.runwithtrans.service.RunWithTransNewManager;
import com.forgon.security.model.Operation;
import com.forgon.security.model.Role;
import com.forgon.security.model.User;
import com.forgon.security.service.RoleManager;
import com.forgon.security.userdetails.UserContainsSessionUser;
import com.forgon.serialnumber.model.SerialNum;
import com.forgon.serialnumber.service.SerialNumManager;
import com.forgon.systemsetting.model.HttpOption;
import com.forgon.tools.MathTools;
import com.forgon.tools.cache.ForgonThreadLocalResourceManager;
import com.forgon.tools.hibernate.ObjectDao;
import com.forgon.tools.json.JSONUtil;
import com.forgon.treenode.service.THTreeNodeManager;

/**
 * @author Angus
 * 
 * Spring的配置文件硬编码为读gzfdzl（广州复大肿瘤）文件夹的配置，
 * 需要改进为读取jdbc.properties文件中project的配置。Terry Kwan，2016-07-10
 * 
 */
@ContextConfiguration(locations={"classpath:spring/*.xml", "classpath:spring/security/*.xml",
		// "classpath:spring/database/sqlserver/*.xml",
"classpath:spring/projects/gzfdzl/*.xml" })
//@ContextConfiguration(locations={"classpath:applicationContext-test.xml"})
public class AbstractCSSDTest extends
AbstractTransactionalTestNGSpringContextTests{

	protected Map<String , Object> map = new HashMap<String, Object>();
	
	@Autowired
	protected DirectoryHelper directoryHelper;
	@Autowired
	protected SysUserManager sysUserManager;
	@Autowired
	protected RoleManager roleManager;
	@Autowired
	protected THTreeNodeManager thTreeNodeManager;
	@Autowired
	protected ObjectDao objectDao;
	@Autowired
	protected PublicInformationManager publicInformationManager;
	@Autowired
	protected AcegiHelper acegiHelper;
	@Autowired
	protected UserDetailsService daoUserDetail;
	@Autowired
	protected OrgUnitManager orgUnitManager;
	@Autowired
	protected GodownEntryManager godownEntryManager;
	@Autowired
	protected DiposableGoodBatchStockManager diposableGoodBatchStockManager;
	@Autowired
	protected IdentificationOfDiposableGoodsManager identificationOfDiposableGoodsManager;
	@Autowired
	protected MaterialDefinitionManager materialDefinitionManager;
	@Autowired
	protected RecyclingApplicationManager recyclingApplicationManager;
	@Autowired
	protected TousseDefinitionManager tousseDefinitionManager;
	@Autowired
	protected TousseInstanceManager tousseInstanceManager;
	@Autowired
	protected SupplyRoomConfigManager supplyRoomConfigManager;
	@Autowired
	protected DiposableGoodsManager diposableGoodsManager;
	@Autowired
	protected DisposableGoodsBatchManager disposableGoodsBatchManager;
	@Autowired
	protected SerialNumManager serialNumManager;
	@Autowired
	protected TousseItemManager tousseItemManager;
	@Autowired
	protected TousseStockManager tousseStockManager;
	@Autowired
	protected DepartmentStockManager departmentStockManager;
	@Autowired
	protected MaterialInstanceManager materialInstanceManager;
	@Autowired
	protected ForeignTousseApplicationManager foreignTousseApplicationManager;
	@Autowired
	protected ProxyDisinfectionManager proxyDisinfectionManager;
	@Autowired
	protected ForeignProxyDisinfectionManager foreignProxyDisinfectionManager;
	@Autowired
	protected WebServiceManager webServiceManager;
	@Autowired
	protected ReturnGoodsRecordManager returnGoodsRecordManager;
	@Autowired
	protected DataGenerater dataGenerater;
	@Autowired
	protected ContainerManager containerManager;
	@Autowired
	protected SterilizerManager sterilizerManager;
	@Autowired
	protected MaintainManager maintainManager;
	@Autowired
	protected InvoicePlanManager invoicePlanManager;
	@Autowired
	protected InvoiceManager invoiceManager;
	@Autowired
	protected WareHouseManager wareHouseManager;
	@Autowired
	protected GoodsStockManager goodsStockManager;
	@Autowired
	protected RunWithTransNewManager runWithTransNewManager;
	@Autowired
	protected InitializeDataManager initializeDataManager;
	
	/**
	 * 组织单位OrgUnit供应室的id
	 */
	protected String orgUnitCSSDId;
	
	public static final float DIPOSABLEGOODS_PRICE_F =  1.1f;
	
	protected static final int AMOUNT = 500;


	/**
	 * 按照用户名登录
	 * @param username 用户名
	 */
	protected void makeActiveUser(String username) {
		String password = "1";
		Collection<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
		LoginUserData loginedUser = new LoginUserData();
		loginedUser.setUserName(username);

		if ("admin".equals(username)) {
			authorities.add(new SimpleGrantedAuthority(
					"ROLE_ADMINISTRATOR_0"));
		}

		UserContainsSessionUser user = (UserContainsSessionUser) daoUserDetail
				.loadUserByUsername(username);

		Authentication authRequest = new UsernamePasswordAuthenticationToken(
				user, password, authorities);

		SecurityContextHolder.getContext().setAuthentication(authRequest);
	}
	
	/**
	 * 创建供测试使用的一次性物品
	 * 说明:test10ml注射器[小号] 1100个<br/>
	 * 		--1402180001批次     <strong> 700</strong>个   条码:<strong> 201410150001</strong><br/>
	 * 			--00001标识号     700个<br/>
	 * 		--1402180002批次       <strong>400</strong>个   条码:<strong> 201410150002</strong><br/>
	 * 			--00002标识号     400个<br/>
	 * 		--1402180003批次       <strong>0</strong>个   条码:<strong> 201410150003</strong><br/>
	 * 			--00003标识号     0个<br/>
	 */
	protected void createDiposableGoods() {
		WareHouse wareHouse1 = wareHouseManager.getDefaultWareHouseByUnitCode(Constants.ORG_UNIT_CODE_CSSD);
		dataGenerater.createTestDataByType("一次性物品", wareHouse1);
	}
	
	/**
	 * 创建两个用于测试的消毒物品器械包定义:<br/>
	 * <li><h3>test止血带</h3>
	 * 	<ul>test止血带<strong>100</strong>扎</ul>
	 * </li>
	 */
	protected void createDisinfectionTousseDefinition(){
		MaterialDefinition materialDefinition = new MaterialDefinition();
		materialDefinition.setName("test止血带");
		materialDefinition.setType("橡胶");
		materialDefinition.setCost(1.5);
		materialDefinition.setIsTraceble("否");
		materialDefinition.setSpecification("20条/扎");
		materialDefinition.setSpelling("ZXD");
		materialDefinition.setStorage(2000L);
		
		materialDefinitionManager.saveOrUpdate(materialDefinition);
		TousseDefinition tousseDefinition = new TousseDefinition();
		
		MaterialInstance materialInstance = new MaterialInstance();
		materialInstance.setCount(1);
		materialInstance.setMaterialDefinition(materialDefinition);
		materialInstance.setMaterialName("test止血带");
		
		tousseDefinition.setName("test止血带");
		tousseDefinition.setIsCleanedEntirely("是");
		tousseDefinition.setIsRecycling(TousseDefinition.STR_YES);
		tousseDefinition.setIsPacking(TousseDefinition.STR_NO);
		tousseDefinition.setIsTraceable(TousseDefinition.STR_NO);
		tousseDefinition.setTaskGroup("术科组"); 
		tousseDefinition.setTousseType(TousseDefinition.PACKAGE_TYPE_DISINFECTION);
		tousseDefinition.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tousseDefinition.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition.getMaterialInstances().add(materialInstance);
		tousseDefinition.setForDisplay(true);
		objectDao.saveOrUpdate(materialInstance);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition);
		
		//消毒物品
		TousseDefinition disinfectionTousse = new TousseDefinition();
		disinfectionTousse.setTousseType(TousseDefinition.PACKAGE_TYPE_DISINFECTION);
		disinfectionTousse.setIsTraceable("否");
		disinfectionTousse.setName("止血带_20141016");
		disinfectionTousse.setPrice(2.5);
		disinfectionTousse.setIsCleanedEntirely("否");
		disinfectionTousse.setIsRecycling(TousseDefinition.STR_YES);
		disinfectionTousse.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		disinfectionTousse.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		objectDao.save(disinfectionTousse);
		disinfectionTousse.setAncestorID(disinfectionTousse.getId());
		objectDao.saveOrUpdate(disinfectionTousse);
		
		CssdHandleTousses cssdHandleTousses = new CssdHandleTousses();
		cssdHandleTousses.setOrgUnitCode(tousseDefinition.getHandlerDepartCode());
		cssdHandleTousses.setOrgUnitName(tousseDefinition.getHandlerDepartName());
		cssdHandleTousses.setTaskGroup(tousseDefinition.getTaskGroup());
		cssdHandleTousses.setTousseDefinitionId(tousseDefinition.getAncestorID());
		cssdHandleTousses.setTousseName(tousseDefinition.getName());
		objectDao.save(cssdHandleTousses);
	}
	
	
	protected void initDisinfectToussesData(){
		MaterialDefinition materialDefinition1 = new MaterialDefinition();
		materialDefinition1.setName("Test雾化器");
		materialDefinition1.setType("橡胶");
		materialDefinition1.setCost(1.5);
		materialDefinition1.setIsTraceble("否");
		materialDefinition1.setSpelling("WHQ");
		materialDefinition1.setStorage(2000L);
		materialDefinitionManager.saveOrUpdate(materialDefinition1);
		MaterialInstance materialInstance1 = new MaterialInstance();
		materialInstance1.setCount(100);
		materialInstance1.setMaterialDefinition(materialDefinition1);
		materialInstance1.setMaterialName("Test雾化器");
		
		
		MaterialDefinition materialDefinition11 = new MaterialDefinition();
		materialDefinition11.setName("封口盖");
		materialDefinition11.setType("橡胶");
		materialDefinition11.setCost(0.5);
		materialDefinition11.setIsTraceble("否");
		materialDefinition11.setSpelling("FKG");
		
		materialDefinitionManager.saveOrUpdate(materialDefinition11);
		MaterialInstance materialInstance11 = new MaterialInstance();
		materialInstance11.setCount(200);
		materialInstance11.setMaterialDefinition(materialDefinition11);
		materialInstance11.setMaterialName("封口盖");
		
		TousseDefinition tousseDefinition1 = new TousseDefinition();
		materialInstance1.setTousse(tousseDefinition1);
		materialInstance11.setTousse(tousseDefinition1);
		tousseDefinition1.setName("Test雾化器");
		tousseDefinition1.setIsCleanedEntirely("是");
		tousseDefinition1.setIsApplyEntireTousse("是");
		tousseDefinition1.setIsRecycling(TousseDefinition.STR_YES);
		tousseDefinition1.setIsPacking(TousseDefinition.STR_YES);
		tousseDefinition1.setIsTraceable(TousseDefinition.STR_NO);
		tousseDefinition1.setTaskGroup("器械组"); 
		tousseDefinition1.setTousseType(TousseDefinition.PACKAGE_TYPE_DISINFECTION);
		tousseDefinition1.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tousseDefinition1.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition1.setForDisplay(true);
		
		
		objectDao.saveOrUpdate(materialInstance1);
		objectDao.saveOrUpdate(materialInstance11);
		
		List<MaterialInstance> materialInstances = new ArrayList<MaterialInstance>();
		materialInstances.add(materialInstance1);
		materialInstances.add(materialInstance11);
		
		tousseDefinition1.setMaterialInstances(materialInstances);
		
		tousseDefinitionManager.saveOrUpdate(tousseDefinition1);
		
		assertNotNull(tousseDefinition1.getMaterialInstances());
		assertEquals(2, tousseDefinition1.getMaterialInstances().size());
		
		MaterialDefinition materialDefinition2 = new MaterialDefinition();
		materialDefinition2.setName("止血带");
		materialDefinition2.setType("橡胶");
		materialDefinition2.setCost(1.5);
		materialDefinition2.setIsTraceble("否");
		materialDefinition2.setSpecification(null);
		materialDefinition2.setSpelling("ZXD");
		materialDefinition2.setStorage(100L);
		
		materialDefinitionManager.saveOrUpdate(materialDefinition2);
		MaterialInstance materialInstance2 = new MaterialInstance();
		materialInstance2.setCount(100);
		materialInstance2.setMaterialDefinition(materialDefinition2);
		materialInstance2.setMaterialName("止血带");
		
		TousseDefinition tousseDefinition2 = new TousseDefinition();
		materialInstance2.setTousse(tousseDefinition2);
		tousseDefinition2.setName("止血带[100条/扎]");
		tousseDefinition2.setIsCleanedEntirely("否");
		tousseDefinition2.setIsApplyEntireTousse("是");
		tousseDefinition2.setIsRecycling(TousseDefinition.STR_YES);
		tousseDefinition2.setIsPacking(TousseDefinition.STR_NO);
		tousseDefinition2.setIsTraceable(TousseDefinition.STR_NO);
		tousseDefinition2.setTaskGroup("术科组"); 
		tousseDefinition2.setTousseType(TousseDefinition.PACKAGE_TYPE_DISINFECTION);
		tousseDefinition2.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tousseDefinition2.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition2.setForDisplay(true);
		
		materialInstances = new ArrayList<MaterialInstance>();
		materialInstances.add(materialInstance2);
		
		tousseDefinition2.setMaterialInstances(materialInstances);
		
		objectDao.saveOrUpdate(materialInstance2);
		
		tousseDefinitionManager.saveOrUpdate(tousseDefinition2);
		
		
		MaterialDefinition materialDefinition3 = new MaterialDefinition();
		materialDefinition3.setName("呼吸机");
		materialDefinition3.setType("橡胶");
		materialDefinition3.setCost(25.0);
		materialDefinition3.setIsTraceble("是");
		materialDefinition3.setSpecification(null);
		materialDefinition3.setSpelling("HXJ");
		materialDefinition3.setStorage(20L);
		
		materialDefinitionManager.saveOrUpdate(materialDefinition3);
		MaterialInstance materialInstance3 = new MaterialInstance();
		materialInstance3.setCount(100);
		materialInstance3.setMaterialDefinition(materialDefinition3);
		materialInstance3.setMaterialName("呼吸机");
		
		TousseDefinition tousseDefinition3 = new TousseDefinition();
		materialInstance3.setTousse(tousseDefinition3);
		tousseDefinition3.setName("呼吸机");
		tousseDefinition3.setIsCleanedEntirely("否");
		tousseDefinition3.setIsApplyEntireTousse("否");
		tousseDefinition3.setIsRecycling(TousseDefinition.STR_YES); // 需要回收
		tousseDefinition3.setIsTraceable(TousseDefinition.STR_YES);   // 可追溯
		tousseDefinition3.setIsPacking(TousseDefinition.STR_YES);   // 需要装配
		tousseDefinition3.setTaskGroup("术科组"); 
		tousseDefinition3.setTousseType(TousseDefinition.PACKAGE_TYPE_DISINFECTION);
		tousseDefinition3.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tousseDefinition3.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition3.setForDisplay(true);
		
		materialInstances = new ArrayList<MaterialInstance>();
		materialInstances.add(materialInstance3);
		
		tousseDefinition3.setMaterialInstances(materialInstances);
		
		objectDao.saveOrUpdate(materialInstance3);
		
		tousseDefinitionManager.saveOrUpdate(tousseDefinition3);
		
		
		
	}
	
	/**
	 * 初始化供应室处理器械包配置(供应室和手术室分别能处理所有的器械包)
	 */
	private void initCssdHandleTousses(){
		List<TousseDefinition> tdList = 
				objectDao.findBySql(TousseDefinition.class.getSimpleName(), "where forDisplay=true");
		for(TousseDefinition td : tdList){
			//测试供应室
			CssdHandleTousses cssdHandleToussesForCssd = new CssdHandleTousses();
			cssdHandleToussesForCssd.setOrgUnitCode(Constants.ORG_UNIT_CODE_CSSD);
			cssdHandleToussesForCssd.setOrgUnitName(Constants.ORG_UNIT_NAME_CSSD);
			cssdHandleToussesForCssd.setTaskGroup(td.getTaskGroup());
			cssdHandleToussesForCssd.setTousseDefinitionId(td.getAncestorID());
			cssdHandleToussesForCssd.setTousseName(td.getName());
			objectDao.save(cssdHandleToussesForCssd);
			
			//测试手术室
			CssdHandleTousses cssdHandleToussesForOr = new CssdHandleTousses();
			cssdHandleToussesForOr.setOrgUnitCode(Constants.ORG_UNIT_CODE_OR);
			cssdHandleToussesForOr.setOrgUnitName(Constants.ORG_UNIT_NAME_OR);
			cssdHandleToussesForOr.setTaskGroup(td.getTaskGroup());
			cssdHandleToussesForOr.setTousseDefinitionId(td.getAncestorID());
			cssdHandleToussesForOr.setTousseName(td.getName());
			objectDao.save(cssdHandleToussesForOr);
			
		}
	}
	
	/**
	 * 创建一个用于测试的外来器械包定义:<br/>
	 * <li><h3>test骨科外来器械包</h3>
	 * 	<ul>test骨科剥离器</ul>
	 * 	<ul>test骨科植入性钢钉</ul>
	 * </li>
	 */
	protected void createForeignTousseDefinition(){
		MaterialDefinition materialDefinition = new MaterialDefinition();
		materialDefinition.setName("test骨科剥离器");
		materialDefinition.setIsTraceble("是");
		materialDefinition.setSpecification("尖头");
		materialDefinition.setCost(1600D);
		materialDefinition.setSpelling("testGKBLQ");
		materialDefinition.setType("金属");
		materialDefinition.setStorage(30L);
		
		MaterialDefinition materialDefinition2 = new MaterialDefinition();
		materialDefinition2.setName("test骨科植入性钢钉");
		materialDefinition2.setIsTraceble("是");
		materialDefinition2.setSpecification("8mm");
		materialDefinition2.setCost(1200D);
		materialDefinition2.setSpelling("testGKZRXGD");
		materialDefinition2.setType("金属");
		materialDefinition2.setStorage(30L);
		
		materialDefinitionManager.saveOrUpdate(materialDefinition);
		materialDefinitionManager.saveOrUpdate(materialDefinition2);
		
		//外来器械包
		TousseDefinition tousseDefinition = new TousseDefinition();
		MaterialInstance materialInstance = new MaterialInstance();
		materialInstance.setCount(1);
		materialInstance.setMaterialDefinition(materialDefinition);
		materialInstance.setMaterialName("test骨科剥离器");
		materialInstance.setTousse(tousseDefinition);
		
		MaterialInstance materialInstance2 = new MaterialInstance();
		materialInstance2.setCount(5);
		materialInstance2.setMaterialDefinition(materialDefinition2);
		materialInstance2.setMaterialName("test骨科植入性钢钉");
		materialInstance2.setTousse(tousseDefinition);
		
		tousseDefinition.setName("test骨科外来器械包");
		tousseDefinition.setIsCleanedEntirely("是");
		tousseDefinition.setTaskGroup("OR器械组");
		tousseDefinition.setTousseType(TousseDefinition.PACKAGE_TYPE_FOREIGN);
		List<MaterialInstance> materialInstanceList  = new ArrayList<MaterialInstance>();
		materialInstanceList.add(materialInstance);
		materialInstanceList.add(materialInstance2);
		tousseDefinition.setMaterialInstances(materialInstanceList);
		objectDao.saveOrUpdate(materialInstance);
		objectDao.saveOrUpdate(materialInstance2);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition);
	}
	/**
	 * 创建一个用于测试的普通器械包定义:<br/>
	 * <li><h3>Test开胸包</h3>
	 * 	<ul>镊子【14cm】 <strong>2</strong>把</ul>
	 * 	<ul>弯尖剪【18cm】<strong>3</strong>把</ul>
	 * </li>
	 * <li><h3>材料说明</h3>
	 *	<ul>镊子【14cm】--<strong>18</strong>/把、库存<strong>500</strong>把</ul>
	 *	<ul>弯尖剪【18cm】--<strong>28</strong>/把、库存<strong>200</strong>把</ul>
	 *	<ul></ul>
	 * </li>
	 */
	protected void createTousseDefinition(){
		
		MaterialDefinition materialDefinition1 = new MaterialDefinition();
		materialDefinition1.setName("镊子");
		materialDefinition1.setType("金属类");
		materialDefinition1.setSpelling("NZ");
		materialDefinition1.setCost(18.00);
		materialDefinition1.setSpecification("14cm");
		materialDefinition1.setStorage(500L);
		materialDefinition1.setIsTraceble("是");
		materialDefinitionManager.saveOrUpdate(materialDefinition1);
		
		MaterialDefinition materialDefinition2 = new MaterialDefinition();
		materialDefinition2.setName("弯尖剪");
		materialDefinition2.setType("金属类");
		materialDefinition2.setSpelling("WJJ");
		materialDefinition2.setCost(28.00);
		materialDefinition2.setSpecification("18cm");
		materialDefinition2.setStorage(200L);
		materialDefinition2.setIsTraceble("是");
		materialDefinitionManager.saveOrUpdate(materialDefinition2);

		TousseDefinition tousseDefinition1 = new TousseDefinition();
		
		MaterialInstance materialInstance1 = new MaterialInstance();
		materialInstance1.setTousse(tousseDefinition1);
		materialInstance1.setMaterialDefinition(materialDefinition1);
		materialInstance1.setCount(2);
		materialInstance1.setMaterialName(materialDefinition1.getName());
		
		objectDao.saveOrUpdate(materialInstance1);
		
		MaterialInstance materialInstance2 = new MaterialInstance();
		materialInstance2.setTousse(tousseDefinition1);
		materialInstance2.setMaterialDefinition(materialDefinition2);
		materialInstance2.setCount(3);
		materialInstance2.setMaterialName(materialDefinition2.getName());
		
		objectDao.saveOrUpdate(materialInstance2);
		
		//普通器械包
		tousseDefinition1.setName("Test开胸包");
		tousseDefinition1.setIsCleanedEntirely("是");
		tousseDefinition1.setTaskGroup("灭菌组");
		tousseDefinition1.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition1.setHandlerDepartName(Constants.ORG_UNIT_NAME_DISINFECT);
		tousseDefinition1.setHandlerDepartCode(Constants.ORG_UNIT_CODE_DISINFECT);

		tousseDefinition1.getMaterialInstances().add(materialInstance1);
		tousseDefinition1.getMaterialInstances().add(materialInstance2);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition1);
		
		TousseDefinition tousseDefinition2 = new TousseDefinition();
		//普通器械包
		tousseDefinition2.setName("Test缝合包");
		tousseDefinition2.setIsCleanedEntirely("是");
		tousseDefinition2.setTaskGroup("器械组");
		tousseDefinition2.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition2.setHandlerDepartName(Constants.ORG_UNIT_NAME_DISINFECT);
		tousseDefinition2.setHandlerDepartCode(Constants.ORG_UNIT_CODE_DISINFECT);

		tousseDefinition2.getMaterialInstances().add(materialInstance1);
		tousseDefinition2.getMaterialInstances().add(materialInstance2);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition2);
		
		TousseDefinition tousseDefinition3 = new TousseDefinition();
		//普通器械包
		tousseDefinition3.setName("Test清创包");
		tousseDefinition3.setIsCleanedEntirely("是");
		tousseDefinition3.setTaskGroup("器械组");
		tousseDefinition3.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition3.setHandlerDepartName(Constants.ORG_UNIT_NAME_DISINFECT);
		tousseDefinition3.setHandlerDepartCode(Constants.ORG_UNIT_CODE_DISINFECT);

		tousseDefinition3.getMaterialInstances().add(materialInstance1);
		tousseDefinition3.getMaterialInstances().add(materialInstance2);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition3);
		
		TousseDefinition tousseDefinition4 = new TousseDefinition();
		//普通器械包
		tousseDefinition4.setName("Test宫碘包");
		tousseDefinition4.setIsCleanedEntirely("是");
		tousseDefinition4.setTaskGroup("器械组");
		tousseDefinition4.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition4.setHandlerDepartName(Constants.ORG_UNIT_NAME_DISINFECT);
		tousseDefinition4.setHandlerDepartCode(Constants.ORG_UNIT_CODE_DISINFECT);

		tousseDefinition4.getMaterialInstances().add(materialInstance1);
		tousseDefinition4.getMaterialInstances().add(materialInstance2);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition4);
		
		// 不回收的包
		{
			TousseDefinition tousseDefinition = new TousseDefinition();
			tousseDefinition.setName("不回收的包");
			tousseDefinition.setIsCleanedEntirely("是");
			tousseDefinition.setTaskGroup("灭菌组");
			tousseDefinition.setIsRecycling(TousseDefinition.STR_NO);
			tousseDefinition.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
			tousseDefinition.setHandlerDepartName(Constants.ORG_UNIT_NAME_DISINFECT);
			tousseDefinition.setHandlerDepartCode(Constants.ORG_UNIT_CODE_DISINFECT);

			tousseDefinition.getMaterialInstances().add(materialInstance1);
			tousseDefinition.getMaterialInstances().add(materialInstance2);
			tousseDefinitionManager.saveOrUpdate(tousseDefinition);
		}
		
	}
	
	/**
	 * 创建聚合包定义
	 */
	private TousseDefinition bulidComboTousseDefinition(){
		//聚合包定义
		TousseDefinition comboTousse = new TousseDefinition();
		comboTousse.setName("Test聚合包");
		comboTousse.setTousseType(TousseDefinition.PACKAGE_TYPE_COMBO);
		comboTousse.setHandlerDepartCode(Constants.ORG_UNIT_CODE_NEIKE);
		comboTousse.setHandlerDepartName(Constants.ORG_UNIT_NAME_NEIKE);
		comboTousse.setIsCustomPacking(TousseDefinition.STR_NO);
		objectDao.saveOrUpdate(comboTousse);
		
		comboTousse.setAncestorID(comboTousse.getId());
		objectDao.saveOrUpdate(comboTousse);
		
		ComboTousseOrgUint ctOrgUnito = new ComboTousseOrgUint();
		ctOrgUnito.setTousseType(TousseDefinition.PACKAGE_TYPE_COMBO);
		ctOrgUnito.setUnitCode(Constants.ORG_UNIT_CODE_NEIKE);
		ctOrgUnito.setUnitName(Constants.ORG_UNIT_NAME_NEIKE);
		ctOrgUnito.setComboTousseDefinitionId(comboTousse.getId());
		objectDao.saveOrUpdate(ctOrgUnito);
		
		//聚合包内普通器械包
		TousseDefinition td_开胸包 = tousseDefinitionManager.getTousseDefinitionByName("Test开胸包");
		TousseDefinition td_开颅包 = tousseDefinitionManager.getTousseDefinitionByName("Test开颅包");
		
		ComboTousseComposite ct = new ComboTousseComposite();
		ct.setComboTousseDefinitionId(comboTousse.getId());
		ct.setTousseDefinitionId(td_开胸包.getId());
		objectDao.saveOrUpdate(ct);
		
		ComboTousseComposite ct2 = new ComboTousseComposite();
		ct2.setComboTousseDefinitionId(comboTousse.getId());
		ct2.setTousseDefinitionId(td_开颅包.getId());
		objectDao.saveOrUpdate(ct2);
		return comboTousse;
	}
	
	
	/**
	 * 创建一个用于测试的外部代理灭菌器械包定义:<br/>
	 * <li><h3>test121#压力蒸汽灭菌包</h3>
	 * 	<ul>棉布<strong>1</strong>条</ul>
	 * </li>
	 */
	protected void createForeignProxyTousseDefinition(){
		DisposableGoods diposableGoods = new DisposableGoods();
		diposableGoods.setName("test棉布");
		//diposableGoods.setAmount(1000L);
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setType("test棉布");
	
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		List<DiposableGoodsInstance> diposableGoodsInstances = new ArrayList<DiposableGoodsInstance>();
		DiposableGoodsInstance diposableGoodsInstance = new DiposableGoodsInstance();
		diposableGoodsInstance.setAmount(1);
		diposableGoodsInstance.setDiposableGoods(diposableGoods);
		
		objectDao.saveOrUpdate(diposableGoodsInstance);
		
		diposableGoodsInstances.add(diposableGoodsInstance);
		
		TousseDefinition tousseDefinition = new TousseDefinition();
		tousseDefinition.setName("test121#压力蒸汽灭菌包");
		tousseDefinition.setIsCleanedEntirely("是");
		tousseDefinition.setTaskGroup("灭菌组");
		tousseDefinition.setTousseType(TousseDefinition.PACKAGE_TYPE_FOREIGNPROXY);
		tousseDefinition.setHandlerDepartName(Constants.ORG_UNIT_NAME_DISINFECT);
		tousseDefinition.setHandlerDepartCode(Constants.ORG_UNIT_CODE_DISINFECT);
		tousseDefinition.setDiposableGoodsItems(diposableGoodsInstances);
		tousseDefinition.setPackageType("棉布");
		tousseDefinition.setPrice(5.5);
		tousseDefinition.setProxyDisinfectionPrice(5.5);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition);
	}
	
	// key-批次条码  stockBarcode,value-发货数量 amount
	protected String createSendOutParam(Map<String ,Object> map) {
		map.put("sender", "朱广兴");
		JSONStringer stringer = new JSONStringer();
		String stockBarcode ;
		int amount;
		stringer.object().key("departCode").value(map.get("departCode"))
		.key("sender").value(map.get("sender")).key("invoiceItems")
		.array();
		if(map.size() !=0 ){
			for(Map.Entry<String, Object> entry :map.entrySet()){
				stockBarcode = entry.getKey();
				if(stockBarcode.equals("departCode") || stockBarcode.equals("sender")){
					continue;
				}
				amount = (Integer) entry.getValue();
				stringer.object().key("barcode").value(stockBarcode).key("sendAmount").value(amount).endObject();
			}
		}
		stringer.endArray().endObject();
		String jsonParam = stringer.toString();
		return jsonParam;
	}
	/**
	 * 
	 */
	private void initCSSDDataWithTrans(){
		runWithTransNewManager.runWith_TRANS_NEW(new RunWithTransNewTask() {
			@Override
			public void runTask() {
				/**
				 * 清空基础数据、业务数据等表
				 */
				cleanAll();
				/**
				 * 初始化角色、权限、人员(基础信息及条码)、科室(基础信息及条码)以及各表间的关联数据
				 */
				initDirectoryInfo();
				
				/**
				 * 初始化任务组、一次性物品类型、仓库、篮筐、科室供应室配置、灭菌炉等
				 */
				initBaseData();
				
				/**
				 * 初始化供应室服务临床科室配置
				 */
				initCssdServiceDepts();
				
				/**
				 * 初始化材料与器械包定义(器械包定义数量:11)
				 */
				initMaterialAndTousseData();
				
				/**
				 * 初始化消毒物品定义(器械包定义数量:3)
				 */
				initDisinfectToussesData();
				
				/**
				 * 初始化供应室处理器械包配置
				 */
				initCssdHandleTousses();
				
				/**
				 * 初始化一次性物品定义
				 */
				initDiposableGoodsData();
				
				/**
				 * 初始化聚合包定义(器械包定义数量:1)
				 */
				bulidComboTousseDefinition();
				
				/**
				 * 初始化失效期
				 */
				initExpirationDateInfo();
				
				ForgonThreadLocalResourceManager.afterRequest();

//				createDiposableGoods();
			}
		});
	}
	/**
	 * 测试数据初始化
	 */
	public void initCSSDData() {
		initCSSDDataWithTrans();
	}
	
	private void initExpirationDateInfo(){
		ExpirationDateInfo info = new ExpirationDateInfo();
		info.setPackageType("棉布");
		info.setValidDate(7);
		info.setWarningDate(3);
		info.setValidDateUnit(ExpirationDateInfo.DATEUNIT_DAY);
		objectDao.saveOrUpdate(info);
		
		ExpirationDateInfo info2 = new ExpirationDateInfo();
		info2.setPackageType("纸塑");
		info2.setValidDate(6);
		info2.setWarningDate(1);
		info2.setValidDateUnit(ExpirationDateInfo.DATEUNIT_MONTH);
		objectDao.saveOrUpdate(info2);
		
		
	}

	public void cleanAll() {
		
		//清除基础数据导入导出的几个表数据,如果不清除的话，将会随着测试用例不断运行及时间推移一直累积下去导出基础数据导出失败
		objectDao.excuteSQL("delete from HttpOption");
		objectDao.excuteSQL("delete from TaskGroup");
		objectDao.excuteSQL("delete from ExpirationDateInfo");
		objectDao.excuteSQL("delete from Supplier");
		
		objectDao.excuteSQL("delete from washrecord_washmaterial");
		objectDao.excuteSQL("delete from washanddisinfectrecordmaterial");
		
		objectDao.excuteSQL("delete from tousseinstance_washrecord");
		objectDao.excuteSQL("delete from classifyBasket_WashRecord");
		
		objectDao.excuteSQL("delete from WashAndDisinfectRecord");
		objectDao.excuteSQL("delete from TousseInstanceUseRecord");//清除聚合包关联使用记录中间表数据
		objectDao.excuteSQL("delete from sterilization_tousseinstance");
		objectDao.excuteSQL("delete from TousseInstance");
		
		objectDao.excuteSQL("delete from sterilization_reviewed");
		objectDao.excuteSQL("delete from sterilizerRecord");
		objectDao.excuteSQL("delete from SterilizationRecordPic");
		objectDao.excuteSQL("delete from SterilizationRecord");

		
		objectDao.excuteSQL("delete from QualityMonitoringDefinition");
		objectDao.excuteSQL("delete from QualityMonitoringInstance");
		
		objectDao.excuteSQL("delete from tousseStock");//器械包库存表之前未delete导致库存发货测试用例关于库存的断言未通过
		
		runWithTransNewManager.runWith_TRANS_NEW(new RunWithTransNewTask() {
			@Override
			public void runTask() {
				objectDao.excuteSQL("delete from SerialNum");
			}
		});
		
		objectDao.excuteSQL("delete from supplyRoomConfig");
		objectDao.excuteSQL("delete from beCleanItem");
		
		
		objectDao.excuteSQL("delete from materialInstance");
		objectDao.excuteSQL("delete from traceableMaterial");
		objectDao.excuteSQL("delete from materialentryitem");
		objectDao.excuteSQL("delete from materialentry");
		
		
		objectDao.excuteSQL("delete from imagefile");
		
		objectDao.excuteSQL("delete from TousseGroup");

		objectDao.excuteSQL("delete from InventoryItem");
		objectDao.excuteSQL("delete from InventoryRecord");
		objectDao.excuteSQL("delete from StockIdentificationOfGoods");
		objectDao.excuteSQL("delete from StockDiposableGoodBatch");
		objectDao.excuteSQL("delete from StockDiposableGoods");
		objectDao.excuteSQL("delete from StockTakeRecord");
		
		objectDao.excuteSQL("delete from classifieditem");
		objectDao.excuteSQL("delete from ClassifyBasket_RecyclingRecord");
		objectDao.excuteSQL("delete from classifyBasket");
		
		objectDao.excuteSQL("delete from materialDefinition");
		objectDao.excuteSQL("delete from TousseItem");
		
		objectDao.excuteSQL("delete from recyclingItem_errorDamage");
		objectDao.excuteSQL("delete from MaterialErrorDamageDetail");
		objectDao.excuteSQL("delete from RecyclingItem");
		
		objectDao.excuteSQL("delete from diposablegoodsitem");
		
		objectDao.excuteSQL("delete from packingTask");
		objectDao.excuteSQL("delete from PackingRecord");
		objectDao.excuteSQL("delete from PackingRecordOutItem");
		
		objectDao.excuteSQL("delete from invoiceItem");



		


		objectDao.excuteSQL("delete from LostMaterialItem");
		
		
		objectDao.excuteSQL("delete from ForeignTousseApplication");
		objectDao.excuteSQL("delete from proxyDis_rBasket");
		objectDao.excuteSQL("delete from ForeignProxyItem");
		objectDao.excuteSQL("delete from ForeignProxyDisinfection");
		objectDao.excuteSQL("delete from ProxyDisinfection");
		

		objectDao.excuteSQL("delete from classifybasket_recyclingrecord");
		objectDao.excuteSQL("delete from recyclingRecord");

		objectDao.excuteSQL("delete from returngoodsitem");
		objectDao.excuteSQL("delete from returngoodsrecord");
		objectDao.excuteSQL("delete from recyclingApplication");
		objectDao.excuteSQL("delete from DiposableGoodsInstance");

		objectDao.excuteSQL("delete from videoFile");
		
		objectDao.excuteSQL("delete from tousseDefinitiontemplateitem");
		
		objectDao.excuteSQL("delete from idCardInstance");
		objectDao.excuteSQL("delete from idCardDefinition");
		
		objectDao.excuteSQL("delete from tousseDefinition");
		objectDao.excuteSQL("delete from invoice");
		objectDao.excuteSQL("delete from invoicePlan");
		
		objectDao.excuteSQL("delete from receiveRecordItem");
		objectDao.excuteSQL("delete from DisposableGoodsIdentification");
		objectDao.excuteSQL("delete from DisposableGoodsBatchStock");

		objectDao.excuteSQL("delete from DiposableGoodsTemplateItem");
		
		// 删除一次性物品入库单
		objectDao.excuteSQL("delete from GodownEntryItem");
		objectDao.excuteSQL("delete from GodownEntry");
		
		objectDao.excuteSQL("delete from DisposableGoodsStock");
		
		objectDao.excuteSQL("delete from DisposableGoodsBatch");
		objectDao.excuteSQL("delete from DisposableGoods");
		
		
		//objectDao.excuteSQL("delete from DataDirectory_GYEY_COST_ACCOUNTING");
		
		objectDao.excuteSQL("delete from OrgUserRelation");
		objectDao.excuteSQL("delete from SS_USER_ROLE");
		objectDao.excuteSQL("delete from SS_UnDirectManaged_OrgUnit");
		
		objectDao.excuteSQL("delete from SS_USERS");
		
		
		objectDao.excuteSQL("delete from ReviewedBasket");
		objectDao.excuteSQL("delete from Container");
		objectDao.excuteSQL("delete from rinser_cleanMethod");
		objectDao.excuteSQL("delete from CleanMethod");
		objectDao.excuteSQL("delete from ConsumptiveConfig");
		objectDao.excuteSQL("delete from Rinser");
		objectDao.excuteSQL("delete from sterilizer_sterilistion");
		objectDao.excuteSQL("delete from Sterilisation");
		objectDao.excuteSQL("delete from DetectionItem");
		objectDao.excuteSQL("delete from Sterilizer");
		
		objectDao.excuteSQL("delete from OrgUnit");
		
		objectDao.excuteSQL("delete from UseRecord");
		
		objectDao.excuteSQL("delete from RecallRecordItem");
		objectDao.excuteSQL("delete from RecallRecord");

		objectDao.excuteSQL("delete from DepartmentStock");
		
		//多仓库新增加的相关实体(条码表放置最后)
		objectDao.excuteSQL("delete from CssdHandleTousses");
		objectDao.excuteSQL("delete from CssdServiceDepts");
		objectDao.excuteSQL("delete from GoodsStock");
		objectDao.excuteSQL("delete from WareHouse");
		objectDao.excuteSQL("delete from barcodeDevice");
	}
	
	/**
	 * 初始化基础数据
	 * 任务组：【常规组】（测试供应室）、【术科组】（测试供应室）、【器械组】（测试手术室）
	 * 一次性物品类型：【注射器】、【纱块】
	 * 系统参数(科室供应室配置)、仓库、篮筐、灭菌炉等
	 */
	public void initBaseData() {
		initSerialNum();

		// 任务组
		TaskGroup TaskGroup1 = new TaskGroup();
		TaskGroup1.setTaskGroupName("常规组");
		TaskGroup1.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		TaskGroup1.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		
		TaskGroup TaskGroup2 = new TaskGroup();
		TaskGroup2.setTaskGroupName("术科组");
		TaskGroup2.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		TaskGroup2.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		
		TaskGroup TaskGroup3 = new TaskGroup();
		TaskGroup3.setTaskGroupName("器械组");
		TaskGroup3.setDepartCode(Constants.ORG_UNIT_CODE_OR);
		TaskGroup3.setDepartName(Constants.ORG_UNIT_NAME_OR);
		
		// 一次性物品类型
		HttpOption httpoption1 = new HttpOption();
		httpoption1.setOptionListId(HttpOption.SYSTEMSETTING_DIPOSABLEGOODS_TYPE);
		httpoption1.setOptionText("注射器");
		httpoption1.setOptionValue("注射器");
		objectDao.saveOrUpdate(httpoption1);
		
		HttpOption httpoption2 = new HttpOption();
		httpoption2.setOptionListId(HttpOption.SYSTEMSETTING_DIPOSABLEGOODS_TYPE);
		httpoption2.setOptionText("纱块");
		httpoption2.setOptionValue("纱块");
		objectDao.saveOrUpdate(httpoption2);

		//系统参数(科室供应室配置)
		SupplyRoomConfig supplyRoomConfig = new SupplyRoomConfig();
		supplyRoomConfig.setDayStartTime("05:00");
		supplyRoomConfig.setDisposableGoodsExpTime(20);
		supplyRoomConfig.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_0);
		supplyRoomConfig.setDefalutTaskGroup("常规组");//外来器械处理任务组
		supplyRoomConfig.setCustomTousseDefaultTaskGroup("常规组");//自定义器械处理任务组
		supplyRoomConfig.setUnitName("阳光医院");
		supplyRoomConfig.setAfterRecyclingTousseDeliver(false);
		supplyRoomConfig.setAutoSignInvoice(false);
		supplyRoomConfig.setAutoMergeApplication(false);
		supplyRoomConfig.setSecondSupplyRoomNeedRecycle(true);
		supplyRoomConfig.setTimingSignInvoiceTime(240);
		supplyRoomConfig.setSequence(0);
		supplyRoomConfig.setInvoiceOrigin(SupplyRoomConfig.INVOICE_ORIGIN_RECYCLING);
		supplyRoomConfig.setDiposablePriceFluctuation(DIPOSABLEGOODS_PRICE_F);
		supplyRoomConfig.setDptCodeOfForeignTousse(Constants.ORG_UNIT_CODE_OR);//新增加的属性
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig);

		SupplyRoomConfig supplyRoomConfig1 = new SupplyRoomConfig();
		supplyRoomConfig1.setOrgUnitCoding(Constants.ORG_UNIT_CODE_CSSD);
		supplyRoomConfig1.setOrgUnitName(Constants.ORG_UNIT_NAME_CSSD);
		supplyRoomConfig1.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_1);
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig1);

		SupplyRoomConfig supplyRoomConfig2 = new SupplyRoomConfig();
		supplyRoomConfig2.setOrgUnitCoding(Constants.ORG_UNIT_CODE_OR);
		supplyRoomConfig2.setOrgUnitName(Constants.ORG_UNIT_NAME_OR);
		supplyRoomConfig2.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_2);
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig2);
		
		SupplyRoomConfig supplyRoomConfig30 = new SupplyRoomConfig();
		supplyRoomConfig30.setOrgUnitCoding("testNeike");
		supplyRoomConfig30.setOrgUnitName("测试内科");
		supplyRoomConfig30.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_3);
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig30);

		SupplyRoomConfig supplyRoomConfig31 = new SupplyRoomConfig();
		supplyRoomConfig31.setOrgUnitCoding("testNeike");
		supplyRoomConfig31.setOrgUnitName("测试内科");
		supplyRoomConfig31.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_4);
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig31);
		
		SupplyRoomConfig supplyRoomConfig40 = new SupplyRoomConfig();
		supplyRoomConfig40.setOrgUnitCoding("testWaike");
		supplyRoomConfig40.setOrgUnitName("测试外科");
		supplyRoomConfig40.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_3);
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig40);

		SupplyRoomConfig supplyRoomConfig41 = new SupplyRoomConfig();
		supplyRoomConfig41.setOrgUnitCoding("testWaike");
		supplyRoomConfig41.setOrgUnitName("测试外科");
		supplyRoomConfig41.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_4);
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig41);
		
		//初始化仓库(测试一级供应室配置两个仓库;其它测试科室(二级供应室与临床科室各配置一个仓库))
		WareHouse wareHouse1 = new WareHouse();
		wareHouse1.setCreatedUserId(1l);
		wareHouse1.setCreatedUserName("admin");
		wareHouse1.setCreateTime(new Date());
		wareHouse1.setName("测试供应室仓库1");
		wareHouse1.setOrgUnitCode(Constants.ORG_UNIT_CODE_CSSD);
		wareHouse1.setOrgUnitName(Constants.ORG_UNIT_NAME_CSSD);
		wareHouse1.setBarcode("010009001");
		wareHouse1.setType(BarcodeDevice.BARCODE_TYPE_WAREHOUSE);
		wareHouse1.setSequence(1L);
		objectDao.save(wareHouse1);
		
		WareHouse wareHouse2 = new WareHouse();
		wareHouse2.setCreatedUserId(1l);
		wareHouse2.setCreatedUserName("admin");
		wareHouse2.setCreateTime(new Date());
		wareHouse2.setName("测试手术室仓库1");
		wareHouse2.setOrgUnitCode(Constants.ORG_UNIT_CODE_OR);
		wareHouse2.setOrgUnitName(Constants.ORG_UNIT_NAME_OR);
		wareHouse2.setBarcode("010009002");
		wareHouse2.setType(BarcodeDevice.BARCODE_TYPE_WAREHOUSE);
		wareHouse2.setSequence(1L);
		objectDao.save(wareHouse2);
		
		WareHouse wareHouse3 = new WareHouse();
		wareHouse3.setCreatedUserId(1l);
		wareHouse3.setCreatedUserName("admin");
		wareHouse3.setCreateTime(new Date());
		wareHouse3.setName("测试内科仓库1");
		wareHouse3.setOrgUnitCode("testNeike");
		wareHouse3.setOrgUnitName("测试内科");
		wareHouse3.setBarcode("010009003");
		wareHouse3.setType(BarcodeDevice.BARCODE_TYPE_WAREHOUSE);
		wareHouse3.setSequence(1L);
		objectDao.save(wareHouse3);
		
		WareHouse wareHouse4 = new WareHouse();
		wareHouse4.setCreatedUserId(1l);
		wareHouse4.setCreatedUserName("admin");
		wareHouse4.setCreateTime(new Date());
		wareHouse4.setName("测试外科仓库1");
		wareHouse4.setOrgUnitCode("testWaike");
		wareHouse4.setOrgUnitName("测试外科");
		wareHouse4.setBarcode("010009004");
		wareHouse4.setType(BarcodeDevice.BARCODE_TYPE_WAREHOUSE);
		wareHouse4.setSequence(1L);
		objectDao.save(wareHouse4);
		
		Container container1 = new Container();
		container1.setBarcode("019000001");
		container1.setContainerName("清洗筐116");
		container1.setPurpose(Container.CONTAINER_PURPOSE_CLEAN_BASKET);
		container1.setContainerType(Container.CONTAINERTYPE_BASKET);
		container1.setStatus(Container.CONTAINER_STATUS_FREE);
		container1.setType(BarcodeDevice.BARCODE_TYPE_CONTAINER);
		containerManager.saveOrUpdate(container1);
		
		Container container2 = new Container();
		container2.setBarcode("019000002");
		container2.setContainerName("清洗筐117");
		container2.setPurpose(Container.CONTAINER_PURPOSE_CLEAN_BASKET);
		container2.setContainerType(Container.CONTAINERTYPE_BASKET);
		container2.setStatus(Container.CONTAINER_STATUS_FREE);
		container2.setType(BarcodeDevice.BARCODE_TYPE_CONTAINER);
		containerManager.saveOrUpdate(container2);
		
		Container container3 = new Container();
		container3.setBarcode("019000003");
		container3.setContainerName("清洗筐118");
		container3.setPurpose(Container.CONTAINER_PURPOSE_CLEAN_BASKET);
		container3.setContainerType(Container.CONTAINERTYPE_BASKET);
		container3.setStatus(Container.CONTAINER_STATUS_FREE);
		container3.setType(BarcodeDevice.BARCODE_TYPE_CONTAINER);
		containerManager.saveOrUpdate(container3);
		
		Container container4 = new Container();
		container4.setBarcode("019000004");
		container4.setContainerName("清洗筐119");
		container4.setPurpose(Container.CONTAINER_PURPOSE_CLEAN_BASKET);
		container4.setContainerType(Container.CONTAINERTYPE_BASKET);
		container4.setStatus(Container.CONTAINER_STATUS_FREE);
		container4.setType(BarcodeDevice.BARCODE_TYPE_CONTAINER);
		containerManager.saveOrUpdate(container4);
		
		Container container5 = new Container();
		container5.setBarcode("018000001");
		container5.setContainerName("灭菌筐01");
		container5.setPurpose(Container.CONTAINER_PURPOSE_DISINFECTION);
		container5.setContainerType(Container.CONTAINERTYPE_BASKET);
		container5.setStatus(Container.CONTAINER_STATUS_FREE);
		container5.setType(BarcodeDevice.BARCODE_TYPE_CONTAINER);
		containerManager.saveOrUpdate(container5);
		
		Container container6 = new Container();
		container6.setBarcode("018000002");
		container6.setContainerName("灭菌筐02");
		container6.setPurpose(Container.CONTAINER_PURPOSE_DISINFECTION);
		container6.setContainerType(Container.CONTAINERTYPE_BASKET);
		container6.setStatus(Container.CONTAINER_STATUS_FREE);
		container6.setType(BarcodeDevice.BARCODE_TYPE_CONTAINER);
		containerManager.saveOrUpdate(container6);
		
		containerManager.createVirtualContainer(999 , null);
		

		// 灭菌炉(属于供应室)
		Sterilizer sterilizer1 = new Sterilizer();
		sterilizer1.setName("1号高温蒸汽灭菌炉");
		sterilizer1.setBarcode(serialNumManager.getSerialNumberStr("条码"));
		
		OrgUnit cssdDept = thTreeNodeManager.getOrgUnitByName(Constants.ORG_UNIT_NAME_CSSD, false);
		assertNotNull(cssdDept);
		
		sterilizer1.setDepartment(cssdDept.getName());
		sterilizer1.setOrgUnitCoding(cssdDept.getOrgUnitCoding());
		
		objectDao.save(sterilizer1);
		

		// 灭菌炉(属于二级供应室--手术室)
		Sterilizer sterilizer2 = new Sterilizer();
		sterilizer2.setName("6号高温蒸汽灭菌炉");
		sterilizer2.setBarcode(serialNumManager.getSerialNumberStr("条码"));
		
		OrgUnit orDept = thTreeNodeManager.getOrgUnitByName(Constants.ORG_UNIT_NAME_OR, false);
		assertNotNull(orDept);
		
		sterilizer2.setDepartment(orDept.getName());
		sterilizer2.setOrgUnitCoding(orDept.getOrgUnitCoding());
		
		objectDao.save(sterilizer2);
		
	}
	
	/**
	 * 初始化供应室服务临床科室配置
	 * 设置所有一二级供应室针对器械包与一次性物品服务所有申请科室与结算科室
	 * 
	 */
	private void initCssdServiceDepts(){
		//一级供应室服务两个临床科室(器械包、消毒物品)
		CssdServiceDepts cssdServiceDepts = new CssdServiceDepts();
		cssdServiceDepts.setClinicOrgUnitCode("testNeike");
		cssdServiceDepts.setClinicOrgUnitName("测试内科");
		cssdServiceDepts.setCssdOrgUnitCode(Constants.ORG_UNIT_CODE_CSSD);
		cssdServiceDepts.setCssdOrgUnitName(Constants.ORG_UNIT_NAME_CSSD);
		cssdServiceDepts.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		objectDao.save(cssdServiceDepts);
		
		cssdServiceDepts = new CssdServiceDepts();
		cssdServiceDepts.setClinicOrgUnitCode("testNeike");
		cssdServiceDepts.setClinicOrgUnitName("测试内科");
		cssdServiceDepts.setCssdOrgUnitCode(Constants.ORG_UNIT_CODE_CSSD);
		cssdServiceDepts.setCssdOrgUnitName(Constants.ORG_UNIT_NAME_CSSD);
		cssdServiceDepts.setTousseType(DisposableGoods.TYPE_NAME);
		objectDao.save(cssdServiceDepts);
		
		cssdServiceDepts = new CssdServiceDepts();
		cssdServiceDepts.setClinicOrgUnitCode("testWaike");
		cssdServiceDepts.setClinicOrgUnitName("测试外科");
		cssdServiceDepts.setCssdOrgUnitCode(Constants.ORG_UNIT_CODE_CSSD);
		cssdServiceDepts.setCssdOrgUnitName(Constants.ORG_UNIT_NAME_CSSD);
		cssdServiceDepts.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		objectDao.save(cssdServiceDepts);
		
		cssdServiceDepts = new CssdServiceDepts();
		cssdServiceDepts.setClinicOrgUnitCode("testWaike");
		cssdServiceDepts.setClinicOrgUnitName("测试外科");
		cssdServiceDepts.setCssdOrgUnitCode(Constants.ORG_UNIT_CODE_CSSD);
		cssdServiceDepts.setCssdOrgUnitName(Constants.ORG_UNIT_NAME_CSSD);
		cssdServiceDepts.setTousseType(DisposableGoods.TYPE_NAME);
		objectDao.save(cssdServiceDepts);
		
		//二级供应室服务两个临床科室(器械包、消毒物品)
		cssdServiceDepts = new CssdServiceDepts();
		cssdServiceDepts.setClinicOrgUnitCode("testNeike");
		cssdServiceDepts.setClinicOrgUnitName("测试内科");
		cssdServiceDepts.setCssdOrgUnitCode(Constants.ORG_UNIT_CODE_OR);
		cssdServiceDepts.setCssdOrgUnitName(Constants.ORG_UNIT_NAME_OR);
		cssdServiceDepts.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		objectDao.save(cssdServiceDepts);
		
		cssdServiceDepts = new CssdServiceDepts();
		cssdServiceDepts.setClinicOrgUnitCode("testNeike");
		cssdServiceDepts.setClinicOrgUnitName("测试内科");
		cssdServiceDepts.setCssdOrgUnitCode(Constants.ORG_UNIT_CODE_OR);
		cssdServiceDepts.setCssdOrgUnitName(Constants.ORG_UNIT_NAME_OR);
		cssdServiceDepts.setTousseType(DisposableGoods.TYPE_NAME);
		objectDao.save(cssdServiceDepts);
		
		cssdServiceDepts = new CssdServiceDepts();
		cssdServiceDepts.setClinicOrgUnitCode("testWaike");
		cssdServiceDepts.setClinicOrgUnitName("测试外科");
		cssdServiceDepts.setCssdOrgUnitCode(Constants.ORG_UNIT_CODE_OR);
		cssdServiceDepts.setCssdOrgUnitName(Constants.ORG_UNIT_NAME_OR);
		cssdServiceDepts.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		objectDao.save(cssdServiceDepts);
		
		cssdServiceDepts = new CssdServiceDepts();
		cssdServiceDepts.setClinicOrgUnitCode("testWaike");
		cssdServiceDepts.setClinicOrgUnitName("测试外科");
		cssdServiceDepts.setCssdOrgUnitCode(Constants.ORG_UNIT_CODE_OR);
		cssdServiceDepts.setCssdOrgUnitName(Constants.ORG_UNIT_NAME_OR);
		cssdServiceDepts.setTousseType(DisposableGoods.TYPE_NAME);
		objectDao.save(cssdServiceDepts);

	}

	/**
	 * 初始化序列号类,否则会报错
	 */
	protected void initSerialNum() {
		runWithTransNewManager.runWith_TRANS_NEW(new RunWithTransNewTask() {
			@Override
			public void runTask() {
				SerialNum serialNum1 = new SerialNum();
				serialNum1.setType("申请单");
				serialNum1.setSerialNumber("10000");
				serialNum1.setIsRollback("否");
				serialNum1.setIsEveryDayClean("是");
				serialNum1.setDefaultSerialNum("YYMMDD@@@");

				SerialNum serialNum2 = new SerialNum();
				serialNum2.setType("发货单");
				serialNum2.setSerialNumber("10000");
				serialNum2.setIsRollback("否");
				serialNum2.setIsEveryDayClean("是");
				serialNum2.setDefaultSerialNum("YYMMDD@@@");

				SerialNum serialNum3 = new SerialNum();
				serialNum3.setType("条码");
				serialNum3.setSerialNumber("10000");
				serialNum3.setIsRollback("是");
				serialNum3.setIsEveryDayClean("否");
				serialNum3.setDefaultSerialNum("01@@@@@@@");

				SerialNum serialNum4 = new SerialNum();
				serialNum4.setType("入库单");
				serialNum4.setSerialNumber("10000");
				serialNum4.setIsRollback("否");
				serialNum4.setIsEveryDayClean("是");
				serialNum4.setDefaultSerialNum("YYMMDD@@@");
				
				SerialNum serialNum5 = new SerialNum();
				serialNum5.setType("清洗消毒");
				serialNum5.setSerialNumber("10000");
				serialNum5.setIsRollback("否");
				serialNum5.setIsEveryDayClean("是");
				serialNum5.setDefaultSerialNum("YYMMDD@@@");

				objectDao.saveOrUpdate(serialNum1);
				objectDao.saveOrUpdate(serialNum2);
				objectDao.saveOrUpdate(serialNum3);
				objectDao.saveOrUpdate(serialNum4);
				objectDao.saveOrUpdate(serialNum5);
			}
		});
	}

	/**
	 * 初始化器械材料及包定义(11个)
	 * 器械材料：
	 * 			【Test镊子】、【Test钳子】、【Test棉球】、【Test胆道探条】
	 * 			【Test静脉拉钩】（1对）、【Test取石钳】（1对）、【Test拉钩】
	 * 器械包：
	 * 			Test开胸包（术科组）
	 * 				【Test镊子】 * 2
	 * 				【Test钳子】 * 5
	 * 			Test开颅包（术科组）
	 * 				【Test钳子】 * 3
	 * 				【Test棉球】 * 4
	 * 			Test开口包（术科组）
	 * 				【Test镊子】 * 1
	 * 				【Test棉球】 * 2
	 * 			Test穿刺包（术科组）
	 * 				【Test钳子】 * 5
	 * 				【Test棉球】 * 4
	 * 			TestOR胆加仪（器械组）【testOR】处理科室
	 * 				【Test胆道探条】 * 7
	 * 				【Test静脉拉钩】（1对） * 2
	 * 			TestOR甲加仪（半年期）（器械组）【testOR】处理科室
	 * 				【Test胆道探条】 * 7
	 * 				【Test静脉拉钩】（1对） * 3
	 * 				【Test取石钳】（1对） * 4
	 * 				【Test拉钩】 * 1
	 */
	public void initMaterialAndTousseData() {
		makeActiveUser("admin");
		
		// 器械包分组设置
		TousseGroup group1 = new TousseGroup();
		group1.setTousseGroupName("专科批");
		objectDao.save(group1);
		
		TousseGroup group2 = new TousseGroup();
		group2.setTousseGroupName("普通批");
		
		objectDao.save(group2);

		MaterialDefinition materialDefinition1 = new MaterialDefinition();
		materialDefinition1.setName("Test镊子");
		materialDefinition1.setType("金属类");
		materialDefinition1.setSpelling("TEATNZ");
		materialDefinition1.setCost(2.4);
		materialDefinitionManager.saveOrUpdate(materialDefinition1);

		MaterialDefinition materialDefinition2 = new MaterialDefinition();
		materialDefinition2.setName("Test钳子");
		materialDefinition2.setType("金属类");
		materialDefinition2.setSpelling("TESTQZ");
		materialDefinition2.setIntoBasketMaxAmount(60);
		materialDefinitionManager.saveOrUpdate(materialDefinition2);

		MaterialDefinition materialDefinition3 = new MaterialDefinition();
		materialDefinition3.setName("Test棉球");
		materialDefinition3.setType("布类");
		materialDefinition3.setSpelling("TESTMQ");
		materialDefinition3.setIntoBasketMaxAmount(60);
		materialDefinitionManager.saveOrUpdate(materialDefinition3);
		
		MaterialDefinition materialDefinition4 = new MaterialDefinition();
		materialDefinition4.setName("Test胆道探条");
		materialDefinition4.setType("布类");
		materialDefinition4.setSpelling("DDTT");
		materialDefinition4.setIntoBasketMaxAmount(20);
		materialDefinitionManager.saveOrUpdate(materialDefinition4);
		
		MaterialDefinition materialDefinition5 = new MaterialDefinition();
		materialDefinition5.setName("Test静脉拉钩");
		materialDefinition5.setSpecification("1对");
		materialDefinition5.setType("金属类");
		materialDefinition5.setSpelling("JMLG");
		materialDefinitionManager.saveOrUpdate(materialDefinition5);
		
		MaterialDefinition materialDefinition6 = new MaterialDefinition();
		materialDefinition6.setName("Test取石钳");
		materialDefinition6.setSpecification("1对");
		materialDefinition6.setType("金属类");
		materialDefinition6.setSpelling("QSQ");
		materialDefinitionManager.saveOrUpdate(materialDefinition6);
		
		MaterialDefinition materialDefinition7 = new MaterialDefinition();
		materialDefinition7.setName("Test拉钩");
		materialDefinition7.setType("金属类");
		materialDefinition7.setSpelling("LG");
		materialDefinitionManager.saveOrUpdate(materialDefinition7);
		
		MaterialDefinition materialDefinition8 = new MaterialDefinition();
		materialDefinition8.setName("棉布");
		materialDefinition8.setType("布类");
		materialDefinition8.setSpelling("TEATNZ");
		materialDefinitionManager.saveOrUpdate(materialDefinition8);
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~下面是器械包定义~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
		TousseDefinition tousseDefinition1 = new TousseDefinition();
		tousseDefinition1.setName("Test开胸包");
		tousseDefinition1.setTaskGroup("术科组");
		tousseDefinition1.setTousseGroupID(group1.getId());
		tousseDefinition1.setTousseGroupName("专科批");
		tousseDefinition1.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition1.setPrice(10.0);
		tousseDefinition1.setSpelling("testkxb");
		tousseDefinition1.setWbCode("testgeq");
		tousseDefinition1.setExternalCode("1001GYT1AA");
		tousseDefinition1.setIntoBasketMaxAmount(5);
		//是否整包清洗
		tousseDefinition1.setIsCleanedEntirely(TousseDefinition.STR_YES);
		//是否追朔
		tousseDefinition1.setIsTraceable(TousseDefinition.STR_YES);
		tousseDefinition1.setIsCustomPacking(TousseDefinition.STR_YES);
		tousseDefinition1.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		// 自动入筐的数量
		tousseDefinition1.setPackingAmountPerVirtualBasket(5);
		
		MaterialInstance materialInstance1 = new MaterialInstance();
		materialInstance1.setTousse(tousseDefinition1);
		materialInstance1.setMaterialDefinition(materialDefinition1);
		materialInstance1.setCount(2);
		materialInstance1.setMaterialName(materialDefinition1.getName());

		MaterialInstance materialInstance2 = new MaterialInstance();
		materialInstance2.setTousse(tousseDefinition1);
		materialInstance2.setMaterialDefinition(materialDefinition2);
		materialInstance2.setCount(5);
		materialInstance2.setMaterialName(materialDefinition2.getName());
		
		tousseDefinition1
				.setMaterialInstances(new ArrayList<MaterialInstance>());
		tousseDefinition1.getMaterialInstances().add(materialInstance1);
		tousseDefinition1.getMaterialInstances().add(materialInstance2);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition1);
		
		// 器械包实例？
//		TousseInstance tousseInstance = new TousseInstance();
//		tousseInstance.setUnTraceableTousse(true);
//		tousseInstance.setTousseName(tousseDefinition1.getName());
//		tousseInstance.setBarcode("020020379");
//		tousseInstance.setTousseDefinition(tousseDefinition1);
//		tousseInstance.setStatus(TousseInstance.STATUS_DISINFECTED);
//		tousseInstance.setType(BarcodeDevice.BARCODE_TYPE_PACKAGE);
//		tousseInstanceManager.saveOrUpdate(tousseInstance);
		

		TousseDefinition tousseDefinition2 = new TousseDefinition();
		tousseDefinition2.setName("Test开颅包");
		tousseDefinition2.setTaskGroup("术科组");
		tousseDefinition2.setTousseGroupID(group1.getId());
		tousseDefinition2.setTousseGroupName("专科批");
		tousseDefinition2.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition2.setPrice(50.0);
		tousseDefinition2.setSpelling("testklb");
		tousseDefinition2.setWbCode("testghq");
		tousseDefinition2.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tousseDefinition2.setExternalCode("1002GYT2AA");
		//是否整包清洗
		tousseDefinition2.setIsCleanedEntirely(TousseDefinition.STR_NO);
		tousseDefinition2.setIsCustomPacking(TousseDefinition.STR_YES);
		
		//是否追朔
		tousseDefinition2.setIsTraceable(TousseDefinition.STR_YES);
				
		MaterialInstance materialInstance3 = new MaterialInstance();
		materialInstance3.setMaterialDefinition(materialDefinition2);
		materialInstance3.setCount(3);
		materialInstance3.setTousse(tousseDefinition2);
		materialInstance3.setMaterialName(materialDefinition2.getName());

		MaterialInstance materialInstance4 = new MaterialInstance();
		materialInstance4.setMaterialDefinition(materialDefinition3);
		materialInstance4.setCount(4);
		materialInstance4.setTousse(tousseDefinition2);
		
		MaterialInstance materialInstance55 = new MaterialInstance();
		materialInstance55.setMaterialDefinition(materialDefinition4);
		materialInstance55.setCount(2);
		materialInstance55.setTousse(tousseDefinition2);
		
		MaterialInstance materialInstance66 = new MaterialInstance();
		materialInstance66.setMaterialDefinition(materialDefinition5);
		materialInstance66.setCount(5);
		materialInstance66.setTousse(tousseDefinition2);

		tousseDefinition2.setMaterialInstances(new ArrayList<MaterialInstance>());
		tousseDefinition2.getMaterialInstances().add(materialInstance3);
		tousseDefinition2.getMaterialInstances().add(materialInstance4);
		tousseDefinition2.getMaterialInstances().add(materialInstance55);
		tousseDefinition2.getMaterialInstances().add(materialInstance66);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition2);

		
		TousseDefinition tousseDefinition3 = new TousseDefinition();
		tousseDefinition3.setName("Test开口包");
		tousseDefinition3.setTaskGroup("术科组");
		tousseDefinition3.setTousseGroupID(group1.getId());
		tousseDefinition3.setTousseGroupName("专科批");
		tousseDefinition3.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition3.setPrice(8.5);
		tousseDefinition3.setSpelling("testkkb");
		tousseDefinition3.setWbCode("testgkq");
		tousseDefinition3.setExternalCode("1003GYT3AA");
		tousseDefinition3.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		// 自动入筐的数量
		tousseDefinition3.setPackingAmountPerVirtualBasket(20);
		
		//是否整包清洗
		tousseDefinition3.setIsCleanedEntirely(TousseDefinition.STR_YES);
		tousseDefinition3.setIsCustomPacking(TousseDefinition.STR_YES);
		//是否追朔
		tousseDefinition3.setIsTraceable(TousseDefinition.STR_YES);
		
		//是否转换申请单设置为是(便于使用记录进行测试)
		tousseDefinition3.setIsConvertApplyGoods(TousseDefinition.STR_YES);
				
		MaterialInstance materialInstance5 = new MaterialInstance();
		materialInstance5.setMaterialDefinition(materialDefinition1);
		materialInstance5.setCount(1);

		MaterialInstance materialInstance6 = new MaterialInstance();
		materialInstance6.setMaterialDefinition(materialDefinition3);
		materialInstance6.setCount(2);

		tousseDefinition3.setMaterialInstances(new ArrayList<MaterialInstance>());
		tousseDefinition3.getMaterialInstances().add(materialInstance5);
		tousseDefinition3.getMaterialInstances().add(materialInstance6);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition3);

		TousseDefinition tousseDefinition4 = new TousseDefinition();
		tousseDefinition4.setName("Test穿刺包");
		tousseDefinition4.setTaskGroup("术科组");
		tousseDefinition4.setTousseGroupID(group1.getId());
		tousseDefinition4.setTousseGroupName("专科批");
		tousseDefinition4.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition4.setPrice(13.0);
		tousseDefinition4.setSpelling("testccb");
		tousseDefinition4.setWbCode("testpgq");
		tousseDefinition4.setExternalCode("9001GYT4AA");
		tousseDefinition4.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		// 自动入筐的数量
		tousseDefinition4.setPackingAmountPerVirtualBasket(33);
		
		//是否整包清洗
		tousseDefinition4.setIsCleanedEntirely(TousseDefinition.STR_NO);
		tousseDefinition4.setIsCustomPacking(TousseDefinition.STR_NO);
		
		//是否转换申请单设置为否(便于使用记录进行测试)
		tousseDefinition4.setIsConvertApplyGoods(TousseDefinition.STR_NO);
		
		MaterialInstance materialInstance7 = new MaterialInstance();
		materialInstance7.setMaterialDefinition(materialDefinition2);
		materialInstance7.setCount(5);

		MaterialInstance materialInstance8 = new MaterialInstance();
		materialInstance8.setMaterialDefinition(materialDefinition3);
		materialInstance8.setCount(4);

		tousseDefinition4
				.setMaterialInstances(new ArrayList<MaterialInstance>());
		tousseDefinition4.getMaterialInstances().add(materialInstance7);
		tousseDefinition4.getMaterialInstances().add(materialInstance8);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition4);
		
		TousseDefinition tousseDefinition5 = new TousseDefinition();
		tousseDefinition5.setName("TestOR胆加仪");
		tousseDefinition5.setTaskGroup("器械组");
		tousseDefinition5.setTousseGroupID(group2.getId());
		tousseDefinition5.setTousseGroupName("普通批");
		tousseDefinition5.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition5.setSpelling("testordjy");
		tousseDefinition5.setWbCode("testorelw");
		tousseDefinition5.setExternalCode("9002GYT20AA");
		tousseDefinition5.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		
		// 自动入筐的数量设置为0，表示不启用自动入筐功能
		tousseDefinition4.setPackingAmountPerVirtualBasket(0);
		
		//是否整包清洗
		tousseDefinition5.setIsCleanedEntirely(TousseDefinition.STR_YES);
		tousseDefinition5.setIsCustomPacking(TousseDefinition.STR_NO);
		
		MaterialInstance materialInstance9 = new MaterialInstance();
		materialInstance9.setMaterialDefinition(materialDefinition4);
		materialInstance9.setCount(7);

		MaterialInstance materialInstance10 = new MaterialInstance();
		materialInstance8.setMaterialDefinition(materialDefinition5);
		materialInstance8.setCount(2);

		tousseDefinition5
				.setMaterialInstances(new ArrayList<MaterialInstance>());
		tousseDefinition5.getMaterialInstances().add(materialInstance9);
		tousseDefinition5.getMaterialInstances().add(materialInstance10);
		tousseDefinition5.setHandlerDepartCode(Constants.ORG_UNIT_CODE_OR);
		tousseDefinition5.setHandlerDepartName(Constants.ORG_UNIT_NAME_OR);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition5);
		
		TousseDefinition tousseDefinition6 = new TousseDefinition();
		tousseDefinition6.setName("TestOR甲加仪（半年期）");
		tousseDefinition6.setTaskGroup("器械组");
		tousseDefinition6.setTousseGroupID(group2.getId());
		tousseDefinition6.setTousseGroupName("普通批");
		tousseDefinition6.setExternalCode("EX001");
		tousseDefinition6.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);

		//是否整包清洗
		tousseDefinition6.setIsCleanedEntirely(TousseDefinition.STR_YES);
		tousseDefinition6.setIsCustomPacking(TousseDefinition.STR_NO);

		MaterialInstance materialInstance11 = new MaterialInstance();
		materialInstance11.setMaterialDefinition(materialDefinition4);
		materialInstance11.setCount(7);

		MaterialInstance materialInstance12 = new MaterialInstance();
		materialInstance12.setMaterialDefinition(materialDefinition5);
		materialInstance12.setCount(3);
		
		MaterialInstance materialInstance13 = new MaterialInstance();
		materialInstance13.setMaterialDefinition(materialDefinition6);
		materialInstance13.setCount(4);
		
		MaterialInstance materialInstance14 = new MaterialInstance();
		materialInstance14.setMaterialDefinition(materialDefinition7);
		materialInstance14.setCount(1);

		tousseDefinition6
				.setMaterialInstances(new ArrayList<MaterialInstance>());
		tousseDefinition6.getMaterialInstances().add(materialInstance11);
		tousseDefinition6.getMaterialInstances().add(materialInstance12);
		tousseDefinition6.getMaterialInstances().add(materialInstance13);
		tousseDefinition6.getMaterialInstances().add(materialInstance14);
		tousseDefinition6.setHandlerDepartCode(Constants.ORG_UNIT_CODE_OR);
		tousseDefinition6.setHandlerDepartName(Constants.ORG_UNIT_NAME_OR);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition6);
		
		TousseDefinition tousseDefinition7 = new TousseDefinition();
		tousseDefinition7.setName("Test治疗巾");
		tousseDefinition7.setTaskGroup("术科组");
		tousseDefinition7.setTousseGroupID(group2.getId());
		tousseDefinition7.setTousseGroupName("普通批");
		tousseDefinition7.setPrice(2.0);
		tousseDefinition7.setTousseType(TousseDefinition.PACKAGE_TYPE_DRESSING);
		tousseDefinition7.setSpelling("testzlj");
		tousseDefinition7.setWbCode("testzlj");
		tousseDefinition7.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tousseDefinition7.setExternalCode("1009");
		//是否整包清洗
		tousseDefinition7.setIsCleanedEntirely(TousseDefinition.STR_NO);
		tousseDefinition7.setIsCustomPacking(TousseDefinition.STR_YES);
		
		//是否追朔
		tousseDefinition7.setIsTraceable(TousseDefinition.STR_NO);
		
		MaterialInstance materialInstance100 = new MaterialInstance();
		materialInstance100.setMaterialDefinition(materialDefinition2);
		materialInstance100.setCount(7);

		tousseDefinition7.setMaterialInstances(new ArrayList<MaterialInstance>());
		tousseDefinition7.getMaterialInstances().add(materialInstance100);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition7);
		
		MaterialInstance materialInstance15 = new MaterialInstance();
		materialInstance15.setCount(1);
//		materialInstance15.setIncludeImplant("否");
		materialInstance15.setMaterialDefinition(materialDefinition8);
		materialInstance15.setMaterialName("棉布");
		
		
		TousseDefinition tousseDefinition8 = new TousseDefinition();
		tousseDefinition8.setTousseGroupID(group2.getId());
		tousseDefinition8.setTousseGroupName("普通批");
		tousseDefinition8.setAssetsBelong(Constants.ORG_UNIT_NAME_DISINFECT);
		tousseDefinition8.setHandlerDepartCode(Constants.ORG_UNIT_NAME_DISINFECT);
		tousseDefinition8.setHandlerDepartCode(Constants.ORG_UNIT_CODE_DISINFECT);
		tousseDefinition8.setIncludeImplant(0);
		tousseDefinition8.setIsCleanedEntirely("是");
		tousseDefinition8.setIsCustomPacking("否");
		tousseDefinition8.setIsRecycling("是");
		tousseDefinition8.setIsTraceable("是");
		tousseDefinition8.getMaterialInstances().add(materialInstance15);
		tousseDefinition8.setName("4#压力蒸汽灭菌包");
		tousseDefinition8.setTaskGroup("灭菌组");
		tousseDefinition8.setTousseType(TousseDefinition.PACKAGE_TYPE_FOREIGNPROXY);
		materialInstance15.setTousse(tousseDefinition8);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition8);
		
		TousseDefinition tousseDefinition9 = new TousseDefinition();
		//普通器械包
		tousseDefinition9.setName("Test缝合包");
		tousseDefinition9.setIsCleanedEntirely("是");
		tousseDefinition9.setTaskGroup("器械组");
		tousseDefinition9.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition9.setHandlerDepartName(Constants.ORG_UNIT_NAME_DISINFECT);
		tousseDefinition9.setHandlerDepartCode(Constants.ORG_UNIT_CODE_DISINFECT);

		tousseDefinition9.getMaterialInstances().add(materialInstance1);
		tousseDefinition9.getMaterialInstances().add(materialInstance2);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition9);
		
		//新增加清创包与宫碘包的定义以支撑各个测试用的用例数据
		TousseDefinition tousseDefinition10 = new TousseDefinition();
		//普通器械包
		tousseDefinition10.setName("Test清创包");
		tousseDefinition10.setIsCleanedEntirely("是");
		tousseDefinition10.setTaskGroup("器械组");
		tousseDefinition10.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition10.setHandlerDepartName(Constants.ORG_UNIT_NAME_DISINFECT);
		tousseDefinition10.setHandlerDepartCode(Constants.ORG_UNIT_CODE_DISINFECT);

		tousseDefinition10.getMaterialInstances().add(materialInstance1);
		tousseDefinition10.getMaterialInstances().add(materialInstance2);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition10);
		
		TousseDefinition tousseDefinition11 = new TousseDefinition();
		//普通器械包
		tousseDefinition11.setName("Test宫碘包");
		tousseDefinition11.setIsCleanedEntirely("是");
		tousseDefinition11.setTaskGroup("器械组");
		tousseDefinition11.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition11.setHandlerDepartName(Constants.ORG_UNIT_NAME_DISINFECT);
		tousseDefinition11.setHandlerDepartCode(Constants.ORG_UNIT_CODE_DISINFECT);

		tousseDefinition11.getMaterialInstances().add(materialInstance1);
		tousseDefinition11.getMaterialInstances().add(materialInstance2);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition11);
		
		List<TousseDefinition> tList = tousseDefinitionManager.findTousseDefinitionList();
		assertNotNull(tList);
		assertEquals(tList.size(), 11);

		
	}
	/*
	 * 初始化所有器械包定义
	 */
	protected void initBasicData(){
		//消毒物品器械包定义(2个)
		createDisinfectionTousseDefinition();
		//一次性物品定义
		createDiposableGoods();
		//外部代理灭菌器械包定义(1个)
		createForeignProxyTousseDefinition();
		//外来器械包定义(1个)
		createForeignTousseDefinition();
		//普通器械包定义(4个)
		createTousseDefinition();
	}
	
	/**
	 * 回收记录待回收物品
	 * @return
	 */
	public List<RecyclingItemVo> createRecyclingItemVos() {
		List<RecyclingItemVo> recyclingItemVos = new ArrayList<RecyclingItemVo>();
		RecyclingItemVo vo = new RecyclingItemVo();
		vo.setName("Test开胸包");
		vo.setRecycleAmount(5);
		RecyclingItemVo vo2 = new RecyclingItemVo();
		vo2.setName("Test开颅包");
		vo2.setRecycleAmount(5);
		RecyclingItemVo vo3 = new RecyclingItemVo();
		vo3.setName("Test开口包");
		vo3.setRecycleAmount(2);
		RecyclingItemVo vo4 = new RecyclingItemVo();
		vo4.setName("Test穿刺包");
		vo4.setRecycleAmount(2);
		recyclingItemVos.add(vo);
		recyclingItemVos.add(vo2);
		recyclingItemVos.add(vo3);
		recyclingItemVos.add(vo4);
		return recyclingItemVos;
	}
	
	/**
	 * 生成待回收篮筐数据
	 * @return
	 */
	public List<RecyclingBasketVo> getRecyclingBasketVos() {
		List<RecyclingBasketVo> recyclingBasketVos = new ArrayList<RecyclingBasketVo>();
		RecyclingBasketVo recyclingBasketVo = new RecyclingBasketVo();
		Container container = containerManager.getContainerByBarcode("019000001");
		recyclingBasketVo.setId("0");
		recyclingBasketVo.setBasketBarcode(container.getBarcode());
		recyclingBasketVo.setBasketName(container.getContainerName());
		
		RecyclingClassifiedItemVo classifiedItemVo1 = new RecyclingClassifiedItemVo();
		classifiedItemVo1.setId("0");
		classifiedItemVo1.setAmount(5);
		classifiedItemVo1.setName("Test开胸包");
		classifiedItemVo1.setType("器械包");
		
		RecyclingClassifiedItemVo classifiedItemVo2 = new RecyclingClassifiedItemVo();
		classifiedItemVo2.setId("0");
		classifiedItemVo2.setAmount(5);
		classifiedItemVo2.setName("Test开颅包");
		classifiedItemVo2.setType("器械包");
		
		RecyclingClassifiedItemVo classifiedItemVo3 = new RecyclingClassifiedItemVo();
		classifiedItemVo3.setId("0");
		classifiedItemVo3.setAmount(2);
		classifiedItemVo3.setName("Test开口包");
		classifiedItemVo3.setType("器械包");
		
		RecyclingClassifiedItemVo classifiedItemVo4 = new RecyclingClassifiedItemVo();
		classifiedItemVo4.setId("0");
		classifiedItemVo4.setAmount(2);
		classifiedItemVo4.setName("Test穿刺包");
		classifiedItemVo4.setType("器械包");
		
		recyclingBasketVo.getClassifiedItems().add(classifiedItemVo1);
		recyclingBasketVo.getClassifiedItems().add(classifiedItemVo2);
		recyclingBasketVo.getClassifiedItems().add(classifiedItemVo3);
		recyclingBasketVo.getClassifiedItems().add(classifiedItemVo4);
		
		recyclingBasketVos.add(recyclingBasketVo);
		return recyclingBasketVos;
	}
	
	/**
	 * 创建通用器械包申请单和回收记录
	 * @return
	 */
	public RecyclingRecord createComboApplicationAndRecyclingRecord(){
		RecyclingApplication application = new RecyclingApplication();
		objectDao.saveOrUpdate(application);
		
		long appId = application.getId();
		
		TousseDefinition td_Test开胸包 = tousseDefinitionManager.getTousseDefinitionByName("Test开胸包");
		TousseDefinition td_止血带 = tousseDefinitionManager.getTousseDefinitionByNameForDisplay("止血带");
		
		TousseItem ti1 = new TousseItem();
		ti1.setTousseName("Test开胸包");
		ti1.setAmount(5);
		ti1.setRecyclingAmount(null);
		ti1.setSendOutAmount(0);
		ti1.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		ti1.setInvoicePlan(application);
		ti1.setTousseDefinitionId(td_Test开胸包.getId());

		TousseItem ti2 = new TousseItem();
		ti2.setTousseName("Test治疗巾");
		ti2.setAmount(10);
		ti2.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		ti2.setRecyclingAmount(0);
		ti2.setSendOutAmount(0);
		ti2.setInvoicePlan(application);
		
		TousseItem ti3 = new TousseItem();
		ti3.setTousseType(TousseItem.TYPE_DIPOSABLE_GOODS);
		ti3.setTousseName("注射器[5ML]");
		ti3.setAmount(100);
		ti3.setRecyclingAmount(0);
		ti3.setSendOutAmount(0);
		ti3.setInvoicePlan(application);

		TousseItem ti4 = new TousseItem();
		ti4.setTousseType(TousseDefinition.PACKAGE_TYPE_DISINFECTION);
		ti4.setTousseName("止血带");
		ti4.setInvoicePlanID(appId);
		ti4.setAmount(1);
		ti4.setRecyclingAmount(null);
		ti4.setSendOutAmount(0);
		ti4.setInvoicePlan(application);
		ti4.setTousseDefinitionId(td_止血带.getId());
		
		List<TousseItem> applicationItems = new ArrayList<TousseItem>();
		applicationItems.add(ti1);
		applicationItems.add(ti2);
		applicationItems.add(ti3);
		applicationItems.add(ti4);
		
		application.setRecyclingStatus(InvoicePlan.RECYCLINGSTATUS_AWAITRECYCLE);
		application.setDeliverStatus(InvoicePlan.DELIVERSTATUS_AWAITDELIVER);
		application.setCommittedStatus(true);
		application.setApplicationItems(applicationItems);
		application.setType(InvoicePlan.TYPE_COMBO_FORM);
		application.setIncludeRecyclingItems(InvoicePlan.SIGNED_TRUE);
		objectDao.saveOrUpdate(application);

		RecyclingRecord oldRecord1 = new RecyclingRecord();
		oldRecord1.setDepart("外科");
		oldRecord1.setRecyclingApplication(application);

		return oldRecord1;
	}
	
	/**
	 * 回收记录待回收物品
	 * @return
	 */
	public List<RecyclingItemVo> createComboRecyclingItems() {
		List<RecyclingItemVo> recyclingItems = new ArrayList<RecyclingItemVo>();
		RecyclingItemVo vo = new RecyclingItemVo();
		vo.setName("Test开胸包");
		vo.setRecycleAmount(5);
		RecyclingItemVo vo2 = new RecyclingItemVo();
		vo2.setName("止血带_20141016");
		vo2.setRecycleAmount(1);
		recyclingItems.add(vo);
		recyclingItems.add(vo2);
		return recyclingItems;
	}
	
	/**
	 * 生成待回收篮筐数据
	 * @return
	 */
	public List<RecyclingBasketVo> getComboRecyclingBasketVos() {
		List<RecyclingBasketVo> recyclingBaskets = new ArrayList<RecyclingBasketVo>();
		RecyclingBasketVo recyclingBasketVo = new RecyclingBasketVo();
		Container container = containerManager.getContainerByBarcode("019000001");
		recyclingBasketVo.setId("0");
		recyclingBasketVo.setBasketBarcode(container.getBarcode());
		recyclingBasketVo.setBasketName(container.getContainerName());
		
		RecyclingClassifiedItemVo classifiedItemVo1 = new RecyclingClassifiedItemVo();
		classifiedItemVo1.setId("0");
		classifiedItemVo1.setAmount(5);
		classifiedItemVo1.setName("Test开胸包");
		classifiedItemVo1.setType("器械包");
		
		RecyclingClassifiedItemVo classifiedItemVo2 = new RecyclingClassifiedItemVo();
		classifiedItemVo2.setId("0");
		classifiedItemVo2.setAmount(1);
		classifiedItemVo2.setName("止血带_20141016");
		classifiedItemVo2.setType("消毒物品");
		
		recyclingBasketVo.getClassifiedItems().add(classifiedItemVo1);
		recyclingBasketVo.getClassifiedItems().add(classifiedItemVo2);
		
		recyclingBaskets.add(recyclingBasketVo);
		return recyclingBaskets;
	}
	
	/**
	 * 创建申请单回收记录
	 * @return
	 */
	public RecyclingRecord createApplicationAndRecyclingRecordData(Map<String, Long> map) {
		RecyclingApplication application = new RecyclingApplication();
		TousseItem ti1 = new TousseItem();
		ti1.setTousseName("Test开胸包");
		ti1.setIsRecycling("是");
		ti1.setAmount(5);
		ti1.setRecyclingAmount(null);
		ti1.setSendOutAmount(0);
		ti1.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		ti1.setTousseDefinitionId(map.get("Test开胸包"));
		ti1.setInvoicePlan(application);

		TousseItem ti2 = new TousseItem();
		ti2.setTousseName("Test开颅包");
		ti2.setIsRecycling("是");
		ti2.setAmount(5);
		ti2.setRecyclingAmount(null);
		ti2.setSendOutAmount(0);
		ti2.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		ti2.setTousseDefinitionId(map.get("Test开颅包"));
		ti2.setInvoicePlan(application);

		TousseItem ti3 = new TousseItem();
		ti3.setTousseName("Test开口包");
		ti3.setIsRecycling("是");
		ti3.setAmount(5);
		ti3.setRecyclingAmount(null);
		ti3.setSendOutAmount(0);
		ti3.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		ti3.setTousseDefinitionId(map.get("Test开口包"));
		ti3.setInvoicePlan(application);

		TousseItem ti4 = new TousseItem();
		ti4.setTousseName("Test穿刺包");
		ti4.setAmount(5);
		ti4.setIsRecycling("是");
		ti4.setRecyclingAmount(null);
		ti4.setSendOutAmount(0);
		ti4.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		ti4.setTousseDefinitionId(map.get("Test穿刺包"));
		ti4.setInvoicePlan(application);
		
		TousseItem ti5 = new TousseItem();
		ti5.setTousseName("Test治疗巾");
		ti5.setAmount(10);
		ti1.setIsRecycling("否");
		ti5.setRecyclingAmount(null);
		ti5.setSendOutAmount(0);
		ti5.setTousseType(TousseDefinition.PACKAGE_TYPE_DRESSING);
		ti5.setTousseDefinitionId(map.get("Test治疗巾"));
		ti5.setInvoicePlan(application);
		
		List<TousseItem> applicationItems = new ArrayList<TousseItem>();
		applicationItems.add(ti1);
		applicationItems.add(ti2);
		applicationItems.add(ti3);
		applicationItems.add(ti4);
		applicationItems.add(ti5);
		
		application.setRecyclingStatus(InvoicePlan.RECYCLINGSTATUS_AWAITRECYCLE);
		application.setDeliverStatus(InvoicePlan.DELIVERSTATUS_AWAITDELIVER);
		application.setCommittedStatus(true);
		application.setApplicationItems(applicationItems);
		application.setType(InvoicePlan.TYPE_TOUSSE_APPLICATION_FORM);
		objectDao.saveOrUpdate(application);

		RecyclingRecord oldRecord1 = new RecyclingRecord();
		oldRecord1.setDepart("外科");
		oldRecord1.setRecyclingApplication(application);

		return oldRecord1;
	}
	
	/**
	 * 根据参数生产普通器械包实例
	 * @param barcodeArr 条码数组
	 * @param tousseName 器械包名
	 * @param tousseType 器械包类型
	 * @param orgName    生产部门名称
	 * @param orgCode    生产部门代码 
	 * @param price		 器械包价格
	 */
	protected void createSimpleTousseInstanceByParam(String[] barcodeArr , String tousseName , String tousseType , String orgName , String orgCode,double price){
		TousseDefinition tousseDefinition1 = tousseDefinitionManager.getTousseDefinitionByName(tousseName);
		for(String barcode :barcodeArr){
			TousseInstance tousseInstance1 = new TousseInstance();
			tousseInstance1.setTousseDefinition(tousseDefinition1);
			tousseInstance1.setTousseName(tousseName);
			tousseInstance1.setBarcode(barcode);
			tousseInstance1.setType(tousseType);
			tousseInstance1.setStatus(TousseInstance.STATUS_STERILED);
			tousseInstance1.setPrice(price);
			tousseInstance1.setFluctuationPrice(price);
			tousseInstance1.setSterilingType("P1");
			tousseInstance1.setOrgUnitCoding(orgCode);
			tousseInstance1.setOrgUnitName(orgName);
			tousseInstance1.setStatisticsAmount(1);
			tousseInstance1.setPackageType("纸塑");
			Date date = null;
			try {
				date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2030-10-20 13:00:00");
			} catch (ParseException e) {
				e.printStackTrace();
			}
			tousseInstance1.setValidUntil(date);
			try {
				date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2014-10-21 13:00:00");
			} catch (ParseException e) {
				e.printStackTrace();
			}
			tousseInstance1.setOperationTime(date);
			tousseInstanceManager.setToDefaultWareHouse(tousseInstance1, orgCode);
			tousseInstanceManager.saveOrUpdate(tousseInstance1);
			//入库到GoodStock表
			List<GoodsStock> gslist = new ArrayList<>();
//			GoodsStock gs = TousseInstanceUtils.newGoodsStock(tousseInstance1);
			goodsStockManager.addToList(gslist, tousseInstance1);
			goodsStockManager.saveOrUpdateGoodsStock(gslist, GoodsStockManager.MODE_INSTOCK);
			//不对申请单类型为外部代理来菌单的器械包或器械包定义的类型为外部代理灭菌的器械包实例增加库存
			if(!TousseDefinition.PACKAGE_TYPE_FOREIGNPROXY.equals(tousseType) && TousseDefinition.STR_YES.equals(tousseDefinition1.getIsTraceable())){
				tousseStockManager.increaseStockByTousseName(tousseInstance1.getTousseName());
			}
		}
	}
	
	protected void createComboTousseInstanceByParam(JSONArray comboTousseConfigs){
		for(int i=0;i<comboTousseConfigs.size();++i){
			JSONObject comboTousseConfig = comboTousseConfigs.getJSONObject(i);
			JSONArray tousseConfigs = comboTousseConfig.getJSONArray("tousseConfigs");
			TousseInstance comboTousseInstance = createTousseInstance(comboTousseConfig);
			for(int i2=0;i2<tousseConfigs.size();++i2){
				JSONObject tousseConfig = tousseConfigs.getJSONObject(i2);
				TousseInstance tousseInstance1 = createTousseInstance(tousseConfig);
				
				tousseInstance1.setComboTousseDefinitionId(comboTousseInstance.getTousseDefinition().getId());
				tousseInstance1.setComboTousseDefinitionName(comboTousseInstance.getTousseDefinition().getName());
				tousseInstance1.setComboTousseInstanceId(comboTousseInstance.getId());
				objectDao.update(tousseInstance1);
			}
			
		}
	}
	
	protected TousseInstance createTousseInstance(JSONObject tousseConfig){
		String tousseName = JSONUtil.optString(tousseConfig, "tousseName", "");
		String barcode = JSONUtil.optString(tousseConfig, "barcode", "");
		String tousseType = JSONUtil.optString(tousseConfig, "tousseType", "");
		String orgUnitCoding = JSONUtil.optString(tousseConfig, "orgUnitCoding", "");
		String orgUnitName = JSONUtil.optString(tousseConfig, "orgUnitName", "");
		double price = JSONUtil.optDouble(tousseConfig, "price", 0);
		TousseDefinition tousseDefinition1 = tousseDefinitionManager.getTousseDefinitionByName(tousseName);
		TousseInstance tousseInstance1 = new TousseInstance();
		tousseInstance1.setTousseDefinition(tousseDefinition1);
		tousseInstance1.setTousseName(tousseName);
		tousseInstance1.setBarcode(barcode);
		tousseInstance1.setType(tousseType);
		tousseInstance1.setStatus(TousseInstance.STATUS_STERILED);
		tousseInstance1.setPrice(price);
		tousseInstance1.setFluctuationPrice(price);
		tousseInstance1.setSterilingType("P1");
		tousseInstance1.setOrgUnitCoding(orgUnitCoding);
		tousseInstance1.setOrgUnitName(orgUnitName);
		tousseInstance1.setStatisticsAmount(1);
		tousseInstance1.setPackageType("纸塑");
		Date date = null;
		try {
			date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2030-10-20 13:00:00");
		} catch (ParseException e) {
			e.printStackTrace();
		}
		tousseInstance1.setValidUntil(date);
		try {
			date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2014-10-21 13:00:00");
		} catch (ParseException e) {
			e.printStackTrace();
		}
		tousseInstance1.setOperationTime(date);
		tousseInstanceManager.setToDefaultWareHouse(tousseInstance1, orgUnitCoding);
		tousseInstanceManager.saveOrUpdate(tousseInstance1);
		//入库到GoodStock表
//		GoodsStock gs = TousseInstanceUtils.newGoodsStock(tousseInstance1);
		List<GoodsStock> gsList = new ArrayList<>();
		goodsStockManager.addToList(gsList, tousseInstance1);
		goodsStockManager.saveOrUpdateGoodsStock(gsList, GoodsStockManager.MODE_INSTOCK);
		//不对申请单类型为外部代理来菌单的器械包或器械包定义的类型为外部代理灭菌的器械包实例增加库存
		if(!TousseDefinition.PACKAGE_TYPE_FOREIGNPROXY.equals(tousseType) && TousseDefinition.STR_YES.equals(tousseDefinition1.getIsTraceable())){
			tousseStockManager.increaseStockByTousseName(tousseInstance1.getTousseName());
		}
		return tousseInstance1;
	}
	/**
	 * 根据参数创建普通器械包的申请单
	 * @param serialNum		序列号
	 * @param appType		申请单类型
	 * @param depart    	申请科室
	 * @param departCode	申请科室代码
	 * @param appTime		申请时间
	 * @param map			申请物品
	 */
	@Deprecated
	protected Long createSimpleTousseOrDiposableGoodsApplicationByParam(String serialNum ,String appType, String depart , String departCode , Date appTime , Map<String, Integer> map){
		RecyclingApplication application = new RecyclingApplication();
		application.setSerialNumber(serialNum);
		application.setApplicant("吴启华");
		application.setDepartCoding(departCode);
		application.setDepart(depart);
		application.setSettleAccountsDepartCoding(departCode);
		application.setSettleAccountsDepart(depart);
		application.setHandleDepart(Constants.ORG_UNIT_NAME_CSSD);
		application.setHandleDepartCoding(Constants.ORG_UNIT_CODE_CSSD);
		application.setApplicationTime(appTime);
		application.setCommittedStatus(true);
		application.setDeliverStatus(InvoicePlan.DELIVERSTATUS_AWAITDELIVER);
		application.setType(appType);
		List<TousseItem> items = new ArrayList<TousseItem>();
		for(Map.Entry<String, Integer> entry : map.entrySet()){
			TousseItem item = new TousseItem();
			item.setTousseName(entry.getKey());
			item.setAmount(entry.getValue());
			//item.setTousseType(tousseType);
			if(appType.equals(InvoicePlan.TYPE_DIPOSABLE_GOODS_APPLICATION_FORM)){
				item.setDiposable("是");
				item.setTousseType(TousseItem.TYPE_DIPOSABLE_GOODS);
			}else{
				item.setDiposable("否");
			}
			item.setInvoicePlan(application);
			items.add(item);
			tousseItemManager.saveOrUpdate(item);
		}
		if(appType.equals(InvoicePlan.TYPE_BORROWINGSINGLE)){
			application.setReturnStatus(InvoicePlan.RETURN_STATUS_UNRETURNED);
		}
		application.setApplicationItems(items);
		objectDao.saveOrUpdate(application);
		return application.getId();
	}
	
	/**
	 * 根据JSON参数创建物品的申请单
	 * @param serialNum     流水号
	 * @param appType       申请单类型
	 * @param appliant      申请人
	 * @param depart        申请科室
	 * @param departCode    申请科室编码
	 * @param handleDepart  处理科室
	 * @param handleDepartCoding  处理科室编码
	 * @param handleDepartId      处理科室ID
	 * @param appTime       申请时间
	 * @param jsonArray     申请物品列表
	 * @return  创建的申请单的ID
	 */
	protected Long createSimpleTousseOrDiposableGoodsApplicationByJsonParam(
			String serialNum, String appType, String appliant, String depart,
			String departCode, String handleDepart, String handleDepartCoding,
			String handleDepartId, Date appTime, JSONArray jsonArray){
		RecyclingApplication application = new RecyclingApplication();
		application.setSerialNumber(serialNum);
		application.setApplicant(appliant);
		application.setDepartCoding(departCode);
		application.setDepart(depart);
		application.setSettleAccountsDepartCoding(departCode);
		application.setSettleAccountsDepart(depart);
		application.setHandleDepart(handleDepart);
		application.setHandleDepartCoding(handleDepartCoding);
		application.setApplicationTime(appTime);
		application.setCommittedStatus(true);
		application.setDeliverStatus(InvoicePlan.DELIVERSTATUS_AWAITDELIVER);
		application.setType(appType);
		List<TousseItem> items = new ArrayList<TousseItem>();
		for(int i=0;i<jsonArray.size();i++){
			TousseItem item = new TousseItem();
			JSONObject obj = (JSONObject)jsonArray.get(i);
			String tousseItemName = obj.optString("name");
			item.setTousseName(tousseItemName);
			int amount = obj.optInt("amount");
			item.setAmount(amount);
			
			Integer recyclingAmount = null;
			try{
				Object object = obj.get("recyclingAmount");
				if (object != null){
					recyclingAmount = MathTools.object2Integer(object);
				}
			}
			catch(Exception e){
				
			}
			
			item.setRecyclingAmount(recyclingAmount);
			
			double price = obj.optDouble("price",0d);
			item.setPrice(price);
			item.setRowPrice(amount * price);
			String tousseType = obj.optString("tousseType");
			item.setTousseType(tousseType);
			if (item.getTousseType().equals(TousseItem.TYPE_DIPOSABLE_GOODS)
					|| appType
							.equals(InvoicePlan.TYPE_DIPOSABLE_GOODS_APPLICATION_FORM)) {
				item.setDiposable("是");

				JSONObject nameObj = CssdUtils
						.getGoodsNameAndSp(tousseItemName);
				DisposableGoods goods = diposableGoodsManager
						.getDisposableGoodsByName(nameObj.optString("materialName"),
								nameObj.optString("specification"));
				
				if (goods != null){
					item.setDisposableGoodsId(goods.getId());
				}
				else{
					logger.debug("找不到一次性物品定义：" + tousseItemName);
				}

			} else {
				item.setDiposable("否");

				// 设置TousseDefinitionId
					TousseDefinition td = tousseDefinitionManager
							.getTousseDefinitionByName(tousseItemName);
					if (td != null) {
						Long tousseDefinitionId = td.getId();
						item.setTousseDefinitionId(tousseDefinitionId);
						item.setIsInvoice(td.getIsInvoice());
					} else {
						logger.debug("找不到器械包定义：" + tousseItemName);
					}

			}
			item.setInvoicePlan(application);
			items.add(item);
			tousseItemManager.saveOrUpdate(item);
		}
		if(appType.equals(InvoicePlan.TYPE_BORROWINGSINGLE)){
			application.setReturnStatus(InvoicePlan.RETURN_STATUS_UNRETURNED);
		}
		application.setApplicationItems(items);
		objectDao.saveOrUpdate(application);
		return application.getId();
	}
	
	/**
	 * 初始化一次性物品
	 * 
	 * 注射器【5ML】 1000个，有1个批次【b-20140101】，1个标识号【i-001】
	 * 注射器【10ML】 2000个，有1个批次【b-20140101】，2个标识号【i-001】【i-002】
	 * 纱块【6*8】 1000个，有2个批次【b-20140101】【b-20140202】，各1个标识号【i-001】【i-002】
	 */
	protected void initDiposableGoodsData() {
		Map<String, Object> result = new HashMap<String, Object>();
		
		WareHouse wareHouse1 = wareHouseManager.getDefaultWareHouseByUnitCode(Constants.ORG_UNIT_CODE_CSSD);
		assertNotNull(wareHouse1);
		Long warehouseID = wareHouse1.getId();
		String warehouseName = wareHouse1.getName();
		// 先保存定义
		// 注射器【5ML】
		DisposableGoods disposableGoods1 = new DisposableGoods();
		disposableGoods1.setName("注射器");
		disposableGoods1.setSpecification("5ML");
		disposableGoods1.setReferencePrice(1.5);
		disposableGoods1.setType("注射器");
		diposableGoodsManager.saveOrUpdate(disposableGoods1);
		// 注射器【10ML】
		DisposableGoods disposableGoods2 = new DisposableGoods();
		disposableGoods2.setName("注射器");
		disposableGoods2.setSpecification("10ML");
		disposableGoods2.setReferencePrice(1.4);
		disposableGoods2.setType("注射器");
		diposableGoodsManager.saveOrUpdate(disposableGoods2);
		// 纱块【6*8】
		DisposableGoods disposableGoods3 = new DisposableGoods();
		disposableGoods3.setName("纱块");
		disposableGoods3.setSpecification("6*8");
		disposableGoods3.setReferencePrice(1.4);
		disposableGoods3.setType("纱块");
		diposableGoodsManager.saveOrUpdate(disposableGoods3);
		
		//增加申请测试用例所需用到的一次性物品定义数据
		DisposableGoods diposableGoods = new DisposableGoods();
		diposableGoods.setName("一次性导尿包");
		diposableGoods.setSpecification("12#");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("一次性压舌板");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("木质");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("动脉采血器");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("2ML");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("一次性腰穿包");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("9#");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("灭菌棉球");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("10粒/包");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("一次性弯盘");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("单腰A型");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("一次性使用灌肠袋");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("灭菌纱块");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("6*8CM2块/包（100/盒)");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("一次型使用无菌注射针");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("6#");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("医用棉签");
		diposableGoods.setSpecification("12CM20支/包");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setType("医用棉签");	
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("灭菌纱块");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("6*8CM2块/包（100/盒)");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("灭菌纱块");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("8*12CM2块/包");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("注射器");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("20ML");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		
		diposableGoods = new DisposableGoods();
		diposableGoods.setName("一次性使用吸痰管");
		diposableGoods.setIsPartOfTousseMaterial(DisposableGoodsStock.CONSTANT_YES);
		diposableGoods.setSpecification("12#");
		diposableGoodsManager.saveOrUpdate(diposableGoods);
		// 开始入库
		// 注射器【5ML】 1000个，有1个批次，1个标识号
		GodownEntry entry = new GodownEntry();
		entry.setWarehouseID(warehouseID);
		entry.setWarehouseName(warehouseName);
		GodownEntryItem godownEntryItem1 = new GodownEntryItem();
		godownEntryItem1.setBatchNumber("b-20140101");
		godownEntryItem1.setAmount(1000L);
		godownEntryItem1.setCost(1.5);
		godownEntryItem1.setDisposableGoodsID(disposableGoods1.getId());
		godownEntryItem1.setManufacturer("广州白云山制药厂");
		godownEntryItem1.setSupplierName("广州捷康医疗");
		godownEntryItem1.setGodownEntry(entry);
		godownEntryItem1.setExpDate(new Date());
		godownEntryItem1.setIdentification("i-001");
		entry.getItemsList().add(godownEntryItem1);
		//注射器【10ML】 2000个，有1个批次，2个标识号
		GodownEntryItem godownEntryItem2 = new GodownEntryItem();
		godownEntryItem2.setBatchNumber("b-20140101");
		godownEntryItem2.setAmount(1500L);
		godownEntryItem2.setCost(1.3);
		godownEntryItem2.setDisposableGoodsID(disposableGoods2.getId());
		godownEntryItem2.setManufacturer("广州白云山制药厂");
		godownEntryItem2.setSupplierName("广州捷康医疗");
		godownEntryItem2.setGodownEntry(entry);
		godownEntryItem2.setExpDate(new Date());
		godownEntryItem2.setIdentification("i-001");
		entry.getItemsList().add(godownEntryItem2);
		
		GodownEntryItem godownEntryItem3 = new GodownEntryItem();
		godownEntryItem3.setBatchNumber("b-20140101");
		godownEntryItem3.setAmount(500L);
		godownEntryItem3.setCost(1.4);
		godownEntryItem3.setDisposableGoodsID(disposableGoods2.getId());
		godownEntryItem3.setManufacturer("广州白云山制药厂");
		godownEntryItem3.setSupplierName("广州捷康医疗");
		godownEntryItem3.setGodownEntry(entry);
		godownEntryItem3.setExpDate(new Date());
		godownEntryItem3.setIdentification("i-002");
		entry.getItemsList().add(godownEntryItem3);
		//纱块【6*8】 2000个，有2个批次，各1个标识号
		GodownEntryItem godownEntryItem4 = new GodownEntryItem();
		godownEntryItem4.setBatchNumber("b-20140101");
		godownEntryItem4.setAmount(1500L);
		godownEntryItem4.setCost(1.3);
		godownEntryItem4.setDisposableGoodsID(disposableGoods3.getId());
		godownEntryItem4.setManufacturer("广州白云山制药厂");
		godownEntryItem4.setSupplierName("广州捷康医疗");
		godownEntryItem4.setGodownEntry(entry);
		godownEntryItem4.setExpDate(new Date());
		godownEntryItem4.setIdentification("i-001");
		entry.getItemsList().add(godownEntryItem4);
		
		GodownEntryItem godownEntryItem5 = new GodownEntryItem();
		godownEntryItem5.setBatchNumber("b-20140202");
		godownEntryItem5.setAmount(500L);
		godownEntryItem5.setCost(1.4);
		godownEntryItem5.setDisposableGoodsID(disposableGoods3.getId());
		godownEntryItem5.setManufacturer("广州白云山制药厂");
		godownEntryItem5.setSupplierName("广州捷康医疗");
		godownEntryItem5.setGodownEntry(entry);
		godownEntryItem5.setExpDate(new Date());
		godownEntryItem5.setIdentification("i-002");
		entry.getItemsList().add(godownEntryItem5);
		godownEntryManager.saveGodownEntry_TRANS_REQUIRED(entry, result);
		
		DisposableGoodsStock disposableGoodsStock1 = diposableGoodsManager.getDisposableGoodsStockByName(wareHouse1.getId(),"注射器", "5ML");
		assertNotNull(disposableGoodsStock1);
		assertEquals(1000, disposableGoodsStock1.getAmount().longValue());
		
		DisposableGoodsStock disposableGoodsStock2 = diposableGoodsManager.getDisposableGoodsStockByName(wareHouse1.getId(),"注射器", "10ML");
		assertNotNull(disposableGoodsStock2);
		assertEquals(2000, disposableGoodsStock2.getAmount().longValue());
		
		Set<DisposableGoodsBatchStock> batchs = disposableGoodsStock2.getGoodsBatchs();
		assertNotNull(batchs);
		assertEquals(1, batchs.size());
		
		List<DisposableGoodsIdentification> idents = batchs.iterator().next().getIdentifications();
		assertNotNull(idents);
		assertEquals(2, idents.size());
		
		//纱块【6*8】 2000个，有2个批次，各1个标识号
		DisposableGoodsStock disposableGoodsStock3 = diposableGoodsManager.getDisposableGoodsStockByName(wareHouse1.getId(),"纱块", "6*8");
		assertNotNull(disposableGoodsStock3);
		assertEquals(2000, disposableGoodsStock3.getAmount().longValue());
	}
	
	/**
	 * 初始化用户、角色、组织机构
	 * 角色：【role1】、【role2】、【USER】、【OTHER】
	 * 操作：【operation1】、【operation2】、【operation3】
	 * 		阳光医院 【yangguangyiyuan】
	 * 			--测试手术室【testOR】 
	 * 				oruser1【role1】、oruser2【role1】、oruser3【role1】
	 * 			--测试供应室【testCSSD】
	 * 				cssduser1【role2】、cssduser2【role2】、cssduser3【role2】
	 */
	public void initDirectoryInfo() {

		// makeActiveUser("admin");

		String rootCompanyId = "ROOT-Company1";
		Role role1 = createRole("role1", "role1DisplayName", rootCompanyId);
		Role role2 = createRole("role2", "role2DisplayName", rootCompanyId);
		Role role3 = createRole("USER", "全体用户", rootCompanyId);
		Role roleOther = createRole("OTHER", "其他用户", rootCompanyId);
		roleManager.save(role1, null);
		roleManager.save(role2, null);
		roleManager.save(role3, null);
		roleManager.save(roleOther, null);

		assertNotNull(roleManager.getRoleByRoleName(role1.getName()));
		assertNotNull(roleManager.getRoleByRoleName(role2.getName()));
		assertNotNull(roleManager.getRoleByRoleName(role3.getName()));
		assertNotNull(roleManager.getRoleByRoleName(roleOther.getName()));

		Operation operation1 = new Operation();
		operation1.setOperationId("operation1");
		operation1.setOperationName("操作1");
		objectDao.save(operation1);

		Operation operation2 = new Operation();
		operation2.setOperationId("operation2");
		operation2.setOperationName("操作2");
		objectDao.save(operation2);

		Operation operation3 = new Operation();
		operation3.setOperationId("operation3");
		operation3.setOperationName("操作3");
		objectDao.save(operation3);

		Set<Operation> operations = new HashSet<Operation>();
		operations.add(operation1);
		operations.add(operation2);
		operations.add(operation3);
		role1.setOperations(operations);

		roleManager.save(role1, null);

		// 初始化组织机构根节点和系统管理员用户
		initializeDataManager.initOrgUnit();
		
		OrgUnit orgUnitROOT = (OrgUnit) thTreeNodeManager.getTHTreeNodeById(
				OrgUnit.class.getSimpleName(), Long.valueOf(0));
		
		
		assertNotNull(orgUnitROOT);
		
		assertEquals("组织机构",orgUnitROOT.getName());
		
//		OrgUnit rootNode = (OrgUnit) directoryHelper.createOrgUnit("阳光医院",
//				"yangguangyiyuan", "name1", rootNode);
		
//		assertNotNull(rootNode);

//		OrgUnit orgUnitROOT = directoryHelper.createOrgUnit("阳光医院",
//				"yangguangyiyuan", "name1", rootNode);
//		
		
		OrgUnit orgUnitOR = directoryHelper.createOrgUnit(Constants.ORG_UNIT_NAME_OR, Constants.ORG_UNIT_CODE_OR,
				"name2", orgUnitROOT);
		assertTrue(directoryHelper.isOrgUnitName(Constants.ORG_UNIT_NAME_OR));
		OrgUnit orgUnitCSSD = directoryHelper.createOrgUnit(Constants.ORG_UNIT_NAME_CSSD,
				Constants.ORG_UNIT_CODE_CSSD, "name2", orgUnitROOT);
		
		orgUnitCSSDId = "" + orgUnitCSSD.getId();
		
		assertTrue(directoryHelper.isOrgUnitCodeExist(Constants.ORG_UNIT_CODE_CSSD));
		
		OrgUnit neike = directoryHelper.createOrgUnit("测试内科",
				"testNeike", "name3", orgUnitROOT);
		assertTrue(directoryHelper.isOrgUnitCodeExist("testNeike"));
		
		BarcodeDevice barcode1 = new BarcodeDevice();
		barcode1.setType(BarcodeDevice.BARCODE_TYPE_ORGUNIT);
		barcode1.setBarcode("310000120");
		objectDao.save(barcode1);
		
		neike.setBarcodeDevice(barcode1);
		objectDao.save(neike);
		
		OrgUnit waike = directoryHelper.createOrgUnit("测试外科",
				"testWaike", "name4", orgUnitROOT);
		assertTrue(directoryHelper.isOrgUnitCodeExist("testWaike"));
		BarcodeDevice barcode2 = new BarcodeDevice();
		barcode2.setType(BarcodeDevice.BARCODE_TYPE_ORGUNIT);
		barcode2.setBarcode("310000121");
		objectDao.save(barcode2);
		
		waike.setBarcodeDevice(barcode2);
		objectDao.save(waike);
		
		
		User orUser1 = createUser("oruser1", "0100002001", orgUnitOR.getId().toString(),
				orgUnitOR.getOrgUnitCoding(), null, role1.getId().toString());
		User orUser2 = createUser("oruser2", "0100002002", orgUnitOR.getId().toString(),
				orgUnitOR.getOrgUnitCoding(), null, role1.getId().toString());
		User orUser3 = createUser("oruser3", "0100002003", orgUnitOR.getId().toString(),
				orgUnitOR.getOrgUnitCoding(), null, role1.getId().toString());
		User cssdUser1 = createUser("cssduser1","0100001001", 
				orgUnitCSSD.getId().toString(), orgUnitCSSD.getOrgUnitCoding(),
				null, role2.getId().toString());
		User cssdUser2 = createUser("cssduser2","0100001002", 
				orgUnitCSSD.getId().toString(), orgUnitCSSD.getOrgUnitCoding(),
				null, role2.getId().toString());
		User cssdUser3 = createUser("cssduser3","0100001003", 
				orgUnitCSSD.getId().toString(), orgUnitCSSD.getOrgUnitCoding(),
				null, role2.getId().toString());
		
		
		Role adminRole = roleManager.getRoleByRoleName("ROLE_ADMINISTRATOR_0");
		String roleIds = role2.getId().toString() + User.ORGUNIT_ROLE_SEPARATOR + adminRole.getId().toString();
		
		User admin = createUser("admin","0100001008", 
				orgUnitCSSD.getId().toString(), orgUnitCSSD.getOrgUnitCoding(),
				null, roleIds);

		assertTrue(directoryHelper.isUserName("oruser1"));
		assertTrue(directoryHelper.isUserName("oruser2"));
		assertTrue(directoryHelper.isUserName("cssduser1"));
		assertTrue(directoryHelper.isUserName("cssduser2"));
		assertTrue(directoryHelper.isUserName("cssduser3"));
		assertTrue(directoryHelper.isUserName("admin"));
	}

	/**
	 * 
	 * @param userId
	 *            用户id
	 * @param orgUnitIdsUserBelong
	 *            用户所属的组织单位
	 * @param orgUnitIdsUserDirectManaged
	 *            用户直接管理的部门id
	 * @param orgUnitIdsUserUnDirectManaged
	 *            用户分管的部门id
	 * @param roleIds
	 *            用户拥有的角色id
	 * @return
	 */
	private User createUser(String userId, String barcode, String orgUnitIdsUserBelong,
			String orgUnitIdsUserDirectManaged,
			String orgUnitIdsUserUnDirectManaged, String roleIds) {
		User user = new User();
		user.setName(userId);
		user.setFullName(userId + "FullName");
		user.setPasswd("1");
		user.setBarcode(barcode);
		user.setOrgUnitIds(orgUnitIdsUserBelong);
		user.setManagerOrgUnitIds(orgUnitIdsUserDirectManaged);
		user.setLeaderOrgUnitIds(orgUnitIdsUserUnDirectManaged);
		user.setRoleIds(roleIds);
		sysUserManager.saveUser(user);
		return user;
	}

	/**
	 * 创建角色
	 * @param simpleName
	 * @param roleDescn
	 * @param companyId
	 * @return
	 */
	protected Role createRole(String simpleName, String roleDescn,
			String companyId) {

		Role role = null;
		String roleName = "ROLE_" + simpleName + "_" + companyId;
		if (!directoryHelper.isRoleName(roleName)) {
			role = new Role();
			role.setSimpleName(simpleName);
			role.setDescn(roleDescn);
			role.setCompanyId(companyId);

		} else {
			role = roleManager.getRoleByRoleName(roleName);
		}
		return role;
	}

	private static void destroySecureContext() {
		SecurityContextHolder.clearContext();
	}

//	@Override
//	protected String[] getConfigLocations() {
//		setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_NAME);
//
//		String database = CssdUtils.getConfigProperty("database");
//		String project = CssdUtils.getConfigProperty("project");
//		
//		return new String[] { "spring/*.xml", "spring/database/" + database + "/*.xml",
//				"spring/projects/" + project + "/*.xml" };
//	}
//

	protected void onTearDownInTransaction() {
		destroySecureContext();
	}
	
	/**
	 * 添加回收项。回收单与回收项为一对多的关系
	 * 
	 * @param jsonArray
	 * @param basketBarcode
	 * @param basketId
	 * @param tousseName
	 * @param tousseDefinitionID
	 * @param amount
	 * @param itemType
	 * @param tousseNameForMaterial  ?
	 * @param tousseAmountForMaterial
	 * @param basketGroupBarcodes
	 */
	public void addRecyclingItem(JSONArray jsonArray, String basketBarcode,
			String basketId, String tousseName,Long tousseDefinitionID, Integer amount,
			String itemType, String tousseNameForMaterial,
			Integer tousseAmountForMaterial,String basketGroupBarcodes) {
		addRecyclingItem(jsonArray, basketBarcode, basketId, tousseName,tousseDefinitionID, amount, itemType, tousseNameForMaterial, tousseAmountForMaterial, null,basketGroupBarcodes);
	}
	
	public void addRecyclingItem(JSONArray jsonArray, String basketBarcode,
			String basketId, String tousseName,Long tousseDefinitionID, Integer amount,
			String itemType, String tousseNameForMaterial,
			Integer tousseAmountForMaterial,Long appid,String basketGroupBarcodes) {
		JSONObject obj = new JSONObject();
		obj.put("basketBarcode", basketBarcode);
		obj.put("basketId", basketId);
		obj.put("tousseName", tousseName);
		obj.put("tousseDefinitionID", tousseDefinitionID);
		obj.put("amount", amount);
		obj.put("itemType", itemType);
		obj.put("tousseNameForMaterial", tousseNameForMaterial);
		obj.put("tousseAmountForMaterial", tousseAmountForMaterial);
		obj.put("appid", appid);
		obj.put("basketGroupBarcodes", basketGroupBarcodes);
		jsonArray.add(obj);
	}

	
	protected void appendToCollection(
			Collection<TousseItemVo> vos, String tousseName, int amount, 
			String tousseType, String isRecycling, long id) {
		
		TousseItemVo vo = new TousseItemVo();
		vo.setId(id);
		vo.setTousseName(tousseName);
		vo.setTousseType(tousseType);
		vo.setAmount(amount);
		vo.setIsRecycling(isRecycling);
		if ("一次性物品".equals(tousseType)){
			vo.setDiposable("是");
		}
		else{
			vo.setDiposable("否");
		}
		
		vos.add(vo);
	}
	protected void appendToCollection2(
			Collection<TousseItemVo> vos, String tousseName, int amount,
			String tousseType, String isRecycling, long id, long goodId) {
		TousseItemVo vo = new TousseItemVo();
		vo.setId(id);
		vo.setTousseName(tousseName);
		vo.setTousseType(tousseType);
		vo.setAmount(amount);
		vo.setIsRecycling(isRecycling);
		if ("一次性物品".equals(tousseType)){
			vo.setDiposable("是");
			vo.setDisposableGoodsId(goodId);
		}
		else{
			vo.setDiposable("否");
			vo.setTousseDefinitionID(goodId);
		}
		vos.add(vo);
	}
	/**
	 * 创建仓库,只设置科室编码。测试用例只有这个属性是有用的
	 * @param orgUnitCode
	 */
	protected void createWareHouse(String orgUnitCode){
		WareHouse wh = new WareHouse();
		wh.setOrgUnitCode(orgUnitCode);
		try {
			wareHouseManager.saveOrUpdateWareHouse(wh);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * @param wareHouse_CSSD
	 * @param barcode
	 * @return
	 */
	public JSONObject buildDisposableGoodsInvoiceItem(WareHouse wareHouse_CSSD,
			String barcode,Integer amount) {
		JSONObject invoiceItems1_1 = new JSONObject();
		invoiceItems1_1.put("barcode", barcode);
		invoiceItems1_1.put("tousseType", DisposableGoods.TYPE_NAME);
		
		JSONObject typeInfoOnScanned = new JSONObject();
		
		DisposableGoodsBatchStock disposableGoodsBatchStock = diposableGoodsManager.getByWarehouseIDAndBarcode(wareHouse_CSSD.getId(), barcode);
		///
		typeInfoOnScanned.put("disposableGoodsId", disposableGoodsBatchStock.getDisposableGoodsId());
		typeInfoOnScanned.put("disposableGoodsStockId", disposableGoodsBatchStock.getDisposableGoodsStockId());
		typeInfoOnScanned.put("disposableGoodsBatchId", disposableGoodsBatchStock.getDisposableGoodsBatchId());
		typeInfoOnScanned.put("disposableGoodsBatchStockId", disposableGoodsBatchStock.getId());
		invoiceItems1_1.put("sendAmount", amount);
		invoiceItems1_1.put("isRoutine", TousseInstance.ROUTINE_YES);
		invoiceItems1_1.put("typeInfoOnScanned", typeInfoOnScanned);
		return invoiceItems1_1;
	}
	/**
	 * 设置申请单的信息
	 * @param invoicePlan
	 * @param departCoding 申请科室编码
	 * @param handleDepartCoding 处理科室编码
	 * @param deliverStatus 发货状态
	 * @param recyclingStatus 回收状态
	 * @param committedStatus 是否提交
	 */
	protected void setInvoicePlanInfo(InvoicePlan invoicePlan,String departCoding,String handleDepartCoding,
			String deliverStatus,String recyclingStatus,Boolean committedStatus){
		invoicePlan.setCommittedStatus(committedStatus);
		invoicePlan.setDeliverStatus(deliverStatus);
		invoicePlan.setDepartCoding(departCoding);
		invoicePlan.setHandleDepartCoding(handleDepartCoding);
		invoicePlan.setRecyclingStatus(recyclingStatus);
	}
	/**
	 * 默认回滚数据
	 */
//	@Override
//	protected boolean isDefaultRollback() {
//		return false;
//	}
	/**
	 * 修改发货的系统参数设置
	 * @param afterRecyclingTousseDeliver 是否回收后发货
	 * @param invoiceOrigin 发货数量依据
	 */
	protected void setInvoiceParam(boolean afterRecyclingTousseDeliver, String invoiceOrigin) {
		SupplyRoomConfig supplyRoomConfig = supplyRoomConfigManager.getSystemParamsObj();
		supplyRoomConfig.setAfterRecyclingTousseDeliver(afterRecyclingTousseDeliver);
		supplyRoomConfig.setInvoiceOrigin(invoiceOrigin);
//		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig);
		
		supplyRoomConfig = supplyRoomConfigManager.getSystemParamsObj();
		assertEquals(supplyRoomConfig.getAfterRecyclingTousseDeliver(),afterRecyclingTousseDeliver);
		
		assertEquals(supplyRoomConfig.getInvoiceOrigin(),invoiceOrigin);
	}
}