#include "SendSap.h"
#include <mfg/mfg.h>
#include "CRUL_server_call_httpserver.h"


vector<string> lists2;

// 自定义的写入回调函数
size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp) {
	((std::ostream*)userp)->write((const char*)contents, size * nmemb);
	return size * nmemb;
}
string sendSap(const char* url, const char* data) {
	log("sendSap Url==>%s", url);
	CURL *curl;
	CURLcode res;
	curl = curl_easy_init();
	string result = "";
	if (curl) {
		curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
		curl_easy_setopt(curl, CURLOPT_URL, url);
		curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
		curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
		struct curl_slist *headers = NULL;
		headers = curl_slist_append(headers, "Content-Type: application/xml");
		if (tc_strstr(url, "192.168.0.184") != NULL || tc_strstr(url, "gfpot01") != NULL) {
			headers = curl_slist_append(headers, "Authorization: Basic cG9fcmZjOjFxYXohUUFa");//"po_rfc", "1qaz!QAZ"
		}
		else {
			headers = curl_slist_append(headers, "Authorization: Basic c2hwbG06c2FwQDIwMTk=");//"shplm", "sap@2019"
		}
		curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
		curl_easy_setopt(curl, CURLOPT_POSTFIELDS, G2U(data));

		ostringstream oss;
		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &oss);

		res = curl_easy_perform(curl);
		char ress[4];
		sprintf(ress, "%d", res);
		result.append(ress).append("@@").append(oss.str());
	}
	curl_easy_cleanup(curl);
	curl = NULL;
	string logmsg = "SAP result==>";
	log2(logmsg.append(result));

	return result;
}
//sendJsonHttpPost
string sendMom(const char* url, const char* data) {
	log("sendMom Url==>%s", url);
	if (tc_strstr(url, "http") == NULL) {
		return "";
	}
	CURL *curl;
	CURLcode res;
	curl = curl_easy_init();
	string result = "";
	if (curl) {
		curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
		curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
		curl_easy_setopt(curl, CURLOPT_URL, url);
		curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
		curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
		struct curl_slist *headers = NULL;
		headers = curl_slist_append(headers, "Content-Type: application/xml");
		if (tc_strstr(url, "10.128.11.12") != NULL) {//
			headers = curl_slist_append(headers, "Authorization: Basic MTQyODI0Mjg2NDU2ODMwNzcxNDpkREF3TWpveE1EQXg=");//"po_rfc", "1qaz!QAZ"
		}
		else {
			headers = curl_slist_append(headers, "Authorization: Basic MTcxNDkwNTkyNTc2MjUzNTQyNjpkREF3TWpveE1EQXg=");//"shplm", "sap@2019"
		}
		curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
		curl_easy_setopt(curl, CURLOPT_POSTFIELDS, G2U(data));

		ostringstream oss;
		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &oss);

		res = curl_easy_perform(curl);
		char ress[4];
		sprintf(ress, "%d", res);
		result.append(ress).append("@@").append(U2G(oss.str().c_str()));
	}
	curl_easy_cleanup(curl);
	curl = NULL;
	string logmsg = "MOM result==>";
	log2(logmsg.append(result));

	return result;
}

string SendToSap(const char* data) {
	int pref_cnt = 0;
	char **prefs = NULL;
	ITKCALL(PREF_ask_char_values("CHINT_WhBomUrl_YB", &pref_cnt, &prefs));
	string sapUrl = "", momUrl = "";
	for (int i = 0; i < pref_cnt; i++) {
		string pref = prefs[i];
		string prefix = pref.substr(0, 6);
		if (tc_strcmp(prefix.c_str(), "SAP:1=") == 0) {
			sapUrl.append(pref.substr(6, pref.size() - 6));
		}
		else if (tc_strcmp(prefix.c_str(), "MOM:1=") == 0) {
			momUrl.append(pref.substr(6, pref.size() - 6));
		}
	}
	string errBuff = "";
	vector<string> sapVec;
	Split(sendSap(sapUrl.c_str(), data), "@@", sapVec);
	if (tc_strcmp(sapVec[0].c_str(), "0") != 0) {
		errBuff.append("推送SAP异常:").append(sapVec[1]).append("\\n");
	}

	vector<string> momVec;
	Split(sendMom(momUrl.c_str(), data), "@@", momVec);
	if (tc_strcmp(momVec[0].c_str(), "0") != 0) {
		errBuff.append("推送MOM异常:").append(momVec[1]).append("\\n");
	}
	return errBuff;
}

TiXmlElement* addElement(TiXmlElement *PARENT, const char* name, const char* val) {
	TiXmlElement *CHILD = new TiXmlElement(name);
	PARENT->LinkEndChild(CHILD);
	if (tc_strlen(val) > 0) {
		TiXmlText *materialText = new TiXmlText(val);
		CHILD->LinkEndChild(materialText);
	}

	return CHILD;
}

void print(FlowBean bean) {
	char *split = NULL, *combine = NULL;
	ITKCALL(AOM_ask_value_string(bean.flow_split, "object_string", &split));
	ITKCALL(AOM_ask_value_string(bean.flow_combine, "object_string", &combine));
	log(">> 分离点：<%s> 汇合点：<%s> ", split, combine);
	for (int i = 0; i < bean.flowList.size(); i++) {
		char *os = NULL;
		ITKCALL(AOM_ask_value_string(bean.flowList[i], "object_string", &os));
		log("流程： ->%s", os);
	}
}

void readGXFlow(tag_t gxLine, vector<FlowBean>& flowBeans, FlowBean& currentFlow) {
	int sucCnt = 0, preCnt = 0;
	tag_t *sucs = NULL, *pres = NULL;
	char *os = NULL;
	ITKCALL(AOM_ask_value_string(gxLine, "object_string", &os));
	ITKCALL(AOM_ask_value_tags(gxLine, "Mfg0successors", &sucCnt, &sucs));
	ITKCALL(AOM_ask_value_tags(gxLine, "Mfg0predecessors", &preCnt, &pres));
	log("readGXFlow：%s=%d=%d", os, preCnt, sucCnt);
	currentFlow.flowList.push_back(gxLine);
	if (preCnt > 1) {
		currentFlow.flow_combine_list.push_back(gxLine);
		if (currentFlow.flow_combine == NULLTAG) {
			currentFlow.flow_combine = gxLine;
		}
	}
	if (sucCnt == 0) {
		return;
	}
	for (int i = 1; i < sucCnt; i++) {
		FlowBean newFlow = getClone(currentFlow);
		newFlow.flow_split = gxLine;
		newFlow.isMain = false;
		readGXFlow(sucs[i], flowBeans, newFlow);
		log("newFlow：");
		print(newFlow);
		flowBeans.push_back(newFlow);
	}
	readGXFlow(sucs[0], flowBeans, currentFlow);
}

