package test.forgon.disinfectsystem;

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

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
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 com.forgon.disinfectsystem.departmentapplicationtemplate.service.DepartmentAppTemplateManager;
import com.forgon.disinfectsystem.entity.basedatamanager.departmentapplicationtemplate.DepartmentAppTemplate;
import com.forgon.disinfectsystem.entity.basedatamanager.departmentapplicationtemplate.DiposableGoodsTemplateItem;
import com.forgon.disinfectsystem.entity.basedatamanager.departmentapplicationtemplate.TousseDefinitionTemplateItem;
import com.forgon.tools.SpringBeanManger;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;

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

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.disinfectsystem.basedatamanager.container.service.ContainerManager;
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.DiposableGoodsManager;
import com.forgon.disinfectsystem.diposablegoods.service.GodownEntryManager;
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.cleanmethod.CleanMethod;
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.rinser.Rinser;
import com.forgon.disinfectsystem.entity.basedatamanager.sterilisation.Sterilisation;
import com.forgon.disinfectsystem.entity.basedatamanager.sterilizer.Sterilizer;
import com.forgon.disinfectsystem.entity.basedatamanager.supplier.Supplier;
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.warehouse.WareHouse;
import com.forgon.disinfectsystem.entity.customform.formdefinition.FormDefinition;
import com.forgon.disinfectsystem.entity.idcarddefinition.IDCardDefinition;
import com.forgon.disinfectsystem.entity.idcardinstance.IDCardInstance;
import com.forgon.disinfectsystem.entity.qualitymonitoringmanager.qualitymonitoringconfig.QualityMonitoringDefinition;
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.oa.initdata.service.InitializeDataManager;
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.OperationManager;
import com.forgon.security.service.RoleManager;
import com.forgon.serialnumber.model.SerialNum;
import com.forgon.serialnumber.service.SerialNumManager;
import com.forgon.systemsetting.model.HttpOption;
import com.forgon.tools.cache.ForgonThreadLocalResourceManager;
import com.forgon.tools.db.DatabaseUtil;
import com.forgon.tools.hibernate.ObjectDao;
import com.forgon.treenode.service.THTreeNodeManager;


public class CSSDTestDataProcess {

	protected Map<String , Object> map = new HashMap<String, Object>();
	
	@Autowired
	private DirectoryHelper directoryHelper;
	@Autowired
	private SysUserManager sysUserManager;
	@Autowired
	private RoleManager roleManager;
	@Autowired
	private THTreeNodeManager thTreeNodeManager;
	@Autowired
	private ObjectDao objectDao;
	@Autowired
	private OrgUnitManager orgUnitManager;
	@Autowired
	private GodownEntryManager godownEntryManager;
	@Autowired
	private MaterialDefinitionManager materialDefinitionManager;
	@Autowired
	private TousseDefinitionManager tousseDefinitionManager;
	@Autowired
	private SupplyRoomConfigManager supplyRoomConfigManager;
	@Autowired
	private DiposableGoodsManager diposableGoodsManager;
	@Autowired
	private SerialNumManager serialNumManager;
	@Autowired
	private MaterialInstanceManager materialInstanceManager;
	@Autowired
	private DataGenerater dataGenerater;
	@Autowired
	private ContainerManager containerManager;
	@Autowired
	private SterilizerManager sterilizerManager;
	@Autowired
	private WareHouseManager wareHouseManager;
	@Autowired
	private RunWithTransNewManager runWithTransNewManager;
	@Autowired
	private InitializeDataManager initializeDataManager;
	@Autowired
	private OperationManager operationManager;
	@Autowired
	private DepartmentAppTemplateManager departmentAppTemplateManager;

	/**
	 * 一次性物品价格浮动系统
	 */
	static final float DIPOSABLEGOODS_PRICE_F =  1.1f;
	
	/**
	 * 测试数据初始化(运行每个测试用例时会调用的方法)
	 * 仅清除所有的业务数据
	 */
	public void initCSSDData() {
		cleanAllBusinessData();
	}
	
	/**
	 * 测试数据初始化(初始化基础数据方法只会在容器启动时调用一次)
	 * initializeCSSDTestData
	 */
	public void initializeCSSDTestData() {
		initCSSDDataWithTrans();
	}
	
	/**
	 * 初始化基础数据事务方法
	 */
	private void initCSSDDataWithTrans(){
		runWithTransNewManager.runWith_TRANS_NEW(new RunWithTransNewTask() {
			@Override
			public void runTask() {
				/**
				 * 清空基础数据、业务数据等表
				 */
				cleanAll();
				/**
				 * 初始化角色、权限、人员(基础信息及条码)、科室(基础信息及条码)以及各表间的关联数据
				 */
				initDirectoryInfo();
				
				/**
				 * 初始化基础数据，初始化供应商、初始化任务组、一次性物品类型、仓库、篮筐、科室供应室配置、灭菌炉等等，具体请看initBaseData方法的注释
				 */
				initBaseData();
				
				/**
				 * 初始化供应室服务临床科室配置
				 */
				initCssdServiceDepts();
				
				/**
				 * 初始化材料与器械包定义(器械包定义数量:11)
				 * 器械包9个:Test开胸包  Test开颅包  Test开口包   Test穿刺包   TestOR胆加仪   TestOR甲加仪（半年期） Test缝合包   Test清创包   Test宫碘包
				 * 敷料包1个:Test治疗巾
				 * 外部代理灭菌1个:普通批
				 * 
				 * *****************************************************************************************
				 * 后面的initBasicData方法又增加了以下器械包:消毒物品两个(test止血带、止血带_20141016)、
				 * 外部代理灭菌1个(test121#压力蒸汽灭菌包)、外来器械1个(test骨科外来器械包)
				 * 普通包5个(Test开胸包、Test缝合包、Test清创包、Test宫碘包、不回收的包),实际上只创建一个
				 * 考虑到Test开胸包、Test缝合包、Test清创包、Test宫碘包在初始里有,所有在initBasicData方法不再初始化
				 *
				 */
				initMaterialAndTousseData();
				
				/**
				 * 初始化1个外来器械包:Test钢板
				 */
				initForeignTousse();
				
				/**
				 * 初始化消毒物品定义(器械包定义数量:3)
				 * Test雾化器、止血带[100条/扎]、呼吸机
				 */
				initDisinfectToussesData();
				
				/**
				 * 初始化聚合包定义(器械包定义数量:1)
				 * Test聚合包
				 */
				bulidComboTousseDefinition();
				
				/**
				 * 初始化供应室处理器械包配置
				 */
				initCssdHandleTousses();
				
				/**
				 * 初始化一次性物品定义
				 */
				initDiposableGoodsData();

				//初始化科室模板
				initTemplate();
				
				/**
				 * 初始化失效期
				 */
				initExpirationDateInfo();
				
				/**
				 * 初始化质量监测定义
				 */
				initQualityMonitoring();

				
				ForgonThreadLocalResourceManager.afterRequest();

			}
		});
	}

	/**
	 * 根据提供的器械包物品的数组创建TousseDefinitionTemplateItem列表
	 * @param tousseNames 器械包数组
	 */
	private List<TousseDefinitionTemplateItem> getTousseDefinitionTemplateItem(String []tousseNames){
		List<TousseDefinitionTemplateItem> tousseItems = new ArrayList<>();
		for (int i = 0,size = tousseNames.length; i < size; i++) {
			TousseDefinition td = tousseDefinitionManager.getTousseDefinitionByName(tousseNames[i]);
			TousseDefinitionTemplateItem templateItem = new TousseDefinitionTemplateItem();
			templateItem.setTousseDefinition(td);
			templateItem.setSortNumber(i + 1);
			tousseItems.add(templateItem);
		}
		return tousseItems;
	}

	/**
	 * 根据提供的一次性物品的数组创建DiposableGoodsTemplateItem列表
	 * @param disposableGoods  一次性物品的数组
	 */
	private List<DiposableGoodsTemplateItem> getDisposableGoodsTemplateItem(DisposableGoods[] disposableGoods){
		List<DiposableGoodsTemplateItem> disposableGoodsItems = new ArrayList<>();
		for (int i = 0,size = disposableGoods.length; i < size; i++) {
			DisposableGoods good = diposableGoodsManager.getDisposableGoodsByName(disposableGoods[i].getName(), disposableGoods[i].getSpecification());
			DiposableGoodsTemplateItem diposableGoodsTemplateItem = new DiposableGoodsTemplateItem();
			diposableGoodsTemplateItem.setApplicationDiposableGoods(good);
			diposableGoodsTemplateItem.setSortNumber(i + 1);
			disposableGoodsItems.add(diposableGoodsTemplateItem);
		}
		return disposableGoodsItems;
	}


	/**
	 * 创建科室申领的模板<br/>
	 * <p>1.模板名字是治疗包模板</p>
	 * <p>2.模板类型是治疗包模板</p>
	 * <p>3.模板下的科室是测试内科</p>
	 * <p>4.模板下的器械包物品是Test穿刺包,止血带[100条/扎]</p>
	 * <p>5.模板下的一次性物品是一次性腰穿包 9#</p>
	 */
	private void initTemplate(){
		DisposableGoods disposableGoods1 = new DisposableGoods();
		disposableGoods1.setName("一次性腰穿包");
		disposableGoods1.setSpecification("9#");
		String []tousseNames = new String[]{"Test穿刺包", "止血带[100条/扎]"};
		DisposableGoods[] disposableGoods = new DisposableGoods[]{disposableGoods1};
		String []appTemplateNames = new String[]{"治疗包模板"};
		// String []appTemplateNames = new String[]{"治疗包模板", "一次性物品模板","散件器械模板"};
		for (String appTemplateName : appTemplateNames) {
			DepartmentAppTemplate appTemplate = new DepartmentAppTemplate();
			List<TousseDefinitionTemplateItem> tousseItems = this.getTousseDefinitionTemplateItem(tousseNames);
			List<DiposableGoodsTemplateItem> disposableGoodsItems = this.getDisposableGoodsTemplateItem(disposableGoods);
			appTemplate.setTousseDefinitionTemplateItems(tousseItems);
			appTemplate.setDiposableGoodsTemplateItems(disposableGoodsItems);
			appTemplate.setOrgUnitCode(Constants.ORG_UNIT_CODE_NEIKE);
			// appTemplate.setOrgUnitCode(Constants.ORG_UNIT_CODE_NEIKE + "," + Constants.ORG_UNIT_CODE_OR);
			appTemplate.setOperationTime(new Date());
			appTemplate.setOperator("ccsduser1");
			appTemplate.setTitle(appTemplateName);
			appTemplate.setTemplateType(appTemplateName);
			departmentAppTemplateManager.saveDepartmentAppTemplate(appTemplate);
		}


	}
	
