myvtm/Module/mod_accessauth/AccessAuthFSM.h

#ifndef __ACCESSAUTHFSM_H
#define __ACCESSAUTHFSM_H

#include "SpBase.h"
#include "SpFSM.h"
#include "Blob.h"
#include <mutex>
#include "EventCode.h"
#include "AccessAuthConn.h"
//#include "AccessAuthErrorCode.h"

#include "IHttpFunc.h"
#include "publicFunExport.h"
#include <winpr/sysinfo.h>
static void GetLocalTimeRVC(SYSTEMTIME& stTime)
{
	GetLocalTime(&stTime);
}
#define ACS_SUCCESS "0"
#define REFLECTION(var) #var
#define JUAGEHTTPS(ret) (ret.m_sysCode == 200 || ret.m_sysCode == 201)
typedef struct CAccessAuthHttpsGateReq : public CHTTPReq {

	string terminal_no;
	string branch_no;
	string modular;

	CAccessAuthHttpsGateReq(string terminal, string branch, string module) :
		terminal_no(terminal),
		branch_no(branch),
		modular(module) {
		//m_url = "https://rvcgateway.paas.cmbchina.cn/api/gray/way";
	}

	string ToJson() {
		Dbg("To Json");
		map<string, string> mapReq;
		mapReq[REFLECTION(terminal_no)] = terminal_no;
		Dbg("%s=%s", REFLECTION(terminal_no),terminal_no.c_str());
		mapReq[REFLECTION(branch_no)] = branch_no;
		mapReq[REFLECTION(modular)] = modular;

		pair<bool, string> pairRet = generateJsonStr(mapReq);

		if (pairRet.first) return pairRet.second;
		else return "";
	}
} CAccessAuthHttpsGateReq;

typedef struct CAccessAuthHttpsGateRet : public CHTTPRet {
	bool m_bACS;
	CAccessAuthHttpsGateRet(): m_bACS(false){}
	bool Parse(string strData) {
		Dbg("Parse Json");
		Dbg("strData=%s", strData.c_str());
		if (m_userCode.compare("10000")) return false;
		RVCJson rvcJson;
		rvcJson.SetJson((char*)strData.c_str());
		m_bACS = rvcJson.GetBoolValue(REFLECTION(data));
		rvcJson.Destory();
		return true;
	}
} CAccessAuthHttpsGateRet;

/*
typedef struct CAccessAuthBaseRet : CHTTPRet {
	string request;
	bool success;
	string code;
	string message;
	virtual void Parse(string strData) {
		RVCJson rvcJson;
		rvcJson.SetJson((char*)strData.c_str());
		request = rvcJson.GetStringValue(REFLECTION(request));
		success = rvcJson.GetBoolValue(REFLECTION(success));
		code = rvcJson.GetStringValue(REFLECTION(code));
		message = rvcJson.GetStringValue(REFLECTION(message));
	}
} CAccessAuthBaseRet;
*/
typedef struct CAccessAuthTimeSynReq : CHTTPReq {
	string terminalNo;
	long curTime;
	string reserved;
	CAccessAuthTimeSynReq(string terminalNo, long curTime, string reserved = "")
		: terminalNo(terminalNo), curTime(curTime) {}
	string ToJson() {
		RVCJson rvcJson(true);
		rvcJson.AddStringToObject(REFLECTION(terminalNo),(char*) terminalNo.c_str());
		rvcJson.AddNumberToObject(REFLECTION(curTime), curTime);
		rvcJson.AddStringToObject(REFLECTION(reserved),(char*) reserved.c_str());
		char* tmp = rvcJson.GetJsonStr();
		rvcJson.Destory();
		Dbg("req=%s at CAccessAuthTimeSynReq", tmp);
		string ret;
		ret.assign(tmp);
		delete tmp;
		return ret;
	}
} CAccessAuthTimeSynReq;