//SAPUtil.getFlowStarts
vector<tag_t> getFlowStarts(int c_line_count, tag_t *c_line_tags) {
	vector<tag_t> startLines;
	for (int i = 0; i < c_line_count; i++) {
		int sucCnt = 0, preCnt = 0;
		//tag_t *sucs = NULL, *pres = NULL;
		char *os = NULL, *sucs = NULL, *pres = NULL, *prop1 = NULL, *prop2 = NULL;
		ITKCALL(AOM_ask_value_string(c_line_tags[i], "object_string", &os));
		//ITKCALL(AOM_ask_value_tags(c_line_tags[i], "Mfg0successors", &sucCnt, &sucs));
		//ITKCALL(AOM_ask_value_tags(c_line_tags[i], "Mfg0predecessors", &preCnt, &pres));
		ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "Mfg0successors", &sucs));
		ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "Mfg0predecessors", &pres));
		//ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "Mfg0container", &prop1));
		//ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "bl_rev_ps_children", &prop2));
		log("getFlowStarts：%s=%s=%s", os, pres, sucs);
		//if (preCnt == 0 && sucCnt > 0) {
		if ((!pres || tc_strlen(pres) == 0) && (sucs && tc_strlen(sucs) > 0)) {
			startLines.push_back(c_line_tags[i]);
		}
	}
	return startLines;
}
// 读取质量检验项
void getZljyxInfo2(TiXmlElement* OPCHECKCONTENTS, tag_t gxRev) {
	int count = 0;
	tag_t *checks = NULL;
	ITKCALL(AOM_ask_value_tags(gxRev, "ZT2_QualityCheckRelation", &count, &checks));
	if (count > 0) {
		char *item_id = NULL, *item_revision_id = NULL, *object_name = NULL;
		ITKCALL(AOM_ask_value_string(gxRev, "item_id", &item_id));
		ITKCALL(AOM_UIF_ask_value(gxRev, "item_revision_id", &item_revision_id));
		ITKCALL(AOM_UIF_ask_value(gxRev, "object_name", &object_name));
		string kjjdId = "";
		kjjdId.append(item_id).append("/").append(item_revision_id);
		addElement(OPCHECKCONTENTS, "PARENTTCID", kjjdId.c_str());
		addElement(OPCHECKCONTENTS, "PARENTNAME", object_name);
		addElement(OPCHECKCONTENTS, "OTHER1", "OTHER1");
		addElement(OPCHECKCONTENTS, "OTHER2", "OTHER2");

		TiXmlElement *OPCHECKSONLIST = addElement(OPCHECKCONTENTS, "OPCHECKSONLIST", "");
		tag_t quantityRev = NULLTAG;
		ITKCALL(ITEM_ask_latest_rev(checks[0], &quantityRev));
		count = 0;
		tag_t *zt2_QChecks = NULL;
		ITKCALL(AOM_ask_value_tags(quantityRev, "zt2_QCHECKS", &count, &zt2_QChecks));
		vector<char*> props;
		props.push_back("zt2_code");
		props.push_back("zt2_jjxbh");
		props.push_back("zt2_jyxmc");
		props.push_back("zt2_jyxsjjg");
		props.push_back("zt2_bzgcsxbh");
		props.push_back("zt2_bzgcsx");
		props.push_back("zt2_bzgcxxbh");
		props.push_back("zt2_bzgczxx");
		vector<string> beans;
		map<string, vector<string>> map;
		for (int d = 0; d < count; d++) {
			vector<string> values;
			for (int i = 0; i < props.size(); i++) {
				char *val = NULL;
				ITKCALL(AOM_UIF_ask_value(zt2_QChecks[d], props[i], &val));
				values.push_back(val);
			}
			beans.push_back(values[0]);
			map[values[0]] = values;
		}
		sort(beans.begin(), beans.end());

		for (int d = 0; d < beans.size(); d++) {
			TiXmlElement *OPCHECKSONCONTENTS = addElement(OPCHECKSONLIST, "OPCHECKSONCONTENTS", "");
			addElement(OPCHECKSONCONTENTS, "SEQID", map[beans[d]][0].c_str());
			addElement(OPCHECKSONCONTENTS, "TCID", map[beans[d]][1].c_str());
			addElement(OPCHECKSONCONTENTS, "OPCHECKNR1", map[beans[d]][2].c_str());
			addElement(OPCHECKSONCONTENTS, "OPCHECKVALUE1", map[beans[d]][3].c_str());
			addElement(OPCHECKSONCONTENTS, "OPCHECKNR2", map[beans[d]][4].c_str());
			addElement(OPCHECKSONCONTENTS, "OPCHECKVALUE2", map[beans[d]][5].c_str());
			addElement(OPCHECKSONCONTENTS, "OPCHECKNR3", map[beans[d]][6].c_str());
			addElement(OPCHECKSONCONTENTS, "OPCHECKVALUE3", map[beans[d]][7].c_str());
			addElement(OPCHECKSONCONTENTS, "REMARK", "");
		}
	}
}
// 读取二级工序 并行工序无后续
void getGXInfo2Comb(FlowBean bean, int index, tag_t partRev, char* p_uom, char* now,
	TiXmlElement* OPLIST, TiXmlElement* SONLIST, int valueOf, tag_t gxLine) {

	char plnfl[16];
	sprintf(plnfl, "%06d", index);
	string bezfl = "";
	string flagt = "";
	string vornr1 = "";
	string vornr2 = "";
	if (!bean.isMain) {// 并行
		bezfl = (bean.BEZFL);
		flagt = "1";// 顺序类别
		if (bean.flow_split != NULLTAG)
			vornr1 = getGXNR(bean.flow_split);// 前驱
		if (bean.isOther)
			bean.flow_split = NULLTAG;
		if (bean.flow_combine != NULLTAG)
			vornr2 = getGXNR(bean.flow_combine);// 后置
	}
	else {// 非并行
		flagt = "0";// 顺序类别
	}
	TiXmlElement *OPHEAD = addElement(OPLIST, "OPHEAD", "");
	addElement(OPHEAD, "PLNAL", "1");
	addElement(OPHEAD, "PLNFL", plnfl);
	addElement(OPHEAD, "DATUV", now);
	addElement(OPHEAD, "FLGAT", flagt.c_str());
	addElement(OPHEAD, "LTXA1", "");
	addElement(OPHEAD, "BEZFL", bezfl.c_str());
	addElement(OPHEAD, "VORNR1", vornr1.c_str());
	addElement(OPHEAD, "VORNR2", vornr2.c_str());

	tag_t gxRev = NULLTAG;
	ITKCALL(AOM_ask_value_tag(gxLine, "bl_line_object", &gxRev));
	char *item_id = NULL, *item_revision_id = NULL, *zt2_WorkCenter = NULL, *object_name = NULL, *zt2_ClassificationCode = NULL;
	ITKCALL(AOM_ask_value_string(gxRev, "item_id", &item_id));
	ITKCALL(AOM_UIF_ask_value(gxRev, "item_revision_id", &item_revision_id));
	ITKCALL(AOM_ask_value_string(gxRev, "zt2_WorkCenter", &zt2_WorkCenter));
	ITKCALL(AOM_UIF_ask_value(gxRev, "object_name", &object_name));
	ITKCALL(AOM_UIF_ask_value(gxRev, "zt2_ClassificationCode", &zt2_ClassificationCode));
	char *bl_ZT2_FirstOPRevision_zt2_ControlCode = NULL, *bl_ZT2_FirstOPRevision_zt2_ArtificialTime = NULL,
		*bl_ZT2_FirstOPRevision_zt2_MachineTime = NULL, *bl_ZT2_FirstOPRevision_zt2_ReadinessTime = NULL, *bl_ZT2_FirstOPRevision_zt2_ProCycle = NULL;
	ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ControlCode", &bl_ZT2_FirstOPRevision_zt2_ControlCode));
	ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ArtificialTime", &bl_ZT2_FirstOPRevision_zt2_ArtificialTime));
	ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_MachineTime", &bl_ZT2_FirstOPRevision_zt2_MachineTime));
	ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ReadinessTime", &bl_ZT2_FirstOPRevision_zt2_ReadinessTime));
	ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ProCycle", &bl_ZT2_FirstOPRevision_zt2_ProCycle));
	string kjjdId = "";
	kjjdId.append(item_id).append("/").append(item_revision_id);

	TiXmlElement *OPCONTENTS = addElement(OPHEAD, "OPCONTENTS", "");
	addElement(OPCONTENTS, "OPTCID", kjjdId.c_str());
	addElement(OPCONTENTS, "OPNAME", object_name);
	addElement(OPCONTENTS, "OPTYPE", "");
	addElement(OPCONTENTS, "VORNR", getGXNR(gxLine));
	addElement(OPCONTENTS, "ARBPL", zt2_WorkCenter);
	addElement(OPCONTENTS, "STEUS", bl_ZT2_FirstOPRevision_zt2_ControlCode);
	addElement(OPCONTENTS, "LTXA1", object_name);
	addElement(OPCONTENTS, "USR00", zt2_ClassificationCode);
	addElement(OPCONTENTS, "BMSCH", "1");
	addElement(OPCONTENTS, "PLNME", p_uom);
	addElement(OPCONTENTS, "VGW01", bl_ZT2_FirstOPRevision_zt2_ArtificialTime);
	addElement(OPCONTENTS, "VGE01", "MIN");
	addElement(OPCONTENTS, "VGW02", bl_ZT2_FirstOPRevision_zt2_MachineTime);
	addElement(OPCONTENTS, "VGE02", "MIN");
	addElement(OPCONTENTS, "VGW05", bl_ZT2_FirstOPRevision_zt2_ReadinessTime);
	addElement(OPCONTENTS, "VGE05", "MIN");
	addElement(OPCONTENTS, "PROCYCLE", bl_ZT2_FirstOPRevision_zt2_ProCycle);
	addElement(OPCONTENTS, "PROCYCLEUNIT", "MIN");
	addElement(OPCONTENTS, "OTHER1", "");
	addElement(OPCONTENTS, "OTHER2", "");

	TiXmlElement *OPMATERCONTENTS = addElement(OPCONTENTS, "OPMATERCONTENTS", "");
	tag_t *c_line_tags = NULL;
	int c_line_count = 0;
	ITKCALL(BOM_line_ask_all_child_lines(gxLine, &c_line_count, &c_line_tags));
	for (int i = 0; i < c_line_count; i++) {
		tag_t subRev = NULLTAG;
		ITKCALL(AOM_ask_value_tag(c_line_tags[i], "bl_line_object", &subRev));
		char *zt2_MaterialNo = NULL, *bl_quantity = NULL, *remark = NULL;
		ITKCALL(AOM_UIF_ask_value(subRev, "zt2_MaterialNo", &zt2_MaterialNo));
		ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "bl_quantity", &bl_quantity));
		ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "bl_occ_type", &remark));

		TiXmlElement *OPMATER = addElement(OPMATERCONTENTS, "OPMATER", "");
		addElement(OPMATER, "WLBM", zt2_MaterialNo);
		addElement(OPMATER, "QUE", bl_quantity);

		if (tc_strcmp(remark, "ZT2_FuLiao") == 0 || tc_strcmp(remark, "辅料") == 0) {
			addElement(OPMATER, "OPTPYE", "2");
			char *item_id2 = NULL, *item_revision_id2 = NULL, *zt2_unit = NULL, *ZT2_Remark = NULL;
			ITKCALL(AOM_UIF_ask_value(subRev, "item_id", &item_id2));
			ITKCALL(AOM_UIF_ask_value(subRev, "item_revision_id", &item_revision_id2));
			ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "ZT2_Remark", &ZT2_Remark));
			string tcId = "", errMsg = "";
			tcId.append(item_id2).append("/").append(item_revision_id2);
			tag_t item = NULLTAG;
			ITKCALL(ITEM_ask_item_of_rev(subRev, &item));
			ITKCALL(AOM_ask_value_string(item, "zt2_unit", &zt2_unit));
			char* uom = getUnti(zt2_unit);
			char *zysapmenge = NULL;
			zysapmenge = (char*)MEM_alloc((16 + 1) * sizeof(char));
			tc_strcpy(zysapmenge, getZYSAPMENGE(subRev, NULLTAG, c_line_tags[i], false, "1", errMsg));
			char valof[16];
			sprintf(valof, "%d", valueOf);

			TiXmlElement *SONCONTENTS = addElement(SONLIST, "SONCONTENTS", "");
			addElement(SONCONTENTS, "TCID", tcId.c_str());
			addElement(SONCONTENTS, "WLBM", zt2_MaterialNo);
			addElement(SONCONTENTS, "DATUV", now);
			addElement(SONCONTENTS, "QUE", zysapmenge);
			addElement(SONCONTENTS, "QUIT", uom);
			addElement(SONCONTENTS, "SORTF", "");
			addElement(SONCONTENTS, "SEQID", valof);
			addElement(SONCONTENTS, "POSTP", "L");
			addElement(SONCONTENTS, "REMARK", ZT2_Remark);
			addElement(SONCONTENTS, "OTHER1", "");
			addElement(SONCONTENTS, "OTHER2", "");
		}
		else {
			addElement(OPMATER, "OPTPYE", "1");
		}
	}
	TiXmlElement *OPFILELIST = addElement(OPCONTENTS, "OPFILELIST", "");
	int datasetCnt = 0;
	tag_t *datasets = NULL;
	ITKCALL(AOM_ask_value_tags(gxRev, "IMAN_specification", &datasetCnt, &datasets));
	for (int d = 0; d < datasetCnt; d++) {
		char *type = NULL;
		ITKCALL(WSOM_ask_object_type2(datasets[d], &type));
		if (find(lists2.begin(), lists2.end(), type) != lists2.end()) {
			char *fileName = NULL, *fileUid = NULL;
			ITKCALL(AOM_UIF_ask_value(datasets[d], "object_name", &fileName));
			ITK__convert_tag_to_uid(datasets[d], &fileUid);
			TiXmlElement *FILECONTENTS = addElement(OPFILELIST, "FILECONTENTS", "");
			addElement(FILECONTENTS, "FILEID", item_id);
			addElement(FILECONTENTS, "FILENAME", fileName);
			addElement(FILECONTENTS, "FILETYPE", "文件");
			addElement(FILECONTENTS, "FILECODE", item_id);
			addElement(FILECONTENTS, "FILEUID", fileUid);
			addElement(FILECONTENTS, "OTHER1", "OTHER1");
			addElement(FILECONTENTS, "OTHER2", "OTHER2");
		}
	}
	TiXmlElement *OPGYSZFILELIST = addElement(OPCONTENTS, "OPGYSZFILELIST", "");
	int ruleCnt = 0;
	tag_t *rules = NULL;
	ITKCALL(AOM_ask_value_tags(gxRev, "ZT2_ProcessRuleRelation", &ruleCnt, &rules));
	if (ruleCnt > 0) {
		tag_t processRuleRevision = NULLTAG;
		ITKCALL(ITEM_ask_latest_rev(rules[0], &processRuleRevision));
		int datasetCnt2 = 0;
		tag_t *datasets2 = NULL;
		ITKCALL(AOM_ask_value_tags(processRuleRevision, "IMAN_specification", &datasetCnt2, &datasets2));
		for (int d = 0; d < datasetCnt2; d++) {
			char *type = NULL;
			ITKCALL(WSOM_ask_object_type2(datasets2[d], &type));
			if (find(lists2.begin(), lists2.end(), type) != lists2.end()) {
				char *fileName = NULL, *fileUid = NULL;
				ITKCALL(AOM_UIF_ask_value(datasets2[d], "object_name", &fileName));
				ITK__convert_tag_to_uid(datasets2[d], &fileUid);
				char *item_id2 = NULL, *item_revision_id2 = NULL;
				ITKCALL(AOM_UIF_ask_value(processRuleRevision, "item_id", &item_id2));
				ITKCALL(AOM_UIF_ask_value(processRuleRevision, "item_revision_id", &item_revision_id2));
				string tcId = "";
				tcId.append(item_id2).append("/").append(item_revision_id2);

				TiXmlElement *FILECONTENTS = addElement(OPGYSZFILELIST, "FILECONTENTS", "");
				addElement(FILECONTENTS, "FILEID", tcId.c_str());
				addElement(FILECONTENTS, "FILENAME", fileName);
				if (tc_strstr(type, "PDF") != NULL) {
					addElement(FILECONTENTS, "FILETYPE", "pdf");
				}
				else if (tc_strstr(type, "Word") != NULL) {
					addElement(FILECONTENTS, "FILETYPE", "docx");
				}
				else {
					addElement(FILECONTENTS, "FILETYPE", "xlsx");
				}
				addElement(FILECONTENTS, "FILEUID", fileUid);
				addElement(FILECONTENTS, "FILECODE", item_id);
				addElement(FILECONTENTS, "OTHER1", "OTHER1");
				addElement(FILECONTENTS, "OTHER2", "OTHER2");
			}
		}
	}
	TiXmlElement *OPGXZYZDSFILELIST = addElement(OPCONTENTS, "OPGXZYZDSFILELIST", "");
	ruleCnt = 0;
	tag_t *books = NULL;
	ITKCALL(AOM_ask_value_tags(gxRev, "ZT2_ProcGuidBookRelation", &ruleCnt, &books));
	if (ruleCnt > 0) {
		tag_t procGuidBookRevision = NULLTAG;
		ITKCALL(ITEM_ask_latest_rev(books[0], &procGuidBookRevision));
		int datasetCnt2 = 0;
		tag_t *datasets2 = NULL;
		ITKCALL(AOM_ask_value_tags(procGuidBookRevision, "IMAN_specification", &datasetCnt2, &datasets2));
		for (int d = 0; d < datasetCnt2; d++) {
			char *type = NULL;
			ITKCALL(WSOM_ask_object_type2(datasets2[d], &type));
			if (find(lists2.begin(), lists2.end(), type) != lists2.end()) {
				char *fileName = NULL, *fileUid = NULL;
				ITKCALL(AOM_UIF_ask_value(datasets2[d], "object_name", &fileName));
				ITK__convert_tag_to_uid(datasets2[d], &fileUid);
				char *item_id2 = NULL, *item_revision_id2 = NULL;
				ITKCALL(AOM_UIF_ask_value(procGuidBookRevision, "item_id", &item_id2));
				ITKCALL(AOM_UIF_ask_value(procGuidBookRevision, "item_revision_id", &item_revision_id2));
				string tcId = "";
				tcId.append(item_id2).append("/").append(item_revision_id2);

				TiXmlElement *FILECONTENTS = addElement(OPGXZYZDSFILELIST, "FILECONTENTS", "");
				addElement(FILECONTENTS, "FILEID", tcId.c_str());
				addElement(FILECONTENTS, "FILENAME", fileName);
				if (tc_strstr(type, "PDF") != NULL) {
					addElement(FILECONTENTS, "FILETYPE", "pdf");
				}
				else if (tc_strstr(type, "Word") != NULL) {
					addElement(FILECONTENTS, "FILETYPE", "docx");
				}
				else {
					addElement(FILECONTENTS, "FILETYPE", "xlsx");
				}
				addElement(FILECONTENTS, "FILEUID", fileUid);
				addElement(FILECONTENTS, "OTHER1", "OTHER1");
				addElement(FILECONTENTS, "OTHER2", "OTHER2");
			}
		}
	}
	TiXmlElement *OPCHECKCONTENTS = addElement(OPCONTENTS, "OPCHECKCONTENTS", "");
	getZljyxInfo2(OPCHECKCONTENTS, gxRev);
}

