#include "jk_custom.h"
#include "tc_log.h"
#include <res/res_itk.h>

typedef struct{
	string jk8ProductType;//产品类型
	string 	jk8ProductModNO;// 产品型号
	string 	jk8ProductIdentifyNO;// 识别号
	string 	jk8ProductName;// 产品名称
	string 	jk8BaseMeterManufactor;// 基表厂家   5
	string 	jk8ICCardType;// IC卡型号
	string 	jk8CircBoardModNO;// 线路板型号
	string 	jk8ProgramFeatures;// 程序特征
	string 	jk8InsteadType;// 替代型号
	string 	jk8FunctionOverview;// 功能概述  10
	string 	jk8CustSpecRequirements;// 客户特殊要求
	//string 	jk8U8NO;// U8编码号  （去掉）
	string 	jk8Valve;// 阀门
	string 	jk8EncryptType;// 加密类型
	string 	jk8Applicant;// 申请人
	string 	jk8RecordDate;// 登记日期
	string 	jk8ApplyMarket;// 适用市场
	string 	jk8BMManfMatched;// 配套基表厂家

	string jk8ProjectName;//项目名称
	string jk8ProjectNO;//项目编号  19

	string jk8Status;// 状态    //2018.6.4新加4属性
	string jk8ValveType;// 阀门类型
	string jk8CommunicateMode;// 通信方式
	string jk8PowerSupplyMode;// 供电类型  23

	//2019.07.31
	string jk8GasType;//气体种类
	string jk8AlaDectRelation;//报警部分与检测部分的关系
	string jk8UsePlace;//使用场所
	string jk8OutputSignal;//输出信号种类
	string jk8ProFeatNum;//产品特征号

	//2020-03-31
	string jk8Manufacturer;//生产厂家
	string jk8CommunicateMode2;//通信方式2

}JK_SUMMARY_STRUCT;


typedef struct{
	string	jk8Companylogo;//公司标识
	string 	jk8MeasureType;// 计量方式
	string 	jk8CommunicateMode;// 通讯方式
	string 	jk8Application;// 应用范围
	string 	jk8PCBNO;// pcb编码   5
	string  jk8Projectname;//项目名称
}JK_SUMMARY_PCB_STRUCT;


extern "C" int POM_AM__set_application_bypass(logical bypass);
/**
* 获取四张扩展表的属性
*
*/
void JK_get_form_prop(tag_t form_tag,JK_SUMMARY_STRUCT &bean,char *form_type){
//	char * form_value[28];
//	int prop_count = 28;
	//2020-03-31
	char * form_value[30];
	int prop_count = 30;
	WriteLog_jk("开始获取单张表属性 \n");
	tag_t user_tag =NULLTAG;
	ITKCALL(AOM_ask_value_tag(form_tag,"owning_user",&user_tag));
	if(user_tag!=NULLTAG)
	{
		ITKCALL(AOM_ask_value_string(user_tag,"user_name",&form_value[13]))
	}else{
		form_value[13] = (char *)MEM_alloc(sizeof(char)*128);//申请人
	}
	form_value[14] = (char *)MEM_alloc(sizeof(char)*128);//登记日期
	//ITKCALL(AOM_ask_value_string(form_tag,"jk8RecordDate",&form_value[14]));// 登记日期
	time_t now;
	struct tm *p;
	time(&now);
	p = localtime(&now);
	sprintf(form_value[14], "%d年%d月%d日", 1900+p->tm_year,p->tm_mon+1 ,p->tm_mday );
	if(strcmp(form_type , "JK8CotlerPModAppForm")==0){//控制器表单(产品型号)

		for (int i = 0; i < prop_count; i++)
		{
			if((i!=4)&&(i!=9)&&1<i<17||i==20||i==22){
				form_value[i] = (char *)MEM_alloc(sizeof(char)*128);
				strcpy(form_value[i],"");// 状态  默认为空
			}

		}

		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductModNO",&form_value[1]));// 产品型号
		//ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductIdentifyNO",&form_value[2]));// 识别号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8BMManufactor",&form_value[4]));// 基表厂家
		ITKCALL(AOM_ask_value_string(form_tag,"jk8FunctionOverview",&form_value[9]));// 功能概述
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectName",&form_value[17]));// 项目名称
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectNO",&form_value[18]));// 项目编号
		form_value[19] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[19],"");// 状态  默认为空
	//	ITKCALL(AOM_ask_value_string(form_tag,"jk8ValveType",&form_value[20]));// 阀门类型
		ITKCALL(AOM_ask_value_string(form_tag,"jk8CommunicateMode",&form_value[21]));// 通信方式
	//	ITKCALL(AOM_ask_value_string(form_tag,"jk8PowerSupplyMode",&form_value[22]));// 供电方式

	}else if(strcmp(form_type , "JK8ColPIdenNOAppForm")==0){//控制器产品识别号
		for (int i = 0; i < prop_count; i++)
		{
			if(2<i<17){
				form_value[i] = (char *)MEM_alloc(sizeof(char)*128);
				strcpy(form_value[i],"");// 状态  默认为空
			}

		}
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductModNO",&form_value[1]));// 产品型号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductIdentifyNO",&form_value[2]));// 识别号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectName",&form_value[17]));// 项目名称
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectNO",&form_value[18]));// 项目编号
		form_value[19] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[19],"");// 状态  默认为空
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ValveType",&form_value[20]));// 阀门类型
		ITKCALL(AOM_ask_value_string(form_tag,"jk8CommunicateMode",&form_value[21]));// 通信方式
		ITKCALL(AOM_ask_value_string(form_tag,"jk8PowerSupplyMode",&form_value[22]));// 供电方式
		form_value[23] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[23],"");//气体种类代号   默认为空
		form_value[24] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[24],"");//使用场所   默认为空
		form_value[25] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[25],"");//报警部分与检测部分的关系   默认为空
		form_value[26] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[26],"");//输出信号种类   默认为空
		form_value[27] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[27],"");//产品特征号   默认为空

	}
	else if(strcmp(form_type , "JK8ALPModAppForm")==0)//2019.07.31报警器产品型号
	{
		for (int i = 0; i < prop_count; i++)
		{
			if(i!=1&&i!=3&&i!=13&&i!=14&&i!=17&&i!=18&&i!=23&&i!=24&&i!=25&&i!=26&&i!=27){
				form_value[i] = (char *)MEM_alloc(sizeof(char)*128);
				strcpy(form_value[i],"");// 状态  默认为空
			}

		}



//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductType",&form_value[0]));//产品类型
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductModNO",&form_value[1]));// 产品型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductIdentifyNO",&form_value[2]));// 识别号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductName",&form_value[3]));// 产品名称
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8BMManufactor",&form_value[4]));// 基表厂家
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ICCardType",&form_value[5]));// IC卡型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8CircBoardModNO",&form_value[6]));// 线路板型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProgramFeatures",&form_value[7]));// 程序特征
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8InsteadType",&form_value[8]));// 替代型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8FunctionOverview",&form_value[9]));// 功能概述
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8CustSpecRequirements",&form_value[10]));// 客户特殊要求
		//ITKCALL(AOM_ask_value_string(attachments[i],"jk8U8NO",&form_value));// U8编码号  （去掉）
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8Valve",&form_value[11]));// 阀门
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8EncryptType",&form_value[12]));// 加密类型
		//
		//ITKCALL(AOM_ask_value_string(form_tag,"jk8Applicant",&form_value[13]));// 申请人
		

//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ApplyMarket",&form_value[15]));// 适用市场
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8BMManfMatched",&form_value[16]));// 配套基表厂家
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectName",&form_value[17]));// 项目名称
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectNO",&form_value[18]));// 项目编号





		ITKCALL(AOM_ask_value_string(form_tag,"jk8GasType",&form_value[23]));// 气体种类
		ITKCALL(AOM_ask_value_string(form_tag,"jk8UsePlace",&form_value[24]));// 使用场所
		ITKCALL(AOM_ask_value_string(form_tag,"jk8AlaDectRelation",&form_value[25]));// 报警部分与检测部分的关系
		ITKCALL(AOM_ask_value_string(form_tag,"jk8OutputSignal",&form_value[26]));// 输出信号种类
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProFeatNum",&form_value[27]));// 产品特征号


	}
	// 2020-03-31
	
	else if(strcmp(form_type , "JK8WarnerNPModINOAppForm")==0)//报警器产品型号识别号申请表
	{
		for (int i = 0; i < prop_count; i++)
		{
			if(i!=1&&i!=3&&i!=13&&i!=14&&i!=17&&i!=18&&i!=23&&i!=24&&i!=25&&i!=26&&i!=27){
				form_value[i] = (char *)MEM_alloc(sizeof(char)*128);
				strcpy(form_value[i],"");// 状态  默认为空
			}

		}



//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductType",&form_value[0]));//产品类型
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductModNO",&form_value[1]));// 产品型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductIdentifyNO",&form_value[2]));// 识别号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductName",&form_value[3]));// 产品名称
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8BMManufactor",&form_value[4]));// 基表厂家
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ICCardType",&form_value[5]));// IC卡型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8CircBoardModNO",&form_value[6]));// 线路板型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProgramFeatures",&form_value[7]));// 程序特征
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8InsteadType",&form_value[8]));// 替代型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8FunctionOverview",&form_value[9]));// 功能概述
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8CustSpecRequirements",&form_value[10]));// 客户特殊要求
		//ITKCALL(AOM_ask_value_string(attachments[i],"jk8U8NO",&form_value));// U8编码号  （去掉）
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8Valve",&form_value[11]));// 阀门
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8EncryptType",&form_value[12]));// 加密类型
		//
		//ITKCALL(AOM_ask_value_string(form_tag,"jk8Applicant",&form_value[13]));// 申请人
		

//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ApplyMarket",&form_value[15]));// 适用市场
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8BMManfMatched",&form_value[16]));// 配套基表厂家
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectName",&form_value[17]));// 项目名称
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectNO",&form_value[18]));// 项目编号





		ITKCALL(AOM_ask_value_string(form_tag,"jk8GasType",&form_value[23]));// 气体种类
		ITKCALL(AOM_ask_value_string(form_tag,"jk8UsePlace",&form_value[24]));// 使用场所
		ITKCALL(AOM_ask_value_string(form_tag,"jk8AlaDectRelation",&form_value[25]));// 报警部分与检测部分的关系
		ITKCALL(AOM_ask_value_string(form_tag,"jk8OutputSignal",&form_value[26]));// 输出信号种类
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProFeatNum",&form_value[27]));// 产品特征号

		ITKCALL(AOM_ask_value_string(form_tag,"jk8Manufacturer",&form_value[28]));// 生产厂家
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductType",&form_value[0]));// 产品类型
		ITKCALL(AOM_ask_value_string(form_tag,"jk8CommunicateMode2",&form_value[29]));// 通信方式2


	}
	else if(strcmp(form_type , "JK8WarnerNPINOAppForm")==0)//报警器产品识别号申请表
	{
		for (int i = 0; i < prop_count; i++)
		{
			if(i!=1&&i!=3&&i!=13&&i!=14&&i!=17&&i!=18&&i!=23&&i!=24&&i!=25&&i!=26&&i!=27){
				form_value[i] = (char *)MEM_alloc(sizeof(char)*128);
				strcpy(form_value[i],"");// 状态  默认为空
			}

		}



//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductType",&form_value[0]));//产品类型
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductModNO",&form_value[1]));// 产品型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductIdentifyNO",&form_value[2]));// 识别号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductName",&form_value[3]));// 产品名称
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8BMManufactor",&form_value[4]));// 基表厂家
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ICCardType",&form_value[5]));// IC卡型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8CircBoardModNO",&form_value[6]));// 线路板型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProgramFeatures",&form_value[7]));// 程序特征
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8InsteadType",&form_value[8]));// 替代型号
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8FunctionOverview",&form_value[9]));// 功能概述
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8CustSpecRequirements",&form_value[10]));// 客户特殊要求
		//ITKCALL(AOM_ask_value_string(attachments[i],"jk8U8NO",&form_value));// U8编码号  （去掉）
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8Valve",&form_value[11]));// 阀门
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8EncryptType",&form_value[12]));// 加密类型
		//
		//ITKCALL(AOM_ask_value_string(form_tag,"jk8Applicant",&form_value[13]));// 申请人
		

