#include"kutil.h"
#include "ado.h"
#include "Error_Define.h"
#define debug true
#define ITK_err 919012

//导出数据集文件 
int export_dataset_file_to_dir(tag_t dataset, const char *ref_name, const char* temp_path, char *ext, char **filename, char **original_name)
{
	int ifail = ITK_ok;
	tag_t ref_object = NULLTAG,
		datasettype = NULLTAG,
		new_ds = NULLTAG,
		tool = NULLTAG,
		folder_tag = NULLTAG,
		spec_dataset_rev = NULLTAG;
	AE_reference_type_t reference_type;
	tag_t new_file_tag = NULLTAG;
	IMF_file_t file_descriptor;
	char *target_ds_name = NULL;
	char *new_file_name;
	WSOM_ask_name2(dataset, &target_ds_name);
	WriteLog(debug, "开始从数据集<%s>下载文件", target_ds_name);
	DOFREE(target_ds_name);
	*filename = (char *)MEM_alloc(sizeof(char) * 512);
	*original_name = (char *)MEM_alloc(sizeof(char) * 512);
	strcpy(*filename, "");
	AE_ask_dataset_latest_rev(dataset, &spec_dataset_rev);
	AE_ask_dataset_named_ref2(dataset, ref_name, &reference_type, &ref_object);
	if (ref_object == NULLTAG)
	{
		WriteLog(debug, "文件引用为空");
		return 1;
	}
	if (reference_type == AE_PART_OF)
	{
		char *pathname2 = NULL;
		IMF_ask_file_pathname2(ref_object, SS_WNT_MACHINE, &pathname2);
		DOFREE(pathname2);
		char *origin_file_name2 = NULL;
		IMF_ask_original_file_name2(ref_object, &origin_file_name2);
		strcpy(*original_name, origin_file_name2);
		DOFREE(origin_file_name2);
		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_file[SS_MAXPATHLEN] = "";
		strcpy(temp_file, temp_path);
		strcat(temp_file, "\\");
		strcat(temp_file, new_file_name);
		WriteLog(debug, "临时文件路径：%s", temp_file);
		if ((_access(temp_file, 0)) != -1) {
			if (!remove(temp_file)) {
				remove(temp_file);
			}
		}
		ITKCALL(ifail = IMF_export_file(ref_object, temp_file));
		strcpy(*filename, temp_file);
		return ifail;
	}
	return -1;
}
int uploadFile(void* returnValue) {
	int ifail = ITK_ok;
	char *datasetUid,*refName,*ext, *dataset_file_path, *dataset_file_name;
	ITKCALL(ifail = USERARG_get_string_argument(&datasetUid));
	ITKCALL(ifail = USERARG_get_string_argument(&refName));
	ITKCALL(ifail = USERARG_get_string_argument(&ext));
	tag_t dataset;
	ITK__convert_uid_to_tag(datasetUid, &dataset);
	export_dataset_file_to_dir(debug, dataset, refName, "D:\\Siemens\\IIS\\web\\file", ext, &dataset_file_path, &dataset_file_name);
	string buff = dataset_file_path;
	*((char**)returnValue) = (char*)MEM_alloc((strlen(buff.c_str()) + 1) * sizeof(char));
	tc_strcpy(*((char**)returnValue), buff.c_str());
	return ifail;
}