// 读取二级工序
void getGXInfo2(FlowBean bean, int index, tag_t partRev, char* p_uom, char* now,
	TiXmlElement* OPLIST, TiXmlElement* SONLIST, int valueOf) {

	char plnfl[16];
	sprintf(plnfl, "%06d", index);
	string bezfl = "";
	string flagt = "";
	string vornr1 = "";
	string vornr2 = "";
	boolean bx = false;
	if (!bean.isMain) {// 并行
        bx = true;
		bezfl = (bean.BEZFL);
		flagt = "1";// 顺序类别
		if (bean.flow_split != NULLTAG)
			vornr1 = getGXNR(bean.flow_split);// 前驱
		if (bean.isOther)
			bean.flow_split = NULLTAG;
		if (bean.flow_combine != NULLTAG)
			vornr2 = getGXNR(bean.flow_combine);// 后置
	}
	else {// 非并行
		flagt = "0";// 顺序类别
	}
	TiXmlElement *OPHEAD = addElement(OPLIST, "OPHEAD", "");
	addElement(OPHEAD, "PLNAL", "1");
	addElement(OPHEAD, "PLNFL", plnfl);
	addElement(OPHEAD, "DATUV", now);
	addElement(OPHEAD, "FLGAT", flagt.c_str());
	addElement(OPHEAD, "LTXA1", "");
	addElement(OPHEAD, "BEZFL", bezfl.c_str());
	addElement(OPHEAD, "VORNR1", vornr1.c_str());
	addElement(OPHEAD, "VORNR2", vornr2.c_str());
	boolean inBx = (bean.flow_split == NULLTAG);
	char *flow_combine = NULL;
	ITK__convert_tag_to_uid(bean.flow_combine, &flow_combine);
	int cnt = bean.flowList.size();
	for (int i = 0; i < cnt; i++) {
		tag_t gxLine = bean.flowList[i];
		char *uid = NULL;
		ITK__convert_tag_to_uid(gxLine, &uid);
		if (bx) {
			if (tc_strcmp(uid, flow_combine) == 0) {
				break;
			}
			if (inBx) {
				if (gxLine == NULLTAG) {
					inBx = true;
					continue;
				}
			}
			else {
				char *flow_split = NULL;
				ITK__convert_tag_to_uid(bean.flow_split, &flow_split);
				if (tc_strcmp(uid, flow_split) == 0) {
					inBx = true;
				}
				continue;
			}
		}
		tag_t gxRev = NULLTAG;
		ITKCALL(AOM_ask_value_tag(gxLine, "bl_line_object", &gxRev));
		char *item_id = NULL, *item_revision_id = NULL, *zt2_WorkCenter = NULL, *object_name = NULL, *zt2_ClassificationCode = NULL;
		ITKCALL(AOM_ask_value_string(gxRev, "item_id", &item_id));
		ITKCALL(AOM_UIF_ask_value(gxRev, "item_revision_id", &item_revision_id));
		ITKCALL(AOM_ask_value_string(gxRev, "zt2_WorkCenter", &zt2_WorkCenter));
		ITKCALL(AOM_UIF_ask_value(gxRev, "object_name", &object_name));
		ITKCALL(AOM_UIF_ask_value(gxRev, "zt2_ClassificationCode", &zt2_ClassificationCode));
		char *bl_ZT2_FirstOPRevision_zt2_ControlCode = NULL, *bl_ZT2_FirstOPRevision_zt2_ArtificialTime = NULL,
			*bl_ZT2_FirstOPRevision_zt2_MachineTime = NULL, *bl_ZT2_FirstOPRevision_zt2_ReadinessTime = NULL, *bl_ZT2_FirstOPRevision_zt2_ProCycle = NULL;
		ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ControlCode", &bl_ZT2_FirstOPRevision_zt2_ControlCode));
		ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ArtificialTime", &bl_ZT2_FirstOPRevision_zt2_ArtificialTime));
		ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_MachineTime", &bl_ZT2_FirstOPRevision_zt2_MachineTime));
		ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ReadinessTime", &bl_ZT2_FirstOPRevision_zt2_ReadinessTime));
		ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ProCycle", &bl_ZT2_FirstOPRevision_zt2_ProCycle));
		string kjjdId = "";
		kjjdId.append(item_id).append("/").append(item_revision_id);

		TiXmlElement *OPCONTENTS = addElement(OPHEAD, "OPCONTENTS", "");
		addElement(OPCONTENTS, "OPTCID", kjjdId.c_str());
		addElement(OPCONTENTS, "OPNAME", object_name);
		addElement(OPCONTENTS, "OPTYPE", "");
		addElement(OPCONTENTS, "VORNR", getGXNR(gxLine));
		addElement(OPCONTENTS, "ARBPL", zt2_WorkCenter);
		addElement(OPCONTENTS, "STEUS", bl_ZT2_FirstOPRevision_zt2_ControlCode);
		addElement(OPCONTENTS, "LTXA1", object_name);
		addElement(OPCONTENTS, "USR00", zt2_ClassificationCode);
		addElement(OPCONTENTS, "BMSCH", "1");
		addElement(OPCONTENTS, "PLNME", p_uom);
		addElement(OPCONTENTS, "VGW01", bl_ZT2_FirstOPRevision_zt2_ArtificialTime);
		addElement(OPCONTENTS, "VGE01", "MIN");
		addElement(OPCONTENTS, "VGW02", bl_ZT2_FirstOPRevision_zt2_MachineTime);
		addElement(OPCONTENTS, "VGE02", "MIN");
		addElement(OPCONTENTS, "VGW05", bl_ZT2_FirstOPRevision_zt2_ReadinessTime);
		addElement(OPCONTENTS, "VGE05", "MIN");
		addElement(OPCONTENTS, "PROCYCLE", bl_ZT2_FirstOPRevision_zt2_ProCycle);
		addElement(OPCONTENTS, "PROCYCLEUNIT", "MIN");
		addElement(OPCONTENTS, "OTHER1", "");
		addElement(OPCONTENTS, "OTHER2", "");

		TiXmlElement *OPMATERCONTENTS = addElement(OPCONTENTS, "OPMATERCONTENTS", "");
		tag_t *c_line_tags = NULL;
		int c_line_count = 0;
		ITKCALL(BOM_line_ask_all_child_lines(gxLine, &c_line_count, &c_line_tags));
		for (int i = 0; i < c_line_count; i++) {
			tag_t subRev = NULLTAG;
			ITKCALL(AOM_ask_value_tag(c_line_tags[i], "bl_line_object", &subRev));
			char *zt2_MaterialNo = NULL, *bl_quantity = NULL, *remark = NULL;
			ITKCALL(AOM_UIF_ask_value(subRev, "zt2_MaterialNo", &zt2_MaterialNo));
			ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "bl_quantity", &bl_quantity));
			ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "bl_occ_type", &remark));

			TiXmlElement *OPMATER = addElement(OPMATERCONTENTS, "OPMATER", "");
			addElement(OPMATER, "WLBM", zt2_MaterialNo);
			addElement(OPMATER, "QUE", bl_quantity);

			if (tc_strcmp(remark, "ZT2_FuLiao") == 0 || tc_strcmp(remark, "辅料") == 0) {
				addElement(OPMATER, "OPTPYE", "2");
				char *item_id2 = NULL, *item_revision_id2 = NULL, *zt2_unit = NULL, *ZT2_Remark = NULL;
				ITKCALL(AOM_UIF_ask_value(subRev, "item_id", &item_id2));
				ITKCALL(AOM_UIF_ask_value(subRev, "item_revision_id", &item_revision_id2));
				ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "ZT2_Remark", &ZT2_Remark));
				string tcId = "", errMsg = "";
				tcId.append(item_id2).append("/").append(item_revision_id2);
				tag_t item = NULLTAG;
				ITKCALL(ITEM_ask_item_of_rev(subRev, &item));
				ITKCALL(AOM_ask_value_string(item, "zt2_unit", &zt2_unit));
				char* uom = getUnti(zt2_unit);
				char *zysapmenge = NULL;
				zysapmenge = (char*)MEM_alloc((16 + 1) * sizeof(char));
				tc_strcpy(zysapmenge, getZYSAPMENGE(subRev, NULLTAG, c_line_tags[i], false, "1", errMsg));
				char valof[16];
				sprintf(valof, "%d", valueOf);

				TiXmlElement *SONCONTENTS = addElement(SONLIST, "SONCONTENTS", "");
				addElement(SONCONTENTS, "TCID", tcId.c_str());
				addElement(SONCONTENTS, "WLBM", zt2_MaterialNo);
				addElement(SONCONTENTS, "DATUV", now);
				addElement(SONCONTENTS, "QUE", zysapmenge);
				addElement(SONCONTENTS, "QUIT", uom);
				addElement(SONCONTENTS, "SORTF", "");
				addElement(SONCONTENTS, "SEQID", valof);
				addElement(SONCONTENTS, "POSTP", "L");
				addElement(SONCONTENTS, "REMARK", ZT2_Remark);
				addElement(SONCONTENTS, "OTHER1", "");
				addElement(SONCONTENTS, "OTHER2", "");
			}
			else {
				addElement(OPMATER, "OPTPYE", "1");
			}
		}
		TiXmlElement *OPFILELIST = addElement(OPCONTENTS, "OPFILELIST", "");
		int datasetCnt = 0;
		tag_t *datasets = NULL;
		ITKCALL(AOM_ask_value_tags(gxRev, "IMAN_specification", &datasetCnt, &datasets));
		for (int d = 0; d < datasetCnt; d++) {
			char *type = NULL;
			ITKCALL(WSOM_ask_object_type2(datasets[d], &type));
			if (find(lists2.begin(), lists2.end(), type) != lists2.end()) {
				char *fileName = NULL, *fileUid = NULL;
				ITKCALL(AOM_UIF_ask_value(datasets[d], "object_name", &fileName));
				ITK__convert_tag_to_uid(datasets[d], &fileUid);
				TiXmlElement *FILECONTENTS = addElement(OPFILELIST, "FILECONTENTS", "");
				addElement(FILECONTENTS, "FILEID", item_id);
				addElement(FILECONTENTS, "FILENAME", fileName);
				addElement(FILECONTENTS, "FILETYPE", "文件");
				addElement(FILECONTENTS, "FILECODE", item_id);
				addElement(FILECONTENTS, "FILEUID", fileUid);
				addElement(FILECONTENTS, "OTHER1", "OTHER1");
				addElement(FILECONTENTS, "OTHER2", "OTHER2");
			}
		}
		TiXmlElement *OPGYSZFILELIST = addElement(OPCONTENTS, "OPGYSZFILELIST", "");
		int ruleCnt = 0;
		tag_t *rules = NULL;
		ITKCALL(AOM_ask_value_tags(gxRev, "ZT2_ProcessRuleRelation", &ruleCnt, &rules));
		if (ruleCnt > 0) {
			tag_t processRuleRevision = NULLTAG;
			ITKCALL(ITEM_ask_latest_rev(rules[0], &processRuleRevision));
			int datasetCnt2 = 0;
			tag_t *datasets2 = NULL;
			ITKCALL(AOM_ask_value_tags(processRuleRevision, "IMAN_specification", &datasetCnt2, &datasets2));
			for (int d = 0; d < datasetCnt2; d++) {
				char *type = NULL;
				ITKCALL(WSOM_ask_object_type2(datasets2[d], &type));
				if (find(lists2.begin(), lists2.end(), type) != lists2.end()) {
					char *fileName = NULL, *fileUid = NULL;
					ITKCALL(AOM_UIF_ask_value(datasets2[d], "object_name", &fileName));
					ITK__convert_tag_to_uid(datasets2[d], &fileUid);
					char *item_id2 = NULL, *item_revision_id2 = NULL;
					ITKCALL(AOM_UIF_ask_value(processRuleRevision, "item_id", &item_id2));
					ITKCALL(AOM_UIF_ask_value(processRuleRevision, "item_revision_id", &item_revision_id2));
					string tcId = "";
					tcId.append(item_id2).append("/").append(item_revision_id2);

					TiXmlElement *FILECONTENTS = addElement(OPGYSZFILELIST, "FILECONTENTS", "");
					addElement(FILECONTENTS, "FILEID", tcId.c_str());
					addElement(FILECONTENTS, "FILENAME", fileName);
					if (tc_strstr(type, "PDF") != NULL) {
						addElement(FILECONTENTS, "FILETYPE", "pdf");
					}
					else if (tc_strstr(type, "Word") != NULL) {
						addElement(FILECONTENTS, "FILETYPE", "docx");
					}
					else {
						addElement(FILECONTENTS, "FILETYPE", "xlsx");
					}
					addElement(FILECONTENTS, "FILEUID", fileUid);
					addElement(FILECONTENTS, "FILECODE", item_id);
					addElement(FILECONTENTS, "OTHER1", "OTHER1");
					addElement(FILECONTENTS, "OTHER2", "OTHER2");
				}
			}
		}
		TiXmlElement *OPGXZYZDSFILELIST = addElement(OPCONTENTS, "OPGXZYZDSFILELIST", "");
		ruleCnt = 0;
		tag_t *books = NULL;
		ITKCALL(AOM_ask_value_tags(gxRev, "ZT2_ProcGuidBookRelation", &ruleCnt, &books));
		if (ruleCnt > 0) {
			tag_t procGuidBookRevision = NULLTAG;
			ITKCALL(ITEM_ask_latest_rev(books[0], &procGuidBookRevision));
			int datasetCnt2 = 0;
			tag_t *datasets2 = NULL;
			ITKCALL(AOM_ask_value_tags(procGuidBookRevision, "IMAN_specification", &datasetCnt2, &datasets2));
			for (int d = 0; d < datasetCnt2; d++) {
				char *type = NULL;
				ITKCALL(WSOM_ask_object_type2(datasets2[d], &type));
				if (find(lists2.begin(), lists2.end(), type) != lists2.end()) {
					char *fileName = NULL, *fileUid = NULL;
					ITKCALL(AOM_UIF_ask_value(datasets2[d], "object_name", &fileName));
					ITK__convert_tag_to_uid(datasets2[d], &fileUid);
					char *item_id2 = NULL, *item_revision_id2 = NULL;
					ITKCALL(AOM_UIF_ask_value(procGuidBookRevision, "item_id", &item_id2));
					ITKCALL(AOM_UIF_ask_value(procGuidBookRevision, "item_revision_id", &item_revision_id2));
					string tcId = "";
					tcId.append(item_id2).append("/").append(item_revision_id2);

					TiXmlElement *FILECONTENTS = addElement(OPGXZYZDSFILELIST, "FILECONTENTS", "");
					addElement(FILECONTENTS, "FILEID", tcId.c_str());
					addElement(FILECONTENTS, "FILENAME", fileName);
					if (tc_strstr(type, "PDF") != NULL) {
						addElement(FILECONTENTS, "FILETYPE", "pdf");
					}
					else if (tc_strstr(type, "Word") != NULL) {
						addElement(FILECONTENTS, "FILETYPE", "docx");
					}
					else {
						addElement(FILECONTENTS, "FILETYPE", "xlsx");
					}
					addElement(FILECONTENTS, "FILEUID", fileUid);
					addElement(FILECONTENTS, "OTHER1", "OTHER1");
					addElement(FILECONTENTS, "OTHER2", "OTHER2");
				}
			}
		}
		TiXmlElement *OPCHECKCONTENTS = addElement(OPCONTENTS, "OPCHECKCONTENTS", "");
		getZljyxInfo2(OPCHECKCONTENTS, gxRev);
	}
}