//		ITKCALL(AOM_ask_value_string(form_tag,"jk8ApplyMarket",&form_value[15]));// 适用市场
//		ITKCALL(AOM_ask_value_string(form_tag,"jk8BMManfMatched",&form_value[16]));// 配套基表厂家
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectName",&form_value[17]));// 项目名称
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectNO",&form_value[18]));// 项目编号





		ITKCALL(AOM_ask_value_string(form_tag,"jk8GasType",&form_value[23]));// 气体种类
		ITKCALL(AOM_ask_value_string(form_tag,"jk8UsePlace",&form_value[24]));// 使用场所
		ITKCALL(AOM_ask_value_string(form_tag,"jk8AlaDectRelation",&form_value[25]));// 报警部分与检测部分的关系
		ITKCALL(AOM_ask_value_string(form_tag,"jk8OutputSignal",&form_value[26]));// 输出信号种类
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProFeatNum",&form_value[27]));// 产品特征号

		ITKCALL(AOM_ask_value_string(form_tag,"jk8Manufacturer",&form_value[28]));// 生产厂家
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductType",&form_value[0]));// 产品类型
		ITKCALL(AOM_ask_value_string(form_tag,"jk8CommunicateMode2",&form_value[29]));// 通信方式2

	}
	else//其他表单类型，包括新产品型号与识别号申请表，识别号申请表，衍生号申请表，特殊要求申请表
	{
		cout<<"2---"<<endl;
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductType",&form_value[0]));//产品类型
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductModNO",&form_value[1]));// 产品型号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductIdentifyNO",&form_value[2]));// 识别号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductName",&form_value[3]));// 产品名称
		ITKCALL(AOM_ask_value_string(form_tag,"jk8BMManufactor",&form_value[4]));// 基表厂家
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ICCardType",&form_value[5]));// IC卡型号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8CircBoardModNO",&form_value[6]));// 线路板型号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProgramFeatures",&form_value[7]));// 程序特征
		ITKCALL(AOM_ask_value_string(form_tag,"jk8InsteadType",&form_value[8]));// 替代型号
		ITKCALL(AOM_ask_value_string(form_tag,"jk8FunctionOverview",&form_value[9]));// 功能概述
		ITKCALL(AOM_ask_value_string(form_tag,"jk8CustSpecRequirements",&form_value[10]));// 客户特殊要求
		//ITKCALL(AOM_ask_value_string(attachments[i],"jk8U8NO",&form_value));// U8编码号  （去掉）
		ITKCALL(AOM_ask_value_string(form_tag,"jk8Valve",&form_value[11]));// 阀门
		ITKCALL(AOM_ask_value_string(form_tag,"jk8EncryptType",&form_value[12]));// 加密类型
		//ITKCALL(AOM_ask_value_string(form_tag,"jk8Applicant",&form_value[13]));// 申请人
		

		ITKCALL(AOM_ask_value_string(form_tag,"jk8ApplyMarket",&form_value[15]));// 适用市场
		ITKCALL(AOM_ask_value_string(form_tag,"jk8BMManfMatched",&form_value[16]));// 配套基表厂家
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectName",&form_value[17]));// 项目名称
		ITKCALL(AOM_ask_value_string(form_tag,"jk8ProjectNO",&form_value[18]));// 项目编号

		form_value[19] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[19],"");// 状态  默认为空
		form_value[20] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[20],"");// 状态  默认为空
		form_value[21] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[21],"");// 状态  默认为空
		form_value[22] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[22],"");// 状态  默认为空
		form_value[23] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[23],"");//气体种类代号   默认为空
		form_value[24] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[24],"");//使用场所   默认为空
		form_value[25] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[25],"");//报警部分与检测部分的关系   默认为空
		form_value[26] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[26],"");//输出信号种类   默认为空
		form_value[27] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[27],"");//产品特征号   默认为空
		form_value[28] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[28],"");//产品特征号   默认为空
		form_value[29] = (char *)MEM_alloc(sizeof(char)*128);
		strcpy(form_value[29],"");//产品特征号   默认为空
		cout<<"3---"<<endl;
		//ITKCALL(AOM_ask_value_string(form_tag,"jk8ValveType",&form_value[20]));// 阀门类型
		//ITKCALL(AOM_ask_value_string(form_tag,"jk8CommunicateMode",&form_value[21]));// 通信方式
		//ITKCALL(AOM_ask_value_string(form_tag,"jk8PowerSupplyMode",&form_value[22]));// 供电方式
	}

	


	{
		if(strcmp(form_type , "JK8NPModINOAppForm")==0){//新产品型号与识别号申请表
			char * jk8ProductType1 =NULL;
			ITKCALL(AOM_ask_value_string(form_tag,"jk8ProductType1",&jk8ProductType1));//产品类型
			if(strcmp(jk8ProductType1,"民用表")==0  ){
				bean.jk8ProductType.assign("tb1");//产品类型
			}else if(strcmp(jk8ProductType1,"流量计")==0 || strcmp(jk8ProductType1,"工业表")==0){
				bean.jk8ProductType.assign("tb2");
			}else if(strcmp(form_value[0],"采集器")==0){
				bean.jk8ProductType.assign("tb3");//产品类型
			}else if(strcmp(form_value[0],"阀门")==0){
				bean.jk8ProductType.assign("tb4");//产品类型
			}else if(strcmp(form_value[0],"集中器")==0){
				bean.jk8ProductType.assign("tb5");//产品类型
			}else if(strcmp(form_value[0],"充值宝")==0){
				bean.jk8ProductType.assign("tb6");//产品类型
			}else if(strcmp(form_value[0],"手持机")==0){
				bean.jk8ProductType.assign("tb7");//产品类型
			}else if(strcmp(form_value[0],"读卡器")==0){
				bean.jk8ProductType.assign("tb8");//产品类型
			}else if(strcmp(form_value[0],"模组")==0){
				bean.jk8ProductType.assign("tb9");//产品类型
			}else if(strcmp(form_value[0],"控制器")==0){
				bean.jk8ProductType.assign("tb10");//产品类型
			}else{
				bean.jk8ProductType.assign("tb11");//产品类型
			}
			if(jk8ProductType1 != NULL){
				MEM_free(jk8ProductType1);
				jk8ProductType1 = NULL;
			}
		}else if(strcmp(form_type , "JK8CotlerPModAppForm")==0){ //控制器产品型号
			bean.jk8ProductType.assign("tb10");//产品类型
		}else if(strcmp(form_type , "JK8ColPIdenNOAppForm")==0){//控制器识别号
			bean.jk8ProductType.assign("tb10");//产品类型
		}else if(strcmp(form_type , "JK8ALPModAppForm")==0){//报警器产品型号
			bean.jk8ProductType.assign("tb12");//产品类型
		}else{
			bean.jk8ProductType.assign(form_value[0]);//产品类型
		}
		bean.jk8ProductModNO.assign(form_value[1]);// 产品型号
		bean.jk8ProductIdentifyNO.assign(form_value[2]);// 识别号
		bean.jk8ProductName.assign(form_value[3]);// 产品名称
		bean.jk8BaseMeterManufactor.assign(form_value[4]);// 基表厂家   5
		bean.jk8ICCardType.assign(form_value[5]);// IC卡型号
		bean.jk8CircBoardModNO.assign(form_value[6]);// 线路板型号
		bean.jk8ProgramFeatures.assign(form_value[7]);// 程序特征
		bean.jk8InsteadType.assign(form_value[8]);// 替代型号
		bean.jk8FunctionOverview.assign(form_value[9]);// 功能概述  10
		bean.jk8CustSpecRequirements.assign(form_value[10]);
		//bean.jk8U8NO.assign(form_value[0]);// U8编码号  （去掉）
		bean.jk8Valve.assign(form_value[11]);// 阀门
		bean.jk8EncryptType.assign(form_value[12]);// 加密类型
		bean.jk8Applicant.assign(form_value[13]);// 申请人
		bean.jk8RecordDate.assign(form_value[14]);// 登记日期
		bean.jk8ApplyMarket.assign(form_value[15]);// 适用市场
		bean.jk8BMManfMatched.assign(form_value[16]);// 配套基表厂家

		bean.jk8ProjectName.assign(form_value[17]);// 项目名称
		bean.jk8ProjectNO.assign(form_value[18]);// 项目编号
		bean.jk8Status.assign(form_value[19]);// 状态
		bean.jk8ValveType.assign(form_value[20]);// 阀门类型
		bean.jk8CommunicateMode.assign(form_value[21]); // 通信方式
		bean.jk8PowerSupplyMode.assign(form_value[22]);// 供电方式

		//2019.07.31 气体种类  
		bean.jk8GasType.assign(form_value[23]);
		bean.jk8UsePlace.assign(form_value[24]);
		bean.jk8AlaDectRelation.assign(form_value[25]);
		bean.jk8OutputSignal.assign(form_value[26]);
		bean.jk8ProFeatNum.assign(form_value[27]);
		// 2020-03-31
		bean.jk8Manufacturer.assign(form_value[28]);
		bean.jk8CommunicateMode2.assign(form_value[29]);
	}

	//释放资源
	for(int i = 0 ;i <prop_count;i++){
		if(form_value[i]!=NULL){
			MEM_free(form_value[i]);
			form_value[i] = NULL;
		}
	}
}