	/**
	 * 清除所有的表数据
	 */
	private void cleanAll() {
		//删除所有的表(根据列出的删除语句)
		//deleteAllTable();
		//根据查询当前数据库的表,截断所有的表
		runWithTransNewManager.runWith_TRANS_NEW(new RunWithTransNewTask() {
			@Override
			public void runTask() {
				try {
					deleteTableDataDynamic(null);
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		});
	}
	
	/**
	 * 仅清除所有的业务表数据(每次运行测试用例时调用的方法)
	 */
	private void cleanAllBusinessData() {
		//根据查询当前数据库的表,截断所有的表
		runWithTransNewManager.runWith_TRANS_NEW(new RunWithTransNewTask() {
			@Override
			public void runTask() {
				try {
					//不需要删除的表
					String[] excludeTableNames = 
						{"'BarCodeDevice'","'OrgUnit'","'SS_OPERATION'","'SS_ROLE_OPERATION'","'SS_ROLES'","'SS_USERS'","'OrgUserRelation'",
							"'SS_USER_ROLE'","'SS_USERATTRIBUTE'","'SerialNum'","'WareHouse'","'Supplier'","'TaskGroup'","'HttpOption'",
							"'Rinser'","'CleanMethod'","'rinser_cleanMethod'","'Sterilizer'","'Sterilisation'","'sterilizer_sterilistion'","'SupplyRoomConfig'","'Container'","'CssdServiceDepts'","'CssdHandleTousses'",
							"'TousseGroup'","'MaterialDefinition'","'TousseDefinition'","'MaterialInstance'","'DiposableGoodsInstance'","'ComboTousseOrgUint'","'ComboTousseComposite'","'MaterialInstance'","'IDCardDefinition'","'IDCardInstance'",
							"'DisposableGoods'","'DisposableGoodsStock'","'DisposableGoodsBatch'","'DisposableGoodsBatchStock'","'DisposableGoodsIdentification'",
							"'ExpirationDateInfo'","'QualityMonitoringDefinition'","'FormDefinition'","'DiposableGoodsTemplateItem'","'TousseDefinitionTemplateItem'","'DepartmentAppTemplate'"};
					deleteTableDataDynamic(excludeTableNames);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}
	
	/**
	 * 动态delete所有的表(免维护)
	 * sqlserver和oracle的处理方式略有不同
	 * @param excludeTableNames 不需要删除的表需要列出
	 */
	private void deleteTableDataDynamic(String[] excludeTableNames) throws SQLException{
		String database = CssdUtils.getConfigProperty("database");
		//由于测试用例暂未知道数据库是sqlserver还是oracle还是mysql等,所先按sqlserver的方式处理,抛异常后再按oracle处理,再抛异常后再按其它数据库处理...
		List<String> sqlList = new ArrayList<String>();
		if(DatabaseUtil.isSqlServer(database)){
			//1.按sqlserver处理
			//1.1禁用所有外键
			ResultSet rs = objectDao.executeSql("select 'ALTER TABLE ['  + b.name +  '] NOCHECK CONSTRAINT ' +  a.name disableFk from sysobjects a ,sysobjects b where a.xtype ='f' and a.parent_obj = b.id");
			while(rs.next()){
				sqlList.add(rs.getString("disableFk") + ";");
			}
			if(CollectionUtils.isNotEmpty(sqlList)){
				objectDao.excuteSQL(StringUtils.join(sqlList," "));
			}
			DatabaseUtil.closeResultSetAndStatement(rs);
			
			//1.2.截断所有表
			sqlList.clear();
			//删除语句
			String clearTableDataSql = "select 'delete from '  + name +  ' ' deleteTable from sysobjects where xtype ='u'";
			//截断语句
//			String clearTableDataSql = "select 'truncate table '  + name +  ' ' deleteTable from sysobjects where xtype ='u'";
			
			if(excludeTableNames != null && excludeTableNames.length > 0){
				String condition = "and upper(name) not in (" + StringUtils.join(Arrays.asList(excludeTableNames), ",").toUpperCase() + ")";
				clearTableDataSql += condition;
			}
			
			rs = objectDao.executeSql(clearTableDataSql);
			while(rs.next()){
				sqlList.add(rs.getString("deleteTable") + ";");
			}
			if(CollectionUtils.isNotEmpty(sqlList)){
				objectDao.excuteSQL(StringUtils.join(sqlList," "));
			}
			DatabaseUtil.closeResultSetAndStatement(rs);
			
			//1.3启用所有外键
			sqlList.clear();
			rs = objectDao.executeSql("select 'ALTER TABLE ['  + b.name +  '] CHECK CONSTRAINT ' +  a.name enableFk from sysobjects a ,sysobjects b where a.xtype ='f' and a.parent_obj = b.id");
			while(rs.next()){
				sqlList.add(rs.getString("enableFk") + ";");
			}
			if(CollectionUtils.isNotEmpty(sqlList)){
				objectDao.excuteSQL(StringUtils.join(sqlList," "));
			}
			DatabaseUtil.closeResultSetAndStatement(rs);
		}if(DatabaseUtil.isOracle(database)){
			assertTrue(true, "按sqlserver处理删除数据报错,再按照oracle进行处理删除数据");
			try{
				//1.按oracle处理
				//1.1禁用所有外键
				sqlList.clear();
				ResultSet rs = objectDao.executeSql("select 'alter table '||table_name||' disable constraint '||constraint_name disableFk from user_constraints where constraint_type='R'");
				while(rs.next()){
					sqlList.add("execute immediate '" + rs.getString("disableFk") + "';");
				}
				if(CollectionUtils.isNotEmpty(sqlList)){
					objectDao.excuteSQL(StringUtils.join(sqlList," "));
				}
				DatabaseUtil.closeResultSetAndStatement(rs);
				
				//1.2.删除所有表
				sqlList.clear();
				//删除语句
				String clearTableDataSql = "select 'delete from '||table_name deleteTable from user_tables ";
				//截断语句
//				String clearTableDataSql = "select 'truncate table '||table_name deleteTable from user_tables";
				if(excludeTableNames != null && excludeTableNames.length > 0){
					String condition = " where upper(table_name) not in (" + StringUtils.join(Arrays.asList(excludeTableNames), ",").toUpperCase() + ")";
					clearTableDataSql += condition;
				}
				rs = objectDao.executeSql(clearTableDataSql);
				while(rs.next()){
					sqlList.add(rs.getString("deleteTable") + ";");
				}
				if(CollectionUtils.isNotEmpty(sqlList)){
					objectDao.excuteSQL(StringUtils.join(sqlList," ") + "commit;");
				}
				DatabaseUtil.closeResultSetAndStatement(rs);
				
				//1.3启用所有外键
				sqlList.clear();
				rs = objectDao.executeSql("select 'alter table '||table_name||' enable constraint '||constraint_name enableFk from user_constraints where constraint_type='R'");
				while(rs.next()){
					sqlList.add("execute immediate '" + rs.getString("enableFk") + "';");
				}
				if(CollectionUtils.isNotEmpty(sqlList)){
					objectDao.excuteSQL(StringUtils.join(sqlList," "));
				}
				DatabaseUtil.closeResultSetAndStatement(rs);
			}catch(Exception e1){
				e1.printStackTrace();
				assertTrue(false, "按oracle处理删除数据也报错");
			}
		}
	}
	
	/**
	 * 	初始化5个科室：<br/>
	 * 			1、组织机构（科室的根节点）<br/>
	 * 			2、测试供应室（供应室类型：一级供应室，条码：310000118）<br/>
	 * 			3、测试手术室（供应室类型：手术室，条码：310000119）<br/>
	 * 			4、测试内科（供应室类型：普通临床，条码：310000120）<br/>
	 * 			5、测试外科（供应室类型：普通临床，条码：310000121）<br/>
	 * 	初始化7个角色：<br/>
	 * 			1、系统管理员<br/>
	 * 			2、申领员<br/>
	 * 			3、回收员<br/>
	 * 			4、清洗员<br/>
	 * 			5、装配员<br/>
	 * 			6、审核员<br/>
	 * 			7、灭菌员<br/>
	 * 	初始化9个用户：<br/>
	 * 			1、admin（拥有的权限：系统管理员，所属科室：测试供应室）<br/>
	 * 			2、cssduser1（拥有的权限：系统管理员，所属科室：测试供应室）<br/>
	 * 			3、cssduser2（拥有的权限：回收员，所属科室：测试供应室）<br/>
	 * 			4、cssduser3（拥有的权限：清洗员、装配员、审核员、灭菌员，所属科室：测试供应室）<br/>
	 * 			5、oruser1（拥有的权限：系统管理员，所属科室：测试手术室）<br/>
	 * 			6、oruser2（拥有的权限：申领员，所属科室：测试手术室）<br/>
	 * 			7、oruser3（拥有的权限：申领员，所属科室：测试手术室）<br/>
	 * 			8、neikeuser1（拥有的权限：申领员，所属科室：测试内科）<br/>
	 * 			9、neikeuser2（拥有的权限：申领员，所属科室：测试内科）<br/>
	 * 
	 */
	private void initDirectoryInfo() {
		//初始化“组织机构”根节点
		initializeDataManager.initOrgUnit();
		OrgUnit orgUnitROOT = (OrgUnit) thTreeNodeManager.getTHTreeNodeById(
				OrgUnit.class.getSimpleName(), Long.valueOf(0));
		//创建“测试供应室”
		OrgUnit orgUnitCSSD = directoryHelper.createOrgUnit(
				Constants.ORG_UNIT_NAME_CSSD, Constants.ORG_UNIT_CODE_CSSD,
				"310000118", orgUnitROOT);
		//创建“测试手术室”
		OrgUnit orgUnitOR = directoryHelper.createOrgUnit(
				Constants.ORG_UNIT_NAME_OR, Constants.ORG_UNIT_CODE_OR,
				"310000119", orgUnitROOT);
		//创建“测试内科”
		OrgUnit neike = directoryHelper.createOrgUnit(
				Constants.ORG_UNIT_NAME_NEIKE, Constants.ORG_UNIT_CODE_NEIKE,
				"310000120", orgUnitROOT);
		
		//创建“测试外科”
		OrgUnit waike = directoryHelper.createOrgUnit(
				Constants.ORG_UNIT_NAME_WAIKE, Constants.ORG_UNIT_CODE_WAIKE,
				"310000121", orgUnitROOT);
		
		assertEquals("组织机构", orgUnitROOT.getName());
		assertTrue(directoryHelper.isOrgUnitCodeExist(Constants.ORG_UNIT_CODE_CSSD));
		assertTrue(directoryHelper.isOrgUnitCodeExist(Constants.ORG_UNIT_CODE_OR));
		assertTrue(directoryHelper.isOrgUnitCodeExist(Constants.ORG_UNIT_CODE_NEIKE));
		assertTrue(directoryHelper.isOrgUnitCodeExist(Constants.ORG_UNIT_CODE_WAIKE));
		//并且把一级供应室的id用一个变量接收起来，以备后用
		String orgUnitCSSDId = orgUnitCSSD.getId().toString();
		String orgUnitORId = orgUnitOR.getId().toString();
		String neikeId = neike.getId().toString();
		String orgUnitROOTCode = orgUnitROOT.getOrgUnitCoding();
		
		//初始化“operationdefine.xml”配置的权限
		initOperation();
		Role role_系统管理员 = createRole_系统管理员("0", orgUnitROOTCode, null);
		Role role_申领员 = createRole_申领员("1", orgUnitROOTCode, null);
		Role role_回收员 = createRole_回收员("2", orgUnitROOTCode, null);
		Role role_清洗员 = createRole_清洗员("3", orgUnitROOTCode, null);
		Role role_装配员 = createRole_装配员("4", orgUnitROOTCode, null);
		Role role_审核员 = createRole_审核员("5", orgUnitROOTCode, null);
		Role role_灭菌员 = createRole_灭菌员("6", orgUnitROOTCode, null);
		String rId0 = role_系统管理员.getId().toString();
		String rId1 = role_申领员.getId().toString();
		String rId2 = role_回收员.getId().toString();
		String rId3 = role_清洗员.getId().toString();
		String rId4 = role_装配员.getId().toString();
		String rId5 = role_审核员.getId().toString();
		String rId6 = role_灭菌员.getId().toString();
		
		User admin = createUser("admin", "0100001008", Constants.ORG_UNIT_CODE_CSSD, orgUnitCSSDId, rId0);
		User cssdUser1 = createUser("cssduser1", "0100001001", Constants.ORG_UNIT_CODE_CSSD, orgUnitCSSDId, rId0);
		User cssdUser2 = createUser("cssduser2", "0100001002", Constants.ORG_UNIT_CODE_CSSD, orgUnitCSSDId, rId2);
		User cssdUser3 = createUser("cssduser3", "0100001003", Constants.ORG_UNIT_CODE_CSSD, orgUnitCSSDId, String.format("%s;%s;%s;%s", rId3, rId4, rId5, rId6));
		User orUser1 = createUser("oruser1", "0100002001", Constants.ORG_UNIT_CODE_OR, orgUnitORId, rId0);
		User orUser2 = createUser("oruser2", "0100002002", Constants.ORG_UNIT_CODE_OR, orgUnitORId, rId1);
		User orUser3 = createUser("oruser3", "0100002003", Constants.ORG_UNIT_CODE_OR, orgUnitORId, rId1);
		User neikeUser1 = createUser("neikeuser1", "0100003001", Constants.ORG_UNIT_CODE_NEIKE, neikeId, rId1);
		User neikeUser2 = createUser("neikeuser2", "0100003002", Constants.ORG_UNIT_CODE_NEIKE, neikeId, rId1);
		
		assertTrue(directoryHelper.isUserName(admin.getName()));
		assertTrue(directoryHelper.isUserName(cssdUser1.getName()));
		assertTrue(directoryHelper.isUserName(cssdUser2.getName()));
		assertTrue(directoryHelper.isUserName(cssdUser3.getName()));
		assertTrue(directoryHelper.isUserName(orUser1.getName()));
		assertTrue(directoryHelper.isUserName(orUser2.getName()));
		assertTrue(directoryHelper.isUserName(orUser3.getName()));
		assertTrue(directoryHelper.isUserName(neikeUser1.getName()));
		assertTrue(directoryHelper.isUserName(neikeUser2.getName()));
	}

	/**
	 * 初始化“operationdefine.xml”配置的权限
	 */
	private void initOperation() {
		Set<Operation> xmlOperationList = operationManager
				.getOperationListFromXml();
		List<Operation> dbOperationList = operationManager.findAll();
		operationManager.removeDBOperationNotInXml(dbOperationList,
				xmlOperationList);
		operationManager.updateOperationToDB(dbOperationList, xmlOperationList);
	}

	/**
	 * 创建“系统管理员”角色
	 * @param simpleName		角色id
	 * @param companyId			科室编码	
	 * @param parentIds			父角色的id集合，用逗号分隔	
	 * @return					此角色对象
	 */
	private Role createRole_系统管理员(String simpleName, String companyId, String parentIds) {
		Set<Operation> xmlOperationList = operationManager
				.getOperationListFromXml();
		int length = xmlOperationList.size();
		String[] operationIds = new String[length];
		int temp = 0;
		for (Operation o : xmlOperationList) {
			operationIds[temp] = o.getOperationId();
			temp ++;
		}
		
		Role role = createRole(simpleName, "系统管理员", companyId, operationIds, parentIds);
		return role;
	}
	/**
	 * 创建“申领员”角色
	 * @param simpleName		角色id
	 * @param companyId			科室编码	
	 * @param parentIds			父角色的id集合，用逗号分隔	
	 * @return					此角色对象
	 */
	private Role createRole_申领员(String simpleName, String companyId, String parentIds) {
		String[] operationIds = {
				"SSTS_RecycApplication_Create",
				"SSTS_RecycApplication_Update",
				"SSTS_RecycApplication_Select",
				"SSTS_RecycApplication_Delete",
				"SSTS_DisposableGoods_Create",
				"SSTS_Disinfection_Create",
				"SSTS_PACKAGE_Create",
				"SSTS_Application_ShowAll",
				"SSTS_Application_ShowTodoOnly",
				"SSTS_Application_Custom_Create",
				"SSTS_ForeignTousseApplication_Create",
				"SSTS_ForeignTousseApplication_Update",
				"SSTS_ForeignTousseApplication_Select",
				"SSTS_ForeignTousseApplication_Delete",
				"SSTS_ForeignTousseApplication_Terminate",
				"SSTS_ForeignTousseApplication_ShowAll",
				"SSTS_DepartPrintApplicationGoods",
				"SSTS_PrintApplicationGoods",
				"SSTS_Invoice_Sign",
				"SSTS_recallRecyclingApplication",
				"SSTS_borrowRecord_Create",
				"SSTS_borrowRecord_Update",
				"SSTS_borrowRecord_Select",
				"SSTS_borrowRecord_Delete",
				"SSTS_borrow_Create",
				"SSTS_borrow_Update",
				"SSTS_borrow_Select",
				"SSTS_borrow_Delete",
				"SSTS_UseRecord_Create",
				"SSTS_UseRecord_Update",
				"SSTS_UseRecord_Select",
				"SSTS_UseRecord_Delete",
				"SSTS_UseRecord_Review",
				"SSTS_UseRecord_Convert",
				"SSTS_UseRecord_SeeAll"
		};
		Role role = createRole(simpleName, "申领员", companyId, operationIds, parentIds);
		return role;
	}
	/**
	 * 创建“回收员”角色
	 * @param simpleName		角色id
	 * @param companyId			科室编码	
	 * @param parentIds			父角色的id集合，用逗号分隔	
	 * @return					此角色对象
	 */
	private Role createRole_回收员(String simpleName, String companyId, String parentIds) {
		String[] operationIds = {
				"SSTS_RecycRecord_Create",
				"SSTS_RecycRecord_Update",
				"SSTS_RecycRecord_Select",
				"SSTS_RecycRecord_Delete"
		};
		Role role = createRole(simpleName, "回收员", companyId, operationIds, parentIds);
		return role;
	}
	/**
	 * 创建“清洗员”角色
	 * @param simpleName		角色id
	 * @param companyId			科室编码	
	 * @param parentIds			父角色的id集合，用逗号分隔	
	 * @return					此角色对象
	 */
	private Role createRole_清洗员(String simpleName, String companyId, String parentIds) {
		String[] operationIds = {
				"SSTS_WashRecord_Create",
				"SSTS_WashRecord_Update",
				"SSTS_WashRecord_Select",
				"SSTS_WashRecord_Delete",
				"SSTS_WashTransitionRecord_Create",
				"SSTS_WashTransitionRecord_Select"
		};
		Role role = createRole(simpleName, "清洗员", companyId, operationIds, parentIds);
		return role;
	}
	/**
	 * 创建“装配员”角色
	 * @param simpleName		角色id
	 * @param companyId			科室编码	
	 * @param parentIds			父角色的id集合，用逗号分隔	
	 * @return					此角色对象
	 */
	private Role createRole_装配员(String simpleName, String companyId, String parentIds) {
		String[] operationIds = {
				"SSTS_Packing_Manager",
				"SSTS_PackingTask_Delete",
				"SSTS_CustomPacking_Manager",
				"SSTS_HistoryPacking_Manager",
				"SSTS_HistoryPacking_Update",
				"SSTS_HistoryPacking_Change_Patient",
				"SSTS_RecyclingDetail_Print"
		};
		Role role = createRole(simpleName, "装配员", companyId, operationIds, parentIds);
		return role;
	}
	/**
	 * 创建“审核员”角色
	 * @param simpleName		角色id
	 * @param companyId			科室编码	
	 * @param parentIds			父角色的id集合，用逗号分隔	
	 * @return					此角色对象
	 */
	private Role createRole_审核员(String simpleName, String companyId, String parentIds) {
		String[] operationIds = {
				"SSTS_Tousse_Review"
		};
		Role role = createRole(simpleName, "审核员", companyId, operationIds, parentIds);
		return role;
	}
	/**
	 * 创建“灭菌员”角色
	 * @param simpleName		角色id
	 * @param companyId			科室编码	
	 * @param parentIds			父角色的id集合，用逗号分隔	
	 * @return					此角色对象
	 */
	private Role createRole_灭菌员(String simpleName, String companyId, String parentIds) {
		String[] operationIds = {
				"SSTS_Sterilization_Create",
				"SSTS_Sterilization_Update",
				"SSTS_Sterilization_Select",
				"SSTS_Sterilization_Delete",
				"SSTS_Sterilization_Loading",
				"SSTS_Sterilization_remove",
				"SSTS_ProxyDisinfection_Create",
				"SSTS_ProxyDisinfection_Update",
				"SSTS_ProxyDisinfection_Select",
				"SSTS_ProxyDisinfection_Delete",
				"SSTS_ForeignProxyDisinfection_Create",
				"SSTS_ForeignProxyDisinfection_Update",
				"SSTS_ForeignProxyDisinfection_Select",
				"SSTS_ForeignProxyDisinfection_Delete",
				"SSTS_ForeignProxyDisinfection_Apply"
		};
		Role role = createRole(simpleName, "灭菌员", companyId, operationIds, parentIds);
		return role;
	}
	
	/**
	 * 创建角色
	 * @param simpleName		角色id
	 * @param roleDescn			角色名称
	 * @param companyId			科室编码	
	 * @param operationIds		权限id数组	
	 * @param parentIds			父角色的id集合，用逗号分隔	
	 * @return					此角色对象
	 */
	private Role createRole(String simpleName, String roleDescn, String companyId,
			 String[] operationIds, String parentIds) {
		Role role = null;
		if (directoryHelper.isRoleName(roleDescn)) {
			role = roleManager.getRoleByRoleDescn(roleDescn);
		} else {
			role = new Role();
			role.setSimpleName(simpleName);
			role.setDescn(roleDescn);
			role.setCompanyId(companyId);
			Set<Operation> set = new HashSet<Operation>();
			for (String operationId : operationIds) {
				Operation operation = operationManager.getByOperationId(operationId);
				if (operation == null) {
					throw new RuntimeException(String.format("权限id“%s”不存在", operationId));
				} else {
					set.add(operation);
				}
				
			}
			role.setOperations(set);
			roleManager.save(role, parentIds);
		}
		return role;
	}
	
	/**
	 * 创建用户
	 * @param name					用户登录名
	 * @param barcode				用户条码
	 * @param currentOrgUnitCode	用户当前的科室编码
	 * @param orgUnitIds			用户所属的科室id集合，用分号分隔
	 * @param roleIds				用户拥有的角色id，用分号分隔
	 * @return						此用户对象
	 */
	private User createUser(String name, String barcode, String currentOrgUnitCode, String orgUnitIds, String roleIds) {
		User user = new User();
		user.setName(name);
		user.setFullName(name + "全名");
		user.setBarcode(barcode);
		user.setCurrentOrgUnitCode(currentOrgUnitCode);
		user.setPasswd("1");
		user.setOrgUnitIds(orgUnitIds);
		user.setRoleIds(roleIds);
		user.setType(BarcodeDevice.BARCODE_TYPE_USER);
		sysUserManager.saveUser(user);
		return user;
	}

	/**
	 * <h1>初始化基础数据</h1>
	 * <h2>初始化4个仓库</h2>
	 * 		1、测试供应室仓库1（条码：010009001，所属科室：测试供应室）<br/>
	 * 		2、测试手术室仓库1（条码：010009002，所属科室：测试手术室）<br/>
	 * 		3、测试内科仓库1（条码：010009003，所属科室：测试内科）<br/>
	 * 		4、测试外科仓库1（条码：010009004，所属科室：测试外科）
	 * 
	 * <h2>初始化3家供应商</h2>
	 * 		1、广州天成医疗技术有限公司（供货单位）<br/>
	 * 		2、浙江苏嘉（生产厂家）<br/>
	 * 		3、广州京弘电子有限公司（外来器械租用商）
	 * 
	 * <h2>初始化5个任务组</h2>
	 * 		1、常规组（所属科室：测试供应室）<br/>
	 * 		2、术科组（所属科室：测试供应室）<br/>
	 * 		3、外来器械组（所属科室：测试供应室）<br/>
	 * 		4、手术器械组（所属科室：测试手术室）<br/>
	 * 		5、临床器械组（所属科室：测试手术室）
	 * 
	 * <h2>初始化10种材料类型，存储于HttpOption表中</h2>
	 * 		1、器械<br/>
	 * 		2、金属<br/>
	 * 		3、棉布<br/>
	 * 		4、无纺布<br/>
	 * 		5、玻璃<br/>
	 * 		6、橡胶<br/>
	 * 		7、硅胶<br/>
	 * 		8、木质<br/>
	 * 		9、敷料<br/>
	 * 		10、塑料
	 * 
	 * <h2>初始化2种一次性物品类型，存储于HttpOption表中</h2>
	 * 		1、注射器<br/>
	 * 		1、纱块
	 *
	 * <h2>初始化2组灭菌炉分组，存储于HttpOption表中</h2>
	 * 		1、大型压力蒸汽<br/>
	 * 		2、低温等离子
	 *
	 * <h2>初始化灭4种菌目的，存储于HttpOption表中</h2>
	 * 		1、器械包灭菌<br/>
	 * 		2、每天例行监测<br/>
	 * 		3、装载监测<br/>
	 * 		4、更换部件或维护监测
	 *
	 * <h2>初始化7种包装类型，存储于HttpOption表中</h2>
	 * 		1、棉布<br/>
	 * 		2、纸塑<br/>
	 * 		3、无纺布(双层)<br/>
	 * 		4、灭菌盒<br/>
	 * 		5、槽<br/>
	 * 		6、器械盒<br/>
	 * 		7、胶带
	 *
	 * <h2>初始化8个清洗程序</h2>
	 * 	1、P1（条码：010172001）<br/>
	 * 	2、P2（条码：010172002）<br/>
	 * 	3、P3（条码：010172003）<br/>
	 * 	4、P4（条码：010172004）<br/>
	 * 	5、P5（条码：010172005）<br/>
	 * 	6、P6（条码：010172006）<br/>
	 * 	7、化学（条码：010172007）<br/>
	 * 	8、手工清洗（条码：010172008）<br/>
	 * 
	 * <h2>初始化2台清洗机</h2>
	 * 	1、清洗机1（属性科室：测试供应室，条码：010173001，含有的清洗程序：P1、P2、P3、P4）<br/>
	 * 	2、手工清洗（属性科室：测试手术室，条码：010173002，含有的清洗程序：P5、P6、化学、手工清洗）
	 *
	 * <h2>初始化9种灭菌程序</h2>
	 * 		1、P01（条码：010174001）<br/>
	 * 		2、P02（条码：010174002）<br/>
	 * 		3、P03（条码：010174003）<br/>
	 * 		4、P04（条码：010174004）<br/>
	 * 		5、P05（条码：010174005）<br/>
	 * 		6、P06（条码：010174006）<br/>
	 * 		7、低温等离子（条码：010174007）<br/>
	 * 		8、高水平消毒（条码：010174008）<br/>
	 * 		9、超大超重器械（条码：010174009）<br/>
	 * <h2>初始化2个灭菌炉</h2>
	 * 		1、1号高温蒸汽灭菌炉（所属科室：测试供应室，条码：010175001，含有的灭菌程序：P01、P02、P03、P04、P05）<br/>
	 * 		2、6号高温蒸汽灭菌炉（所属科室：测试手术室，条码：010175002，含有的灭菌程序：P06、低温等离子、高水平消毒、超大超重器械）
	 *
	 * <h2>初始化供应室配置</h2>
	 * 		1、科室供应室配置<br/>
	 * 		2、一级供应室（包含的科室：测试供应室）<br/>
	 * 		3、二级供应室（包含的科室：测试手术室）<br/>
	 * 		4、申请科室（包含的科室：测试内科、测试外科）<br/>
	 * 		5、结算科室（包含的科室：测试内科、测试外科）
	 *
	 * <h2>初始化4个清洗篮筐</h2>
	 * 		1、清洗筐116（条码：019000001，所属科室：测试供应室）<br/>
	 * 		2、清洗筐117（条码：019000002，所属科室：测试供应室）<br/>
	 * 		3、清洗筐118（条码：019000003，所属科室：测试供应室）<br/>
	 * 		4、清洗筐119（条码：019000004，所属科室：测试供应室）<br/>
	 * 
	 * <h2>初始化2个灭菌篮筐</h2>
	 * 		1、灭菌筐01（条码：018000001，所属科室：测试供应室）<br/>
	 * 		2、灭菌筐02（条码：018000002，所属科室：测试供应室）<br/>
	 * 		3、灭菌筐001（条码：018000101，所属科室：测试手术室）<br/>
	 * 
	 * <h2>初始化999个虚拟篮筐：（条码：001~999）</h2>
	 * 
	 */
	private void initBaseData() {
		//初始化序列号
		initSerialNum();
		//初始化4个仓库
		initWareHouse();
		//初始化3家供应商
		initSupplier();
		//初始化5个任务组
		initTaskGroup();
		//初始化10种材料类型
		initMaterialType();
		//初始化2种一次性物品类型
		initDisposableGoodsType();
		//初始化2组灭菌炉分组
		initSterilerGroup();
		//初始化灭4种菌目的
		initSterilizationPurpose();
		//初始化7种包装类型
		initPackingType();
		//初始化8个清洗程序，3台清洗机
		initCleanMethodAndRinser();
		//初始化9种灭菌程序，2个灭菌炉
		initSterilisationAndSterilizer();
		//初始化供应室配置
		initSupplyRoomConfig();
		//初始化4个清洗篮筐、3个灭菌篮筐、999个虚拟篮筐
		initContainer();
	}
	
	/**
	 * 初始化序列号类,否则会报错
	 */
	private 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);
			}
		});
	}
	

	/**
	 * 初始化4个仓库：<br/>
	 * 		1、测试供应室仓库1（条码：010009001，所属科室：测试供应室）<br/>
	 * 		2、测试手术室仓库1（条码：010009002，所属科室：测试手术室）<br/>
	 * 		3、测试内科仓库1（条码：010009003，所属科室：测试内科）<br/>
	 * 		4、测试外科仓库1（条码：010009004，所属科室：测试外科）
	 */
	private void initWareHouse() {
		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(Constants.ORG_UNIT_CODE_NEIKE);
		wareHouse3.setOrgUnitName(Constants.ORG_UNIT_NAME_NEIKE);
		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(Constants.ORG_UNIT_CODE_WAIKE);
		wareHouse4.setOrgUnitName(Constants.ORG_UNIT_NAME_WAIKE);
		wareHouse4.setBarcode("010009004");
		wareHouse4.setType(BarcodeDevice.BARCODE_TYPE_WAREHOUSE);
		wareHouse4.setSequence(1L);
		objectDao.save(wareHouse4);
	}
	

	/**
	 * 初始化3家供应商：<br/>
	 * 		1、广州天成医疗技术有限公司（供货单位）<br/>
	 * 		2、浙江苏嘉（生产厂家）<br/>
	 * 		3、广州京弘电子有限公司（外来器械租用商）
	 * 
	 */
	private void initSupplier(){
		Supplier sup1 = new Supplier();
		sup1.setCompanyName("广州天成医疗技术有限公司");
		sup1.setSpelling("GZTCYLJSYXGS");
		sup1.setRentTousse(Supplier.SUPPLIER_TYPE_SUPPLIER);
		objectDao.saveOrUpdate(sup1);
		
		Supplier sup2 = new Supplier();
		sup2.setCompanyName("浙江苏嘉");
		sup2.setSpelling("ZJSJ");
		sup2.setRentTousse(Supplier.SUPPLIER_TYPE_MADECOMPANY);
		objectDao.saveOrUpdate(sup2);
		
		Supplier sup3 = new Supplier();
		sup3.setCompanyName("广州京弘电子有限公司");
		sup3.setSpelling("GZJHDZYXGS");
		sup3.setRentTousse(Supplier.SUPPLIER_TYPE_RENTTOUSSE);
		objectDao.saveOrUpdate(sup3);
	}
	
	/**
	 * 初始化5个任务组：<br/>
	 * 		1、常规组（所属科室：测试供应室）<br/>
	 * 		2、术科组（所属科室：测试供应室）<br/>
	 * 		3、外来器械组（所属科室：测试供应室）<br/>
	 * 		4、手术器械组（所属科室：测试手术室）<br/>
	 * 		5、临床器械组（所属科室：测试手术室）
	 */
	private void initTaskGroup() {
		TaskGroup tg_常规组 = new TaskGroup();
		tg_常规组.setTaskGroupName(Constants.TASKGROUP_CHANGGUZU);
		tg_常规组.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tg_常规组.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		
		TaskGroup tg_术科组 = new TaskGroup();
		tg_术科组.setTaskGroupName(Constants.TASKGROUP_SHUKEZU);
		tg_术科组.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tg_术科组.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		
		TaskGroup tg_外来器械组 = new TaskGroup();
		tg_外来器械组.setTaskGroupName(Constants.TASKGROUP_WAILAIQIXIEZU);
		tg_外来器械组.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tg_外来器械组.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		
		TaskGroup tg_手术器械组 = new TaskGroup();
		tg_手术器械组.setTaskGroupName(Constants.TASKGROUP_SHOUSHUQIXIEZU);
		tg_手术器械组.setDepartCode(Constants.ORG_UNIT_CODE_OR);
		tg_手术器械组.setDepartName(Constants.ORG_UNIT_NAME_OR);
		
		TaskGroup tg_临床器械组 = new TaskGroup();
		tg_临床器械组.setTaskGroupName(Constants.TASKGROUP_LINCHUANGQIXIEZU);
		tg_临床器械组.setDepartCode(Constants.ORG_UNIT_CODE_OR);
		tg_临床器械组.setDepartName(Constants.ORG_UNIT_NAME_OR);
		
		
		objectDao.saveOrUpdate(tg_常规组);
		objectDao.saveOrUpdate(tg_术科组);
		objectDao.saveOrUpdate(tg_外来器械组);
		objectDao.saveOrUpdate(tg_手术器械组);
		objectDao.saveOrUpdate(tg_临床器械组);
	}

	/**
	 * 初始化10种材料类型，存储于HttpOption表中：<br/>
	 * 		1、器械<br/>
	 * 		2、金属<br/>
	 * 		3、棉布<br/>
	 * 		4、无纺布<br/>
	 * 		5、玻璃<br/>
	 * 		6、橡胶<br/>
	 * 		7、硅胶<br/>
	 * 		8、木质<br/>
	 * 		9、敷料<br/>
	 * 		10、塑料
	 */
	private void initMaterialType(){
		HttpOption httpoptionMT1 = new HttpOption();
		httpoptionMT1.setOptionListId(HttpOption.SYSTEMSETTING_MATERIALTYPE);
		httpoptionMT1.setOptionText("器械");
		httpoptionMT1.setOptionValue("器械");
		httpoptionMT1.setSequence(1);
		objectDao.saveOrUpdate(httpoptionMT1);
		
		HttpOption httpoptionMT2 = new HttpOption();
		httpoptionMT2.setOptionListId(HttpOption.SYSTEMSETTING_MATERIALTYPE);
		httpoptionMT2.setOptionText("金属");
		httpoptionMT2.setOptionValue("金属");
		httpoptionMT2.setSequence(2);
		objectDao.saveOrUpdate(httpoptionMT2);
		
		HttpOption httpoptionMT3 = new HttpOption();
		httpoptionMT3.setOptionListId(HttpOption.SYSTEMSETTING_MATERIALTYPE);
		httpoptionMT3.setOptionText("棉布");
		httpoptionMT3.setOptionValue("棉布");
		httpoptionMT3.setSequence(3);
		objectDao.saveOrUpdate(httpoptionMT3);
		
		HttpOption httpoptionMT4 = new HttpOption();
		httpoptionMT4.setOptionListId(HttpOption.SYSTEMSETTING_MATERIALTYPE);
		httpoptionMT4.setOptionText("无纺布");
		httpoptionMT4.setOptionValue("无纺布");
		httpoptionMT4.setSequence(4);
		objectDao.saveOrUpdate(httpoptionMT4);
		
		HttpOption httpoptionMT5 = new HttpOption();
		httpoptionMT5.setOptionListId(HttpOption.SYSTEMSETTING_MATERIALTYPE);
		httpoptionMT5.setOptionText("玻璃");
		httpoptionMT5.setOptionValue("玻璃");
		httpoptionMT5.setSequence(5);
		objectDao.saveOrUpdate(httpoptionMT5);
		
		HttpOption httpoptionMT6 = new HttpOption();
		httpoptionMT6.setOptionListId(HttpOption.SYSTEMSETTING_MATERIALTYPE);
		httpoptionMT6.setOptionText("橡胶");
		httpoptionMT6.setOptionValue("橡胶");
		httpoptionMT6.setSequence(6);
		objectDao.saveOrUpdate(httpoptionMT6);
		
		HttpOption httpoptionMT7 = new HttpOption();
		httpoptionMT7.setOptionListId(HttpOption.SYSTEMSETTING_MATERIALTYPE);
		httpoptionMT7.setOptionText("硅胶");
		httpoptionMT7.setOptionValue("硅胶");
		httpoptionMT7.setSequence(7);
		objectDao.saveOrUpdate(httpoptionMT7);
		
		HttpOption httpoptionMT8 = new HttpOption();
		httpoptionMT8.setOptionListId(HttpOption.SYSTEMSETTING_MATERIALTYPE);
		httpoptionMT8.setOptionText("木质");
		httpoptionMT8.setOptionValue("木质");
		httpoptionMT8.setSequence(8);
		objectDao.saveOrUpdate(httpoptionMT8);
		
		HttpOption httpoptionMT9 = new HttpOption();
		httpoptionMT9.setOptionListId(HttpOption.SYSTEMSETTING_MATERIALTYPE);
		httpoptionMT9.setOptionText("敷料");
		httpoptionMT9.setOptionValue("敷料");
		httpoptionMT9.setSequence(9);
		objectDao.saveOrUpdate(httpoptionMT9);
		
		HttpOption httpoptionMT10 = new HttpOption();
		httpoptionMT10.setOptionListId(HttpOption.SYSTEMSETTING_MATERIALTYPE);
		httpoptionMT10.setOptionText("塑料");
		httpoptionMT10.setOptionValue("塑料");
		httpoptionMT10.setSequence(10);
		objectDao.saveOrUpdate(httpoptionMT10);
	}
	

	/**
	 * 初始化2种一次性物品类型，存储于HttpOption表中：<br/>
	 * 		1、注射器<br/>
	 * 		1、纱块
	 */
	private void initDisposableGoodsType() {
		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);
	}
	