void readTowGx(tag_t line, tag_t partRev, char* now, TiXmlElement* OPLIST, TiXmlElement* SONLIST, int valueOf) {
	tag_t item = NULLTAG, *c_line_tags = NULL;
	int c_line_count = 0;
	ITKCALL(BOM_line_ask_all_child_lines(line, &c_line_count, &c_line_tags));
	vector<tag_t> startLines = getFlowStarts(c_line_count, c_line_tags);
	if (startLines.size() > 0) {
		log("找到工序流起始点2：%d", startLines.size());
	}
	char *zt2_unit = NULL;
	ITKCALL(ITEM_ask_item_of_rev(partRev, &item));
	ITKCALL(AOM_ask_value_string(item, "zt2_unit", &zt2_unit));
	char* p_uom = getUnti(zt2_unit);
	vector<FlowBean> flowBeans;
	for (int i = 0; i < startLines.size(); i++) {
		FlowBean currentFlow;
		currentFlow.isMain = (i == 0);
		readGXFlow(startLines[i], flowBeans, currentFlow);
		flowBeans.push_back(currentFlow);
	}
	boolean flagBx = false;
	// 打印流信息
	if (flowBeans.size() > 0) {
		log("---已加载PERT数据2---");
		for (FlowBean b : flowBeans) {
			print(b);
		}
	}
	else {
		// 无PERT数据
		log("无PERT数据2");
		FlowBean bean;
		bean.isMain = true;
		flagBx = true;
		for (int j = 0; j < c_line_count; j++) {
			bean.flowList.push_back(c_line_tags[j]);
		}
		//bean.print();
		flowBeans.push_back(bean);
	}
	// 排序
	getSort(flowBeans);

	int ind = 0;
	for (int i = 0; i < flowBeans.size(); i++) {
		FlowBean bean = flowBeans[i];
		if (bean.flow_combine == NULLTAG && flagBx) {
			for (int t = 0; t < bean.flowList.size(); t++) {
				getGXInfo2Comb(bean, ind, partRev, p_uom, now, OPLIST, SONLIST, valueOf, bean.flowList[t]);
				ind ++;
			}
		}
		else {
			getGXInfo2(bean, ind, partRev, p_uom, now, OPLIST, SONLIST, valueOf);
			ind++;
		}
	}
}