/**
*
* 获取汇总表的属性
*
*/
void JK_get_summary_form_prop(tag_t form_tag,vector<JK_SUMMARY_STRUCT> &bean_vec,int * isOk){
//	int prop_count = 28;
//	int count[28],sum_count =0;
//	char ** form_value[28];
	// 20200331
	int prop_count = 30;
	int count[30],sum_count =0;
	char ** form_value[30];
	//POM_AM__set_application_bypass(true);
	*isOk = 1;
	WriteLog_jk("获取汇总表单【%d】的属性\n",form_tag);
	printf("获取汇总表单【%d】的属性\n",form_tag);
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ProductType",&count[0],&form_value[0]));//产品类型
	sum_count = count[0];
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ProductModNO",&count[1],&form_value[1]));// 产品型号
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ProductIdentifyNO",&count[2],&form_value[2]));// 识别号
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ProductName",&count[3],&form_value[3]));// 产品名称
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8BaseMeterManufactor",&count[4],&form_value[4]));// 基表厂家
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ICCardType",&count[5],&form_value[5]));// IC卡型号
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8CircBoardModNO",&count[6],&form_value[6]));// 线路板型号
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ProgramFeatures",&count[7],&form_value[7]));// 程序特征
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8InsteadType",&count[8],&form_value[8]));// 替代型号
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8FunctionOverview",&count[9],&form_value[9]));// 功能概述
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8CustSpecRequirements",&count[10],&form_value[10]));// 客户特殊要求
	//ITKCALL(AOM_ask_value_string(attachments[i],"jk8U8NO",&form_value));// U8编码号  （去掉）
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8Valve",&count[11],&form_value[11]));// 阀门
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8EncryptType",&count[12],&form_value[12]));// 加密类型
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8Applicant",&count[13],&form_value[13]));// 申请人
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8RecordDate",&count[14],&form_value[14]));// 登记日期
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ApplyMarket",&count[15],&form_value[15]));// 适用市场
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8BMManfMatched",&count[16],&form_value[16]));// 配套基表厂家

	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ProjectName",&count[17],&form_value[17]));// 项目名称
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ProjectNO",&count[18],&form_value[18]));// 项目编号

	ITKCALL(AOM_ask_value_strings(form_tag,"jk8Status",&count[19],&form_value[19]));// 项目名称
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ValveType",&count[20],&form_value[20]));// 项目编号
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8CommunicateMode",&count[21],&form_value[21]));// 项目名称
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8PowerSupplyMode",&count[22],&form_value[22]));// 项目编号
	//2019.07.31
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8GasType",&count[23],&form_value[23]));// 气体种类
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8AlaDectRelation",&count[24],&form_value[24]));// 报警部分与检测部分的关系
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8UsePlace",&count[25],&form_value[25]));// 使用场所
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8OutputSignal",&count[26],&form_value[26]));// 输出信号种类
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8ProFeatNum",&count[27],&form_value[27]));// 产品特征号
	//2020-03-31
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8Manufacturer",&count[28],&form_value[28]));// 生产厂家
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8CommunicateMode2",&count[29],&form_value[29]));// 通信方式2
	for(int i  = 0 ;i < (prop_count-1);i++){
		if(count[i] !=count[i+1]){
			*isOk = 0;
			WriteLog_jk("汇总表单属性不正确=>\n");
			printf("属性不正确=>\n");
		}
	}
	printf("222222222222222222=>\n");
	if( *isOk ==1){
		printf("3333333333333333=>\n");
		for(int i = 0 ;i <sum_count;i++ ){
			JK_SUMMARY_STRUCT bean ;
			bean.jk8ProductType.assign(form_value[0][i]);//产品类型
			bean.jk8ProductModNO.assign(form_value[1][i]);// 产品型号
			bean.jk8ProductIdentifyNO.assign(form_value[2][i]);// 识别号
			bean.jk8ProductName.assign(form_value[3][i]);// 产品名称
			bean.jk8BaseMeterManufactor.assign(form_value[4][i]);// 基表厂家   5
			bean.jk8ICCardType.assign(form_value[5][i]);// IC卡型号
			bean.jk8CircBoardModNO.assign(form_value[6][i]);// 线路板型号
			bean.jk8ProgramFeatures.assign(form_value[7][i]);// 程序特征
			bean.jk8InsteadType.assign(form_value[8][i]);// 替代型号
			bean.jk8FunctionOverview.assign(form_value[9][i]);// 功能概述  10
			bean.jk8CustSpecRequirements.assign(form_value[10][i]);// 客户特殊要求
			//bean.jk8U8NO.assign(form_value[0][i]);// U8编码号  （去掉）
			bean.jk8Valve.assign(form_value[11][i]);// 阀门
			bean.jk8EncryptType.assign(form_value[12][i]);// 加密类型
			bean.jk8Applicant.assign(form_value[13][i]);// 申请人
			bean.jk8RecordDate.assign(form_value[14][i]);// 登记日期
			bean.jk8ApplyMarket.assign(form_value[15][i]);// 适用市场
			bean.jk8BMManfMatched.assign(form_value[16][i]);// 配套基表厂家

			bean.jk8ProjectName.assign(form_value[17][i]);// 项目名称
			bean.jk8ProjectNO.assign(form_value[18][i]);// 项目编号

			bean.jk8Status.assign(form_value[19][i]);// 状态
			bean.jk8ValveType.assign(form_value[20][i]);// 阀门类型
			bean.jk8CommunicateMode.assign(form_value[21][i]);// 通信方式
			bean.jk8PowerSupplyMode.assign(form_value[22][i]);// 供电类型
			//2019.07.31
			bean.jk8GasType.assign(form_value[23][i]);// 气体种类
			bean.jk8AlaDectRelation.assign(form_value[24][i]);// 报警部分
			bean.jk8UsePlace.assign(form_value[25][i]);// 使用场所
			bean.jk8OutputSignal.assign(form_value[26][i]);// 输出信号种类
			bean.jk8ProFeatNum.assign(form_value[27][i]);// 产品特征号
			//2020-03-31
			bean.jk8Manufacturer.assign(form_value[28][i]);// 生产厂家
			bean.jk8CommunicateMode2.assign(form_value[29][i]);// 通信方式2

			bean_vec.push_back(bean);
		}
	}
	printf("444444444444444=>\n");
	for(int i = 0 ;i < prop_count; i++){
		for(int j = 0;j < count[i];j++){
			MEM_free(form_value[i][j]);
			form_value[i][j] =NULL;
		}
		MEM_free(form_value[i]);
		form_value[i] = NULL;
	}
	//POM_AM__set_application_bypass(false);
	printf("555555555555=>\n");

}

/**
*	设置汇总表属性
*/
void JK_set_summary_form_prop(tag_t form_tag,vector<JK_SUMMARY_STRUCT> bean_vec){
	WriteLog_jk("开始设置汇总表属性\n");
	int i = 0,j=0 ;
	int prop_count = 30;
	char ** values[30];
	if(bean_vec.size() > 0){
		for(i = 0 ;i < prop_count;i++){
			values[i] =(char**) MEM_alloc(sizeof(char*)*bean_vec.size());
			for(j =0;j < bean_vec.size();j++){
				values[i][j] = (char *) MEM_alloc(sizeof(char)*256);
			}
		}
		for(i = 0 ;i < bean_vec.size();i++){
			JK_SUMMARY_STRUCT bean = bean_vec[i];
			strcpy(values[0][i],bean.jk8ProductType.c_str());
			strcpy(values[1][i],bean.jk8ProductModNO.c_str());// 产品型号
			strcpy(values[2][i],bean.jk8ProductIdentifyNO.c_str());// 识别号
			strcpy(values[3][i],bean.jk8ProductName.c_str());// 产品名称
			strcpy(values[4][i],bean.jk8BaseMeterManufactor.c_str());// 基表厂家   5
			strcpy(values[5][i],bean.jk8ICCardType.c_str());// IC卡型号
			strcpy(values[6][i],bean.jk8CircBoardModNO.c_str());// 线路板型号
			strcpy(values[7][i],bean.jk8ProgramFeatures.c_str());// 程序特征
			strcpy(values[8][i],bean.jk8InsteadType.c_str());;// 替代型号
			strcpy(values[9][i],bean.jk8FunctionOverview.c_str());// 功能概述  10
			strcpy(values[10][i],bean.jk8CustSpecRequirements.c_str());// 客户特殊要求
			//bean.jk8U8NO.c_str());// U8编码号  （去掉）
			strcpy(values[11][i],bean.jk8Valve.c_str());// 阀门
			strcpy(values[12][i],bean.jk8EncryptType.c_str());// 加密类型
			strcpy(values[13][i],bean.jk8Applicant.c_str());// 申请人
			strcpy(values[14][i],bean.jk8RecordDate.c_str());// 登记日期
			strcpy(values[15][i],bean.jk8ApplyMarket.c_str());// 适用市场
			strcpy(values[16][i],bean.jk8BMManfMatched.c_str());// 配套基表厂家

			strcpy(values[17][i],bean.jk8ProjectName.c_str());// 项目名称
			strcpy(values[18][i],bean.jk8ProjectNO.c_str());// 项目编号

			strcpy(values[19][i],bean.jk8Status.c_str());// 状态
			strcpy(values[20][i],bean.jk8ValveType.c_str());// 阀门类型
			strcpy(values[21][i],bean.jk8CommunicateMode.c_str());// 通信方式
			strcpy(values[22][i],bean.jk8PowerSupplyMode.c_str());// 供电类型

			strcpy(values[23][i],bean.jk8GasType.c_str());// 气体种类
			strcpy(values[24][i],bean.jk8UsePlace.c_str());// 使用场所
			strcpy(values[25][i],bean.jk8AlaDectRelation.c_str());// 报警部分
			strcpy(values[26][i],bean.jk8OutputSignal.c_str());// 输出信号种类
			strcpy(values[27][i],bean.jk8ProFeatNum.c_str());// 产品特征号

			// 2020-03-31
			strcpy(values[28][i],bean.jk8Manufacturer.c_str());// 生产厂家
			strcpy(values[29][i],bean.jk8CommunicateMode2.c_str());// 通信方式2

		}
	}
	
	ITKCALL(AOM_set_value_strings(form_tag,"jk8ProductType",bean_vec.size(),values[0]));//产品类型
	ITKCALL(AOM_set_value_strings(form_tag,"jk8ProductModNO",bean_vec.size(),values[1]));// 产品型号
	ITKCALL(AOM_set_value_strings(form_tag,"jk8ProductIdentifyNO",bean_vec.size(),values[2]));// 识别号
	ITKCALL(AOM_set_value_strings(form_tag,"jk8ProductName",bean_vec.size(),values[3]));// 产品名称
	ITKCALL(AOM_set_value_strings(form_tag,"jk8BaseMeterManufactor",bean_vec.size(),values[4]));// 基表厂家
	ITKCALL(AOM_set_value_strings(form_tag,"jk8ICCardType",bean_vec.size(),values[5]));// IC卡型号
	ITKCALL(AOM_set_value_strings(form_tag,"jk8CircBoardModNO",bean_vec.size(),values[6]));// 线路板型号
	ITKCALL(AOM_set_value_strings(form_tag,"jk8ProgramFeatures",bean_vec.size(),values[7]));// 程序特征
	ITKCALL(AOM_set_value_strings(form_tag,"jk8InsteadType",bean_vec.size(),values[8]));// 替代型号
	ITKCALL(AOM_set_value_strings(form_tag,"jk8FunctionOverview",bean_vec.size(),values[9]));// 功能概述
	ITKCALL(AOM_set_value_strings(form_tag,"jk8CustSpecRequirements",bean_vec.size(),values[10]));// 客户特殊要求
	//ITKCALL(AOM_ask_value_string(attachments[i],"jk8U8NO",&form_value));// U8编码号  （去掉）
	ITKCALL(AOM_set_value_strings(form_tag,"jk8Valve",bean_vec.size(),values[11]));// 阀门
	ITKCALL(AOM_set_value_strings(form_tag,"jk8EncryptType",bean_vec.size(),values[12]));// 加密类型
	ITKCALL(AOM_set_value_strings(form_tag,"jk8Applicant",bean_vec.size(),values[13]));// 申请人
	ITKCALL(AOM_set_value_strings(form_tag,"jk8RecordDate",bean_vec.size(),values[14]));// 登记日期
	ITKCALL(AOM_set_value_strings(form_tag,"jk8ApplyMarket",bean_vec.size(),values[15]));// 适用市场
	ITKCALL(AOM_set_value_strings(form_tag,"jk8BMManfMatched",bean_vec.size(),values[16]));// 配套基表厂家

	ITKCALL(AOM_set_value_strings(form_tag,"jk8ProjectName",bean_vec.size(),values[17]));// 项目名称
	ITKCALL(AOM_set_value_strings(form_tag,"jk8ProjectNO",bean_vec.size(),values[18]));// 项目编号

	ITKCALL(AOM_set_value_strings(form_tag,"jk8Status",bean_vec.size(),values[19]));// 状态
	ITKCALL(AOM_set_value_strings(form_tag,"jk8ValveType",bean_vec.size(),values[20]));// 阀门类型
	ITKCALL(AOM_set_value_strings(form_tag,"jk8CommunicateMode",bean_vec.size(),values[21]));// 通信方式
	ITKCALL(AOM_set_value_strings(form_tag,"jk8PowerSupplyMode",bean_vec.size(),values[22]));// 供电类型
	
	//2019.07.31
	ITKCALL(AOM_set_value_strings(form_tag,"jk8GasType",bean_vec.size(),values[23]));// 气体种类
	ITKCALL(AOM_set_value_strings(form_tag,"jk8UsePlace",bean_vec.size(),values[24]));// 使用场所
	ITKCALL(AOM_set_value_strings(form_tag,"jk8AlaDectRelation",bean_vec.size(),values[25]));// 报警部分
	ITKCALL(AOM_set_value_strings(form_tag,"jk8OutputSignal",bean_vec.size(),values[26]));// 输出信号种类
	ITKCALL(AOM_set_value_strings(form_tag,"jk8ProFeatNum",bean_vec.size(),values[27]));// 产品特征号

	// 2020-03-31
	ITKCALL(AOM_set_value_strings(form_tag,"jk8Manufacturer",bean_vec.size(),values[28]));// 生产厂家
	ITKCALL(AOM_set_value_strings(form_tag,"jk8CommunicateMode2",bean_vec.size(),values[29]));// 通信方式2

	ITKCALL(AOM_save(form_tag));
	ITKCALL(AOM_refresh(form_tag,false));
	ITKCALL(AOM_unlock(form_tag,0));
	WriteLog_jk("传递汇总表结束,保存数据完成\n");
	printf("------------传递汇总表0000-----------------");

	//释放资源
	/*for(i = 0 ;i <prop_count;i++){
	for(j =0;j < bean_vec.size();j++){
	MEM_free(values[i][j]);
	values[i][j] = NULL;
	}
	MEM_free(values[i]);
	values[i] = NULL;
	}*/
	printf("------------传递汇总表1111-----------------");
}