typedef struct CAccessAuthTimeSynRet : CHTTPRet {
	struct data {
		long timeDiff;
		int authVersion;
		string sessionKey;
		string reserved;
	} data;
	bool Parse(string strData) {
		Dbg("ret=%s at CAccessAuthTimeSynRet", strData.c_str());
		if (m_userCode.compare(ACS_SUCCESS)) return true;
		RVCJson rvcJson;
		rvcJson.SetJson(strData.c_str());
		auto retJson = rvcJson.GetJsonValue(REFLECTION(data));
			
		data.timeDiff = retJson->GetNumberValue(REFLECTION(timeDiff));
		data.authVersion = retJson->GetNumberIntValue(REFLECTION(authVersion));
		data.sessionKey = retJson->GetStringValue(REFLECTION(sessionKey));
		char * tmpReserved = retJson->GetStringValue(REFLECTION(reserved));
		data.reserved = tmpReserved == NULL ? "" : tmpReserved;
		rvcJson.Destory();
		retJson->Destory();
		delete retJson;
		return true;
	}
} CAccessAuthTimeSynRet;

typedef struct CAccessAuthLockStateReq : CHTTPReq {
	string terminalNo;
	CAccessAuthLockStateReq(string terminalNo) : terminalNo(terminalNo) {}
	string ToJson() {
		RVCJson rvcJson(true);
		rvcJson.AddStringToObject(REFLECTION(terminalNo),(char*) terminalNo.c_str());
		string ret;
		char* tmp = rvcJson.GetJsonStr();
		ret.assign(tmp);
		delete tmp;
		rvcJson.Destory();
		Dbg("req=%s at CAccessAuthLockStateReq", ret.c_str());
		return ret;
	}
} CAccessAuthLockStateReq;

typedef struct CAccessAuthLockStateRet : CHTTPRet {
	struct data {
		string lockState;
	} data;
	bool Parse(string strData) {
		Dbg("ret=%s at CAccessAuthLockStateRet", strData.c_str());
		if (m_userCode.compare(ACS_SUCCESS)) return true;
		RVCJson rvcJson;
		rvcJson.SetJson(strData.c_str());
		auto retJson = rvcJson.GetJsonValue(REFLECTION(data));
		data.lockState = retJson->GetStringValue(REFLECTION(lockState));
		rvcJson.Destory();
		retJson->Destory();
		delete retJson;
		return true;
	}
} CAccessAuthLockStateRet;

typedef struct CAccessAuthUpdateWKReq : CHTTPReq {
	string terminalNo;
	CAccessAuthUpdateWKReq(string terminalNo) : terminalNo(terminalNo) {}
	string ToJson() {
		RVCJson rvcJson(true);
		rvcJson.AddStringToObject(REFLECTION(terminalNo),(char*) terminalNo.c_str());
		string ret;
		char* tmp = rvcJson.GetJsonStr();
		ret.assign(tmp);
		delete tmp;
		rvcJson.Destory();
		Dbg("req=%s at CAccessAuthUpdateWKReq", ret.c_str());
		return ret;
	}
} CAccessAuthUpdateWKReq;

typedef struct CAccessAuthUpdateWKRet : CHTTPRet {
	struct data {
		string TMK;
		string TPK;
		string EDK;
		string index;
		string reserved;
	} data;
	bool Parse(string strData) {
		Dbg("ret=%s at CAccessAuthUpdateWKRet", strData.c_str());
		if (m_userCode.compare(ACS_SUCCESS)) return true;
		RVCJson rvcJson;
		rvcJson.SetJson((char*)strData.c_str());
		auto retJson = rvcJson.GetJsonValue(REFLECTION(data));
		data.TMK = retJson->GetStringValue(REFLECTION(TMK));
		data.TPK = retJson->GetStringValue(REFLECTION(TPK));
		data.EDK = retJson->GetStringValue(REFLECTION(EDK));
		data.index = retJson->GetStringValue(REFLECTION(index));
		rvcJson.Destory();
		retJson->Destory();
		delete retJson;
		return true;
	}
} CAccessAuthUpdateWKRet;