// 读取一级工序
void getGXInfo(FlowBean bean, int index, tag_t partRev, char* p_uom, char* now,
		tag_t line, TiXmlElement* KJJDLIST, TiXmlElement* SONLIST, int valueOf) {
	string vornr1 = "";
	string vornr2 = "";
	boolean bx = false;
	string flagt = "";
	string bezfl = "";// 参考顺序
	if (!bean.isMain) {// 并行
		bezfl = (bean.BEZFL);
		bx = true;
		flagt = "1";// 顺序类别
		if (bean.flow_split != NULLTAG) {
			vornr1 = getGXNR(bean.flow_split);// 前驱
		}
		if (bean.isOther)
			bean.flow_split = NULLTAG;
		if (bean.flow_combine != NULLTAG) {
			vornr2 = getGXNR(bean.flow_combine);// 后置
		}
	}
	else {// 非并行
		flagt = "0";// 顺序类别
	}
	char plnfl[16];
	sprintf(plnfl, "%06d", index);
	TiXmlElement *KJJDHEAD = addElement(KJJDLIST, "KJJDHEAD", "");
	addElement(KJJDHEAD, "PLNAL", "1");
	addElement(KJJDHEAD, "PLNFL", plnfl);
	addElement(KJJDHEAD, "DATUV", now);
	addElement(KJJDHEAD, "FLGAT", flagt.c_str());
	addElement(KJJDHEAD, "LTXA1", "");
	addElement(KJJDHEAD, "BEZFL", bezfl.c_str());
	addElement(KJJDHEAD, "VORNR1", vornr1.c_str());
	addElement(KJJDHEAD, "VORNR2", vornr2.c_str());
	boolean inBx = (bean.flow_split == NULLTAG);
	char *flow_combine = NULL;
	ITK__convert_tag_to_uid(bean.flow_combine, &flow_combine);
	int cnt = bean.flowList.size();
	for (int i = 0; i < cnt; i++) {
		tag_t gxLine = bean.flowList[i];
		char *uid = NULL;
		ITK__convert_tag_to_uid(gxLine, &uid);
		if (bx) {
			if (tc_strcmp(uid, flow_combine) == 0) {
				break;
			}
			if (inBx) {
				if (gxLine == NULLTAG) {
					inBx = true;
					continue;
				}
			}
			else {
				char *flow_split = NULL;
				ITK__convert_tag_to_uid(bean.flow_split, &flow_split);
				if (tc_strcmp(uid, flow_split) == 0) {
					inBx = true;
				}
				continue;
			}
		}
		tag_t gxRev = NULLTAG;
		ITKCALL(AOM_ask_value_tag(gxLine, "bl_line_object", &gxRev));
		char *item_id = NULL, *item_revision_id = NULL, *zt2_WorkCenter = NULL, *object_name = NULL, *zt2_ClassificationCode = NULL;
		ITKCALL(AOM_ask_value_string(gxRev, "item_id", &item_id));
		ITKCALL(AOM_UIF_ask_value(gxRev, "item_revision_id", &item_revision_id));
		ITKCALL(AOM_ask_value_string(gxRev, "zt2_WorkCenter", &zt2_WorkCenter));
		ITKCALL(AOM_UIF_ask_value(gxRev, "object_name", &object_name));
		ITKCALL(AOM_UIF_ask_value(gxRev, "zt2_ClassificationCode", &zt2_ClassificationCode));
		char *bl_ZT2_FirstOPRevision_zt2_ControlCode = NULL, *bl_ZT2_FirstOPRevision_zt2_ArtificialTime = NULL,
			*bl_ZT2_FirstOPRevision_zt2_MachineTime = NULL, *bl_ZT2_FirstOPRevision_zt2_ReadinessTime = NULL, *bl_ZT2_FirstOPRevision_zt2_ProCycle = NULL;
		ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ControlCode", &bl_ZT2_FirstOPRevision_zt2_ControlCode));
		ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ArtificialTime", &bl_ZT2_FirstOPRevision_zt2_ArtificialTime));
		ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_MachineTime", &bl_ZT2_FirstOPRevision_zt2_MachineTime));
		ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ReadinessTime", &bl_ZT2_FirstOPRevision_zt2_ReadinessTime));
		ITKCALL(AOM_UIF_ask_value(gxLine, "bl_ZT2_FirstOPRevision_zt2_ProCycle", &bl_ZT2_FirstOPRevision_zt2_ProCycle));
		string kjjdId = "";
		kjjdId.append(item_id).append("/").append(item_revision_id);

		TiXmlElement *KJJDCONTENTS = addElement(KJJDHEAD, "KJJDCONTENTS", "");
		addElement(KJJDCONTENTS, "KJJDID", kjjdId.c_str());
		addElement(KJJDCONTENTS, "KJJDTYPE", "1");
		addElement(KJJDCONTENTS, "VORNR", getGXNR(gxLine));
		addElement(KJJDCONTENTS, "ARBPL", zt2_WorkCenter);
		addElement(KJJDCONTENTS, "STEUS", bl_ZT2_FirstOPRevision_zt2_ControlCode);
		addElement(KJJDCONTENTS, "LTXA1", object_name);
		addElement(KJJDCONTENTS, "USR00", zt2_ClassificationCode);
		addElement(KJJDCONTENTS, "BMSCH", "1");
		addElement(KJJDCONTENTS, "PLNME", p_uom);
		addElement(KJJDCONTENTS, "VGW01", bl_ZT2_FirstOPRevision_zt2_ArtificialTime);
		addElement(KJJDCONTENTS, "VGE01", "MIN");
		addElement(KJJDCONTENTS, "VGW02", bl_ZT2_FirstOPRevision_zt2_MachineTime);
		addElement(KJJDCONTENTS, "VGE02", "MIN");
		addElement(KJJDCONTENTS, "VGW05", bl_ZT2_FirstOPRevision_zt2_ReadinessTime);
		addElement(KJJDCONTENTS, "VGE05", "MIN");
		addElement(KJJDCONTENTS, "PROCYCLE", bl_ZT2_FirstOPRevision_zt2_ProCycle);
		addElement(KJJDCONTENTS, "PROCYCLEUNIT", "MIN");
		addElement(KJJDCONTENTS, "OTHER1", "MIN");
		addElement(KJJDCONTENTS, "OTHER2", "MIN");
		TiXmlElement *KJJDFILELIST = addElement(KJJDCONTENTS, "KJJDFILELIST", "");
		int datasetCnt = 0;
		tag_t *datasets = NULL;
		ITKCALL(AOM_ask_value_tags(gxRev, "IMAN_specification", &datasetCnt, &datasets));
		for (int d = 0; d < datasetCnt; d++) {
			char *type = NULL;
			ITKCALL(WSOM_ask_object_type2(datasets[d], &type));
			if (find(lists2.begin(), lists2.end(), type) != lists2.end()) {
				char *fileName = NULL, *fileUid = NULL;
				ITKCALL(AOM_UIF_ask_value(datasets[d], "object_name", &fileName));
				ITK__convert_tag_to_uid(datasets[d], &fileUid);
				TiXmlElement *FILECONTENTS = addElement(KJJDFILELIST, "FILECONTENTS", "");
				addElement(FILECONTENTS, "FILEID", item_id);
				addElement(FILECONTENTS, "FILENAME", fileName);
				addElement(FILECONTENTS, "FILETYPE", "文件");
				addElement(FILECONTENTS, "FIILUID", fileUid);
				addElement(FILECONTENTS, "OTHER1", "OTHER1");
				addElement(FILECONTENTS, "OTHER2", "OTHER2");
			}
		}
		TiXmlElement *OPLIST = addElement(KJJDCONTENTS, "OPLIST", "");
		readTowGx(gxLine, gxRev, now, OPLIST, SONLIST, valueOf);
	}
}