	/**
	 * 初始化2组灭菌炉分组，存储于HttpOption表中：<br/>
	 * 		1、大型压力蒸汽<br/>
	 * 		2、低温等离子
	 */
	private void initSterilerGroup(){
		HttpOption sterilerGroup1 = new HttpOption();
		sterilerGroup1.setOptionListId(HttpOption.SYSTEMSETTING_STERILIZER_GROUP);
		sterilerGroup1.setOptionText("大型压力蒸汽");
		sterilerGroup1.setOptionValue("大型压力蒸汽");
		sterilerGroup1.setSequence(1);
		objectDao.saveOrUpdate(sterilerGroup1);
		
		HttpOption sterilerGroup2 = new HttpOption();
		sterilerGroup2.setOptionListId(HttpOption.SYSTEMSETTING_STERILIZER_GROUP);
		sterilerGroup2.setOptionText("低温等离子");
		sterilerGroup2.setOptionValue("低温等离子");
		sterilerGroup2.setSequence(2);
		objectDao.saveOrUpdate(sterilerGroup2);
	}
	
	/**
	 * 初始化灭4种菌目的，存储于HttpOption表中：<br/>
	 * 		1、器械包灭菌<br/>
	 * 		2、每天例行监测<br/>
	 * 		3、装载监测<br/>
	 * 		4、更换部件或维护监测
	 */
	private void initSterilizationPurpose(){
		HttpOption stserilizationPurpose1 = new HttpOption();
		stserilizationPurpose1.setOptionListId(HttpOption.SYSTEMSETTING_STERILIZATIONPURPOSE);
		stserilizationPurpose1.setOptionText("器械包灭菌");
		stserilizationPurpose1.setOptionValue("器械包灭菌");
		stserilizationPurpose1.setSequence(1);
		objectDao.saveOrUpdate(stserilizationPurpose1);
		
		HttpOption stserilizationPurpose2 = new HttpOption();
		stserilizationPurpose2.setOptionListId(HttpOption.SYSTEMSETTING_STERILIZATIONPURPOSE);
		stserilizationPurpose2.setOptionText("每天例行监测");
		stserilizationPurpose2.setOptionValue("每天例行监测");
		stserilizationPurpose2.setSequence(2);
		objectDao.saveOrUpdate(stserilizationPurpose2);
		
		HttpOption stserilizationPurpose3 = new HttpOption();
		stserilizationPurpose3.setOptionListId(HttpOption.SYSTEMSETTING_STERILIZATIONPURPOSE);
		stserilizationPurpose3.setOptionText("装载监测");
		stserilizationPurpose3.setOptionValue("装载监测");
		stserilizationPurpose3.setSequence(3);
		objectDao.saveOrUpdate(stserilizationPurpose3);
		
		HttpOption stserilizationPurpose4 = new HttpOption();
		stserilizationPurpose4.setOptionListId(HttpOption.SYSTEMSETTING_STERILIZATIONPURPOSE);
		stserilizationPurpose4.setOptionText("更换部件或维护监测");
		stserilizationPurpose4.setOptionValue("更换部件或维护监测");
		stserilizationPurpose4.setSequence(4);
		objectDao.saveOrUpdate(stserilizationPurpose4);
	}
	