typedef struct CAccessAuthGetTokenReq :public CHTTPReq {
public:
	struct TOKEN_R0 {
		int isSM;
		int isFirst;
		string fingerPrintSM;
	} TOKEN_R0;
	struct TOKEN_R1 {
		string terminalNo;
		string TPK;
		string encTerminalInfo;
	} TOKEN_R1;
	struct TOKEN_R2 {
		string type;
		string modal;
		string factory;
		string versoin;
	}**TOKEN_R2;
	struct TOKEN_R3 {
		string signCertHash;
		string uKeyRootHash;
		int authVersion;
		string fingerPrint;
		string publicKey;
		string kmcSyncFlag;
		string reserved;
	} TOKEN_R3;
	struct TOKEN_R4 {
		string pinPadID;
		string reserved;
	}TOKEN_R4;
	struct TOKEN_R5 {
		int existPinPad;
	} TOKEN_R5;
	int R2Count;
	CAccessAuthGetTokenReq(int R2Count) : R2Count(R2Count){
		TOKEN_R2 = new struct TOKEN_R2 *[R2Count];
		for (int i = 0; i < R2Count; i++) {
			TOKEN_R2[i] = new struct TOKEN_R2;
		}
	}
	string ToJson() {
		RVCJson rvcJson(true);
		RVCJson *tokenJson[6];
		for (int i = 0; i < 6; i++){
			if(i == 2) tokenJson[i] = new RVCJson(false);
			else tokenJson[i] = new RVCJson(true);
		}
		
		tokenJson[0]->AddStringToObject(REFLECTION(fingerPrintSM),(char*) TOKEN_R0.fingerPrintSM.c_str());
		tokenJson[0]->AddNumberToObject(REFLECTION(isFirst), TOKEN_R0.isFirst);
		tokenJson[0]->AddNumberToObject(REFLECTION(isSM), TOKEN_R0.isSM);
		Dbg("R0=%s",tokenJson[0]->GetJsonStr());

		tokenJson[1]->AddStringToObject(REFLECTION(terminalNo),(char*) TOKEN_R1.terminalNo.c_str());
		tokenJson[1]->AddStringToObject(REFLECTION(TPK),(char*) TOKEN_R1.TPK.c_str());
		tokenJson[1]->AddStringToObject(REFLECTION(encTerminalInfo),(char*) TOKEN_R1.encTerminalInfo.c_str());
		Dbg("R1=%s", tokenJson[1]->GetJsonStr());

		for (int i = 0; i < R2Count; i++) {
			RVCJson R2Json(true);
			R2Json.AddStringToObject(REFLECTION(type),(char*) TOKEN_R2[i]->type.c_str());
			R2Json.AddStringToObject(REFLECTION(modal),(char*) TOKEN_R2[i]->modal.c_str());
			R2Json.AddStringToObject(REFLECTION(factory),(char*) TOKEN_R2[i]->factory.c_str());
			R2Json.AddStringToObject(REFLECTION(versoin),(char*) TOKEN_R2[i]->versoin.c_str());
			Dbg("R_=%s", R2Json.GetJsonStr());
			tokenJson[2]->AddItemToArray(&R2Json);
			
			R2Json.Destory();
		}
		Dbg("R2=%s", tokenJson[2]->GetJsonStr());

		tokenJson[3]->AddStringToObject(REFLECTION(signCertHash),(char*) TOKEN_R3.signCertHash.c_str());
		tokenJson[3]->AddStringToObject(REFLECTION(uKeyRootHash),(char*) TOKEN_R3.uKeyRootHash.c_str());
		tokenJson[3]->AddNumberToObject(REFLECTION(authVersion), TOKEN_R3.authVersion);
		tokenJson[3]->AddStringToObject(REFLECTION(fingerPrint),(char*) TOKEN_R3.fingerPrint.c_str());
		tokenJson[3]->AddStringToObject(REFLECTION(publicKey),(char*) TOKEN_R3.publicKey.c_str());
		tokenJson[3]->AddStringToObject(REFLECTION(kmcSyncFlag),(char*) TOKEN_R3.kmcSyncFlag.c_str());
		tokenJson[3]->AddStringToObject(REFLECTION(reserved),(char*) TOKEN_R3.reserved.c_str());
		Dbg("R3=%s", tokenJson[3]->GetJsonStr());
		

		tokenJson[4]->AddStringToObject(REFLECTION(pinPadID),(char*) TOKEN_R4.pinPadID.c_str());
		tokenJson[4]->AddStringToObject(REFLECTION(reserved),(char*) TOKEN_R4.reserved.c_str());
		Dbg("R4=%s", tokenJson[4]->GetJsonStr());

		tokenJson[5]->AddNumberToObject(REFLECTION(existPinPad),TOKEN_R5.existPinPad);
		Dbg("R5=%s", tokenJson[5]->GetJsonStr());

		for (int i = 0; i < 6; i++) {
			string strTmp = int2str(i);
			strTmp = "TOKEN_R" + strTmp;
			rvcJson.AddItemToObject(strTmp.c_str(), tokenJson[i]);
		}
		char *tmp = rvcJson.GetJsonStr();
		string ret(tmp);
		delete tmp;
		Dbg("req=%s at CAccessAuthGetTokenReq", ret.c_str());
		for (int i = 0; i < 6; i++) {
			tokenJson[i]->Destory();
			delete tokenJson[i];
		}
		rvcJson.Destory();
		return ret;
	}
}CAccessAuthGetTokenReq;