/**
* 产品汇总表
*/
int JK_summary_form(EPM_rule_message_t msg)
{
	char tc_log_file_name[512];
	time_t				now;
	struct				tm *p;
	time(&now);
	p = localtime(&now);

	//sprintf(startDate,"%04d-%d-%02d 00:00", 1900+p->tm_year,p->tm_mon+1 ,p->tm_mday);
	//sprintf(endDate,"%04d-%d-%02d 23:59", 1900+p->tm_year,p->tm_mon+1 ,p->tm_mday);
	sprintf(tc_log_file_name, "%s\\jk_hzb_log_[%d-%d-%d-%d-%02d].txt",getenv("TEMP"),1900+p->tm_year,p->tm_mon+1 ,p->tm_mday,p->tm_hour,p->tm_min  );
	printf("tc_log_file_name=%s\n",tc_log_file_name);
	CreateLogFile_jk(tc_log_file_name);

	EPM_decision_t decision = EPM_go;
	int ifail = ITK_ok,arg_cnt = 0,i = 0,att_cnt = 0;
	tag_t task_tag = NULLTAG ,rootTask_tag = NULLTAG, *attachments =NULL,summary_form_tag = NULLTAG;
	char *arg = NULL,*argflag = NULL, *argvalue = NULL,type_class[WSO_object_type_size_c+1] ="\0",*form_value = NULL;
	vector<JK_SUMMARY_STRUCT> bean_vec;
	//用来获取汇总表的PUID
	vector<string> pref_vec;
	getPrefStrings("JK_SQB_FORM_PUID",TC_preference_site, pref_vec);
	if(pref_vec.size() > 0){
		ITK__convert_uid_to_tag(pref_vec[0].c_str(),&summary_form_tag);
		if(summary_form_tag == NULLTAG){
			WriteLog_jk("PUID[%s]不能转换成对象\n",pref_vec[0].c_str());
			CloseLog_jk();
			printf("PUID[%s]不能转换成对象\n",pref_vec[0].c_str());
			return EPM_nogo;
		}
		printf("找到了汇总表\n");
		int isOk = 1;
		logical  is_reserved;
		POM_AM__set_application_bypass(true);
		ITKCALL(RES_is_checked_out(summary_form_tag,&is_reserved));
		if (is_reserved)
		{
			WriteLog_jk("汇总表签出,开始签入\n");
			ITKCALL(RES_checkin(summary_form_tag));
		}
		ITKCALL(AOM_lock(summary_form_tag));
		ITKCALL(AOM_refresh(summary_form_tag,false));
		POM_AM__set_application_bypass(false);
		JK_get_summary_form_prop(summary_form_tag,bean_vec,&isOk);
		if(isOk == 0){
			ITKCALL(AOM_unlock(summary_form_tag));
			printf("PUID[%s]表单属性不正确\n",pref_vec[0].c_str());
			WriteLog_jk("PUID[%s]表单属性不正确\n",pref_vec[0].c_str());
			CloseLog_jk();
			return EPM_nogo;
		}
	}else{
		printf("请配置首选项[connor_custSummaryFormPUID]\n");
		WriteLog_jk("请配置首选项[connor_custSummaryFormPUID]\n");
		CloseLog_jk();
		return EPM_nogo;
	}

	//获取当前触发的任务
	task_tag = msg.task;
	//获取根流程节点
	ITKCALL(ifail = EPM_ask_root_task(task_tag, &rootTask_tag));
	//获取目标引用对象
	ITKCALL(ifail = EPM_ask_attachments(rootTask_tag, EPM_target_attachment, &att_cnt, &attachments));
	//循环目标对象
	for(i = 0;i < att_cnt ; i++){
		//获取对象的类型
		/**********************************************
		*	对象类型：JK8DerPIdenNOAppForm
		*	对象类型：JK8SpecPINOAppForm
		*	对象类型：JK8NewPIdenNOAppForm
		*	对象类型：JK8NPModINOAppForm
		*	对象类型：JK8ExtPIdenNOAppForm
		**********************************************/
		ITKCALL( WSOM_ask_object_type(attachments[i], type_class));
		WriteLog_jk("对象类型：%s \n",type_class);
		printf("对象类型：%s \n",type_class);
		if(strcmp(type_class,"JK8DerPIdenNOAppForm") ==0 //衍生产品识别号申请表
			||strcmp(type_class,"JK8SpecPINOAppForm") ==0 //特殊要求产品识别号申请表
			||strcmp(type_class,"JK8NewPIdenNOAppForm") ==0 //新产品识别号申请表
			||strcmp(type_class,"JK8ExtPIdenNOAppForm") ==0 //扩展产品识别号申请表  //2017.12.4增加申请表
			||strcmp(type_class,"JK8NPModINOAppForm") ==0//新产品型号与识别号申请表
			||strcmp(type_class,"JK8CotlerPModAppForm") ==0//控制器产品型号申请表//2018.1.20 新增申请表
			||strcmp(type_class,"JK8ColPIdenNOAppForm") ==0//控制器识别号申请表//2018.6.4 新增申请表
			||strcmp(type_class,"JK8ALPModAppForm") ==0//2019.07.31 新增报警器产品型号申请表
			//2020-03-31
			||strcmp(type_class,"JK8WarnerNPModINOAppForm") ==0   // 报警器产品型号识别号申请表
			||strcmp(type_class,"JK8WarnerNPINOAppForm") ==0           // 报警器产品识别号申请表
			)
		{
			WriteLog_jk("对象类型符合,开始执行代码 \n");
			char *name_fo;
			ITKCALL(AOM_ask_value_string(attachments[i],"object_name",&name_fo));
			WriteLog_jk("对象名称：%s \n",name_fo);

			char *sbhstr,*cpxhstr;
			if(strcmp(type_class,"JK8CotlerPModAppForm") ==0){
				ITKCALL(AOM_ask_value_string(attachments[i],"jk8ProductModNO",&cpxhstr));// 产品型号
				if(strcmp(cpxhstr,"") ==0){
					printf("产品型号为空,无法传递\n");
					ITKCALL(AOM_unlock(summary_form_tag));
					WriteLog_jk("产品型号为空,无法传递\n");
					CloseLog_jk();
					return EPM_nogo;
				}	
			}
			else if(strcmp(type_class,"JK8ALPModAppForm") ==0){
				ITKCALL(AOM_ask_value_string(attachments[i],"jk8ProductModNO",&cpxhstr));// 产品型号
				if(strcmp(cpxhstr,"") ==0){
					printf("产品型号为空,无法传递\n");
					ITKCALL(AOM_unlock(summary_form_tag));
					WriteLog_jk("产品型号为空,无法传递\n");
					CloseLog_jk();
					return EPM_nogo;
				}	
			}
			
			else{
				ITKCALL(AOM_ask_value_string(attachments[i],"jk8ProductIdentifyNO",&sbhstr));// 识别号

				if(strcmp(sbhstr,"") ==0){
					printf("识别号为空,无法传递\n");
					ITKCALL(AOM_unlock(summary_form_tag));
					WriteLog_jk("识别号为空,无法传递\n");
					CloseLog_jk();
					return EPM_nogo;
				}
			}

			JK_SUMMARY_STRUCT bean ;
			//获取单张表的属性
			JK_get_form_prop(attachments[i],bean,type_class);
			cout<<"单张属性获取完毕"<<endl;
			bean_vec.push_back(bean);
		}

	}

	POM_AM__set_application_bypass(true);
	JK_set_summary_form_prop(summary_form_tag,bean_vec);
	printf("------------传递汇总表2222-----------------");
	POM_AM__set_application_bypass(false);

	if(attachments!=NULL)
	{
		MEM_free(attachments);
		attachments = NULL;
	}
	WriteLog_jk("------------传递汇总表结束-----------------");
	CloseLog_jk();
	printf("------------传递汇总表完成-----------------");
	return decision;
}






/**
*	设置汇总表属性pcb
*/
void JK_set_summary_pcb_form_prop(tag_t form_tag,vector<JK_SUMMARY_PCB_STRUCT> bean_vec){
	int i = 0,j=0 ;
	int prop_count = 6;
	char ** values[6];
	if(bean_vec.size() > 0){
		for(i = 0 ;i < prop_count;i++){
			values[i] =(char**) MEM_alloc(sizeof(char*)*bean_vec.size());
			for(j =0;j < bean_vec.size();j++){
				values[i][j] = (char *) MEM_alloc(sizeof(char)*256);
			}
		}
		for(i = 0 ;i < bean_vec.size();i++){
			JK_SUMMARY_PCB_STRUCT bean = bean_vec[i];
			strcpy(values[0][i],bean.jk8PCBNO.c_str());//pcb编码
			strcpy(values[1][i],bean.jk8Companylogo.c_str());// 公司标识
			strcpy(values[2][i],bean.jk8MeasureType.c_str());// 计量原理
			strcpy(values[3][i],bean.jk8CommunicateMode.c_str());// 通讯方式
			strcpy(values[4][i],bean.jk8Application.c_str());// 应用范围  5
			strcpy(values[5][i],bean.jk8Projectname.c_str());
		}
	}
	ITKCALL(AOM_lock(form_tag));
	ITKCALL(AOM_set_value_strings(form_tag,"jk8PCBNO",bean_vec.size(),values[0]));//pcb编码
	ITKCALL(AOM_set_value_strings(form_tag,"jk8Companylogo",bean_vec.size(),values[1]));//公司标识
	ITKCALL(AOM_set_value_strings(form_tag,"jk8MeasureType",bean_vec.size(),values[2]));// 计量原理
	ITKCALL(AOM_set_value_strings(form_tag,"jk8CommunicateMode",bean_vec.size(),values[3]));// 通讯方式
	ITKCALL(AOM_set_value_strings(form_tag,"jk8Application",bean_vec.size(),values[4]));// 应用范围
	ITKCALL(AOM_set_value_strings(form_tag,"jk8Projectname",bean_vec.size(),values[5]));// 应用范围

	ITKCALL(AOM_save(form_tag));
	ITKCALL(AOM_unlock(form_tag,0));
	printf("------------传递汇总表0000-----------------");

	//释放资源
	for(i = 0 ;i <prop_count;i++){
		for(j =0;j < bean_vec.size();j++){
			if(values[i][j]!=NULL){
				MEM_free(values[i][j]);
				values[i][j] = NULL;
			}

		}
		if(values[i]!=NULL){
			MEM_free(values[i]);
			values[i] = NULL;
		}
	}
	printf("------------传递汇总表1111-----------------");
}