void readOneGx(tag_t line, tag_t partRev, char* now, TiXmlElement* KJJDLIST, TiXmlElement *SONLIST, int valueOf) {
	int c_line_count = 0;
	tag_t *c_line_tags = NULL;
	ITKCALL(BOM_line_ask_all_child_lines(line, &c_line_count, &c_line_tags));
	vector<FlowBean> flowBeans;
	vector<tag_t> startLines = getFlowStarts(c_line_count, c_line_tags);
	tag_t item = NULLTAG;
	char *zt2_unit = NULL;
	ITKCALL(ITEM_ask_item_of_rev(partRev, &item));
	ITKCALL(AOM_ask_value_string(item, "zt2_unit", &zt2_unit));
	char* p_uom = getUnti(zt2_unit);
	for (int i = 0; i < startLines.size(); i++) {
		FlowBean currentFlow;
		currentFlow.isMain = (i == 0);
		readGXFlow(startLines[i], flowBeans, currentFlow);
		log("currentFlow：");
		print(currentFlow);
		flowBeans.push_back(currentFlow);
	}
	// 打印流信息
	if (flowBeans.size() > 0) {
		log("---已加载PERT数据1---");
		//for (FlowBean b : flowBeans) {
		for (int i = 0; i < flowBeans.size(); i++) {
			print(flowBeans[i]);
		}
	}
	else {
		// 无PERT数据
		log("无PERT数据1");
		FlowBean bean;
		bean.isMain = true;
		for (int j = 0; j < c_line_count; j++) {
			bean.flowList.push_back(c_line_tags[j]);
		}
		//bean.print();
		flowBeans.push_back(bean);
	}
	// 排序
	getSort(flowBeans);
	//		int ind=0;
	for (int i = 0; i < flowBeans.size(); i++) {
		getGXInfo(flowBeans[i], i, partRev, p_uom, now, line, KJJDLIST, SONLIST, valueOf);
	}
}

void getProcess(tag_t rev, tag_t partRev, char* now, char* groupName, map<string, tag_t> gy_meops, TiXmlElement * BOPLIST, TiXmlElement * SONLIST, int valueOf) {
	if (isTcm2(rev)) {
		return;
	}
	char *zt2_MaterialNo = NULL;
	ITKCALL(AOM_ask_value_string(partRev, "zt2_MaterialNo", &zt2_MaterialNo));
	if (gy_meops.count(zt2_MaterialNo)) {
		return;
	}
	gy_meops[zt2_MaterialNo] = rev;

	tag_t ebom_window = NULLTAG, line = NULLTAG;
	ITKCALL(BOM_create_window(&ebom_window));
	ITKCALL(BOM_set_window_top_line(ebom_window, NULL, rev, NULLTAG, &line));
	int c_line_count = 0;
	tag_t *c_line_tags = NULL;
	ITKCALL(BOM_line_ask_all_child_lines(line, &c_line_count, &c_line_tags));

	char *item_id = NULL, *item_revision_id = NULL, *object_name = NULL, *zt2_unit = NULL;
	ITKCALL(AOM_ask_value_string(rev, "item_id", &item_id));
	ITKCALL(AOM_ask_value_string(rev, "item_revision_id", &item_revision_id));
	ITKCALL(AOM_ask_value_string(rev, "object_name", &object_name));
	string tcid = "";
	tcid.append(item_id).append("/").append(item_revision_id);
	TiXmlElement *BOPCONTENTS = addElement(BOPLIST, "BOPCONTENTS", "");
	addElement(BOPCONTENTS, "BOPTCID", tcid.c_str());
	addElement(BOPCONTENTS, "BOPNAME", object_name);
	addElement(BOPCONTENTS, "BOPTYPE", "S1");
	addElement(BOPCONTENTS, "WLBM", zt2_MaterialNo);
	addElement(BOPCONTENTS, "PLANT", groupName);
	addElement(BOPCONTENTS, "VERWE", "1");
	addElement(BOPCONTENTS, "STATU", "4");
	addElement(BOPCONTENTS, "DATUV", now);
	addElement(BOPCONTENTS, "PLNAL", "1");
	addElement(BOPCONTENTS, "VERWE", tcid.c_str());
	addElement(BOPCONTENTS, "OTHER1", "");
	addElement(BOPCONTENTS, "OTHER2", "");
	TiXmlElement *BOPFILELIST = addElement(BOPCONTENTS, "BOPFILELIST", "");
	int dataset_count = 0;
	tag_t *datasets = NULL;
	ITKCALL(AOM_ask_value_tags(rev, "IMAN_specification", &dataset_count, &datasets));
	for (int i = 0; i < dataset_count; i++) {
		char *type = NULL;
		ITKCALL(WSOM_ask_object_type2(datasets[i], &type));
		if (find(lists2.begin(), lists2.end(), type) != lists2.end()) {
			char *name = NULL, *uid = NULL;
			ITKCALL(AOM_ask_value_string(datasets[i], "object_name", &name));
			ITK__convert_tag_to_uid(datasets[i], &uid);
			TiXmlElement *FILECONTENTS = addElement(BOPFILELIST, "FILECONTENTS", "");
			addElement(FILECONTENTS, "FILEID", item_id);
			addElement(FILECONTENTS, "FILENAME", name);
			addElement(FILECONTENTS, "FILETYPE", "文件");
			addElement(FILECONTENTS, "FIILUID", uid);
			addElement(FILECONTENTS, "OTHER1", "OTHER1");
			addElement(FILECONTENTS, "OTHER2", "OTHER2");
		}
	}
	//tag_t window = NULLTAG, line2 = NULLTAG;
	//ITKCALL(BOM_create_window(&window));
	//ITKCALL(BOM_set_window_top_line(window, NULL, rev, NULLTAG, &line2));
	int count = 0;
	tag_t* openedContexts = NULLTAG, *structuerContexts = NULLTAG, cc = NULLTAG, *c_lines = NULLTAG;
	ITKCALL(MFG_open_context(rev, false, false, &count, &openedContexts, &structuerContexts, &cc));
	TiXmlElement *KJJDLIST = addElement(BOPCONTENTS, "KJJDLIST", "");

	readOneGx(openedContexts[0], partRev, now, KJJDLIST, SONLIST, valueOf);

	ITKCALL(BOM_close_window(ebom_window));//BOM_close_window
}

tag_t getPRevision(tag_t rev) {
	char *type = NULL;
	ITKCALL(WSOM_ask_object_type2(rev, &type));
	if (tc_strcmp(type, "Part Revision") == 0) {
		char *zt2_ifpbom = NULL;
		ITKCALL(AOM_UIF_ask_value(rev, "zt2_ifpbom", &zt2_ifpbom));
		if (tc_strcmp(zt2_ifpbom, "P") == 0) {
			return rev;
		}
		tag_t* designs = NULL;
		int num = 0;
		ITKCALL(AOM_ask_value_tags(rev, "TC_Is_Represented_By", &num, &designs));
		if (num > 0) {
			char *zt2_MaterialNo = NULL;
			ITKCALL(AOM_ask_value_string(rev, "zt2_MaterialNo", &zt2_MaterialNo));
			tag_t* matnrs = NULL;
			num = 0;
			ITKCALL(AOM_ask_value_tags(designs[0], "representation_for", &num, &matnrs));
			for (int i = 0; i < num; i++) {
				char *zt2_MaterialNo2 = NULL, *zt2_ifpbom2 = NULL;
				ITKCALL(AOM_ask_value_string(matnrs[i], "zt2_MaterialNo", &zt2_MaterialNo2));
				ITKCALL(AOM_UIF_ask_value(matnrs[i], "zt2_ifpbom", &zt2_ifpbom2));
				if (tc_strcmp(zt2_ifpbom2, "P") == 0 && tc_strcmp(zt2_MaterialNo2, zt2_MaterialNo) == 0) {
					tag_t item = NULLTAG, *revisions = NULL;
					int count = 0;
					ITKCALL(ITEM_ask_item_of_rev(matnrs[i], &item));
					ITKCALL(AOM_ask_value_tags(item, "revision_list", &count, &revisions));
					for (int j = count - 1; j >= 0; j--) {
						if (isTcm2(revisions[j])) {
							return revisions[j];
						}
					}
				}
			}
		}
	}
	return rev;
}