typedef struct CAccessAuthGetTokenRet : CHTTPRet {
	typedef struct AccessToken {
		string enToken;
		string retHash;
	} AccessToken;
	typedef struct SharedKey {
		string enToken;
		string sharedSK;
		string retHash;
	} ShareKey;
	struct data {
		AccessToken accessToken;
		SharedKey sharedKey;
	} data;
	bool Parse(string strData) {
		Dbg("ret=%s at CAccessAuthGetTokenRet", strData.c_str());
		if (m_userCode.compare(ACS_SUCCESS)) return true;
		RVCJson rvcJson;
		rvcJson.SetJson(strData.c_str());
		
		auto dataJson = rvcJson.GetJsonValue(REFLECTION(data));
		auto tokenJson = dataJson->GetJsonValue(REFLECTION(accessToken));
		
		data.accessToken.enToken = tokenJson->GetStringValue(REFLECTION(enToken));
		data.accessToken.retHash = tokenJson->GetStringValue(REFLECTION(retHash));
		tokenJson->Destory();
		delete tokenJson;
		
		auto sharedJson = dataJson->GetJsonValue(REFLECTION(sharedKey));
		
		data.sharedKey.enToken = sharedJson->GetStringValue(REFLECTION(enToken));
		data.sharedKey.sharedSK = sharedJson->GetStringValue(REFLECTION(sharedSK));
		char* tmp = sharedJson->GetStringValue(REFLECTION(retHash));
		data.sharedKey.retHash =  tmp == NULL?"":tmp;
		
		sharedJson->Destory();
		delete sharedJson;
		dataJson->Destory();
		delete dataJson;
		
		rvcJson.Destory();
		Dbg("leave CAccessAuthGetTokenRet.");
		return true;
	}
} CAccessAuthGetTokenRet;

typedef struct CAccessAuthStageReportReq : CHTTPReq {
	string terminalNo;
	string newStage;
	string ip;
	string runState;
	string ToJson() {
		RVCJson rvcJson(true);
		rvcJson.AddStringToObject(REFLECTION(terminalNo),(char*) terminalNo.c_str());
		rvcJson.AddStringToObject(REFLECTION(newStage),(char*) newStage.c_str());
		rvcJson.AddStringToObject(REFLECTION(ip),(char*) ip.c_str());
		rvcJson.AddStringToObject(REFLECTION(runState),(char*) runState.c_str());
		string ret;
		char* tmp = rvcJson.GetJsonStr();
		ret.assign(tmp);
		delete tmp;
		Dbg("req=%s at CAccessAuthStageReportReq", ret.c_str());
		return ret;
	}
} CAccessAuthStageReportReq;

typedef struct CAccessAuthStageReportRet : CHTTPRet {
	bool Parse(string strData) {
		//if (m_userCode.compare(ACS_SUCCESS)) return false;
		return true;
	}
} CAccessAuthStageReportRet;