/**
* 获取2张扩展表的属性
*	pcb
*/
void JK_get_pcb_form_prop(tag_t form_tag,JK_SUMMARY_PCB_STRUCT &bean,char *form_type){
	char * form_value[5];
	int prop_count = 5;
	ITKCALL(AOM_ask_value_string(form_tag,"jk8PCBNO",&form_value[0]));//pcb编码
	ITKCALL(AOM_ask_value_string(form_tag,"jk8Companylogo",&form_value[1]));// 公司标识
	ITKCALL(AOM_ask_value_string(form_tag,"jk8MeasureType",&form_value[2]));// 计量原理
	ITKCALL(AOM_ask_value_string(form_tag,"jk8CommunicateMode",&form_value[3]));// 通讯方式
	ITKCALL(AOM_ask_value_string(form_tag,"jk8Application",&form_value[4]));// 应用范围
	ITKCALL(AOM_ask_value_string(form_tag,"jk8Projectname",&form_value[5]));// 项目名称


	bean.jk8PCBNO.assign(form_value[0]);// 产品型号
	bean.jk8Companylogo.assign(form_value[1]);// 产品型号
	bean.jk8MeasureType.assign(form_value[2]);// 识别号
	bean.jk8CommunicateMode.assign(form_value[3]);// 产品名称
	bean.jk8Application.assign(form_value[4]);// 基表厂家   5
	bean.jk8Projectname.assign(form_value[5]);// 项目名称

	//释放资源
	for(int i = 0 ;i <prop_count;i++){
		if(form_value[i]!=NULL){
			MEM_free(form_value[i]);
			form_value[i] = NULL;
		}
	}
}



/**
*
* 获取汇总表的属性 pcb
*
*/
void JK_get_summary_pcb_form_prop(tag_t form_tag,vector<JK_SUMMARY_PCB_STRUCT> &bean_vec,int * isOk){
	int prop_count = 6;
	int count[6],sum_count =0;
	char ** form_value[6];
	//POM_AM__set_application_bypass(true);
	*isOk = 1;
	printf("获取汇总表单【%d】的属性\n",form_tag);
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8PCBNO",&count[0],&form_value[0]));//PCB编码
	sum_count = count[0];
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8Companylogo",&count[1],&form_value[1]));// 公司标识
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8MeasureType",&count[2],&form_value[2]));// 计量原理
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8CommunicateMode",&count[3],&form_value[3]));// 通讯方式
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8Application",&count[4],&form_value[4]));// 应用范围
	ITKCALL(AOM_ask_value_strings(form_tag,"jk8Projectname",&count[5],&form_value[5]));// 项目名称
	for(int i  = 0 ;i < (prop_count-1);i++){
		if(count[i] !=count[i+1]){
			*isOk = 0;
			printf("属性不正确=>\n");
		}
	}
	printf("222222222222222222=>\n");
	if( *isOk ==1){
		printf("3333333333333333=>\n");
		for(int i = 0 ;i <sum_count;i++ ){
			JK_SUMMARY_PCB_STRUCT bean ;
			bean.jk8PCBNO.assign(form_value[0][i]);//PCB编码
			bean.jk8Companylogo.assign(form_value[1][i]);// 公司标识
			bean.jk8MeasureType.assign(form_value[2][i]);// 计量原理
			bean.jk8CommunicateMode.assign(form_value[3][i]);// 通讯方式
			bean.jk8Application.assign(form_value[4][i]);// 应用范围   5
			bean.jk8Projectname.assign(form_value[5][i]);// 项目名称   6

			bean_vec.push_back(bean);
		}
	}
	printf("444444444444444=>\n");
	for(int i = 0 ;i < prop_count; i++){
		for(int j = 0;j < count[i];j++){
			if(form_value[i][j]!=NULL){
				MEM_free(form_value[i][j]);
				form_value[i][j] =NULL;
			}
		}
		if(form_value[i]!=NULL){
			MEM_free(form_value[i]);
			form_value[i] = NULL;
		}
	}
	//POM_AM__set_application_bypass(false);
	printf("555555555555=>\n");

}


/**
* pcb汇总表
*/
int JK_summary_pcb_form(EPM_rule_message_t msg)
{
	EPM_decision_t decision = EPM_go;
	int ifail = ITK_ok,arg_cnt = 0,i = 0,att_cnt = 0;
	tag_t task_tag = NULLTAG ,rootTask_tag = NULLTAG, *attachments =NULL,summary_form_tag = NULLTAG;
	char *arg = NULL,*argflag = NULL, *argvalue = NULL,type_class[WSO_object_type_size_c+1] ="\0",*form_value = NULL;
	vector<JK_SUMMARY_PCB_STRUCT> bean_vec;
	//用来获取汇总表的PUID
	vector<string> pref_vec;
	getPrefStrings("JK_PCBReg_uid",TC_preference_site, pref_vec);
	if(pref_vec.size() > 0){
		ITK__convert_uid_to_tag(pref_vec[0].c_str(),&summary_form_tag);
		if(summary_form_tag == NULLTAG){
			printf("PUID[%s]不能转换成对象\n",pref_vec[0].c_str());
			return EPM_nogo;
		}
		printf("找到了汇总表\n");
		int isOk = 1;
		JK_get_summary_pcb_form_prop(summary_form_tag,bean_vec,&isOk);
		if(isOk == 0){
			printf("PUID[%s]表单属性不正确\n",pref_vec[0].c_str());
			return EPM_nogo;
		}
	}else{
		printf("请配置首选项[JK_PCBReg_uid]\n");
		return EPM_nogo;
	}

	//获取当前触发的任务
	task_tag = msg.task;
	//获取根流程节点
	ITKCALL(ifail = EPM_ask_root_task(task_tag, &rootTask_tag));
	//获取目标引用对象
	ITKCALL(ifail = EPM_ask_attachments(rootTask_tag, EPM_target_attachment, &att_cnt, &attachments));
	//循环目标对象
	for(i = 0;i < att_cnt ; i++){
		//获取对象的类型
		/**********************************************
		*	对象类型：JK8PCBNOAppForm
		*	对象类型：JK8SpecPINOAppForm
		**********************************************/
		ITKCALL( WSOM_ask_object_type(attachments[i], type_class));
		printf("对象类型：%s \n",type_class);
		if(strcmp(type_class,"JK8PCBNOAppForm") ==0 //PCB编码申请表
			||strcmp(type_class,"JK8DerPCBNOAppForm") ==0 )//衍生PCB编码申请表
		{
			char *sbhstr;
			ITKCALL(AOM_ask_value_string(attachments[i],"jk8PCBNO",&sbhstr));// 识别号
			if(strcmp(sbhstr,"") ==0){
				printf("识别号为空,无法传递\n");
				return EPM_nogo;
			}
			JK_SUMMARY_PCB_STRUCT bean ;
			//获取单张表的属性
			JK_get_pcb_form_prop(attachments[i],bean,type_class);
			bean_vec.push_back(bean);
		}

	}

	POM_AM__set_application_bypass(true);
	JK_set_summary_pcb_form_prop(summary_form_tag,bean_vec);
	printf("------------传递汇总表2222-----------------");
	POM_AM__set_application_bypass(false);

	if(attachments!=NULL)
	{
		MEM_free(attachments);
		attachments = NULL;
	}
	printf("------------传递汇总表完成-----------------");
	return decision;
}