void getWbsMsg(tag_t pRev, char* groupName, vector<string>& wbsList, TiXmlElement *WBSLIST) {
	char *zt2_MaterialNo = NULL, *zt2_WBSNo = NULL;
	ITKCALL(AOM_ask_value_string(pRev, "zt2_WBSNo", &zt2_WBSNo));
	if (!zt2_WBSNo || tc_strlen(zt2_WBSNo) == 0 || find(wbsList.begin(), wbsList.end(), zt2_WBSNo) != wbsList.end()) {
		return;
	}
	ITKCALL(AOM_ask_value_string(pRev, "zt2_MaterialNo", &zt2_MaterialNo));
	TiXmlElement *WBSCONTENTS = addElement(WBSLIST, "WBSCONTENTS", "");
	addElement(WBSCONTENTS, "WBS", zt2_WBSNo);
	addElement(WBSCONTENTS, "PLANT", groupName);
	addElement(WBSCONTENTS, "MATERIALNO", zt2_MaterialNo);

	wbsList.push_back(zt2_WBSNo);
}

void checkMatnr(string& errMessage, tag_t matnrRev) {
	char *os = NULL, *zt2_State = NULL;
	ITKCALL(AOM_ask_value_string(matnrRev, "object_string", &os));
	ITKCALL(AOM_ask_value_string(matnrRev, "zt2_State", &zt2_State));
	if (tc_strcmp(zt2_State, "封存") == 0 || tc_strcmp(zt2_State, "D1") == 0) {
		errMessage.append("物料:").append(os).append("已封存,无法传递SAP\\n");
	}
	char **zt2_SZFactory = NULL, **zt2_SZProcuretype = NULL, **zt2_SZSealedornot = NULL;
	int num1 = 0, num2 = 0, num3 = 0;
	ITKCALL(AOM_ask_value_strings(matnrRev, "zt2_SZFactory", &num1, &zt2_SZFactory));
	ITKCALL(AOM_ask_value_strings(matnrRev, "zt2_SZProcuretype", &num2, &zt2_SZProcuretype));
	ITKCALL(AOM_ask_value_strings(matnrRev, "zt2_SZSealedornot", &num3, &zt2_SZSealedornot));
	boolean flag = false;
	for (int i = 0; i < num1; i++) {
		if (tc_strcmp(zt2_SZFactory[i], "M060") == 0) {
			flag = true;
			if (num2 > i && tc_strcmp(zt2_SZProcuretype[i], "/") == 0) {
				errMessage.append("物料:").append(os).append(" 不可用,无法传递SAP\\n");
			}
			if (num3 > i && tc_strcmp(zt2_SZSealedornot[i], "Y") == 0) {
				errMessage.append("物料:").append(os).append(" 已封存,无法传递SAP\\n");
			}
		}
	}
	if (!flag) {
		errMessage.append("物料:").append(os).append(" 没有维护物料视图,无法传递SAP\\n");
	}
}

void expandAllBomPart(tag_t pRev, tag_t line, TiXmlElement *INTERGRATIONLIST, char* groupName, char* now, 
		vector<string> wbsList, string& errMsg, map<string, tag_t> gy_meops, const char* batchNum) {
	TiXmlElement *WBSLIST = INTERGRATIONLIST->FirstChildElement("WBSLIST");
	if (WBSLIST == NULL) {
		WBSLIST = addElement(INTERGRATIONLIST, "WBSLIST", "");
	}
	getWbsMsg(pRev, groupName, wbsList, WBSLIST);
	tag_t* tzs = NULL;
	int num = 0;
	ITKCALL(AOM_ask_value_tags(pRev, "TC_Is_Represented_By", &num, &tzs));
	int c_line_count = 0;
	tag_t *c_line_tags = NULL;
	ITKCALL(BOM_line_ask_all_child_lines(line, &c_line_count, &c_line_tags));
	if (c_line_count == 0) {
		return;
	}
	TiXmlElement *WLLIST = INTERGRATIONLIST->FirstChildElement("WLLIST");
	if (WLLIST == NULL) {
		WLLIST = addElement(INTERGRATIONLIST, "WLLIST", "");
	}
	TiXmlElement *WLCONTENTS = addElement(WLLIST, "WLCONTENTS", "");
	//
	char *item_id = NULL, *item_revision_id = NULL, *zt2_MaterialNo = NULL, *zt2_unit = NULL;
	ITKCALL(AOM_ask_value_string(pRev, "item_id", &item_id));
	ITKCALL(AOM_ask_value_string(pRev, "item_revision_id", &item_revision_id));
	string tcid = "";
	tcid.append(item_id).append("/").append(item_revision_id);
	addElement(WLCONTENTS, "TCID", tcid.c_str());
	//
	ITKCALL(AOM_ask_value_string(pRev, "zt2_MaterialNo", &zt2_MaterialNo));
	addElement(WLCONTENTS, "WLBM", zt2_MaterialNo);
	//
	TiXmlElement *BOMCONTENTS = addElement(WLCONTENTS, "BOMCONTENTS", "");
	addElement(WLCONTENTS, "WLFILELIST", "");
	TiXmlElement *BOPLIST = addElement(WLCONTENTS, "BOPLIST", "");

	//if (c_line_count > 0)
	addElement(BOMCONTENTS, "PARENTTCID", tcid.c_str());
	addElement(BOMCONTENTS, "PARENTWLBM", zt2_MaterialNo);
	addElement(BOMCONTENTS, "PLANT", groupName);
	addElement(BOMCONTENTS, "DATUV", now);
	addElement(BOMCONTENTS, "STLAN", "1");
	addElement(BOMCONTENTS, "STLAL", "1");
	char *zt2_Quantity = NULL;
	ITKCALL(AOM_ask_value_string(pRev, "zt2_Quantity", &zt2_Quantity));
	addElement(BOMCONTENTS, "QUANTITY", zt2_Quantity);
	tag_t item;
	ITKCALL(ITEM_ask_item_of_rev(pRev, &item));
	ITKCALL(AOM_ask_value_string(item, "zt2_unit", &zt2_unit));
	char* unit = getUnti(zt2_unit);
	log("str = [%s] \n", unit);
	addElement(BOMCONTENTS, "QUIT", zt2_unit);
	char* revUid;
	ITK__convert_tag_to_uid(pRev, &revUid);
	addElement(BOMCONTENTS, "UID", revUid);
	addElement(BOMCONTENTS, "BATCHNUMBER", batchNum);

	//string maxSeq = "10";
	int maxSeq = 0;
	TiXmlElement *SONLIST = addElement(BOMCONTENTS, "SONLIST", "");
	for (int i = 0; i < c_line_count; i++) {
		tag_t c_line_tag = NULLTAG, designRev = NULLTAG;
		char* c_line_os = NULL;
		ITKCALL(AOM_ask_value_string(c_line_tags[i], "object_string", &c_line_os));
		log("c_line_os = [%s]", c_line_os);
		//lidy20250217传递部件的版本是最新已发布的版本，如果最新版本未发布的就传上个发布的版本，
		//如果最新版本是A版本且未发布，就只传他的自己本身
		bool release = true;
		tag_t bomRev = NULLTAG, ebom_window = NULLTAG, rev2 = NULLTAG;
		ITKCALL(BOM_create_window(&ebom_window));
		ITKCALL(AOM_ask_value_tag(c_line_tags[i], "bl_line_object", &bomRev));
		if (!isTcm2(bomRev)) {
			tag_t bomItem = NULLTAG, *revs = NULLTAG;
			int c = 0;
			ITKCALL(ITEM_ask_item_of_rev(bomRev, &bomItem));
			ITKCALL(ITEM_list_all_revs(bomItem, &c, &revs));
			for (int i = c - 1; i >= 0; i--) {
				if (isTcm2(revs[i])) {
					ITKCALL(BOM_set_window_top_line(ebom_window, NULL, revs[i], NULLTAG, &c_line_tag));
					rev2 = revs[i];
					break;
				}
			}
			if (c_line_tag == NULLTAG) {
				log("未发布");
				release = false;
			}
		}
		if (c_line_tag == NULLTAG)
			c_line_tag = c_line_tags[i];

		char *type2 = NULL;
		ITKCALL(AOM_ask_value_tag(c_line_tag, "bl_line_object", &designRev));
		ITKCALL(WSOM_ask_object_type2(designRev, &type2));
		if (tc_strcmp(type2, "ZT2_XNZJBRevision") == 0) {

		}
		TiXmlElement *SONCONTENTS = addElement(SONLIST, "SONCONTENTS", "");
		tag_t item2 = NULLTAG;
		if(rev2 == NULLTAG)
			rev2 = getBOMPart(c_line_tag, groupName);
		char *item_id2 = NULL, *item_revision_id2 = NULL, *zt2_MaterialNo2 = NULL, *zt2_unit2 = NULL, *bl_sequence_no = NULL, *ZT2_Remark = NULL;
		ITKCALL(AOM_ask_value_string(rev2, "item_id", &item_id2));
		ITKCALL(AOM_ask_value_string(rev2, "item_revision_id", &item_revision_id2));
		ITKCALL(AOM_ask_value_string(rev2, "zt2_MaterialNo", &zt2_MaterialNo2));
		ITKCALL(ITEM_ask_item_of_rev(rev2, &item2));
		ITKCALL(AOM_ask_value_string(item2, "zt2_unit", &zt2_unit2));
		ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "bl_sequence_no", &bl_sequence_no));
		ITKCALL(AOM_UIF_ask_value(c_line_tags[i], "ZT2_Remark", &ZT2_Remark));
		checkMatnr(errMsg, rev2);
		string tcid2 = "";
		tcid2.append(item_id2).append("/").append(item_revision_id2);
		addElement(SONCONTENTS, "TCID", tcid2.c_str());
		addElement(SONCONTENTS, "WLBM", zt2_MaterialNo2);
		addElement(SONCONTENTS, "DATUV", now);
		char *menge = NULL;// = getZYSAPMENGE(rev2, NULLTAG, c_line_tag, false, codeRemark, errMsg);
		menge = (char*)MEM_alloc((16 + 1) * sizeof(char));
		tc_strcpy(menge, getZYSAPMENGE(rev2, NULLTAG, c_line_tags[i], false, "1", errMsg));
		char* unit22 = getUnti(zt2_unit2);
		addElement(SONCONTENTS, "QUE", menge);
		addElement(SONCONTENTS, "QUIT", unit22);
		addElement(SONCONTENTS, "SORTF", "");
		addElement(SONCONTENTS, "SEQID", bl_sequence_no);
		addElement(SONCONTENTS, "POSTP", "L");
		addElement(SONCONTENTS, "REMARK", ZT2_Remark);
		addElement(SONCONTENTS, "OTHER1", "");
		addElement(SONCONTENTS, "OTHER2", "");
		if (!bl_sequence_no || tc_strcmp(bl_sequence_no, "") == 0) {
			maxSeq += 10;
		}
		else {
			int seq = stoi(bl_sequence_no);
			if (seq > maxSeq) {
				maxSeq = seq;
			}
		}
		/*if (i == c_line_count - 1) {
			maxSeq = to_string(seq);
		}*/
		if(release)
			expandAllBomPart(rev2, c_line_tag, INTERGRATIONLIST, groupName, now, wbsList, errMsg, gy_meops, batchNum);
		ITKCALL(BOM_close_window(ebom_window));
	}
	tag_t meops = getProcessTag(pRev, groupName);
	//int valueOf = stoi(maxSeq);
	if (pRev != NULLTAG && meops != NULLTAG) {
		char *os = NULL, *pos = NULL;
		ITKCALL(AOM_ask_value_string(pRev, "object_string", &os));
		ITKCALL(AOM_ask_value_string(meops, "object_string", &pos));
		log("物料[%s]工艺信息:%s", os, pos);
		getProcess(meops, pRev, now, groupName, gy_meops, BOPLIST, SONLIST, maxSeq);
	}
}
//写入BOM头信息到DETAILS表
void logXmlMsg(TiXmlElement* interGrationList, char* code, const char* productNos, const char* batchNo, char* wbsNo, char* alterstatus) {
	TiXmlElement *WLLIST = interGrationList->FirstChildElement("WLLIST");
	for (TiXmlElement *content = WLLIST->FirstChildElement("WLCONTENTS"); content != NULL; content = content->NextSiblingElement("WLCONTENTS")) {
		TiXmlElement *BOMCONTENTS = content->FirstChildElement("BOMCONTENTS");
		const char *tcId = BOMCONTENTS->FirstChildElement("PARENTTCID")->GetText();
		vector<string> ids;
		Split(tcId, "/", ids);
		const char *parentMantrNo = BOMCONTENTS->FirstChildElement("PARENTWLBM")->GetText();
		const char *uid = BOMCONTENTS->FirstChildElement("UID")->GetText();

		string insertSql = "insert into CHINT_BOM_TO_SAP_DETIALS (code,batchnumber,plmsendstatus,plmsendstarttime,factory,productmaterialno,pitemid,puid,materialno,wbsno,plmstatus,plmalterstatus) VALUES ('%s','%s','PLM开始传递',SYSDATE,'%s','%s','%s','%s','%s','%s','未处理','%s') ";
		char selectRxfs[3000];
		sprintf(selectRxfs, insertSql.c_str(), code, batchNo, "M060", productNos, ids[0].c_str(), uid, parentMantrNo, wbsNo, alterstatus);
		log("selectRecord2 ===> %s\n", selectRxfs);
		ExecuteSQLNoInputParam(selectRxfs);
		ExecuteSQLNoInputParam((char*)"commit");
	}
}