typedef struct CAccessAuthInitDeviceReq : CHTTPReq {
	string cr1;
	string cr3;
	string r2;
	string cDevPubKey;
	string vendor;
	string terminalNo;
	string ToJson() {
		RVCJson rvcJson(true);
		rvcJson.AddStringToObject(REFLECTION(cr1),(char*) cr1.c_str());
		rvcJson.AddStringToObject(REFLECTION(cr3),(char*) cr3.c_str());
		rvcJson.AddStringToObject(REFLECTION(r2),(char*) r2.c_str());
		rvcJson.AddStringToObject(REFLECTION(cDevPubKey),(char*) cDevPubKey.c_str());
		rvcJson.AddStringToObject(REFLECTION(vendor),(char*) vendor.c_str());
		rvcJson.AddStringToObject(REFLECTION(terminalNo), (char*)terminalNo.c_str());
		string ret;
		char* tmp = rvcJson.GetJsonStr();
		ret.assign(tmp);
		delete tmp;
		Dbg("req=%s at CAccessAuthInitDeviceReq", ret.c_str());
		rvcJson.Destory();
		return ret;
	}
} CAccessAuthInitDeviceReq;

typedef struct CAccessAuthInitDeviceRet : CHTTPRet {
	struct data {
		string r3;
		string cr2;
		string r1;
	}data;
	bool Parse(string strData) {
		Dbg("ret=%s at CAccessAuthInitDeviceRet", strData.c_str());
		if (m_userCode.compare(ACS_SUCCESS)) return true;
		RVCJson rvcJson;
		rvcJson.SetJson((char*)strData.c_str());
		auto retJson = rvcJson.GetJsonValue(REFLECTION(data));
		//data.r3 = retJson->GetNumberValue(REFLECTION(r3));
		data.r3 = retJson->GetStringValue(REFLECTION(r3));
		//data.cr2 = retJson->GetNumberValue(REFLECTION(cr2));
		data.cr2 = retJson->GetStringValue(REFLECTION(cr2));
		//data.r1 = retJson->GetNumberValue(REFLECTION(r1));
		data.r1 = retJson->GetStringValue(REFLECTION(r1));
		rvcJson.Destory();
		return true;
	}
} CAccessAuthInitDeviceRet;

typedef struct CAccessAuthExitReq : CHTTPReq {
	string terminalNo;
	int triggerReason;
	int rebootWay;
	int terminalStage;
	string ToJson() {
		RVCJson rvcJson(true);
		rvcJson.AddStringToObject(REFLECTION(terminalNo),(char*) terminalNo.c_str());
		rvcJson.AddNumberToObject(REFLECTION(triggerReason),triggerReason);
		rvcJson.AddNumberToObject(REFLECTION(rebootWay), rebootWay);
		rvcJson.AddNumberToObject(REFLECTION(terminalStage), terminalStage);
		string ret;
		char* tmp = rvcJson.GetJsonStr();
		ret.assign(tmp);
		delete tmp;
		Dbg("req=%s at CAccessAuthExitReq", ret.c_str());
		return ret;
	}
} CAccessAuthExitReq;

typedef struct CAccessAuthExitRet : CHTTPRet {
	bool Parse(string strData) {
		if (m_userCode.compare(ACS_SUCCESS)) return true;
		if (strData.empty()) Dbg("ret is NULL at CAccessAuthExitReq");
		else {
			Dbg("ret=%s at CAccessAuthExitReq",strData.c_str());
		}
		return true;
	}
} CAccessAuthExitRet;