//提交流程检查指定审批节点是否都指派审批人员
int EPMC_check_process_member(EPM_action_message_t msg)
{
	int customError = ITK_ok,
		args_cnt = 0,
		piStringCount = 0,
		subtask_count = 0,
		icnt = 0,
		step = 0,
		signoff_count = 0,
		user_count = 0;

	char* trans_args_value = NULL,
		* para_flag = NULL,
		* para_value = NULL,
		** pppStringList = NULL,
		noassigned_task_name[128 * 5] = "",
		err_msg[650] = "流程节点‘",
		* task_name = NULL;

	tag_t pRoot = NULLTAG,
		* subtasks = NULL,
		signoff_task = NULLTAG,
		* signoffs = NULL,
		* users = NULL,
		groupmember = NULLTAG,
		user_tag = NULLTAG;

	printf("*******************************************************************************\n");
	printf("*              EPMC_check_process_member is comming ！                        *\n");
	printf("*******************************************************************************\n");

	args_cnt = TC_number_of_arguments(msg.arguments);
	TC_init_argument_list(msg.arguments);

	if (args_cnt)
	{
		trans_args_value = TC_next_argument(msg.arguments);
		ITKCALL(ITK_ask_argument_named_value(trans_args_value, &para_flag, &para_value));

		ITKCALL(EPM__parse_string(para_value, ",", &piStringCount, &pppStringList));

		if (para_flag)
		{
			MEM_free(para_flag);
			para_flag = NULL;
		}

		if (para_value)
		{
			MEM_free(para_value);
			para_value = NULL;
		}
	}

	ITKCALL(EPM_ask_root_task(msg.task, &pRoot));
	if (pRoot)
	{
		ITKCALL(EPM_ask_sub_tasks(pRoot, &subtask_count, &subtasks));

		for (step = 0; step < subtask_count; step++)
		{
			ITKCALL(EPM_ask_name2(subtasks[step], &task_name));
			printf("task_name = %s\n", task_name);
			for (icnt = 0; icnt < piStringCount; icnt++)
			{
				if (tc_strcmp(task_name, pppStringList[icnt]) == 0)
				{
					//ITKCALL( EPM_ask_sub_task(subtasks[step], "perform-signoffs", &signoff_task) );
					ITKCALL(EPM_ask_sub_task(subtasks[step], "select-signoff-team", &signoff_task));
					if (signoff_task)
					{
						ITKCALL(EPM_ask_task_reviewers_users(signoff_task, &user_count, &users));
						printf("user_count = %d\n", user_count);
						if (!user_count)
						{
							tc_strcat(noassigned_task_name, task_name);
							tc_strcat(noassigned_task_name, ",");
						}
						if (users)
						{
							MEM_free(users);
							users = NULL;
						}

						if (signoffs)
						{
							MEM_free(signoffs);
							signoffs = NULL;
						}
					}
				}
			}
		}

		if (subtasks)
		{
			MEM_free(subtasks);
			subtasks = NULL;
		}
	}

	if (pppStringList)
	{
		MEM_free(pppStringList);
		pppStringList = NULL;
	}

	if (tc_strcmp(noassigned_task_name, ""))
	{
		tc_strcat(err_msg, noassigned_task_name);
		tc_strcat(err_msg, "’未指派，请指派！");
		//EMH_store_error_s1(EMH_severity_user_error, ERROR_LOCK_ARGUMENTS, noassigned_task_name);
		EMH_store_error_s1(EMH_severity_user_error, ERROR_LOCK_ARGUMENTS, err_msg);

		customError = ERROR_LOCK_ARGUMENTS;

		memset(noassigned_task_name, '\0', sizeof(noassigned_task_name));
	}

	printf("*******************************************************************************\n");
	printf("*              EPMC_check_process_member is end ！                            *\n");
	printf("*******************************************************************************\n");

	return customError;
}