void BomSapWh(vector<tag_t> ccpVector, char* projectNo, char* groupName, char* wbs,
	char* now, string& errMsgBuf, char*code, char* transfer, char* userName, char* projectName) {
	log("**************  BomSapWh  **************");
	lists2.clear();
	lists2.push_back("PDF");
	lists2.push_back("MS Word");
	lists2.push_back("MS WordX");
	lists2.push_back("MS Excel");
	lists2.push_back("MS ExcelX");

	int url_num = 0;
	char** rule_vals = NULL;
	char alterstatus[2] = "N";
	//是否需要修改状态
	ITKCALL(PREF_ask_char_values("CHINT_BOMTOSAP_STATUS_RULE", &url_num, &rule_vals));
	for (int i = 0; i < url_num; i++) {
		vector<string> vec;
		Split(rule_vals[i], ":", vec);
		if (tc_strcmp(vec[0].c_str(), "M060") == 0) {
			tc_strcpy(alterstatus, vec[1].c_str());
			break;
		}
	}
	string materialNoTmp = "";
	//TiXmlElement *interLogElem = NULL;
	vector<TiXmlDocument> interLogList;
	string batchNum = code;
	batchNum.append("-00001");

	for (int len = 0; len < ccpVector.size(); len++) {
		tag_t rev = ccpVector[len];
		tag_t prev = getPRevision(rev);
		char* revUid;
		ITK__convert_tag_to_uid(prev, &revUid);
		log("P物料UID:%s", revUid);
		tag_t ebom_window = NULLTAG, line = NULLTAG;
		ITKCALL(BOM_create_window(&ebom_window));
		ITKCALL(BOM_set_window_top_line(ebom_window, NULL, prev, NULLTAG, &line));

		TiXmlDocument XmlDocument;
		XmlDocument.Parse("<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:urn=\"urn:chintelectric.com:xi:plm\"><soapenv:Header/><soapenv:Body><urn:MT_MATERIAL_BOP_REQ></urn:MT_MATERIAL_BOP_REQ></soapenv:Body></soapenv:Envelope>");
		TiXmlElement* XmlRoot = XmlDocument.RootElement();
		TiXmlElement *MT_MATERIAL_BOP_REQ = XmlRoot->FirstChildElement("soapenv:Body")->FirstChildElement();
		TiXmlElement *INTERGRATIONLIST = addElement(MT_MATERIAL_BOP_REQ, "INTERGRATIONLIST", "");

		vector<string> wbsList;
		map<string, tag_t> gy_meops;
		string errMsg = "";
		expandAllBomPart(prev, line, INTERGRATIONLIST, groupName, now, wbsList, errMsg, gy_meops, batchNum.c_str());
		TiXmlPrinter printer;
		XmlDocument.Accept(&printer);
		string bomlog = "BOM全document===>";
		bomlog.append(printer.CStr());
		log2(bomlog);
		string logmsg = "errMsg =>";
		//log2(logmsg.append(errMsg));
		logmsg.append(errMsg);
		printf("%s\n", logmsg.c_str());
		info(logmsg.c_str());
		if (errMsg.length() > 0) {
			errMsgBuf.append("BOM异常:\\n").append(errMsg);
			//
			string updateSum = "update CHINT_BOM_TO_SAP_SUM set \"DATASTATUS\" = '数据检查有问题' ,SAPRESULT = 'PLM检查未通过',PLMRESULT = '已发送飞书通知' where code = '%s' ";
			char selectRxfs[800];
			string timel;
			sprintf(selectRxfs, updateSum.c_str(), code);
			log("selectRecord2 ===> %s\n", selectRxfs);
			ExecuteSQLNoInputParam(selectRxfs);
			ExecuteSQLNoInputParam((char*)"commit");
			//错误数据已发送飞书提醒
			sendNotice(code, errMsgBuf, wbs, groupName, userName, projectName);
			return;
		}
		char *zt2_MaterialNo = NULL;
		ITKCALL(AOM_ask_value_string(prev, "zt2_MaterialNo", &zt2_MaterialNo));
		materialNoTmp.append(zt2_MaterialNo).append(";");
		logXmlMsg(INTERGRATIONLIST, code, zt2_MaterialNo, batchNum.c_str(), wbs, alterstatus);
		errMsg = SendToSap(printer.CStr());
		log("SendToSap end");
		if (errMsg.length() > 0) {
			log("errMsg.length() > 0");
			errMsgBuf.append("传递异常:\\n").append(errMsg);
			//
			string updateSum = "update CHINT_BOM_TO_SAP_SUM set \"DATASTATUS\" = '传递异常' ,SAPRESULT = '传递异常',PLMRESULT = '已发送飞书通知' where code = '%s' ";
			char selectRxfs[800];
			string timel;
			sprintf(selectRxfs, updateSum.c_str(), code);
			log("selectRecord3 ===> %s\n", selectRxfs);
			ExecuteSQLNoInputParam(selectRxfs);
			ExecuteSQLNoInputParam((char*)"commit");
			//错误数据已发送飞书提醒
			sendNotice(code, errMsgBuf, wbs, groupName, userName, projectName);
			return;
		}
		//interLogElem = INTERGRATIONLIST;
		interLogList.push_back(XmlDocument);
		ITKCALL(BOM_close_window(ebom_window));
	}
	log("2");
	//if (interLogElem != NULL) {
	/*if (interLogList.size() > 0) {
		for (int i = 0; i < interLogList.size(); i++) {
			TiXmlElement* XmlRoot = interLogList[i].RootElement();
			TiXmlElement *XmlREQ = XmlRoot->FirstChildElement("soapenv:Body")->FirstChildElement();
			TiXmlElement *INTERGRATIONLIST = XmlREQ->FirstChildElement("INTERGRATIONLIST");
			logXmlMsg(INTERGRATIONLIST, code, materialNoTmp.c_str(), batchNum.c_str(), wbs, alterstatus);
		}
	}*/
	string time1 = getPlmTime(code);
	string updateSum = "update CHINT_BOM_TO_SAP_SUM set \"NUMBER\" = %d ,datastatus = '数据正常推送SAP',organizationaltime = '%s',taskstauts = '组织完成',PLMFINISHTIME = SYSDATE where code = '%s' ";
	char selectRxfs[800];
	string timel;
	sprintf(selectRxfs, updateSum.c_str(), 1, time1.c_str(), code);
	log("selectRecord2 ===> %s\n", selectRxfs);
	ExecuteSQLNoInputParam(selectRxfs);
	ExecuteSQLNoInputParam((char*)"commit");

}