	/**
	 * 初始化7种包装类型，存储于HttpOption表中：<br/>
	 * 		1、棉布<br/>
	 * 		2、纸塑<br/>
	 * 		3、无纺布(双层)<br/>
	 * 		4、灭菌盒<br/>
	 * 		5、槽<br/>
	 * 		6、器械盒<br/>
	 * 		7、胶带
	 */
	private void initPackingType(){
		HttpOption httpoptionPackingTpye1 = new HttpOption();
		httpoptionPackingTpye1.setOptionListId(HttpOption.SYSTEMSETTING_PACKAGING_TYPE);
		httpoptionPackingTpye1.setOptionText("棉布");
		httpoptionPackingTpye1.setOptionValue("棉布");
		httpoptionPackingTpye1.setSequence(1);
		objectDao.saveOrUpdate(httpoptionPackingTpye1);
		
		HttpOption httpoptionPackingTpye2 = new HttpOption();
		httpoptionPackingTpye2.setOptionListId(HttpOption.SYSTEMSETTING_PACKAGING_TYPE);
		httpoptionPackingTpye2.setOptionText("纸塑");
		httpoptionPackingTpye2.setOptionValue("纸塑");
		httpoptionPackingTpye2.setSequence(2);
		objectDao.saveOrUpdate(httpoptionPackingTpye2);
		
		HttpOption httpoptionPackingTpye3 = new HttpOption();
		httpoptionPackingTpye3.setOptionListId(HttpOption.SYSTEMSETTING_PACKAGING_TYPE);
		httpoptionPackingTpye3.setOptionText("无纺布(双层)");
		httpoptionPackingTpye3.setOptionValue("无纺布(双层)");
		httpoptionPackingTpye3.setSequence(3);
		objectDao.saveOrUpdate(httpoptionPackingTpye3);
		
		HttpOption httpoptionPackingTpye4 = new HttpOption();
		httpoptionPackingTpye4.setOptionListId(HttpOption.SYSTEMSETTING_PACKAGING_TYPE);
		httpoptionPackingTpye4.setOptionText("灭菌盒");
		httpoptionPackingTpye4.setOptionValue("灭菌盒");
		httpoptionPackingTpye4.setSequence(4);
		objectDao.saveOrUpdate(httpoptionPackingTpye4);
		
		HttpOption httpoptionPackingTpye5 = new HttpOption();
		httpoptionPackingTpye5.setOptionListId(HttpOption.SYSTEMSETTING_PACKAGING_TYPE);
		httpoptionPackingTpye5.setOptionText("槽");
		httpoptionPackingTpye5.setOptionValue("槽");
		httpoptionPackingTpye5.setSequence(5);
		objectDao.saveOrUpdate(httpoptionPackingTpye5);
		
		HttpOption httpoptionPackingTpye6 = new HttpOption();
		httpoptionPackingTpye6.setOptionListId(HttpOption.SYSTEMSETTING_PACKAGING_TYPE);
		httpoptionPackingTpye6.setOptionText("器械盒");
		httpoptionPackingTpye6.setOptionValue("器械盒");
		httpoptionPackingTpye6.setSequence(6);
		objectDao.saveOrUpdate(httpoptionPackingTpye6);
		
		HttpOption httpoptionPackingTpye7 = new HttpOption();
		httpoptionPackingTpye7.setOptionListId(HttpOption.SYSTEMSETTING_PACKAGING_TYPE);
		httpoptionPackingTpye7.setOptionText("胶带");
		httpoptionPackingTpye7.setOptionValue("胶带");
		httpoptionPackingTpye7.setSequence(7);
		objectDao.saveOrUpdate(httpoptionPackingTpye7);
	}
	