/**
* 
* 发送邮件
*
*/
int JK_send_email(EPM_action_message_t msg){
	int ifail = 0, att_cnt = 0 ,i =0,compare=0; 
	tag_t task_tag =NULLTAG , rootTask_tag =NULLTAG , *attachments =NULL;
	char wuliao[10240] = "\0", * itemName = NULL, * itemID = NULL ,* itemUser = NULL,*jk8SpecModel=NULL,*jk8TechModel=NULL; 
	//vector<string> emailNameVec ;
	printf( "\n ----------发送邮箱开始---------\n");
	//获取配置的发送到
	//getPrefStrings("JK_SendEmailName_Option",TC_preference_site,emailNameVec);

	//获得参数配置-SignName  邮箱1;邮箱2
	char arg1value[1024] = "",arg2value[1024] = "",arg3value[1024]="",arg4value[1024]="",
		signcounter_info[1024] = "", *value = NULL;
	char *argflag =NULL,*argvalue=NULL ,*arg = NULL;
	BOOL bypass = FALSE;
	int arg_cnt = 0;
	char emailName[1024] = "";
	char title[256] = "";


	arg_cnt = TC_number_of_arguments(msg.arguments);
	ECHO("参数个数为：%d\n",arg_cnt);
	POM_AM__set_application_bypass(true);
	if (arg_cnt > 0)
	{
		for (i=0;i<arg_cnt;i++)
		{
			arg = TC_next_argument(msg.arguments);
			ifail = ITK_ask_argument_named_value((const char*)arg, &argflag, &argvalue);
			printf("参数1：%s \n",argflag);
			printf("参数2：%s \n",argvalue);
			if (stricmp(argflag, "addr") == 0)
			{
				if(argvalue != NULL)
				{
					strcpy(emailName,argvalue);

					printf("参数邮箱：%s \n",emailName);



				}
			}else if(stricmp(argflag, "title") == 0){
				if(argvalue != NULL)
				{
					strcpy(title,argvalue);

					printf("标题：%s \n",title);



				}
			}



		}
		MEM_free(argflag);
		MEM_free(argvalue);
	}
	printf("222222222222222222222\n");
	//获取当前触发的任务
	task_tag = msg.task;


	//获取根流程节点
	ITKCALL(ifail = EPM_ask_root_task(task_tag, &rootTask_tag));

	//获取目标引用对象
	ITKCALL(ifail = EPM_ask_attachments(rootTask_tag, EPM_target_attachment, &att_cnt, &attachments));
	//循环目标对象

	strcat(wuliao,"{");
	for(i = 0;i < att_cnt ; i++){
		tag_t item_tag = NULLTAG;
		tag_t form_tag = NULLTAG;
		//判断是否是item
		if(checkIsTypeOrSubtype(attachments[i],"Item")){
			item_tag = attachments[i];
		}
		//判断是否是itemRevision
		if(checkIsTypeOrSubtype(attachments[i],"ItemRevision") ){
			//通过版本获取item
			ITEM_ask_item_of_rev(attachments[i],&item_tag);
			int formcount;
			tag_t * formTagS;
			AOM_ask_value_tags(attachments[i],"IMAN_master_form_rev",&formcount,&formTagS);
			if(formcount>0){
				form_tag = formTagS[0];
				printf("-----------------获得---------------------\n");
			}

		}
		if(stricmp(title, "") != 0){
			if(item_tag != NULLTAG){
				tag_t owning_user = NULLTAG;
				AOM_ask_value_string(item_tag,"item_id",&itemID);//获取对象的item_id
				AOM_ask_value_string(item_tag,"object_name",&itemName);//获取对象的名称
				AOM_ask_value_tag(item_tag,"owning_user",&owning_user);//获取对象的所有者
				ITKCALL(AOM_ask_value_string(owning_user,"user_name",&itemUser))
					strcat(wuliao,"[编码:");
				strcat(wuliao,itemID);
				strcat(wuliao," 名称:");
				strcat(wuliao,itemName);
				strcat(wuliao," 所有者:");
				strcat(wuliao,itemUser);
				strcat(wuliao,"]");
				//strcat(itemNames,itemName);
				if(itemID !=NULL){
					MEM_free(itemID);
					itemID =NULL;
				}

				if(itemName !=NULL){
					MEM_free(itemName);
					itemName =NULL;
				}
				if(itemUser !=NULL){
					MEM_free(itemUser);
					itemUser =NULL;
				}

			}



		}else{
			if(item_tag != NULLTAG&&form_tag!=NULLTAG){
				tag_t owning_user = NULLTAG;
				AOM_ask_value_string(item_tag,"item_id",&itemID);//获取对象的item_id
				AOM_ask_value_string(item_tag,"object_name",&itemName);//获取对象的名称
				AOM_ask_value_tag(item_tag,"owning_user",&owning_user);//获取对象的所有者
				ITKCALL(AOM_ask_value_string(owning_user,"user_name",&itemUser))
					AOM_ask_value_string(form_tag,"jk8SpecModel",&jk8SpecModel);//获取表单的规格型号
				AOM_ask_value_string(form_tag,"jk8TechModel",&jk8TechModel);//获取对象的技术型号


				//TODO 通过判断E-U8物料的名称是否以“E-8”开头来决定是否发邮件
				compare=strncmp(itemID,"E-8",3);
				if(compare == 0){
					ECHO("物料为E-U8物料不发送邮件");
					if(itemID !=NULL){
						MEM_free(itemID);
						itemID =NULL;
					}

					if(itemName !=NULL){
						MEM_free(itemName);
						itemName =NULL;
					}
					if(itemUser !=NULL){
						MEM_free(itemUser);
						itemUser =NULL;
					}
					if(jk8SpecModel !=NULL){
						MEM_free(jk8SpecModel);
						jk8SpecModel =NULL;
					}
					if(jk8TechModel !=NULL){
						MEM_free(jk8TechModel);
						jk8TechModel =NULL;
					}

					continue;
					//return 0;

				}


				strcat(wuliao,"[编码:");
				strcat(wuliao,itemID);
				strcat(wuliao," 名称:");
				strcat(wuliao,itemName);
				strcat(wuliao," 规格型号:");
				strcat(wuliao,jk8SpecModel);
				strcat(wuliao," 技术型号：:");
				strcat(wuliao,jk8TechModel);
				strcat(wuliao," 申请者:");
				strcat(wuliao,itemUser);
				strcat(wuliao,"]");
				//strcat(itemNames,itemName);
				if(itemID !=NULL){
					MEM_free(itemID);
					itemID =NULL;
				}

				if(itemName !=NULL){
					MEM_free(itemName);
					itemName =NULL;
				}
				if(itemUser !=NULL){
					MEM_free(itemUser);
					itemUser =NULL;
				}
				if(jk8SpecModel !=NULL){
					MEM_free(jk8SpecModel);
					jk8SpecModel =NULL;
				}
				if(jk8TechModel !=NULL){
					MEM_free(jk8TechModel);
					jk8TechModel =NULL;
				}
			}
		}


	}
	strcat(wuliao,"}");





	char cmd[20560] = "\0"; 
	char * tc_root_dir = getenv("tc_root");
	char  jar_file[2560] = "\0";
	if(stricmp(title, "") != 0){
		strcpy(jar_file, tc_root_dir);
		strcat(jar_file, "\\bin\\");
		strcat(jar_file, "JK_Email.jar");

		strcpy( cmd, "java -jar " );
		strcat(cmd , " \"");
		strcat(cmd ,jar_file);
		strcat( cmd, "\" \"" ); 
		strcat( cmd, title ); 
		//strcat( cmd, "\" \"" );
		//strcat( cmd, itemNames ); 
		/*if(emailNameVec.size() > 0){
		strcat( cmd, "\" \"" );
		strcat( cmd , emailNameVec[0].c_str());
		}*/
		//printf( "\n 首选项邮箱 %s\n",emailNameVec[0].c_str() );
		if(emailName!=NULL){
			strcat( cmd, "\" \"" );
			strcat( cmd , emailName);
		}
		strcat( cmd, "\" \"" ); 
		strcat( cmd, wuliao ); 
		strcat( cmd,"\"");
		printf( "\n%s\n",cmd );
	}else{
		strcpy(jar_file, tc_root_dir);
		strcat(jar_file, "\\bin\\");
		strcat(jar_file, "JK_SendEmail.jar");

		strcpy( cmd, "java -jar " );
		strcat(cmd , " \"");
		strcat(cmd ,jar_file);
		strcat( cmd, "\" \"" ); 
		strcat( cmd, wuliao ); 
		//strcat( cmd, "\" \"" );
		//strcat( cmd, itemNames ); 
		/*if(emailNameVec.size() > 0){
		strcat( cmd, "\" \"" );
		strcat( cmd , emailNameVec[0].c_str());
		}*/
		//printf( "\n 首选项邮箱 %s\n",emailNameVec[0].c_str() );
		if(emailName!=NULL){
			strcat( cmd, "\" \"" );
			strcat( cmd , emailName);
		}
		strcat( cmd,"\"");
	}
	printf( "\n%s\n",cmd );
	system( cmd );




	if(attachments !=NULL){
		MEM_free(attachments);
		attachments = NULL;
	}

	return 0;
}

/**
* 
* 发送邮件
*
*/
int JK_send_email_2(EPM_action_message_t msg){
	int ifail = 0, att_cnt = 0 ,i =0,compare=0; 
	tag_t task_tag =NULLTAG , rootTask_tag =NULLTAG ;
	char wuliao[10240] = "\0";// * itemName = NULL, * itemID = NULL ,* itemUser = NULL,*jk8SpecModel=NULL,*jk8TechModel=NULL; 
	//vector<string> emailNameVec ;
	printf( "\n ----------发送邮箱开始---------\n");
	//获取配置的发送到
	//getPrefStrings("JK_SendEmailName_Option",TC_preference_site,emailNameVec);

	//获得参数配置-SignName  邮箱1;邮箱2
	char arg1value[1024] = "",arg2value[1024] = "",arg3value[1024]="",arg4value[1024]="",
		signcounter_info[1024] = "", *value = NULL;
	char *argflag =NULL,*argvalue=NULL ,*arg = NULL;
	BOOL bypass = FALSE;
	int arg_cnt = 0;
	char emailName[1024] = "";
	char title[256] = "";
	char *my_job_name =NULL,*my_task_name=NULL,*template_name = NULL;
	tag_t temp_task_tag =NULLTAG;

	arg_cnt = TC_number_of_arguments(msg.arguments);
	ECHO("参数个数为：%d\n",arg_cnt);
	POM_AM__set_application_bypass(true);
	if (arg_cnt > 0)
	{
		for (i=0;i<arg_cnt;i++)
		{
			arg = TC_next_argument(msg.arguments);
			ifail = ITK_ask_argument_named_value((const char*)arg, &argflag, &argvalue);
			printf("参数1：%s \n",argflag);
			printf("参数2：%s \n",argvalue);
			if (stricmp(argflag, "addr") == 0)
			{
				if(argvalue != NULL)
				{
					strcpy(emailName,argvalue);
					printf("参数邮箱：%s \n",emailName);
				}
			}else if(stricmp(argflag, "title") == 0){
				if(argvalue != NULL)
				{
					strcpy(title,argvalue);
					printf("标题：%s \n",title);
				}
			}
		}
		MEM_free(argflag);
		MEM_free(argvalue);
	}
	printf("222222222222222222222\n");
	//获取当前触发的任务
	task_tag = msg.task;
	AOM_ask_value_string(task_tag,"job_name",&my_job_name);
	AOM_ask_value_string(task_tag,"object_name",&my_task_name);

	//获取根流程节点
	ITKCALL(ifail = EPM_ask_root_task(task_tag, &rootTask_tag));
	AOM_ask_value_tag(rootTask_tag,"task_template",&temp_task_tag);
	AOM_ask_value_string(temp_task_tag,"object_name",&template_name);


	//循环目标对象
	//	if(strcmp(template_name,"LCM_007")==0 
	//		|| strcmp(template_name,"LCM_009")==0
	//		|| strcmp(template_name,"LCM_016")==0
	//		|| strcmp(template_name,"LCM_025")==0
	//		|| strcmp(template_name,"LCM_026")==0
	//		|| strcmp(template_name,"LCM_027")==0){
	sprintf(wuliao,"%s(%s)",my_job_name,my_task_name);
	char cmd[20560] = "\0"; 
	char * tc_root_dir = getenv("tc_root");
	char  jar_file[2560] = "\0";
	strcpy(jar_file, tc_root_dir);
	strcat(jar_file, "\\bin\\");
	strcat(jar_file, "JK_SendMail20180102.jar");

	strcpy( cmd, "java -jar " );
	strcat(cmd , " \"");
	strcat(cmd ,jar_file);
	strcat( cmd, "\" \"" ); 
	strcat( cmd, title ); 
	strcat( cmd, "\" \"" );
	strcat( cmd , emailName);
	strcat( cmd, "\" \"" ); 
	strcat( cmd, wuliao ); 
	strcat( cmd,"\"");
	system( cmd );
	//	}

	if(my_job_name!=NULL){
		MEM_free(my_job_name);
		my_job_name =NULL;
	}
	if(my_task_name!=NULL){
		MEM_free(my_task_name);
		my_task_name =NULL;
	}
	if(template_name!=NULL){
		MEM_free(template_name);
		template_name =NULL;
	}


	return 0;
}


/**
*
* 设置权限
*
*/
void JK_set_owing_usre_and_group(tag_t obj_tag,tag_t user_tag,tag_t group_tag){
	ITKCALL(AOM_refresh(obj_tag,0));
	ITKCALL(AOM_lock(obj_tag));
	ITKCALL(AOM_set_ownership(obj_tag,user_tag,group_tag));
	ITKCALL(AOM_save(obj_tag));
	ITKCALL(AOM_unlock(obj_tag));

}

void removeReleaseStatusByName1(string statusName,tag_t rootTask,vector<tag_t> revVec,int num){
	tag_t release_status =NULLTAG;
	tag_t * attachments = NULL;
	int *att_types=NULL;
	int ifail = 0;
	att_types = (int*) MEM_alloc (sizeof(int) * ( revVec.size() ));
	attachments = (tag_t*) MEM_alloc (sizeof(tag_t) * ( revVec.size() ));
	//制定目标，数组转换
	for ( int indx = 0; indx < revVec.size(); indx++ )
	{
		att_types[indx] = EPM_target_attachment;//EPM_reference_attachment;
		attachments[indx] = revVec[indx];
	}
	//把所有的版本都添加到流程中
	printf("1ifail=>%d\n",ifail);
	ITKCALL(ifail=EPM_add_attachments(rootTask,revVec.size(),attachments,att_types));
	printf("2ifail=>%d\n",ifail);
	ITKCALL(ifail =CR_create_release_status(statusName.c_str(),&release_status));
	printf("4ifail=>%d\n",ifail);
	if(release_status!=NULLTAG){
		POM_AM__set_application_bypass(true);
		//可能有多次基线的情况，所以要删除所有的基线状态
		for(int n=0;n<num;n++)
		{
		ITKCALL(ifail =EPM_remove_status_from_targets(release_status,rootTask));//删除目标下对象的状态
			
		}
		printf("6ifail=>%d\n",ifail);
		POM_AM__set_application_bypass(false); 
	}
	if(att_types)										
	{											
		MEM_free(att_types);							
		att_types = NULL;								
	}
	if(attachments)										
	{											
		MEM_free(attachments);							
		attachments = NULL;								
	}

}