typedef struct CInitlizerMKReq : CHTTPReq {
	struct MKD_NEW1 {
		string enrolAddr;
		string enrolGPS;
		string installVersion;
		string ip;
		string machineModel;
		string machineType;
		string padDeviceID;
		string site;
		string terminalNo;
	}MKD_NEW1;
	//"MKD_REQ1": {
	//	"enrolAddr": "string",
	//		"enrolGPS" : "string",
	//		"ip" : "string",
	//		"machineType" : "string",
	//		"machineVersion" : "string",
	//		"padDeviceID" : "string",
	//		"terminalNo" : "string"
	//},
	struct MKD_REQ2 {
		string branchNo;
		string kmcData;
		string subBankNo;
	}MKD_REQ2;
	struct MKD_REQ3 {
		string factory;
		string modal;
		string type;
		string version;
	}**MKD_REQ3;
	struct MKD_REQ4 {
		string fingerPrint;
		string fingerPrintSM;
		string pinPadID;
		string publicKey;
		string reserverd;
	}MKD_REQ4;
	struct MKD_REQ5 {
		int isFirstSM;
		int isSM;
	}MKD_REQ5;
	struct MKD_SMR2 {
		string branchNo;
		string kmcData;
		string subBankNo;
	}MKD_SMR2;
	int iReq3Count;
	CInitlizerMKReq(int iReq3Count) : iReq3Count(iReq3Count) {
		MKD_REQ3 = new struct MKD_REQ3* [iReq3Count];
		for (int i = 0; i < iReq3Count; i++) {
			MKD_REQ3[i] = new struct MKD_REQ3;
		}
	}
	string ToJson() {
		RVCJson rvcJson(true);
		RVCJson* tokenJson[6];
		for (int i = 0; i < 6; i++) {
			if (i == 2)
				tokenJson[i] = new RVCJson(false);
			else
				tokenJson[i] = new RVCJson(true);
		}
		tokenJson[0]->AddStringToObject(REFLECTION(enrolAddr), (char*)MKD_NEW1.enrolAddr.c_str());
		tokenJson[0]->AddStringToObject(REFLECTION(enrolGPS), (char*)MKD_NEW1.enrolGPS.c_str());
		tokenJson[0]->AddStringToObject(REFLECTION(installVersion), (char*)MKD_NEW1.installVersion.c_str());
		tokenJson[0]->AddStringToObject(REFLECTION(ip), (char*)MKD_NEW1.ip.c_str());
		tokenJson[0]->AddStringToObject(REFLECTION(machineModel), (char*)MKD_NEW1.machineModel.c_str());
		tokenJson[0]->AddStringToObject(REFLECTION(machineType), (char*)MKD_NEW1.machineType.c_str());
		tokenJson[0]->AddStringToObject(REFLECTION(padDeviceID), (char*)MKD_NEW1.padDeviceID.c_str());
		tokenJson[0]->AddStringToObject(REFLECTION(site), (char*)MKD_NEW1.site.c_str());
		tokenJson[0]->AddStringToObject(REFLECTION(terminalNo), (char*)MKD_NEW1.terminalNo.c_str());
		Dbg("MKD_NEW1=%s", tokenJson[0]->GetJsonStr());

		tokenJson[1]->AddStringToObject(REFLECTION(branchNo), (char*)MKD_REQ2.branchNo.c_str());
		tokenJson[1]->AddStringToObject(REFLECTION(kmcData), (char*)MKD_REQ2.kmcData.c_str());
		tokenJson[1]->AddStringToObject(REFLECTION(subBankNo), (char*)MKD_REQ2.subBankNo.c_str());
		Dbg("MKD_REQ2=%s", tokenJson[1]->GetJsonStr());


		for (int i = 0; i < iReq3Count; i++) {
			RVCJson R3Json(true);
			R3Json.AddStringToObject(REFLECTION(type), (char*)MKD_REQ3[i]->type.c_str());
			R3Json.AddStringToObject(REFLECTION(modal), (char*)MKD_REQ3[i]->modal.c_str());
			R3Json.AddStringToObject(REFLECTION(factory), (char*)MKD_REQ3[i]->factory.c_str());
			R3Json.AddStringToObject(REFLECTION(version), (char*)MKD_REQ3[i]->version.c_str());
			Dbg("R_=%s", R3Json.GetJsonStr());
			tokenJson[2]->AddItemToArray(&R3Json);

			R3Json.Destory();
		}
		Dbg("MKD_REQ3=%s", tokenJson[2]->GetJsonStr());

		tokenJson[3]->AddStringToObject(REFLECTION(fingerPrint), (char*)MKD_REQ4.fingerPrint.c_str());
		tokenJson[3]->AddStringToObject(REFLECTION(fingerPrintSM), (char*)MKD_REQ4.fingerPrintSM.c_str());
		tokenJson[3]->AddStringToObject(REFLECTION(pinPadID), (char*)MKD_REQ4.pinPadID.c_str());
		tokenJson[3]->AddStringToObject(REFLECTION(publicKey), (char*)MKD_REQ4.publicKey.c_str());
		tokenJson[3]->AddStringToObject(REFLECTION(reserverd), (char*)MKD_REQ4.reserverd.c_str());
		Dbg("MKD_REQ4=%s", tokenJson[3]->GetJsonStr());


		tokenJson[4]->AddNumberToObject(REFLECTION(isFirstSM), MKD_REQ5.isFirstSM);
		tokenJson[4]->AddNumberToObject(REFLECTION(isSM), MKD_REQ5.isSM);
		Dbg("MKD_REQ5=%s", tokenJson[4]->GetJsonStr());

		tokenJson[5]->AddStringToObject(REFLECTION(branchNo), (char*)MKD_SMR2.branchNo.c_str());
		tokenJson[5]->AddStringToObject(REFLECTION(kmcData), (char*)MKD_SMR2.kmcData.c_str());
		tokenJson[5]->AddStringToObject(REFLECTION(subBankNo), (char*)MKD_SMR2.subBankNo.c_str());
		Dbg("MKD_SMR2=%s", tokenJson[5]->GetJsonStr());

		rvcJson.AddItemToObject("MKD_NEW1", tokenJson[0]);
		rvcJson.AddItemToObject("MKD_REQ2", tokenJson[1]);
		rvcJson.AddItemToObject("MKD_REQ3", tokenJson[2]);
		rvcJson.AddItemToObject("MKD_REQ4", tokenJson[3]);
		rvcJson.AddItemToObject("MKD_REQ5", tokenJson[4]);
		rvcJson.AddItemToObject("MKD_SMR2", tokenJson[5]);

		char* tmp = rvcJson.GetJsonStr();
		string ret(tmp);
		delete tmp;
		Dbg("req=%s at CAccessAuthGetTokenReq", ret.c_str());
		for (int i = 0; i < 6; i++) {
			tokenJson[i]->Destory();
			delete tokenJson[i];
		}
		rvcJson.Destory();
		return ret;
	}
} CInitlizerMKReq;