	/**
	 * 初始化8个清洗程序：<br/>
	 * 	1、P1（条码：010172001）<br/>
	 * 	2、P2（条码：010172002）<br/>
	 * 	3、P3（条码：010172003）<br/>
	 * 	4、P4（条码：010172004）<br/>
	 * 	5、P5（条码：010172005）<br/>
	 * 	6、P6（条码：010172006）<br/>
	 * 	7、化学（条码：010172007）<br/>
	 * 	8、手工清洗（条码：010172008）<br/>
	 * 
	 * 初始化3台清洗机：<br/>
	 * 	1、清洗机1（属性科室：测试供应室，条码：010173001，含有的清洗程序：P1、P2、P3、P4）<br/>
	 * 	2、手工清洗（属性科室：测试手术室，条码：010173002，含有的清洗程序：P5、P6、化学、手工清洗）
	 *  3、清洗机2（属性科室：测试手术室，条码：010173003，含有的清洗程序：P5、P6） 需要确认完成
	 */
	private void initCleanMethodAndRinser(){
		Rinser rinser1 = new Rinser();
		rinser1.setBarcode("010173001");
		rinser1.setName("清洗机1");
		rinser1.setDepartment(Constants.ORG_UNIT_NAME_CSSD);
		rinser1.setOrgUnitCoding(Constants.ORG_UNIT_CODE_CSSD);
		
		CleanMethod cleanMethod1 = new CleanMethod();
		cleanMethod1.setBarcode("010172001");
		cleanMethod1.setCleanMethod("P1");
		cleanMethod1.setCleanMinutes(30);
		cleanMethod1.setCleanParameter("POWER CLEAN，适用于污垢严重器械的清洗消毒。上酶，上润滑油。");
		cleanMethod1.setValue("600");
		objectDao.saveOrUpdate(cleanMethod1);
		
		CleanMethod cleanMethod2 = new CleanMethod();
		cleanMethod2.setBarcode("010172002");
		cleanMethod2.setCleanMethod("P2");
		cleanMethod2.setCleanMinutes(30);
		cleanMethod2.setCleanParameter("OP-D-3，适用于常规器械的清洗消毒，上酶，上润滑油。");
		cleanMethod2.setValue("3000");
		objectDao.saveOrUpdate(cleanMethod2);
		
		CleanMethod cleanMethod3 = new CleanMethod();
		cleanMethod3.setBarcode("010172003");
		cleanMethod3.setCleanMethod("P3");
		cleanMethod3.setCleanMinutes(30);
		cleanMethod3.setCleanParameter("OP-SHORT-D-3，适用于治疗碗/碗盘等的清洗消毒。上酶。");
		cleanMethod3.setValue("3000");
		objectDao.saveOrUpdate(cleanMethod3);
		
		CleanMethod cleanMethod4 = new CleanMethod();
		cleanMethod4.setBarcode("010172004");
		cleanMethod4.setCleanMethod("P4");
		cleanMethod4.setCleanMinutes(30);
		cleanMethod4.setCleanParameter("AN-D，适用于呼吸/麻醉管道的清洗消毒（需配专用装载架）");
		cleanMethod4.setValue("3000");
		objectDao.saveOrUpdate(cleanMethod4);
		
		Set<CleanMethod> cleanMethods1 = new HashSet<CleanMethod>();
		cleanMethods1.add(cleanMethod1);
		cleanMethods1.add(cleanMethod2);
		cleanMethods1.add(cleanMethod3);
		cleanMethods1.add(cleanMethod4);
		rinser1.setCleanMethods(cleanMethods1);
		objectDao.saveOrUpdate(rinser1);
		
		Rinser rinser2 = new Rinser();
		rinser2.setBarcode("010173002");
		rinser2.setName("手工清洗");
		rinser2.setDepartment(Constants.ORG_UNIT_NAME_OR);
		rinser2.setOrgUnitCoding(Constants.ORG_UNIT_CODE_OR);
		
		CleanMethod cleanMethod5 = new CleanMethod();
		cleanMethod5.setBarcode("010172005");
		cleanMethod5.setCleanMethod("P5");
		cleanMethod5.setCleanMinutes(30);
		cleanMethod5.setCleanParameter("AN-BGA（A+B）-D，适用于污染严重的呼吸/麻醉管道的清洗（需配专用装载架）");
		cleanMethod5.setValue("3000");
		objectDao.saveOrUpdate(cleanMethod5);
		
		CleanMethod cleanMethod6 = new CleanMethod();
		cleanMethod6.setBarcode("010172006");
		cleanMethod6.setCleanMethod("P6");
		cleanMethod6.setCleanMinutes(30);
		cleanMethod6.setCleanParameter("OP-BGA（A+B）-D，适用于污染严重器械的清洗消毒。");
		cleanMethod6.setValue("3000");
		objectDao.saveOrUpdate(cleanMethod6);
		
		CleanMethod cleanMethod7 = new CleanMethod();
		cleanMethod7.setBarcode("010172007");
		cleanMethod7.setCleanMethod("化学");
		cleanMethod7.setCleanMinutes(45);
		cleanMethod7.setCleanParameter("化学侵泡后清洗");
		cleanMethod7.setValue("6000");
		objectDao.saveOrUpdate(cleanMethod7);
		
		CleanMethod cleanMethod8 = new CleanMethod();
		cleanMethod8.setBarcode("010172008");
		cleanMethod8.setCleanMethod("手工清洗");
		cleanMethod8.setCleanMinutes(30);
		cleanMethod8.setCleanParameter("化学侵泡后清洗");
		cleanMethod8.setValue("600");
		objectDao.saveOrUpdate(cleanMethod8);
		Set<CleanMethod> cleanMethods2 = new HashSet<CleanMethod>();
		cleanMethods2.add(cleanMethod5);
		cleanMethods2.add(cleanMethod6);
		cleanMethods2.add(cleanMethod7);
		cleanMethods2.add(cleanMethod8);
		rinser2.setCleanMethods(cleanMethods2);
		
		objectDao.saveOrUpdate(rinser2);
		
		Rinser rinser3 = new Rinser();
		rinser3.setBarcode("010173003");
		rinser3.setName("清洗机2");
		rinser3.setDepartment(Constants.ORG_UNIT_NAME_CSSD);
		rinser3.setOrgUnitCoding(Constants.ORG_UNIT_CODE_CSSD);
		rinser3.setIsWashConfirm(com.forgon.Constants.STR_YES);
		
		Set<CleanMethod> cleanMethods3 = new HashSet<CleanMethod>();
		cleanMethods3.add(cleanMethod5);
		cleanMethods3.add(cleanMethod6);
		rinser3.setCleanMethods(cleanMethods3);
		objectDao.saveOrUpdate(rinser3);
		
	}