void removeRevFromTask1(tag_t rootTask,vector<tag_t> revVec){
	cout<<"enter  removeRevFromTask "<<endl;
	tag_t * attachments = NULL;
	
	attachments = (tag_t*) MEM_alloc (sizeof(tag_t) * ( revVec.size() ));
	//制定目标，数组转换
	for ( int indx = 0; indx < revVec.size(); indx++ )
	{
		attachments[indx] = revVec[indx];
	}
	cout<<"mark1--"<<endl;
	POM_AM__set_application_bypass(true);
	ITKCALL(EPM_remove_attachments(rootTask,revVec.size(),attachments));
	POM_AM__set_application_bypass(false);
		cout<<"mark2--"<<endl;
	if(attachments)										
	{											
		MEM_free(attachments);							
		attachments = NULL;								
	}
}
/**
* 
* 转移权限并且删除基线状态
*
*/
int JK_change_qx(EPM_action_message_t msg){
	int ifail = 0 , 
		i = 0 ,
		j = 0 , 
		att_cnt = 0,
		spec_cnt = 0,
		attach_cnt = 0;
	tag_t task_tag = NULLTAG , 
		root_task_tag = NULLTAG ,
		*attachments =NULL,
		owning_user =NULL,
		owning_group =NULL;
	int release_status_num=0;
			int release_status_num_temp=0;
	vector<tag_t> target_vec;
//		*specification_tags = NULL,
//		*attach_tags =NULL;
	POM_AM__set_application_bypass(true);
	task_tag = msg.task;
	ITKCALL(ifail = EPM_ask_root_task(task_tag, &root_task_tag));
	//获取目标引用对象
	ITKCALL(ifail = EPM_ask_attachments(root_task_tag, EPM_target_attachment, &att_cnt, &attachments));
	ITKCALL(ifail = AOM_ask_value_tag(root_task_tag,"owning_user",&owning_user));
	ITKCALL(ifail = AOM_ask_value_tag(root_task_tag,"owning_group",&owning_group));
	//循环目标对象
	for(i = 0 ;i < att_cnt ;i ++)
	{
		if(checkIsTypeOrSubtype(attachments[i],"ItemRevision")){
			

			tag_t *xgwj_tags = NULL;
			tag_t *release_status = NULL;
			
			//tag_t xgwj_tag = NULLTAG;
			int xgwj_count = 0;
			//TODO 先获取attachments[i]的类型，根据类型，再判断用哪个类型
			char *object_type=NULL;
			AOM_ask_value_string(attachments[i],"object_type",&object_type);
			cout<<"object_type-------------"<<object_type<<endl;
			if(strcmp(object_type,"TX2RJGGPSBRevision")==0)
			{
				ITKCALL(ifail = AOM_ask_value_tags(attachments[i],"TX2ReleaseFileRelation",&xgwj_count,&xgwj_tags));
			}else
			{
				ITKCALL(ifail = AOM_ask_value_tags(attachments[i],"JK8RelatedFiles",&xgwj_count,&xgwj_tags));
			}
			if(object_type!=NULL)
			{
				MEM_free(object_type);
				object_type=NULL;
			}

			for(int w = 0;w< xgwj_count;w++)
			{
				JK_set_owing_usre_and_group(xgwj_tags[w],owning_user,owning_group);
				//TODO 2018.5.16用户可能对对象进行了多次基线（比如分阶段和整个项目的），所以要删除所有的基线状态
				AOM_ask_value_tags(xgwj_tags[w],"release_status_list",&release_status_num_temp,&release_status);
				if(release_status_num<release_status_num_temp)
				{
					release_status_num=release_status_num_temp;
				}

				//TODO 2018.4.28删除"基线"状态
				target_vec.push_back(xgwj_tags[w]);
				//2018.4.18 去除转移对象下挂的数据集的权限
//				ITKCALL(AOM_ask_value_tags(xgwj_tags[w],"IMAN_specification",&spec_cnt,&specification_tags));
//				ITKCALL(AOM_ask_value_tags(xgwj_tags[w],"TC_Attaches",&attach_cnt,&attach_tags));
//				//给IMAN_specification关系下的文件赋予权限
//				for(j = 0;j < spec_cnt;j++){
//					JK_set_owing_usre_and_group(specification_tags[j],owning_user,owning_group);
//				}
//				//给TC_Attaches关系下的文件赋予权限
//				for(j = 0;j < attach_cnt;j++){
//					JK_set_owing_usre_and_group(attach_tags[j],owning_user,owning_group);
//				}
//
//				if(specification_tags !=NULL){
//					MEM_free(specification_tags);
//					specification_tags =NULL;
//				}
//
//				if(attach_tags !=NULL){
//					MEM_free(attach_tags);
//					attach_tags =NULL;
//				}
			}
			if(xgwj_tags == NULL){
				MEM_free(xgwj_tags);
				xgwj_tags =NULL;
			}
			if(release_status == NULL){
				MEM_free(release_status);
				release_status =NULL;
			}
		}
	}
	//TODO 2018.4.28
	POM_AM__set_application_bypass(true);
	//	removeReleaseStatus("删除状态流程",target_vec);
	cout<<"mark1"<<endl;
	removeReleaseStatusByName1("Baselined",root_task_tag,target_vec,release_status_num);
	cout<<"mark2"<<endl;
	removeRevFromTask1(root_task_tag,target_vec);
	cout<<"mark3"<<endl;
	POM_AM__set_application_bypass(false);
	cout<<"mark4"<<endl;

	if(attachments != NULL){
		MEM_free(attachments);
		attachments = NULL;
	}
	POM_AM__set_application_bypass(false);
	return 0;
}


/**
* 调用JAR汇总费用信息
*
*/
void summary_fee(char * excelPath, char * logPath){

	char cmd[1028] = "\0"; 
	char * tc_root_dir = getenv("tc_root");
	char  jar_file[256] = "\0";
	strcpy(jar_file, tc_root_dir);
	strcat(jar_file, "\\bin\\");
	strcat(jar_file, "JK_SummaryFee.jar");

	strcpy( cmd, "java -jar " );
	strcat(cmd , " \"");
	strcat(cmd ,jar_file);
	strcat( cmd, "\" \"" ); 
	strcat( cmd, excelPath ); 

	strcat( cmd, "\" \"" );
	strcat( cmd , logPath);

	strcat( cmd,"\"");
	printf( "\n%s\n",cmd );
	system( cmd );
}



int create_summary_fee_file(char *file_content,char *item_id, char **file_name)
{
	time_t now;
	struct tm *p;
	FILE *filePtr = NULL;

	char *temp_dir = getenv("TEMP");
	char local_path[MAX_PATH] = "";

	time(&now);
	p = localtime(&now);
	if(temp_dir[strlen(temp_dir) - 1] == '\\')
	{
		sprintf_s(local_path, "%s%s-%d-%d-%d-%d-%d-%d.dat", temp_dir,item_id,
			1900+p->tm_year,p->tm_mon+1 ,p->tm_mday+1 ,p->tm_hour,p->tm_min ,p->tm_sec);
	}
	else
	{
		sprintf_s(local_path, "%s\\%s-%d-%d-%d-%d-%d-%d.dat", temp_dir,item_id,
			1900+p->tm_year,p->tm_mon+1 ,p->tm_mday+1 ,p->tm_hour,p->tm_min ,p->tm_sec);
	}

	if((filePtr = fopen(local_path, "wt")) == NULL)
	{
		printf("Can not create the temp dat file!\n");
		return -1;
	}
	*file_name = (char *)MEM_alloc(sizeof(char)*512);
	strcpy((*file_name), local_path);

	fwrite(file_content, sizeof(char), strlen(file_content), filePtr);
	fclose(filePtr);

	return ITK_ok;
}


int summary_free_msexcel(tag_t dataset, char *dat_file, char *ext)
{
	tag_t spec_dataset_rev = NULLTAG,
		ref_object = NULLTAG;

	AE_reference_type_t reference_type;

	AE_ask_dataset_latest_rev(dataset, &spec_dataset_rev);

	char ref_name[WSO_name_size_c + 1] = "excel";
	AE_ask_dataset_named_ref(spec_dataset_rev, ref_name, &reference_type, &ref_object);
	if(reference_type == AE_PART_OF)
	{
		char pathname[SS_MAXPATHLEN] = "";
		IMF_ask_file_pathname(ref_object, SS_WNT_MACHINE, pathname);
		char origin_file_name[IMF_filename_size_c + 1] = "";
		IMF_ask_original_file_name(ref_object, origin_file_name);

		char new_ds_name[WSO_name_size_c + 1] = "";
		char *new_file_name = USER_new_file_name(new_ds_name, ref_name, ext, 0);
		char *temp_dir = getenv("temp");
		char temp_file[SS_MAXPATHLEN] = "";
		strcpy(temp_file, temp_dir);
		strcat(temp_file, "\\");
		strcat(temp_file, new_file_name);

		IMF_export_file(ref_object, temp_file);


		int   iCnt;
		char *user_lib_env,pTempStr[500];
		char local_path[MAX_PATH] = "";
		/*char cmd[256] = "";

		strcpy( cmd, "SubstMacros-MSExcel.wsf" );
		strcat( cmd, " \"" ); 
		strcat( cmd, temp_file ); 
		strcat( cmd, "\" \"" );
		strcat( cmd, dat_file ); 
		strcat( cmd, "\"" );
		printf( "\n%s\n",cmd );
		system( cmd );
		*/
		summary_fee(temp_file,dat_file);

		//strcpy(user_lib_env, local_path);


		tag_t new_file_tag = NULLTAG;
		IMF_file_t file_descriptor;	
		IMF_import_file(temp_file, new_file_name, SS_BINARY, &new_file_tag, &file_descriptor);
		IMF_set_original_file_name(new_file_tag, origin_file_name);
		IMF_close_file(file_descriptor);
		AOM_save(new_file_tag);
		AOM_unlock(new_file_tag);

		AOM_lock(spec_dataset_rev);
		//CALL(AOM_load (dataset));
		//CALL(AOM_load(spec_dataset_rev));
		AE_remove_dataset_named_ref_by_tag(spec_dataset_rev, ref_name, ref_object);
		AE_add_dataset_named_ref(spec_dataset_rev, ref_name, AE_PART_OF, new_file_tag);
		AOM_save(spec_dataset_rev);
		AOM_unlock(spec_dataset_rev);
	}
	return ITK_ok;
}