typedef struct CInitlizerMKRet : CHTTPRet {
	struct data {
		string TMK;
		string TPK;
		string EDK;
		string index;
		string reserved;
	} data;
	bool Parse(string strData) {
		Dbg("ret=%s at CInitlizerMKRet", strData.c_str());
		if (m_userCode.compare(ACS_SUCCESS)) return true;
		RVCJson rvcJson;
		rvcJson.SetJson((char*)strData.c_str());
		auto retJson = rvcJson.GetJsonValue(REFLECTION(data));
		data.TMK = retJson->GetStringValue(REFLECTION(tmk));
		data.TPK = retJson->GetStringValue(REFLECTION(tpk));
		data.EDK = retJson->GetStringValue(REFLECTION(edk));
		data.index = retJson->GetStringValue(REFLECTION(index));
		rvcJson.Destory();
		retJson->Destory();
		delete retJson;
		return true;
	}
} CInitlizerMKRet;


class MyMutex;
class CAccessAuthFSM : public FSMImpl<CAccessAuthFSM>, public IFSMStateHooker
{
public:
	CAccessAuthFSM();
	virtual ~CAccessAuthFSM();

	virtual void OnStateTrans(int iSrcState, int iDstState);
	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	enum{s1, s2, s3};

	enum
	{
		Event_StartRegist = EVT_USER+1,
		Event_ConnectionOK,
		Event_EndSyncTime,
		Event_ReqTokenFail,
		Event_ReqTokenSucc,
		Event_ReqTokenCancel,
		Event_NetworkIllegal,
		Event_NetworkRecover,
		Event_AccessAuthSucc
	};