	/**
	 * 初始化9种灭菌程序：<br/>
	 * 		1、P01（条码：010174001）<br/>
	 * 		2、P02（条码：010174002）<br/>
	 * 		3、P03（条码：010174003）<br/>
	 * 		4、P04（条码：010174004）<br/>
	 * 		5、P05（条码：010174005）<br/>
	 * 		6、P06（条码：010174006）<br/>
	 * 		7、低温等离子（条码：010174007）<br/>
	 * 		8、高水平消毒（条码：010174008）<br/>
	 * 		9、超大超重器械（条码：010174009）<br/>
	 * 初始化2个灭菌炉：<br/>
	 * 		1、1号高温蒸汽灭菌炉（所属科室：测试供应室，条码：010175001，含有的灭菌程序：P01、P02、P03、P04、P05）<br/>
	 * 		2、6号高温蒸汽灭菌炉（所属科室：测试手术室，条码：010175002，含有的灭菌程序：P06、低温等离子、高水平消毒、超大超重器械）
	 */
	private void initSterilisationAndSterilizer(){
		Sterilisation sterilisation1 = new Sterilisation();
		sterilisation1.setBarcode("010174001");
		sterilisation1.setSterilisation("P01");
		sterilisation1.setParameter("包装工具,织品，多孔负载（134·C？10 Min）");
		objectDao.saveOrUpdate(sterilisation1);
		
		Sterilisation sterilisation2 = new Sterilisation();
		sterilisation2.setBarcode("010174002");
		sterilisation2.setSterilisation("P02");
		sterilisation2.setParameter("包装，热敏材料，橡胶，多孔负载（121·C 16 Min）");
		objectDao.saveOrUpdate(sterilisation2);
		
		Sterilisation sterilisation3 = new Sterilisation();
		sterilisation3.setBarcode("010174003");
		sterilisation3.setSterilisation("P03");
		sterilisation3.setParameter("单个、未包缠的器械快速过程（134°C 4 Min）");
		objectDao.saveOrUpdate(sterilisation3);
		
		Sterilisation sterilisation4 = new Sterilisation();
		sterilisation4.setBarcode("010174004");
		sterilisation4.setSterilisation("P04");
		sterilisation4.setParameter("B/D测试程序");
		sterilisation4.setSterilizationPurpose("每天例行监测");
		objectDao.saveOrUpdate(sterilisation4);
		
		Sterilisation sterilisation5 = new Sterilisation();
		sterilisation5.setBarcode("010174005");
		sterilisation5.setSterilisation("P05");
		sterilisation5.setParameter("自动测漏程序");
		objectDao.saveOrUpdate(sterilisation5);
		
		Sterilisation sterilisation6 = new Sterilisation();
		sterilisation6.setBarcode("010174006");
		sterilisation6.setSterilisation("P06");
		sterilisation6.setParameter("包装工具、重型（134°C 4 Min）");
		objectDao.saveOrUpdate(sterilisation6);
		
		Sterilisation sterilisation7 = new Sterilisation();
		sterilisation7.setBarcode("010174007");
		sterilisation7.setSterilisation("低温等离子");
		sterilisation7.setParameter("低温等离子");
		sterilisation7.setSterilizationPurpose("器械包灭菌");
		objectDao.saveOrUpdate(sterilisation7);
		
		Sterilisation sterilisation8 = new Sterilisation();
		sterilisation8.setBarcode("010174008");
		sterilisation8.setSterilisation("高水平消毒");
		sterilisation8.setParameter("呼吸机管道，湿化瓶");
		objectDao.saveOrUpdate(sterilisation8);
		
		Sterilisation sterilisation9 = new Sterilisation();
		sterilisation9.setBarcode("010174009");
		sterilisation9.setSterilisation("超大超重");
		sterilisation9.setParameter("超大超重器械");
		sterilisation9.setSterilizationPurpose("器械包灭菌");
		objectDao.saveOrUpdate(sterilisation9);
		
		// 灭菌炉(属于供应室)
		Sterilizer sterilizer1 = new Sterilizer();
		sterilizer1.setName("1号高温蒸汽灭菌炉");
		sterilizer1.setBarcode("010175001");
		sterilizer1.setOwnGroup("大型压力蒸汽");
//		OrgUnit cssdDept = thTreeNodeManager.getOrgUnitByName(Constants.ORG_UNIT_NAME_CSSD, false);
		OrgUnit orgUnitCSSD = orgUnitManager.getByCode(Constants.ORG_UNIT_CODE_CSSD);
		assertNotNull(orgUnitCSSD);
		
		sterilizer1.setDepartment(orgUnitCSSD.getName());
		sterilizer1.setOrgUnitCoding(orgUnitCSSD.getOrgUnitCoding());
		// 设置灭菌程序
		Set<Sterilisation> sterilisations1 = new HashSet<Sterilisation>();
		sterilisations1.add(sterilisation1);
		sterilisations1.add(sterilisation2);
		sterilisations1.add(sterilisation3);
		sterilisations1.add(sterilisation4);
		sterilisations1.add(sterilisation5);
		sterilizer1.setSterilisations(sterilisations1);
		objectDao.save(sterilizer1);
		

		// 灭菌炉(属于二级供应室--手术室)
		Sterilizer sterilizer2 = new Sterilizer();
		sterilizer2.setName("6号高温蒸汽灭菌炉");
		sterilizer2.setBarcode("010175002");
		sterilizer2.setOwnGroup("低温等离子");
//		OrgUnit orDept = thTreeNodeManager.getOrgUnitByName(Constants.ORG_UNIT_NAME_OR, false);
		OrgUnit orgUnitOR = orgUnitManager.getByCode(Constants.ORG_UNIT_CODE_OR);
		assertNotNull(orgUnitOR);
		
		sterilizer2.setDepartment(orgUnitOR.getName());
		sterilizer2.setOrgUnitCoding(orgUnitOR.getOrgUnitCoding());
		// 设置灭菌程序
		Set<Sterilisation> sterilisations2 = new HashSet<Sterilisation>();
		sterilisations2.add(sterilisation6);
		sterilisations2.add(sterilisation7);
		sterilisations2.add(sterilisation8);
		sterilisations2.add(sterilisation9);
		sterilizer2.setSterilisations(sterilisations2);
		objectDao.save(sterilizer2);
	}
	