/**
*  汇总物料信息
*
*
*
*/
int JK_matereial_summary_fee(EPM_action_message_t msg){
	int ifail =0,
		att_cnt = 0,
		excelCnt = 0;
	tag_t task_tag = NULLTAG,
		root_task_tag = NULLTAG,
		* attachments =NULL,
		* excelTags =NULL;
	char *dataset_type = NULL;
	task_tag = msg.task;
	POM_AM__set_application_bypass(true);
	ITKCALL(ifail = EPM_ask_root_task(task_tag, &root_task_tag));
	//获取目标引用对象
	ITKCALL(ifail = EPM_ask_attachments(root_task_tag, EPM_target_attachment, &att_cnt, &attachments));

	for(int i = 0;i < att_cnt;i++){
		tag_t taskTag = attachments[i];
		if(checkIsTypeOrSubtype(taskTag,"JK8BOMCostEstmRevision")){
			ITKCALL(ifail = AOM_ask_value_tags(taskTag,"IMAN_specification",&excelCnt,&excelTags)); 

			for(int j = 0 ;j < excelCnt;j++){
				AOM_ask_value_string(excelTags[j],"object_type",&dataset_type);
				char *data_file = NULL;
				create_summary_fee_file("","费用汇总日志", &data_file);
				if( data_file == NULL )
				{
					continue;
				}
				ECHO("\n 创建文本文件%s",data_file);


				if(strcmp(dataset_type, "MSExcel") ==0 )
				{
					summary_free_msexcel(excelTags[j],data_file,"xls");
				}
				else if(strcmp(dataset_type, "MSExcelX") ==0)
				{
					summary_free_msexcel(excelTags[j],data_file,"xlsx");
				}

				if(dataset_type!=NULL){
					MEM_free(dataset_type);
					dataset_type = NULL;
				}
			}

			if(excelTags!=NULL)
			{
				MEM_free(excelTags);
				excelTags =NULL;
			}
		}

	}
	if(attachments!= NULL){
		MEM_free(attachments);
		attachments = NULL;
	}

	POM_AM__set_application_bypass(false);
	return 0;
}



/*******************************************************
*
* 获取子TOP Bomline属性的属性
*
********************************************************/
void JK_get_bomline_props(tag_t top_line_tag,char errs[10240],char cherrs[10240])
{
	int ifail = 0 ,
		i = 0,
		status_count = 0 ,
		c_line_count = 0 ,
		rev_form_cnt = 0 ,
		isra_cou=0,
		isra_cou_form=0;
	tag_t rev_tag =NULLTAG,
		item_tag = NULLTAG,
		bom_window_tag = NULLTAG,
		*c_line_tags = NULL,
		*rev_form_tags = NULL,
		*isra_tags = NULL,
		*isra_tags_form = NULL;

	char item_id[ITEM_id_size_c + 1] = "\0",
		rev_id[ITEM_id_size_c + 1]  = "\0",
		*user_name = NULL,
		*jk8_mjshl = NULL,
		create_date_str[32] = "\0",
		person_name[SA_person_name_size_c + 1]  = "\0";

	//因为生产代码权限控制的缘故，需要在此处开旁路
	POM_AM__set_application_bypass(true);

	printf("1111");
	ITKCALL(AOM_ask_value_tag(top_line_tag,"bl_line_object",&rev_tag));//获取BOMLINE关联的版本
	ITKCALL(ITEM_ask_item_of_rev(rev_tag,&item_tag));
	ITKCALL(ITEM_ask_id(item_tag,item_id));//物料编码

	printf("判断是否发布%s\n",item_id);
	ITKCALL(AOM_ask_value_tags(rev_tag,"release_status_list",&isra_cou,&isra_tags));//判断是否发布
	if(isra_cou==0){
		printf("%s未发布\n",item_id);
		strcat(errs,"[");
		strcat(errs,item_id);
		strcat(errs,"]");
	}else{
		//20200427如果是整机才检查，组件就不检查
		//20200429如果是开发状态，就不做检查

		ITKCALL(ITEM_ask_rev_id(rev_tag,rev_id));//获取版本号
		//20200318
		char* object_type_release=NULL;
		logical develop=false;
		for (int f=0;f<isra_cou;f++){
			AOM_ask_value_string(isra_tags[f],"object_name",&object_type_release);
			if(strcmp(object_type_release,"JK8Develop")==0 || strcmp(object_type_release,"jk8Develop")==0){
				
				develop=true;
				break;				
			}
		}
		if(develop==false)
		{
			for (int f=0;f<isra_cou;f++){
				AOM_ask_value_string(isra_tags[f],"object_name",&object_type_release);
				if(strcmp(object_type_release,"jk8Checking")==0 || strcmp(object_type_release,"JK8Checking")==0){

					printf("%s发布状态\n",item_id);
					strcat(cherrs,"[");
					strcat(cherrs,item_id);
					strcat(cherrs,"]");
					break;				
				}
			}
		}

		
		if(object_type_release!=NULL)
		{
			MEM_free(object_type_release);
			object_type_release=NULL;
		}
		//ITKCALL(AOM_ask_value_tags(rev_tag,"IMAN_master_form_rev",&rev_form_cnt,&rev_form_tags)); //不判断表单
		//if(rev_form_cnt>0){
		//	ITKCALL(AOM_ask_value_tags(rev_form_tags[0],"release_status_list",&isra_cou_form,&isra_tags_form));//判断表单是否发布
		//	if(isra_cou_form==0){
		//		printf("%s表单未发布\n",item_id);
		//		strcat(errs,"[");
		//		strcat(errs,item_id);
		//		strcat(errs,"]表单");
		//	}
		//	if(isra_tags_form!=NULL){
		//		MEM_free(isra_tags_form);
		//		isra_tags_form =NULL;
		//	}
		//}
		//if(rev_form_tags!=NULL){
		//	MEM_free(rev_form_tags);
		//	rev_form_tags =NULL;
		//}
	}
	ITKCALL(BOM_line_ask_all_child_lines(top_line_tag,&c_line_count,&c_line_tags));
	if(c_line_count == 0){
		printf("没有BOM结构");
		POM_AM__set_application_bypass(false);
		return;
	}
	
	for (int i = 0; i < c_line_count; i++)
	{
		cout<<"2----"<<endl;
		JK_get_bomline_props( c_line_tags[i],errs,cherrs);
	}
	POM_AM__set_application_bypass(false);
	if(c_line_tags!=NULL){
		MEM_free(c_line_tags);
		c_line_tags =NULL;
	}


}



int JK_Bom_is_release(EPM_rule_message_t msg){

	printf("===================================\n");
	printf("根据BOM子件是否发布,限制流程发起 开始\n");
	printf("===================================\n");

	//参数定义
	int ifail = EPM_go , 
		arg_cnt = 0 , 
		i = 0 ,
		att_cnt = 0,
		c_line_count=0;

	tag_t task_tag  = NULLTAG , 
		root_task_tag =NULLTAG , 
		*attachments = NULL,
		bom_window_tag = NULLTAG,
		top_line_tag=NULLTAG,
		*c_line_tags=NULL,
		rev_tag=NULL,
		item_tag=NULL;

	char * argflag = NULL ,
		*argvalue =NULL ,

		*arg = NULL , 
		arg_value[1024] = "\0",
	material_type[1024] = "\0",
		type_class[WSO_object_type_size_c+1] ="\0",
		all_errs[10240]="\0",
		check_errs[10240]="\0",  // 20200318
		item_id[ITEM_id_size_c + 1] = "\0";

	logical is_debug = false;

	//记录错误信息
	map<string,int> errMap;

	vector<string> type_vec;


	//获取handler参数的个数
	arg_cnt = TC_number_of_arguments(msg.arguments);
	ECHO("参数个数为：%d\n",arg_cnt);
	if (arg_cnt > 0)
	{
		for (i=0;i<arg_cnt;i++)
		{
			
			//获取下一个参数（从0开始）
			arg = TC_next_argument(msg.arguments);
			//获取参数的名称和值
			ITK_ask_argument_named_value((const char*)arg, &argflag, &argvalue);
			//需要检查哪些对象的类型
			if (stricmp(argflag, "include_type") == 0)
			{
				if(argvalue != NULL)
				{
					strcpy(arg_value,argvalue);
					Split(arg_value,"/",type_vec);
				}else{

					string key_id;
					key_id.assign("缺少include_type参数");
					errMap.insert(pair<string,int>(key_id,HANDLER_ARGUMENT_ERROR));
				}
			}
			if (stricmp(argflag, "material_type") == 0)
			{
				if(argvalue != NULL)
				{
					strcpy(material_type,argvalue);
				}
			}
		}
		MEM_free(argflag);
		MEM_free(argvalue);
	}

	//获取目标对象
	task_tag = msg.task;
	if(task_tag == NULLTAG)
	{

		return EPM_nogo;
	}
	EPM_ask_root_task(task_tag, &root_task_tag);
	EPM_ask_attachments(root_task_tag, EPM_target_attachment, &att_cnt, &attachments);
	for(i = 0 ;i < att_cnt;i++){
		char errs[1024]="\0";
		char cherrs[1024]="\0";  //20200318
		tag_t target_tag = attachments[i];
		//获取对象的类型 PSBOMViewRevision
		ITKCALL( WSOM_ask_object_type(target_tag, type_class));
		ECHO("对象类型%s\n",type_class);
		string type_str ;
		type_str.assign(type_class);
		vector<string>::iterator it;
		it = find(type_vec.begin(),type_vec.end(),type_str);
		if(it == type_vec.end()){
			ECHO("此类型不包含在include_type中 跳过\n");
			continue;
		}
		POM_AM__set_application_bypass(true);
		ITKCALL(BOM_create_window(&bom_window_tag));//创建window视图
		ITKCALL(BOM_set_window_top_line_bvr(bom_window_tag,target_tag,&top_line_tag));//获取顶层bomline
		ITKCALL(BOM_line_ask_all_child_lines(top_line_tag,&c_line_count,&c_line_tags));
		ITKCALL(AOM_ask_value_tag(top_line_tag,"bl_line_object",&rev_tag));//获取BOMLINE关联的版本
		ITKCALL(ITEM_ask_item_of_rev(rev_tag,&item_tag));
		ITKCALL(ITEM_ask_id(item_tag,item_id));//物料编码
		if(c_line_count == 0){
			printf("没有BOM结构\n");
		}else{
			printf("有BOM结构 数量%d\n",c_line_count);
			for (int t = 0; t < c_line_count; t++)
			{
				printf("开始遍历对象%s\n",item_id);
				POM_AM__set_application_bypass(true);
				cout<<"1----"<<endl;
				JK_get_bomline_props(c_line_tags[t],errs,cherrs);   //20200318
				POM_AM__set_application_bypass(false);
			}

		}
		if(strcmp(errs,"\0")!=0){
			strcat(all_errs,"存在对象{");
			strcat(all_errs,item_id);
			strcat(all_errs,"}下关联子件");
			strcat(all_errs,errs);
			strcat(all_errs,"未发布!\n");
		}
		//20200318
		if(strcmp(cherrs,"\0")!=0){
			strcat(check_errs,"存在对象{");
			strcat(check_errs,item_id);
			strcat(check_errs,"}下关联子件");
			strcat(check_errs,cherrs);
			strcat(check_errs,"处于验证状态!\n");
		}
		if(c_line_tags!=NULL)
		{
			MEM_free(c_line_tags);
			c_line_tags =NULL;
		}
		ITKCALL(BOM_close_window(bom_window_tag));
	}


	if(strcmp(all_errs,"\0")!=0){
		ifail=EPM_nogo;
		printf("错误:%s\n",all_errs);
		EMH_store_error_s1(EMH_severity_information,278701,all_errs);//错误弹窗
	}
	//如果是整机，任何子阶有验证状态的物料 则整机的流程编制无法完成
	if(strcmp(material_type,"1")==0)
	{
		if(strcmp(check_errs,"\0")!=0){
			ifail=EPM_nogo;
			printf("错误:%s\n",check_errs);
			EMH_store_error_s1(EMH_severity_information,278701,check_errs);//错误弹窗
		}
	}
	

	if(attachments!=NULL)
	{
		MEM_free(attachments);
		attachments =NULL;
	}


	return ifail;


}