	BEGIN_FSM_STATE(CAccessAuthFSM)
		FSM_STATE_ENTRY(s1, "Isolate",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2, "Checking",s2_on_entry,s2_on_exit,s2_on_event)
		FSM_STATE_ENTRY(s3, "Authorized", s3_on_entry, s3_on_exit, s3_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CAccessAuthFSM,s1)
		FSM_RULE_ENTRY_ANY(s1, s2, Event_StartRegist)
		FSM_RULE_ENTRY_ANY(s1, s3, Event_AccessAuthSucc)
		FSM_RULE_ENTRY_ANY(s2, s1, Event_ReqTokenCancel)
		FSM_RULE_ENTRY_ANY(s2, s3, Event_AccessAuthSucc)
	END_FSM_RULE()

	void s1_on_entry();
	void s1_on_exit();
	unsigned int s1_on_event(FSMEvent* event);

	void s2_on_entry();
	void s2_on_exit();
	unsigned int s2_on_event(FSMEvent* event);

	void s3_on_entry();

	void s3_on_exit();

	unsigned int s3_on_event(FSMEvent* event);

public:
	void UpdateWK();
	DWORD InitDevice(SpReqAnsContext<AccessAuthService_InitDev_Req, AccessAuthService_InitDev_Ans>::Pointer &ctx);
	DWORD SyncTime();
	int m_finishAccess;
	static void HttpsLogCallBack(const char *logtxt);
	bool m_bAccessACS;
	CAccessAuthConn* m_pConnection;
	CSimpleStringA GetmAccessAuthHost();
	CSimpleStringA GetmInitDeviceHost() { return m_initDeviceHost; }
	CSimpleStringA GetmTerminalList() { return m_terminalList; }
	int GetmnExitReason() { return m_nExitReason; }
	int GetmnExitWay() { return m_nExitWay; }
	bool DecryptWithSessionKey(BYTE* encText, int encTextLen, BYTE* decTest, int& decTestLen);
	//oilyang@20210813 add bNeedEvent.
	//no need to throw event defaultly except the KEY error to call for Close Page
	void doWarnMsg(int errReason, std::string errMsg, bool bNeedEvent = false,string varMsg = "");
	int RtsMapToUserCode(const char* pRtsCode,DWORD dwDefaultUserCode = ERR_ACCESSAUTH_UNKOWN);


	CSimpleStringA GetEntryPermitSysVar();
	ErrorCodeEnum SetEntryPermitSysVar(const CSimpleStringA& newVal);

	void SetNetworkCheckingState(bool busing = true)
	{
		m_fNetworkChecking = busing;
	}

	/*True: Legal; False: illegal*/
	BOOL DetectNetworkLegality();
	BOOL IsCenterSettingFilesExist();

private:
	
	ErrorCodeEnum SetSysVar(const CSimpleStringA &newVal);
	ErrorCodeEnum SecureClientConnect();
	ErrorCodeEnum SecureClientRelease();

	ErrorCodeEnum LoadCenterConfig();

	bool IsNetworkChecking() const { return m_fNetworkChecking; }
	void GetDiffSyncTimeFromCenterSettings();

	int m_nExitReason;
	int m_nExitWay;
	CSimpleStringA m_accessAuthHost;
	CSimpleStringA m_initDeviceHost;
	CSimpleStringA m_terminalList;

	

	ErrorCodeEnum GetIntFromCS(const char* pcSection, const char* pcKey,  int &retInt);
	ErrorCodeEnum GetStrFromCS(const char* pcSection, const char* pcKey,  CSimpleStringA& retStr);

	int m_nCheckMD5;
	//oilyang@20210813 实际上上次关门页改造应该把这个去掉，已经有了(不）重试(不）重启的模式组合
	int m_nAccessFailedCount;

	bool m_fNetworkChecking;
	int m_torelateDiffSyncTimeSecs;
};
class MyMutex {
public:
	explicit MyMutex(std::mutex* pm):mut(pm) {
		mut->lock();
	}
	~MyMutex() {
		mut->unlock();
	}
private:
	std::mutex* mut;
};
#endif // !__ACCESSAUTHFSM_H