int LD_AutoAssign(EPM_action_message_t msg) {
	int ifail = ITK_ok, arg_cnt = 0, att_cnt = 0, task_count = 0;
	char* arg = NULL, * argflag = NULL, * argvalue = NULL;
	tag_t* attachments = NULLTAG, task_tag = NULLTAG, rootTask_tag = NULLTAG, * task_tags = NULLTAG;
	vector<string> values;
	set<string> sh_set;
	getPrefStrings("Connor_PRType_Person_Mapping", TC_preference_site,values);
	//拿到当前节点
	task_tag = msg.task;
	if (task_tag == NULLTAG) {
		goto end;
	}
	ITKCALL(ifail = EPM_ask_root_task(task_tag, &rootTask_tag));
	//获取目标下所有对象
	ITKCALL(ifail = EPM_ask_attachments(rootTask_tag, EPM_target_attachment, &att_cnt, &attachments));
	if (att_cnt == 0) {
		goto end;
	}

	for (int i = 0; i < att_cnt; i++)
	{
		char* object_type = NULL;
		AOM_ask_value_string(attachments[i],"object_type",&object_type);
		if (strcmp("LD6_PRRevision",object_type) == 0) {
			char* problem_type = NULL;
			char* company_value = NULL;
			AOM_ask_value_string(attachments[i], "ld6_company", &company_value);
			AOM_ask_value_string(attachments[i], "ld6_problemType", &problem_type);
			/*for each (string problem in values)
			{
				vector<string> split;
				Split(problem.c_str(), "=", split);
				if (split.size() == 2 && strcmp(split[0].c_str(),problem_type) == 0) {
					if (sh_set.insert(split[1]).second == false) {
						continue;
					}
				}
			}*/
			for each (string company in values)
			{
				vector<string> split; 
				vector<string> split2;
				Split(company.c_str(), ":", split);
				if (split[0].empty()) {
					EMH_store_error_s2(EMH_severity_error, ITK_err, "首选项配置错误", company.c_str());
					goto end;
				}
				//公司属性相同
				if (split.size() == 2 && strcmp(split[0].c_str(), company_value) == 0) {
					Split(split[1].c_str(), "=", split2);
					if (split2.size() == 2) {
						//问题类型为空
						if (split2[0].empty()) {
							if (sh_set.insert(split2[1]).second == false) {
								continue;
							}
						}
						//问题类型不为空，且相同
						else if (strcmp(split2[0].c_str(), problem_type) == 0) {
							if (sh_set.insert(split2[1]).second == false) {
								continue;
							}
						}
					}
					
				}
			}
		}
	}

	char* task_type = NULL;
	WSOM_ask_object_type2(task_tag, &task_type);
	printf("当前节点的类型为:%s\n", task_type);
	if (strcmp("EPMReviewTask", task_type) == 0 || strcmp("EPMAcknowledgeTask", task_type) == 0) {
		char* object_name = NULL;
		int mem_cnt = 0, signoff_cnt = 0;
		tag_t user_tag = NULLTAG, login_group = NULLTAG, * members = NULLTAG, * signoffs = NULLTAG, select_signoff_tag = NULLTAG;
		AOM_ask_value_string(task_tag, "object_name", &object_name);//对象名称
		EPM_ask_sub_task(task_tag, "select-signoff-team", &select_signoff_tag);
		printf("当前节点的名称为:%s\n", object_name);
		
		int attachments_num = 0,* attach_type; tag_t* attachmentTags;
		EPM_ask_all_attachments(select_signoff_tag, &attachments_num, &attachmentTags, &attach_type);
		if (attachments_num > 0) {
			goto end;
		}

		for (set<string>::iterator it = sh_set.begin(); it != sh_set.end(); it++) {
			printf("添加：%s\n", it->c_str());
			ITKCALL(SA_find_user2(it->c_str(), &user_tag));
			ITKCALL(SA_ask_user_login_group(user_tag, &login_group));
			ITKCALL(SA_find_groupmembers(user_tag, login_group, &mem_cnt, &members));
			ITKCALL(EPM_create_adhoc_signoff(select_signoff_tag, members[0], &signoff_cnt, &signoffs));
		}
		if (sh_set.size() > 0) {
			ITKCALL(EPM_set_adhoc_signoff_selection_done(select_signoff_tag, true));
		}
		DOFREE(object_name);
		DOFREE(members);
		DOFREE(signoffs);
	}
	if (strcmp("EPMDoTask", task_type) == 0 || strcmp("EPMConditionTask", task_type) == 0) {
		tag_t user_tag = NULLTAG;
		for (set<string>::iterator it = sh_set.begin(); it != sh_set.end(); it++) {
			ITKCALL(SA_find_user2(it->c_str(), &user_tag));
			ITKCALL(EPM_assign_responsible_party(task_tag, user_tag));//设置编制节点的责任方
		}
	}
end:
	DOFREE(attachments);
	return ifail;
}
int ML_ItemRevSave(METHOD_message_t* msg, va_list args)
{
	printf("=========================创建后操作 Start===================\n");
	int ifail = ITK_ok;
	tag_t new_rev = va_arg(args, tag_t);

	if (isTypeOf(new_rev, "Part Revision")) {
		printf("类型为Part Revision 检查物料描述\n");
		char* ld6_materialDesc, * item_id;
		AOM_ask_value_string(new_rev, "ld6_materialDesc", &ld6_materialDesc);
		AOM_ask_value_string(new_rev, "item_id", &item_id);
		tag_t query;
		int n_found;
		ITKCALL(ifail = QRY_find2("6LD_Om_PartRevision", &query));
		tag_t* tags;
		boolean saveFlag = true;
		char* qry_entries[2] = { "materialDesc" ,"id01" },
			* qry_values[2] = { ld6_materialDesc ,item_id }, * errorId = "";
		ITKCALL(ifail = QRY_execute(query, 2, qry_entries, qry_values, &n_found, &tags));
		if (n_found == 0) {
			saveFlag = true;
		}
		else {

			for (int i = 0; i < n_found; i++) {
				char* itemId;
				AOM_ask_value_string(tags[i], "item_id", &itemId);
				printf("查询到的itemId==> %s\n", itemId);
			}
			ifail = 1;
			saveFlag = false;
			EMH_store_error_s2(EMH_severity_error,
				ITK_err,
				"提示",
				"已存在相同物料描述的对象，无需重复创建!");
		}

	}

	va_end(args);
	return ifail;
}
//
//
//int LD6_CusProdFolderSave(METHOD_message_t* msg, va_list args)
//{
//
//	char* log_file = NULL;
//
//	printf("创建日志文件\n");
//	char* TO_SRM = (char*)malloc(sizeof("LD6_CusProdFolderSave"));
//	strcpy(TO_SRM, "emp_register_handler");
//	CreateLogFile(TO_SRM,"", &log_file);
//
//	WriteLog(true, "=========================文件夹后操作 Start===================\n");
//	int ifail = ITK_ok;
//	tag_t folder = va_arg(args, tag_t);
//
//	if (isTypeOf(folder, "LD6_CusProdFolder")) {
//		//连接数据库保存当前名称到数据库
//		char* folder_uid;
//		ITK__convert_tag_to_uid(folder,&folder_uid);//获取文件夹uid
//		bool conn = open("infodba", "infodba", "TC13", "10.10.22.39");
//		if (conn != NULL && conn) {
//			WriteLog(true, "=========================连接成功===================\n");
//		}
//		else {
//			WriteLog(true, "=========================连接失败==================\n");
//		}
//
//
//	}
//
//	va_end(args);
//	WriteLog(true, "=========================文件夹后操作 End===================\n");
//	CloseLog();
//	return ifail;
//}