	/**
	 * 初始化供应室配置：<br/>
	 * 		1、科室供应室配置<br/>
	 * 		2、一级供应室（包含的科室：测试供应室）<br/>
	 * 		3、二级供应室（包含的科室：测试手术室）<br/>
	 * 		4、申请科室（包含的科室：测试内科、测试外科）<br/>
	 * 		5、结算科室（包含的科室：测试内科、测试外科）
	 */
	private void initSupplyRoomConfig() {
		//科室供应室配置
		SupplyRoomConfig supplyRoomConfig = new SupplyRoomConfig();
		supplyRoomConfig.setDayStartTime("05:00");
		supplyRoomConfig.setDisposableGoodsExpTime(20);
		supplyRoomConfig.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_0);
		supplyRoomConfig.setDefalutTaskGroup(Constants.TASKGROUP_WAILAIQIXIEZU);//外来器械处理任务组
		supplyRoomConfig.setForeignTousseCleanedEntirely(com.forgon.Constants.STR_YES);//外来器械是否整包清洗
		supplyRoomConfig.setBigPackageSterilizerType("超大超重");//超大、重外来器械灭菌方式
		supplyRoomConfig.setDptNameOfForeignTousse(Constants.ORG_UNIT_NAME_CSSD);//外来器械包处理科室
		supplyRoomConfig.setDptCodeOfForeignTousse(Constants.ORG_UNIT_CODE_CSSD);//外来器械包处理科室编码
		supplyRoomConfig.setFtDefaultPackageType("纸塑");//外来器械默认包装类型
		supplyRoomConfig.setFtDefaultSterilingMethod("P01");//自定义器械处理任务组
		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.setIsPackingAfterWashTimeEnd(false);
		supplyRoomConfig.setIsSecondSupplyRoomAutoInvoice(SupplyRoomConfig.SECONDSUPPLYROOM_AUTOINVOICE_FROMALLORG);
		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(Constants.ORG_UNIT_CODE_NEIKE);
		supplyRoomConfig30.setOrgUnitName(Constants.ORG_UNIT_NAME_NEIKE);
		supplyRoomConfig30.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_3);
		SupplyRoomConfig supplyRoomConfig40 = new SupplyRoomConfig();
		supplyRoomConfig40.setOrgUnitCoding(Constants.ORG_UNIT_CODE_WAIKE);
		supplyRoomConfig40.setOrgUnitName(Constants.ORG_UNIT_NAME_WAIKE);
		supplyRoomConfig40.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_3);
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig30);
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig40);
		
		//结算科室（测试内科、测试外科）
		SupplyRoomConfig supplyRoomConfig31 = new SupplyRoomConfig();
		supplyRoomConfig31.setOrgUnitCoding(Constants.ORG_UNIT_CODE_NEIKE);
		supplyRoomConfig31.setOrgUnitName(Constants.ORG_UNIT_NAME_NEIKE);
		supplyRoomConfig31.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_4);
		SupplyRoomConfig supplyRoomConfig41 = new SupplyRoomConfig();
		supplyRoomConfig41.setOrgUnitCoding(Constants.ORG_UNIT_CODE_WAIKE);
		supplyRoomConfig41.setOrgUnitName(Constants.ORG_UNIT_NAME_WAIKE);
		supplyRoomConfig41.setSupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_4);
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig31);
		supplyRoomConfigManager.saveOrUpdate(supplyRoomConfig41);
	}

	/**
	 * 初始化4个清洗篮筐：<br/>
	 * 		1、清洗筐116（条码：019000001，所属科室：测试供应室）<br/>
	 * 		2、清洗筐117（条码：019000002，所属科室：测试供应室）<br/>
	 * 		3、清洗筐118（条码：019000003，所属科室：测试供应室）<br/>
	 * 		4、清洗筐119（条码：019000004，所属科室：测试供应室）<br/>
	 * 
	 * 初始化3个灭菌篮筐：<br/>
	 * 		1、灭菌筐01（条码：018000001，所属科室：测试供应室）<br/>
	 * 		2、灭菌筐02（条码：018000002，所属科室：测试供应室）<br/>
	 * 		3、灭菌筐001（条码：018000101，所属科室：测试手术室）<br/>
	 * 
	 * 初始化999个虚拟篮筐：（条码：001~999）
	 * 
	 */
	private void initContainer() {
		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);
		container1.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		container1.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		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);
		container2.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		container2.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		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);
		container3.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		container3.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		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);
		container4.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		container4.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		containerManager.saveOrUpdate(container4);
		
		Container container8 = new Container();
		container8.setBarcode("019000005");
		container8.setContainerName("清洗筐120");
		container8.setPurpose(Container.CONTAINER_PURPOSE_CLEAN_BASKET);
		container8.setContainerType(Container.CONTAINERTYPE_BASKET);
		container8.setStatus(Container.CONTAINER_STATUS_FREE);
		container8.setType(BarcodeDevice.BARCODE_TYPE_CONTAINER);
		container8.setDepartCode(Constants.ORG_UNIT_CODE_OR);
		container8.setDepartName(Constants.ORG_UNIT_NAME_OR);
		containerManager.saveOrUpdate(container8);
		
		Container container9 = new Container();
		container9.setBarcode("019000006");
		container9.setContainerName("清洗筐121");
		container9.setPurpose(Container.CONTAINER_PURPOSE_CLEAN_BASKET);
		container9.setContainerType(Container.CONTAINERTYPE_BASKET);
		container9.setStatus(Container.CONTAINER_STATUS_FREE);
		container9.setType(BarcodeDevice.BARCODE_TYPE_CONTAINER);
		container9.setDepartCode(Constants.ORG_UNIT_CODE_OR);
		container9.setDepartName(Constants.ORG_UNIT_NAME_OR);
		containerManager.saveOrUpdate(container9);
		
		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);
		container5.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		container5.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		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);
		container6.setDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		container6.setDepartName(Constants.ORG_UNIT_NAME_CSSD);
		containerManager.saveOrUpdate(container6);
		
		Container container7 = new Container();
		container7.setBarcode("018000101");
		container7.setContainerName("灭菌筐001");
		container7.setPurpose(Container.CONTAINER_PURPOSE_DISINFECTION);
		container7.setContainerType(Container.CONTAINERTYPE_BASKET);	
		container7.setStatus(Container.CONTAINER_STATUS_FREE);
		container7.setType(BarcodeDevice.BARCODE_TYPE_CONTAINER);
		container7.setDepartCode(Constants.ORG_UNIT_CODE_OR);
		container7.setDepartName(Constants.ORG_UNIT_NAME_OR);
		containerManager.saveOrUpdate(container7);
		
		containerManager.createVirtualContainer(999 , null);
	}
	
	/**
	 * <h1>初始化供应室服务临床科室配置</h1>
	 * 		1、一级供应室可以服务所有二级供应室、所有申请科室的器械包和一次性物品的申请<br/>
	 * 		2、二级供应室可以服务所有申请科室的器械包和一次性物品的申请
	 * 
	 */
	private void initCssdServiceDepts(){
		List<OrgUnit> allFristSupplyRoom = orgUnitManager.findOrgUnitBySupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_1);
		List<OrgUnit> allSecondSupplyRoom = orgUnitManager.findOrgUnitBySupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_2);
		List<OrgUnit> allApplyDepartment = orgUnitManager.findOrgUnitBySupplyRoomType(SupplyRoomConfig.SUPPLYROOM_TYPE_3);
		
		//一级供应室
		for (OrgUnit fristSupplyRoom : allFristSupplyRoom) {
			List<OrgUnit> temp = new ArrayList<OrgUnit>();
			temp.addAll(allSecondSupplyRoom);
			temp.addAll(allApplyDepartment);
			for (OrgUnit ou : temp) {
				CssdServiceDepts csd1 = new CssdServiceDepts();
				csd1.setClinicOrgUnitCode(ou.getOrgUnitCoding());
				csd1.setClinicOrgUnitName(ou.getName());
				csd1.setCssdOrgUnitCode(fristSupplyRoom.getOrgUnitCoding());
				csd1.setCssdOrgUnitName(fristSupplyRoom.getName());
				csd1.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
				objectDao.save(csd1);
				CssdServiceDepts csd2 = new CssdServiceDepts();
				csd2.setClinicOrgUnitCode(ou.getOrgUnitCoding());
				csd2.setClinicOrgUnitName(ou.getName());
				csd2.setCssdOrgUnitCode(fristSupplyRoom.getOrgUnitCoding());
				csd2.setCssdOrgUnitName(fristSupplyRoom.getName());
				csd2.setTousseType(DisposableGoods.TYPE_NAME);
				objectDao.save(csd2);
			}
		}
		//二级供应室
		for (OrgUnit secondSupplyRoom : allSecondSupplyRoom) {
			for (OrgUnit ou : allApplyDepartment) {
				CssdServiceDepts csd1 = new CssdServiceDepts();
				csd1.setClinicOrgUnitCode(ou.getOrgUnitCoding());
				csd1.setClinicOrgUnitName(ou.getName());
				csd1.setCssdOrgUnitCode(secondSupplyRoom.getOrgUnitCoding());
				csd1.setCssdOrgUnitName(secondSupplyRoom.getName());
				csd1.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
				objectDao.save(csd1);
				CssdServiceDepts csd2 = new CssdServiceDepts();
				csd2.setClinicOrgUnitCode(ou.getOrgUnitCoding());
				csd2.setClinicOrgUnitName(ou.getName());
				csd2.setCssdOrgUnitCode(secondSupplyRoom.getOrgUnitCoding());
				csd2.setCssdOrgUnitName(secondSupplyRoom.getName());
				csd2.setTousseType(DisposableGoods.TYPE_NAME);
				objectDao.save(csd2);
			}
		}
	}
	
	/**
	 * 初始化器械材料及包定义(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
	 */
	private void initMaterialAndTousseData() {
		
		// 器械包分组设置
		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.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition1.setUnit("");
		// 自动入筐的数量
		tousseDefinition1.setPackingAmountPerVirtualBasket(5);
		//包装类型
		tousseDefinition1.setPackageType("纸塑");
		
		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);
		
		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.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition2.setExternalCode("1002GYT2AA");
		tousseDefinition2.setUnit("");
		tousseDefinition2.setIsDisableIDCard(TousseDefinition.STR_NO);
		//是否整包清洗
		tousseDefinition2.setIsCleanedEntirely(TousseDefinition.STR_NO);
		tousseDefinition2.setIsCustomPacking(TousseDefinition.STR_YES);
		//是否追朔
		tousseDefinition2.setIsTraceable(TousseDefinition.STR_YES);
		//包装类型
		tousseDefinition2.setPackageType("纸塑");
				
		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);
		//为“Test开颅包”绑定3个标识牌
		IDCardDefinition iDCardDefinition1 = new IDCardDefinition();
		iDCardDefinition1.setTousseDefinitionID(tousseDefinition2.getId());
		iDCardDefinition1.setCurIdCardInstanceBarcode("010316310");
		objectDao.saveOrUpdate(iDCardDefinition1);
		
		IDCardInstance iDCardInstance1 = new IDCardInstance();
		iDCardInstance1.setIdCardDefinitionID(iDCardDefinition1.getId());
		iDCardInstance1.setBarcode("010316310");
		iDCardInstance1.setStatus(IDCardInstance.STATUS_USING);
		objectDao.saveOrUpdate(iDCardInstance1);
		
		IDCardDefinition iDCardDefinition2 = new IDCardDefinition();
		iDCardDefinition2.setTousseDefinitionID(tousseDefinition2.getId());
		iDCardDefinition2.setCurIdCardInstanceBarcode("010316320");
		objectDao.saveOrUpdate(iDCardDefinition2);
		
		IDCardInstance iDCardInstance2 = new IDCardInstance();
		iDCardInstance2.setIdCardDefinitionID(iDCardDefinition2.getId());
		iDCardInstance2.setBarcode("010316320");
		iDCardInstance2.setStatus(IDCardInstance.STATUS_USING);
		objectDao.saveOrUpdate(iDCardInstance2);
		
		IDCardDefinition iDCardDefinition3 = new IDCardDefinition();
		iDCardDefinition3.setTousseDefinitionID(tousseDefinition2.getId());
		iDCardDefinition3.setCurIdCardInstanceBarcode("010316330");
		objectDao.saveOrUpdate(iDCardDefinition3);
		
		IDCardInstance iDCardInstance3 = new IDCardInstance();
		iDCardInstance3.setIdCardDefinitionID(iDCardDefinition3.getId());
		iDCardInstance3.setBarcode("010316330");
		iDCardInstance3.setStatus(IDCardInstance.STATUS_USING);
		objectDao.saveOrUpdate(iDCardInstance3);
		
		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.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition3.setUnit("");
		// 自动入筐的数量
		tousseDefinition3.setPackingAmountPerVirtualBasket(20);
		//是否整包清洗
		tousseDefinition3.setIsCleanedEntirely(TousseDefinition.STR_YES);
		tousseDefinition3.setIsCustomPacking(TousseDefinition.STR_YES);
		//是否追朔
		tousseDefinition3.setIsTraceable(TousseDefinition.STR_YES);
		//是否转换申请单设置为是(便于使用记录进行测试)
		tousseDefinition3.setIsConvertApplyGoods(TousseDefinition.STR_YES);
		//包装类型
		tousseDefinition3.setPackageType("纸塑");	
		
		MaterialInstance materialInstance5 = new MaterialInstance();
		materialInstance5.setMaterialDefinition(materialDefinition1);
		materialInstance5.setTousse(tousseDefinition3);
		materialInstance5.setCount(1);

		MaterialInstance materialInstance6 = new MaterialInstance();
		materialInstance6.setMaterialDefinition(materialDefinition3);
		materialInstance6.setTousse(tousseDefinition3);
		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.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition4.setUnit("");
		// 自动入筐的数量
		tousseDefinition4.setPackingAmountPerVirtualBasket(33);
		//是否整包清洗
		tousseDefinition4.setIsCleanedEntirely(TousseDefinition.STR_NO);
		tousseDefinition4.setIsCustomPacking(TousseDefinition.STR_NO);
		//是否转换申请单设置为否(便于使用记录进行测试)
		tousseDefinition4.setIsConvertApplyGoods(TousseDefinition.STR_NO);
		//包装类型
		tousseDefinition4.setPackageType("纸塑");
		
		MaterialInstance materialInstance7 = new MaterialInstance();
		materialInstance7.setMaterialDefinition(materialDefinition2);
		materialInstance7.setTousse(tousseDefinition4);
		materialInstance7.setCount(5);

		MaterialInstance materialInstance8 = new MaterialInstance();
		materialInstance8.setMaterialDefinition(materialDefinition3);
		materialInstance8.setTousse(tousseDefinition4);
		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");
		// 自动入筐的数量设置为0，表示不启用自动入筐功能
		tousseDefinition4.setPackingAmountPerVirtualBasket(0);
		//是否整包清洗
		tousseDefinition5.setIsCleanedEntirely(TousseDefinition.STR_YES);
		tousseDefinition5.setIsCustomPacking(TousseDefinition.STR_NO);
		//包装类型
		tousseDefinition5.setPackageType("纸塑");
		
		MaterialInstance materialInstance9 = new MaterialInstance();
		materialInstance9.setMaterialDefinition(materialDefinition4);
		materialInstance9.setTousse(tousseDefinition5);
		materialInstance9.setCount(7);

		MaterialInstance materialInstance10 = new MaterialInstance();
		materialInstance10.setMaterialDefinition(materialDefinition5);
		materialInstance10.setTousse(tousseDefinition5);
		materialInstance10.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);
		tousseDefinition5.setUnit("");
		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);
		//包装类型
		tousseDefinition6.setPackageType("纸塑");
		
		MaterialInstance materialInstance11 = new MaterialInstance();
		materialInstance11.setMaterialDefinition(materialDefinition4);
		materialInstance11.setTousse(tousseDefinition6);
		materialInstance11.setCount(7);

		MaterialInstance materialInstance12 = new MaterialInstance();
		materialInstance12.setMaterialDefinition(materialDefinition5);
		materialInstance12.setTousse(tousseDefinition6);
		materialInstance12.setCount(3);
		
		MaterialInstance materialInstance13 = new MaterialInstance();
		materialInstance13.setMaterialDefinition(materialDefinition6);
		materialInstance13.setTousse(tousseDefinition6);
		materialInstance13.setCount(4);
		
		MaterialInstance materialInstance14 = new MaterialInstance();
		materialInstance14.setMaterialDefinition(materialDefinition7);
		materialInstance14.setTousse(tousseDefinition6);
		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);
		tousseDefinition6.setUnit("");
		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.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition7.setExternalCode("1009");
		tousseDefinition7.setUnit("");
		//是否整包清洗
		tousseDefinition7.setIsCleanedEntirely(TousseDefinition.STR_NO);
		tousseDefinition7.setIsCustomPacking(TousseDefinition.STR_YES);
		//是否追朔
		tousseDefinition7.setIsTraceable(TousseDefinition.STR_NO);
		//包装类型
		tousseDefinition7.setPackageType("纸塑");
		
		MaterialInstance materialInstance100 = new MaterialInstance();
		materialInstance100.setMaterialDefinition(materialDefinition2);
		materialInstance100.setTousse(tousseDefinition7);
		materialInstance100.setCount(7);

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

		
		MaterialInstance materialInstance16 = new MaterialInstance();
		materialInstance16.setTousse(tousseDefinition9);
		materialInstance16.setMaterialDefinition(materialDefinition1);
		materialInstance16.setCount(2);
		materialInstance16.setMaterialName(materialDefinition1.getName());

		MaterialInstance materialInstance17 = new MaterialInstance();
		materialInstance17.setTousse(tousseDefinition9);
		materialInstance17.setMaterialDefinition(materialDefinition2);
		materialInstance17.setCount(5);
		materialInstance17.setMaterialName(materialDefinition2.getName());
		
		tousseDefinition9.getMaterialInstances().add(materialInstance16);
		tousseDefinition9.getMaterialInstances().add(materialInstance17);
		//包装类型
		tousseDefinition9.setPackageType("纸塑");
		tousseDefinitionManager.saveOrUpdate(tousseDefinition9);
		
		//新增加清创包与宫碘包的定义以支撑各个测试用的用例数据
		TousseDefinition tousseDefinition10 = new TousseDefinition();
		//普通器械包
		tousseDefinition10.setName("Test清创包");
		tousseDefinition10.setIsCleanedEntirely("是");
		tousseDefinition10.setTaskGroup("器械组");
		tousseDefinition10.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition10.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tousseDefinition10.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition10.setUnit("");
		//包装类型
		tousseDefinition10.setPackageType("纸塑");
		
		MaterialInstance materialInstance18 = new MaterialInstance();
		materialInstance18.setTousse(tousseDefinition10);
		materialInstance18.setMaterialDefinition(materialDefinition1);
		materialInstance18.setCount(2);
		materialInstance18.setMaterialName(materialDefinition1.getName());

		MaterialInstance materialInstance19 = new MaterialInstance();
		materialInstance19.setTousse(tousseDefinition10);
		materialInstance19.setMaterialDefinition(materialDefinition2);
		materialInstance19.setCount(5);
		materialInstance19.setMaterialName(materialDefinition2.getName());
		tousseDefinition10.getMaterialInstances().add(materialInstance18);
		tousseDefinition10.getMaterialInstances().add(materialInstance19);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition10);
		
		TousseDefinition tousseDefinition11 = new TousseDefinition();
		//普通器械包
		tousseDefinition11.setName("Test宫碘包");
		tousseDefinition11.setIsCleanedEntirely("是");
		tousseDefinition11.setTaskGroup("器械组");
		tousseDefinition11.setTousseType(TousseDefinition.PACKAGE_TYPE_INSIDE);
		tousseDefinition11.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		tousseDefinition11.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		tousseDefinition11.setUnit("");
		//包装类型
		tousseDefinition11.setPackageType("纸塑");
		
		MaterialInstance materialInstance20 = new MaterialInstance();
		materialInstance20.setTousse(tousseDefinition11);
		materialInstance20.setMaterialDefinition(materialDefinition1);
		materialInstance20.setCount(2);
		materialInstance20.setMaterialName(materialDefinition1.getName());

		MaterialInstance materialInstance21 = new MaterialInstance();
		materialInstance21.setTousse(tousseDefinition11);
		materialInstance21.setMaterialDefinition(materialDefinition2);
		materialInstance21.setCount(5);
		materialInstance21.setMaterialName(materialDefinition2.getName());
		tousseDefinition11.getMaterialInstances().add(materialInstance20);
		tousseDefinition11.getMaterialInstances().add(materialInstance21);
		tousseDefinitionManager.saveOrUpdate(tousseDefinition11);
		
		List<TousseDefinition> tList = tousseDefinitionManager.findTousseDefinitionList();
		assertNotNull(tList);
		assertEquals(tList.size(), 11);
	}
	
	/**
	 * 	初始化1个外来器械包：<br/>
	 * 		1、Test骨钩（包含材料：Test钢板*10、Test螺钉*10）
	 */
	private void initForeignTousse() {
		MaterialDefinition md_Test钢板 = new MaterialDefinition();
		md_Test钢板.setName("Test钢板");
		md_Test钢板.setIsImplant(com.forgon.Constants.STR_NO);
		md_Test钢板.setIsForeignMaterial(com.forgon.Constants.STR_YES);
		md_Test钢板.setSpecification("F1");
		md_Test钢板.setType("金属类");
		md_Test钢板.setCost(2.4);
		
		MaterialDefinition md_Test螺钉 = new MaterialDefinition();
		md_Test螺钉.setName("Test螺钉");
		md_Test螺钉.setIsImplant(com.forgon.Constants.STR_YES);
		md_Test螺钉.setIsForeignMaterial(com.forgon.Constants.STR_YES);
		md_Test螺钉.setSpecification("F2");
		md_Test螺钉.setType("金属类");
		md_Test螺钉.setCost(2.4);
		materialDefinitionManager.saveOrUpdate(md_Test钢板);
		materialDefinitionManager.saveOrUpdate(md_Test螺钉);
		
		//初始化外来器械包
		TousseDefinition td_Test骨钩 = new TousseDefinition();
		td_Test骨钩.setName("Test骨钩");
		td_Test骨钩.setTousseType(TousseDefinition.PACKAGE_TYPE_FOREIGN);
		td_Test骨钩.setTaskGroup(Constants.TASKGROUP_WAILAIQIXIEZU);
		td_Test骨钩.setPrice(10.0);
		td_Test骨钩.setHandlerDepartCode(Constants.ORG_UNIT_CODE_CSSD);
		td_Test骨钩.setHandlerDepartName(Constants.ORG_UNIT_NAME_CSSD);
		td_Test骨钩.setPackageType("纸塑");
		td_Test骨钩.setSupplierName("广州天成医疗技术有限公司");
		
		MaterialInstance ti_Test钢板 = new MaterialInstance();
		ti_Test钢板.setTousse(td_Test骨钩);
		ti_Test钢板.setMaterialDefinition(md_Test钢板);
		ti_Test钢板.setCount(10);
		ti_Test钢板.setMaterialName(md_Test钢板.getName());
		
		MaterialInstance ti_Test螺钉 = new MaterialInstance();
		ti_Test螺钉.setTousse(td_Test骨钩);
		ti_Test螺钉.setMaterialDefinition(md_Test螺钉);
		ti_Test螺钉.setCount(10);
		ti_Test螺钉.setMaterialName(md_Test螺钉.getName());
		
		List<MaterialInstance> list1 = new ArrayList<MaterialInstance>();
		list1.add(ti_Test螺钉);
		list1.add(ti_Test钢板);
		td_Test骨钩.setMaterialInstances(list1);
		tousseDefinitionManager.saveOrUpdate(td_Test骨钩);
	}
	
	/**
	 * 初始化消毒物品的器械包定义,共3个
	 * test雾化器、止血带[100条/扎]、呼吸机
	 */
	private 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);
		tousseDefinition1.setPackageType("纸塑");
		tousseDefinition1.setUnit("");
		
		
		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);
		tousseDefinition2.setPackageType("纸塑");
		tousseDefinition2.setUnit("");
		
		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);
		tousseDefinition3.setPackageType("纸塑");
		tousseDefinition3.setUnit("");
		
		materialInstances = new ArrayList<MaterialInstance>();
		materialInstances.add(materialInstance3);
		
		tousseDefinition3.setMaterialInstances(materialInstances);
		
		objectDao.saveOrUpdate(materialInstance3);
		
		tousseDefinitionManager.saveOrUpdate(tousseDefinition3);
	}
	
	/**
	 * 创建聚合包定义
	 */
	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);
		comboTousse.setTaskGroup("术科组");
		comboTousse.setPackageType("棉布");
		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;
	}
	
	/**
	 * 初始化供应室处理器械包配置(供应室和手术室分别能处理所有的器械包)
	 */
	private void initCssdHandleTousses(){
		@SuppressWarnings("unchecked")
		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);
			
		}
	}
	
	/**
	 * 初始化一次性物品
	 * 
	 * 注射器【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】
	 */
	private 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());
	}
	
	/**
	 * 初始化失效期
	 */
	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);
	}
	
	/**
	 * 初始化质量监测定义
	 */
	private void initQualityMonitoring(){
		QualityMonitoringDefinition qd = new QualityMonitoringDefinition();
		qd.setFormName("灭菌失败事件");
		qd.setFormType(FormDefinition.FOMRTYPE_QUALITYMONITORING);
		qd.setScope(QualityMonitoringDefinition.SCOPE_TOUSSE);
		qd.setResponsibilityPart(QualityMonitoringDefinition.QUALITYMONITORING_MODULE_NAME_STERILIZATION);
		qd.setDepartCodes(Constants.ORG_UNIT_CODE_CSSD +";" + Constants.ORG_UNIT_CODE_OR);
		qd.setDepartNames(Constants.ORG_UNIT_NAME_CSSD +";" + Constants.ORG_UNIT_NAME_OR);
		qd.setOrgUnit(Constants.ORG_UNIT_NAME_CSSD);
		qd.setOrgUnitCoding(Constants.ORG_UNIT_CODE_CSSD);
		qd.setIsDeploy(FormDefinition.ACTION_DEPLOY);
		qd.setIsDisabled(com.forgon.Constants.STR_NO);
		qd.setVersion(1);
		objectDao.saveOrUpdate(qd);
	}
	
	
	
	/*
	 * 初始化所有器械包定义
	 */
	public void initBasicData(){
		//消毒供应室的仓库
		createWareHouse(Constants.ORG_UNIT_CODE_DISINFECT);
		//仓库临床科室的仓库
		createWareHouse("3266");
		//消毒物品器械包定义(2个)-test止血带、止血带_20141016
		createDisinfectionTousseDefinition();
		//一次性物品定义
		createDiposableGoods();
		//外部代理灭菌器械包定义(1个)- test121#压力蒸汽灭菌包
		createForeignProxyTousseDefinition();
		//外来器械包定义(1个)-test骨科外来器械包
		createForeignTousseDefinition();
		//普通器械包定义(5个)-Test开胸包、Test缝合包、Test清创包、Test宫碘包、不回收的包
		createTousseDefinition();
	}
	
	/**
	 * 创建仓库,只设置科室编码。测试用例只有这个属性是有用的
	 * @param orgUnitCode
	 */
	private void createWareHouse(String orgUnitCode){
		WareHouse wh = new WareHouse();
		wh.setOrgUnitCode(orgUnitCode);
		wh.setSequence(1L);
		try {
			wareHouseManager.saveOrUpdateWareHouse(wh);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 创建两个用于测试的消毒物品器械包定义:<br/>
	 * test止血带、止血带_20141016
	 */
	private 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);
	}
	
	/**
	 * 创建供测试使用的一次性物品
	 * 说明: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/>
	 */
	private void createDiposableGoods() {
		WareHouse wareHouse1 = wareHouseManager.getDefaultWareHouseByUnitCode(Constants.ORG_UNIT_CODE_CSSD);
		dataGenerater.createTestDataByType("一次性物品", wareHouse1);
	}
	
	/**
	 * 创建一个用于测试的外部代理灭菌器械包定义:<br/>
	 * <li><h3>test121#压力蒸汽灭菌包</h3>
	 * 	<ul>棉布<strong>1</strong>条</ul>
	 * </li>
	 */
	private 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);
	}
	
	/**
	 * 创建一个用于测试的外来器械包定义:<br/>
	 * <li><h3>test骨科外来器械包</h3>
	 * 	<ul>test骨科剥离器</ul>
	 * 	<ul>test骨科植入性钢钉</ul>
	 * </li>
	 */
	private 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/>
	 * Test开胸包、Test缝合包、Test清创包、Test宫碘包、不回收的包
	 * <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>
	 */
	private 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 tousseDefinition = new TousseDefinition();
		
		MaterialInstance materialInstance1 = new MaterialInstance();
		materialInstance1.setTousse(tousseDefinition);
		materialInstance1.setMaterialDefinition(materialDefinition1);
		materialInstance1.setCount(2);
		materialInstance1.setMaterialName(materialDefinition1.getName());
		
		objectDao.saveOrUpdate(materialInstance1);
		
		MaterialInstance materialInstance2 = new MaterialInstance();
		materialInstance2.setTousse(tousseDefinition);
		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.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);
		}
		
	}
}