myvtm/Module/mod_CardIssuerStand/CardIssuerFSM.h

#ifndef __CARD_ISSUER_FSM_H
#define __CARD_ISSUER_FSM_H

#pragma once

#include "SpFSM.h"
#include "CardIssuerStand_server_g.h"
//#include "GUIConsole_client_g.h"
#include "HeartBeat_client_g.h"
#include "AccessAuthorization_client_g.h"
#include "DevFSMCommBase.hpp"
#include "CardIssuerClass.h"
#include "CardAssist.h"
#include "ICDataElement.h"
#include "IHttpFunc.h"
#include "json/json.h"
#define REFLECTION(var) #var
using namespace CardIssuerStand;
//using namespace GUIConsole;
using namespace HeartBeat;
using namespace AccessAuthorization;

enum EvtType
{
	USER_EVT_TEST = EVT_USER+1,
	USER_EVT_QUIT,
	USER_EVT_INIT,
	USER_EVT_INITFINISHED,
	USER_EVT_ACCEPT,
	USER_EVT_ACCEPT_CANCEL,
	USER_EVT_ACCEPTFINISHED,
	USER_EVT_ISSUE,
	USER_EVT_ISSUE_FINISHED,
	USER_EVT_EJECT,
	USER_EVT_CAPTURE,
	USER_EVT_EJECTFINISHED,
	USER_EVT_WAITFINISHED,
	USER_EVT_CAPTUREFINISHED,
	USER_EVT_WAITFETCHINGTIMEOUT,
	USER_EVT_PREONLINE,
	USER_EVT_POSTONLINE,
	USER_EVT_PREONLINEFINISHED,
	USER_EVT_POSTONLINEFINISHED,
	USER_EVT_RESET,
	USER_EVT_RESETFINISHED,
	USER_EVT_EXIT,
	USER_EVT_READ,
	USER_EVT_READ_FINISHED,
	USER_EVT_WRITE,
	USER_EVT_WRITE_FINISHED,
	USER_EVT_GET_MATERIAL_EX,
	USER_EVT_SET_MATERIAL_EX,
	USER_EVT_ISSUE_EX,
	USER_EVT_ISSUE_EX_FINISHED,
	USER_EVT_SAM_IC,
	USER_EVT_SAM_IC_FINISHED,
	USER_EVT_BACK_TO_INIT,
};
enum SAMICCommandType
{
	//SAM
	SAMICCommand_SAM_Select = 0,
	SAMICCommand_SAM_Active,
	SAMICCommand_SAM_Deactivate,
	SAMICCommand_SAM_WarmReset,
	SAMICCommand_SAM_QueryStatus,
	SAMICCommand_SAM_Command,
	//IC
	SAMICCommand_IC_Active = 100,
	SAMICCommand_IC_Deactivate,
	SAMICCommand_IC_WarmReset,
	SAMICCommand_IC_Command,
	SAMICCommand_RFIC_Active,
	SAMICCommand_RFIC_Deactivate,
	SAMICCommand_RFIC_Command,
};

typedef int(*lpCMBdecodeMag2)(char* Mag2Data, char * data);
typedef int(*lpCMBdecodeEx)( char* MagData, char * type, char * data);
typedef int(__stdcall *pfEncryptDukptHSM)(unsigned char* EncryptedData, unsigned char* bdk, unsigned char* curksn, unsigned char* DecryptedData);
typedef int(__stdcall *pfGetEncrypedData)(unsigned char* BDK, unsigned char* KSN, unsigned char*random, unsigned char* result);
class CCardIssuerEntity;
class CCardIssuerFSM;
const int ONE_K = 1024;
const int HOPPER_NUM = 12;

struct Track2Data
{
	int status;
	CSimpleStringA t2Account;
	CSimpleStringA t2Region;
	CSimpleStringA t2CardSerial;
	CSimpleStringA t2CVC;
	CSimpleStringA t2ExpireDate;
};
struct CMBBin
{
	CSimpleStringA bin;//6 byte long
	bool bIC;//IC:true or mag:false
	bool bDC;//debit:true,credit:false
};
struct SCIRecord
{
	CSimpleStringA name;
	CSimpleStringA remoteMac;
};

class CardInitFinishedEvent : public FSMEvent
{
public:
	CardInitFinishedEvent() : FSMEvent(USER_EVT_INITFINISHED){}
	~CardInitFinishedEvent(){}
	SpReqAnsContext<CardIssuerStandService_Insert_Req,CardIssuerStandService_Insert_Ans>::Pointer ctx;

protected:
private:
};

class CardAcceptEvent : public FSMEvent
{
public:
	CardAcceptEvent() : FSMEvent(USER_EVT_ACCEPT) {}
	~CardAcceptEvent() {}
	SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("card accept unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class CardIssueEvent : public FSMEvent
{
public:
	CardIssueEvent() : FSMEvent(USER_EVT_ISSUE) {}
	~CardIssueEvent() {}
	SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("card issue unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};

class CancelAcceptEvent : public FSMEvent
{
public:
	CancelAcceptEvent() : FSMEvent(USER_EVT_ACCEPT_CANCEL) {}
	~CancelAcceptEvent() {}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("card cancel accept unhandled");
	}
};

class CardReadEvent : public FSMEvent
{
public:
	CardReadEvent() : FSMEvent(USER_EVT_READ) {}
	~CardReadEvent() {}
	SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("card read unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};
class CardReadFinishedEvent : public FSMEvent
{
public:
	CardReadFinishedEvent() : FSMEvent(USER_EVT_READ_FINISHED) {}
	~CardReadFinishedEvent() {}
	SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("card read unhandled(new)");
		}
	}
protected:
private:
};
class ResetDeviceEvent : public FSMEvent
{
public:
	ResetDeviceEvent() : FSMEvent(USER_EVT_RESET){}
	~ResetDeviceEvent(){}
protected:
private:
};
class ResetFinishedEvent : public FSMEvent
{
public:
	ResetFinishedEvent() : FSMEvent(USER_EVT_RESETFINISHED){}
	~ResetFinishedEvent(){}
protected:
private:
};
class PreOnlineEvent : public FSMEvent
{
public:
	PreOnlineEvent() : FSMEvent(USER_EVT_PREONLINE){}
	~PreOnlineEvent(){}
	SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class PostOnlineEvent : public FSMEvent
{
public:
	PostOnlineEvent() : FSMEvent(USER_EVT_POSTONLINE){}
	~PostOnlineEvent(){}
	SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class CardCaptureEvent : public FSMEvent
{
public:
	CardCaptureEvent() : FSMEvent(USER_EVT_CAPTURE){}
	~CardCaptureEvent(){}
	SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}

protected:
private:
};
class CardEjectEvent : public FSMEvent
{
public:
	CardEjectEvent() : FSMEvent(USER_EVT_EJECT){}
	~CardEjectEvent(){}
	SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class CardWriteEvent : public FSMEvent
{
public:
	CardWriteEvent() : FSMEvent(USER_EVT_WRITE){}
	~CardWriteEvent(){}
	SpReqAnsContext<CardIssuerStandService_WriteTrack_Req,CardIssuerStandService_WriteTrack_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("card read unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};
class CardWriteFinishedEvent : public FSMEvent
{
public:
	CardWriteFinishedEvent() : FSMEvent(USER_EVT_WRITE_FINISHED){}
	~CardWriteFinishedEvent(){}
	SpReqAnsContext<CardIssuerStandService_WriteTrack_Req,CardIssuerStandService_WriteTrack_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("card read unhandled(new)");
		}
	}
protected:
private:
};
class GetMaterialExEvent : public FSMEvent
{
public:
	GetMaterialExEvent() : FSMEvent(USER_EVT_GET_MATERIAL_EX) {}
	~GetMaterialExEvent() {}
	SpReqAnsContext<CardIssuerStandService_GetMaterialCountEx_Req, CardIssuerStandService_GetMaterialCountEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class SetMaterialExEvent : public FSMEvent
{
public:
	SetMaterialExEvent() : FSMEvent(USER_EVT_SET_MATERIAL_EX){}
	~SetMaterialExEvent(){}
	SpReqAnsContext<CardIssuerStandService_SetMaterialCountEx_Req, CardIssuerStandService_SetMaterialCountEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class CardIssueExEvent : public FSMEvent
{
public:
	CardIssueExEvent() : FSMEvent(USER_EVT_ISSUE_EX){}
	~CardIssueExEvent(){}
	SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("card issue ex unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class SAMICCommandEvent : public FSMEvent
{
public:
	SAMICCommandEvent() : FSMEvent(USER_EVT_SAM_IC){}
	~SAMICCommandEvent(){}
	SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("sam/ic unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};

typedef struct EacQueryByEac_X1 {
	string xEacNbr;
	string xCltNbr;
	string xIacNbr;
} EacQueryByEac_X1;

typedef struct CQueryCardTypeReq : CHTTPReq {
	struct HEAD {
		int xHdrLen;
		string xIsuCnl;
		string xRtnCod;
	}HEAD;
	struct BODY {
		EacQueryByEac_X1 x1;
	}BODY;
	int X1Count;
	CQueryCardTypeReq() {
		X1Count = 1;
	}
	string ToJson() {
		Json::Value allElm,x1Arr;
		allElm[REFLECTION(HEAD)][REFLECTION(xHdrLen)] = HEAD.xHdrLen;
		allElm[REFLECTION(HEAD)][REFLECTION(xIsuCnl)] = HEAD.xIsuCnl;
		allElm[REFLECTION(HEAD)][REFLECTION(xRtnCod)] = HEAD.xRtnCod;

		for (int i = 0; i < X1Count; i++) {
			Json::Value x1Elm;
			Json::FastWriter fwX1Elm;//写入对象
			x1Elm[REFLECTION(xEacNbr)] = BODY.x1.xEacNbr.c_str();
			x1Elm[REFLECTION(xCltNbr)] = BODY.x1.xCltNbr.c_str();
			x1Elm[REFLECTION(xIacNbr)] = BODY.x1.xIacNbr.c_str();
			//string x1JsonStr = fwX1Elm.write(x1Elm);
			x1Arr[i] = x1Elm;
		}
		allElm[REFLECTION(BODY)][REFLECTION(EacQueryByEac_X1)] = x1Arr;

		Json::FastWriter writer;
		string ret = writer.write(allElm);


		return ret;
	}
} CQueryCardTypeReq;
typedef struct EacQueryByEac_Z1 {
	string zEacNbr;
	string zEacSts;
	string zEacTyp;
	string zEacNam;
	string zEacNik;
	string zEacCod;
	string zCltNbr;
	string zIacNbr;
	string zKeySeq;
	string zFndClt;
	string zFndIac;
	string zFndCpb;
	string zFndAtp;
	string zFpnClt;
	string zFpnIac;
	string zCtfCnr;
	string zCtfTyp;
	string zPsbTag;
	string zPsbFac;
	string zPsbNbr;
	string zPsbCod;
	string zPsbSeq;
	string zPsbMdm;
	string zCvcCod;
	string zCvcCd2;
	string zCvcIcd;
	string zMapBus;
	string zMapCnl;
	string zMapDpn;
	string zMapPwd;
	string zMapAut;
	string zWrmFlg;
	string zBlsFlg;
	string zNamFlg;
	string zActFlg;
	string zSlpFlg;
	string zFkcFlg;
	string zSnmFlg;
	string zWrfAll;
	string zWrfNdk;
	string zWrfZft;
	string zWrfDsk;
	string zPayLck;
	string zQryTag;
	string zFncTag;
	string zWdwTag;
	string zPayTag;
	string zTmpTag;
	string zExtTag;
	string zCtfTag;
	string zMskTag;
	string zStfFlg;
	string zSlaFlg;
	string zBatFlg;
	string zAgtFlg;
	string zAmgTag;
	string zCurTag;
	string zImgIdt;
	string zGrpFlg;
	string zOpnDat;
	string zOpnUsr;
	string zOpnChk;
	string zOpnAut;
	string zActDat;
	string zClsDat;
	string zClsUsr;
	string zClsChk;
	string zClsAut;
	string zDatEft;
	string zDatExp;
	string zBbkNbr;
	string zBrnNbr;
	string zBrnMng;
	string zCtyCod;
}EacQueryByEac_Z1;
typedef struct CQueryCardTypeRet : CHTTPRet {
	struct HEAD {
		string xTypCod;
		string xHdrLen;
		string xSysCod;
		string xDskSys;
		string xWkeCod;
		string xKeyVal;
		string xIsuCnl;
		string xEncCod;
		string xDalCod;
		string xCmmTyp;
		string xOrgIsu;
		string xPreIsu;
		string xEntUsr;
		string xUsrPwd;
		string xIsuDat;
		string xIsuTim;
		string xMacCod;
		string xRtnLvl;
		string xRtnCod;
		string xDevNbr;
		string xTlrNbr;
		string xRqsNbr;
		string xCmmRsv;
		string xDocSiz;
		string xItvTms;
		string xMsgFlg;
		string xAppRsv;
	}HEAD;
	struct BODY {
		EacQueryByEac_Z1 z1;
	}BODY;
	int Z1Count;
	CQueryCardTypeRet() : Z1Count(1) {
	}
	bool Parse(string strData) {
		Json::Value root,tmpZ1;
		Json::Reader reader;
		Json::Value::UInt index;
		if (!reader.parse(strData, root, false))
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("reader.parse false");//又不能打印，有什么太大意义?
			return false;
		}
		index = 0;
		HEAD.xRtnCod = root["HEAD"][REFLECTION(xRtnCod)].asCString();
		if (HEAD.xRtnCod.compare("SUC0000") == 0)
		{
			tmpZ1 = root["BODY"][REFLECTION(EacQueryByEac_Z1)];
			BODY.z1.zPsbMdm = tmpZ1[index][REFLECTION(zPsbMdm)].asCString();
			BODY.z1.zEacNbr = tmpZ1[index][REFLECTION(zEacNbr)].asCString();
			BODY.z1.zPsbSeq = tmpZ1[index][REFLECTION(zPsbSeq)].asCString();
			return true;
		}
		else
			return false;
	}
} CQueryCardTypeRet;
typedef struct CRegistSwallowCardReq : CHTTPReq {
	string cardNo;
	string cardType;
	string channel;
	string clearInstanceId;
	string deviceSciNo;
	string bankNo;
	string editTime;
	string editor;
	string fromFlag;
	string idKey;
	string informType;
	string psbCode;
	string reasonCode;
	string state;
	string structId;
	string swallowDate;
	string swallowTime;
	string terminalNo;
	string terminalType;
	string uuid;
	string ToJson() {
		Json::Value allElm, x1Arr;
		allElm[REFLECTION(cardNo)] = cardNo;
		allElm[REFLECTION(deviceSciNo)] = deviceSciNo;
		allElm[REFLECTION(reasonCode)] = reasonCode;
		allElm[REFLECTION(swallowDate)] = swallowDate;
		allElm[REFLECTION(swallowTime)] = swallowTime;
		allElm[REFLECTION(terminalNo)] = terminalNo;
		allElm[REFLECTION(terminalType)] = terminalType;
		Json::FastWriter writer;
		string ret = writer.write(allElm);
		return ret;
	}
} CRegistSwallowCardReq;
typedef struct CRegistSwallowCardRet : CHTTPRet {
	struct returnInfo {
		string returnCode;
		string errorMsg;
	}returnInfo;
	struct data {
	}data;
	bool Parse(string strData) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(strData.c_str());
		Json::Value root, tmpZ1;
		Json::Reader reader;
		if (!reader.parse(strData, root, false))
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("reader.parse false");//又不能打印，有什么太大意义?
			return false;
		}
		if (!root["returnInfo"].isNull()) {
			returnInfo.returnCode = root["returnInfo"][REFLECTION(returnCode)].asCString();
			return true;
		}
		else {
			return false;//报文结构不对，解析失败
		}
		//returnInfo.returnCode = root["returnInfo"][REFLECTION(returnCode)].asCString();
	}
} CRegistSwallowCardRet;

// 同步卡库计数到后台服务实体类
struct SyncMaterialCountInfo
{
	CSimpleStringA strDeviceNo;
	unsigned int dwCardBoxNum;
	CAutoArray<bool> arrMaintainFlag;
	CAutoArray<CSimpleStringA> arrMaintainer;
	CAutoArray<unsigned int> arrMaintainTime;
	CAutoArray<CSimpleStringA> arrCardBoxNo;
	CAutoArray<CSimpleStringA> arrPsbCode;
	CAutoArray<CSimpleStringA> arrPsbName;
	CAutoArray<unsigned int> arrCardInit;
	CAutoArray<unsigned int> arrCardRemains;
	CAutoArray<unsigned int> arrCardIssued;
	CAutoArray<unsigned int> arrCardMixed;
	CAutoArray<unsigned int> arrCardPercent;
};
struct SyncMaterialCountReq1
{
	char TerminalNo[16];
	char DeviceNo[16];
	char Material[16];
	DWORD CardBoxNum;
};
struct SyncMaterialCountReq2
{
	bool bMaintain;
	char Maintainer[16];
	DWORD MaintainTime;
	char CardBoxNo[20];
	char PsbCode[8];
	char PsbName[128];
	DWORD CardInit;
	DWORD CardRemains;
	DWORD CardIssued;
	DWORD CardMixed;
	DWORD CardPercent;		
};
struct SyncMaterialCountHTTPReq : CHTTPReq {
	SyncMaterialCountHTTPReq() { m_timeOut = 30; }
	SyncMaterialCountReq1 reqInfo;
	std::vector<SyncMaterialCountReq2> reqData;

	virtual string ToJson() {
		Json::Value root;
		Json::Value arrayObj;
		root["terminalNo"] = reqInfo.TerminalNo;
		root["deviceNo"] = reqInfo.DeviceNo;
		root["materiel"] = reqInfo.Material;
		root["cardBoxNum"] = (int)reqInfo.CardBoxNum;
		for (int i = 0; i <= reqInfo.CardBoxNum; i++)
		{
			Json::Value item;
			item["CardBoxNo"] = reqData[i].CardBoxNo;
			item["PsbCode"] = reqData[i].PsbCode;
			item["PsbName"] = reqData[i].PsbName;
			item["CardInit"] = (int)reqData[i].CardInit;
			item["CardRemains"] = (int)reqData[i].CardRemains;
			item["CardIssued"] = (int)reqData[i].CardIssued;
			item["CardMixed"] = (int)reqData[i].CardMixed;
			item["CardPercent"] = (int)reqData[i].CardPercent;
			item["Maintainer"] = reqData[i].Maintainer;
			if (reqData[i].MaintainTime == 0)
				item["MaintainTime"] = "";
			else {
				item["MaintainTime"] = CSmallDateTime::GetNow().ToTimeString().GetData();
				//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("MaintainTime:%d", (DWORD)CSmallDateTime::GetNow());
			}

			item["bMaintain"] = reqData[i].bMaintain;
			arrayObj.append(item);
		}
		root["cardIssueList"] = arrayObj;
		return root.toStyledString();
	}
};
struct SyncMaterialCountHTTPRet : CHTTPRet {
	string m_retStr;
	bool Parse(string strData) {
		m_retStr = strData;
		return true;
	}
};


class CCardIssuerFSM : public CCommDevFSM<CCardIssuerFSM, CardIssuerClass>
{
public:
	enum {s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s14};
	BEGIN_FSM_STATE(CCardIssuerFSM)
		FSM_STATE_ENTRY(s0,"Init",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1,"Initializing",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2,"Idle",s2_on_entry,s2_on_exit,s2_on_event)
		FSM_STATE_ENTRY(s3,"Accepting",s3_on_entry,s3_on_exit,s3_on_event)
		FSM_STATE_ENTRY(s4,"Hold",s4_on_entry,s4_on_exit,s4_on_event)
		FSM_STATE_ENTRY(s5,"Reading",s5_on_entry,s5_on_exit,s5_on_event)
		FSM_STATE_ENTRY(s6,"Ejecting",s6_on_entry,s6_on_exit,s6_on_event)
		FSM_STATE_ENTRY(s7,"WaitFetching",s7_on_entry,s7_on_exit,s7_on_event)
		FSM_STATE_ENTRY(s8,"Capturing",s8_on_entry,s8_on_exit,s8_on_event)
		FSM_STATE_ENTRY(s9,"Failed",s9_on_entry,s9_on_exit,s9_on_event)
		FSM_STATE_ENTRY(s10,"Issuing",s10_on_entry,s10_on_exit,s10_on_event)
		FSM_STATE_ENTRY(s11,"Writing",s11_on_entry,s11_on_exit,s11_on_event)
		FSM_STATE_ENTRY(s14, "SAMIC", s14_on_entry, s14_on_exit, s14_on_event)
		END_FSM_STATE()

	BEGIN_FSM_RULE(CCardIssuerFSM,s0)
	
		FSM_RULE_ENTRY(s0, s2, USER_EVT_TEST, 0)
		FSM_RULE_ENTRY(s0,s1,USER_EVT_INIT,0)
		FSM_RULE_ENTRY(s0, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s1,s2,USER_EVT_INITFINISHED,0)
		FSM_RULE_ENTRY(s1,s9,USER_EVT_INITFINISHED,1)
		FSM_RULE_ENTRY(s1, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s2,s3,USER_EVT_ACCEPT,0)
//		FSM_RULE_ENTRY(s2,s9,USER_EVT_ACCEPT,1)
		FSM_RULE_ENTRY(s2, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s2,s10,USER_EVT_ISSUE,0)
		FSM_RULE_ENTRY(s2, s10, USER_EVT_ISSUE_EX, 0)
		FSM_RULE_ENTRY(s3,s4,USER_EVT_ACCEPTFINISHED,0)
		FSM_RULE_ENTRY(s3,s9,USER_EVT_ACCEPTFINISHED,1)
		FSM_RULE_ENTRY(s3,s2,USER_EVT_ACCEPTFINISHED,2)
		FSM_RULE_ENTRY(s3,s2,USER_EVT_ACCEPTFINISHED,3)
		FSM_RULE_ENTRY(s3,s7,USER_EVT_ACCEPTFINISHED,4)
		FSM_RULE_ENTRY(s3, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s4,s5,USER_EVT_READ,0)
		FSM_RULE_ENTRY(s4,s6,USER_EVT_EJECT,0)
		FSM_RULE_ENTRY(s4,s6,USER_EVT_EXIT,0)
		FSM_RULE_ENTRY(s4,s8,USER_EVT_ACCEPT,0)
		FSM_RULE_ENTRY(s4,s8,USER_EVT_EXIT,1)
		FSM_RULE_ENTRY(s4,s8,USER_EVT_CAPTURE,0)
		FSM_RULE_ENTRY(s4,s11,USER_EVT_WRITE,0)
		FSM_RULE_ENTRY(s4, s14, USER_EVT_SAM_IC, 0)
		FSM_RULE_ENTRY(s4, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_ISSUE_EX_FINISHED, 2)
		FSM_RULE_ENTRY(s4, s6, USER_EVT_ISSUE_EX_FINISHED, 6)
		FSM_RULE_ENTRY(s4, s5, USER_EVT_PREONLINE, 0)
		FSM_RULE_ENTRY(s4, s5, USER_EVT_POSTONLINE, 0)
		FSM_RULE_ENTRY(s5,s4,USER_EVT_READ_FINISHED,0)
		FSM_RULE_ENTRY(s5,s9,USER_EVT_READ_FINISHED,1)
		FSM_RULE_ENTRY(s5,s4,USER_EVT_READ_FINISHED,2)
		FSM_RULE_ENTRY(s5, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s5, s4, USER_EVT_EXIT, 0)
		FSM_RULE_ENTRY(s5, s4, USER_EVT_PREONLINEFINISHED, 0)
		FSM_RULE_ENTRY(s5, s4, USER_EVT_POSTONLINEFINISHED, 0)
		FSM_RULE_ENTRY(s6,s7,USER_EVT_EJECTFINISHED,0)
		FSM_RULE_ENTRY(s6,s9,USER_EVT_EJECTFINISHED,1)
		FSM_RULE_ENTRY(s6, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s7,s2,USER_EVT_WAITFINISHED,0)
		FSM_RULE_ENTRY(s7,s9,USER_EVT_WAITFINISHED,1)
		FSM_RULE_ENTRY(s7,s8,USER_EVT_WAITFINISHED,2)
		FSM_RULE_ENTRY(s7, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s8,s2,USER_EVT_CAPTUREFINISHED,0)
		FSM_RULE_ENTRY(s8,s9,USER_EVT_CAPTUREFINISHED,1)
		FSM_RULE_ENTRY(s8, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s9, s2, USER_EVT_RESETFINISHED, 0)
		FSM_RULE_ENTRY(s9, s0, USER_EVT_RESETFINISHED, 2)
		FSM_RULE_ENTRY(s9, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s10,s4,USER_EVT_ISSUE_FINISHED,0)
		FSM_RULE_ENTRY(s10,s9,USER_EVT_ISSUE_FINISHED,1)
		FSM_RULE_ENTRY(s10,s2,USER_EVT_ISSUE_FINISHED,2)
		FSM_RULE_ENTRY(s10, s6, USER_EVT_ISSUE_EX_FINISHED, 6)
		FSM_RULE_ENTRY(s10, s4, USER_EVT_ISSUE_EX_FINISHED, 0)
		FSM_RULE_ENTRY(s10, s9, USER_EVT_ISSUE_EX_FINISHED, 1)
		FSM_RULE_ENTRY(s10, s2, USER_EVT_ISSUE_EX_FINISHED, 2)
		FSM_RULE_ENTRY(s10, s6, USER_EVT_ISSUE_EX_FINISHED, 6)
		FSM_RULE_ENTRY(s10, s2, USER_EVT_ISSUE_EX_FINISHED, 8)
		FSM_RULE_ENTRY(s10, s2, USER_EVT_EXIT, 0)
		FSM_RULE_ENTRY(s11,s4,USER_EVT_WRITE_FINISHED,0)
		FSM_RULE_ENTRY(s11,s4,USER_EVT_WRITE_FINISHED,1)
		FSM_RULE_ENTRY(s14, s4, USER_EVT_SAM_IC_FINISHED, 0)

		
	END_FSM_RULE()

	CCardIssuerFSM() : m_bCancelAccept(false),m_bWaitingAccept(false),
	m_bWaitAccepteMore(false),m_bExit(false),m_resetTimes(0),m_testResult(Error_Succeed)
	//,m_pTACReject(NULL),m_pIACOnline(NULL),m_pTACOnline(NULL),m_pIACDefault(NULL),m_pTACDefault(NULL)
	,m_bCDA(false),m_pDataToARQC(NULL),m_bIssuingExit(false)
	,m_bCardIssued(false),m_issueStatusFromFile(1),m_issueStatus(1),m_currCardNo("")
	, m_captureReason(""), m_machineType(1), m_currentHopper(1), m_hopperNum(1)
	, m_bSettingMaterial(false)	, m_addCardNo(""), m_addCardSerial(""), m_hasCardWhileDevOpen(false)
	,  m_bCancelByRFIC(false), m_devOpenFailedCount(0)
			, m_EacQueryHost(""),m_eacQueryFlag(0), m_bUseCardnoMismatch(false), m_ICRetryTimes(1)
			, m_bCardFromHopper(true), m_bStopUseRF(false),m_rfVendorList(""), m_bUseRFTillNext(false), m_csSwallowCardUrl(""), m_csSyncMaterialUrl("")
		{
			HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x203);
			cmdDecodeMag2 = NULL;
			cmdDecodeEx = NULL;
			m_aidList.Init(3);
			m_aidList[0] = "A000000333";
			m_aidList[1] = "A0000000108888";
			m_aidList[2] = "A000000790";
		}

	~CCardIssuerFSM(){}
	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* event);
	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);
	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_on_event(FSMEvent* event);
	void s5_on_entry();
	void s5_on_exit();
	unsigned int s5_on_event(FSMEvent* event);
	void s6_on_entry();
	void s6_on_exit();
	unsigned int s6_on_event(FSMEvent* event);
	void s7_on_entry();
	void s7_on_exit();
	unsigned int s7_on_event(FSMEvent* event);
	void s8_on_entry();
	void s8_on_exit();
	unsigned int s8_on_event(FSMEvent* event);
	void s9_on_entry();
	void s9_on_exit();
	unsigned int s9_on_event(FSMEvent* event);
	void s10_on_entry();
	void s10_on_exit();
	unsigned int s10_on_event(FSMEvent* event);
	void s11_on_entry();
	void s11_on_exit();
	unsigned int s11_on_event(FSMEvent* event);
	void s14_on_entry();
	void s14_on_exit();
	unsigned int s14_on_event(FSMEvent* event);
	
	ErrorCodeEnum OpenDevice(BYTE btOpenType, const char *pDevSN);
	int Initial();
	bool GetDevStatus(bool bPrint=true);
	int UnAcceptCard();
	int CaptureCard(SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>::Pointer ctx);
	int EjectCard(SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>::Pointer ctx);
	int WaitFetchingCard();
	int ReadCard(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx);
	int PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx);
	int PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx);
	int ReadCard_Contact(SpReqAnsContext<CardIssuerStandService_Read_Req,CardIssuerStandService_Read_Ans>::Pointer ctx, bool& bICOK);
	int PreOnline_Contact(SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>::Pointer ctx, bool& bICOK);
	int PostOnline_Contact(SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>::Pointer ctx, bool& bICOK);
	int ReadCard_RF(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx);
	int PreOnline_RF(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx);
	int PostOnline_RF(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx);
	int Reset();
	int InternalAcceptCard();
	int AcceptCard(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx);
	int IssueCard(SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx, SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctxEx);
	int WriteCard(SpReqAnsContext<CardIssuerStandService_WriteTrack_Req,CardIssuerStandService_WriteTrack_Ans>::Pointer ctx);

	bool GetWaitFlag(){return m_bWaitingAccept;}
	void SetWaitMore(){m_bWaitAccepteMore = true;}
	void SetExitFlag(bool bFlag=true){m_bExit = bFlag;}
	bool FSMSetIssueFlag(int value=1);
	void FrontSetIssueFlag(bool bValue = true){ FSMSetIssueFlag(bValue); }
	int QueryIssueFlag(){ return m_issueStatus; }
	bool SetCardCaptured(const int num,bool bNewClear=false);
	bool SetCardIssued(const int num,const int hopper);
	bool SetCardRemains(const int num, const int hopper,bool bInit = false);
	bool SetCardMixed(const int num, const int hopper);
	ErrorCodeEnum MachineMoveCardBackNotHold();
	ErrorCodeEnum MachineMoveCardFrontGate(bool bInBussiness=false);

	void SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext);
	DevStateEnum GetDevState()
	{
		if ((m_eDevState == DEVICE_STATUS_NORMAL) 
			&& ((m_bHasHopper[0] && m_mixedEx[0] >= 3) || !m_bHasHopper[0])
			&& ((m_bHasHopper[1] && m_mixedEx[1] >= 3) || !m_bHasHopper[1])
			&& ((m_bHasHopper[2] && m_mixedEx[2] >= 3) || !m_bHasHopper[2]))
			return DEVICE_STATUS_MAINTAINCE;
		else
			return m_eDevState;
	}
	int QueryCardInfo();

	int SetDevStateAndSendMsg(const DevStateEnum eState, bool bForceSend = true);
	int UpdateLocalRunCfg(CAutoArray<int> hopperArr);
	int SyncDataToDB(bool bMaintain[12],bool bSetCaptured=true);//同步物料计数
	void SetHopperNum(int hopperNum);
	void DoExitWhenIdle();
	int SAMICCommand(SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx);

	bool WriteCardInfo(CSmartPointer<IConfigInfo> &cfgRun, const char *acc, const char* serial, int slot, bool bClear = false, bool bHasCard = false);
	bool ReadCardInfo(CSmartPointer<IConfigInfo> &cfgRun, CSimpleStringA &acc, CSimpleStringA &serial, int slot);

	void DecodeTracksData(const char *track2, DWORD dwT2size, const char *track3, DWORD dwT3size,char *&magData,bool bT2OK=true,bool bT3OK=true);
	int GetFSMState()
	{ 
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("m_currentFSMState:%d", m_currentFSMState));
		return m_currentFSMState;
	}
	void GetCardInfo(int &findCard, int &cardPos)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<GetCardInfo>, findCard:%d, cardPos:%d", findCard, cardPos));
		findCard = m_findCard;
		cardPos = m_cardPos;
	}
	int SplitDevModelInfo();
	void SetCancelByRFICFlag(bool bCancel = true) { m_bCancelByRFIC = bCancel; }
	CSimpleStringA GetPreOnlineICCardNo() { return m_currCardNo; }
	void CloseAndClearDevObj(bool bCheckConnecting = true, bool bCloseOnly = false);
	bool GetDevInitFlag() { return m_bOpened; }
	bool GetDevInitingFlag() { return m_bOpening; }

	void SetEnterMainPage();
	static void HttpsLogCallBack(const char* logtxt);
	//0:unknow（havn't access microservice or access failed），1：both mag & ic ，2：mag only，3：ic only
	int JudgeCardType(CSimpleStringA cardno, bool &bMismatch);
	void QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx);
	bool RegistCardWhileCaptureCard(CSimpleStringA cardno);
	bool SyncMaterialCount(IHttpFunc* client,SyncMaterialCountInfo syncInfo);
protected:
	int m_iInsertTries;
	int m_resetTries;
	int m_ejectTries;
private:
	///
	int m_resetTimes;
	lpCMBdecodeMag2 cmdDecodeMag2;
	lpCMBdecodeEx cmdDecodeEx;	
	bool m_bCancelAccept, m_bWaitingAccept, m_bWaitAccepteMore, m_bExit
		, m_bCDA, m_bIssuingExit, m_bCardIssued, m_bHasHopper[HOPPER_NUM]
		, m_bSettingMaterial, m_hasCardWhileDevOpen, m_bCancelByRFIC
		, m_bCardActiveNotify, m_bCardFromHopper, m_bUseCardnoMismatch, m_bStopUseRF;
	bool m_bUseRFTillNext;//if ReadCard by RF,the following PreOnline & PostOnline always use RF till the next card(insert/issue)
	ErrorCodeEnum m_testResult;

	int m_CardCaptured;
	int m_issueStatusFromFile, m_issueStatus/*the status maybe changed by Business call*/;
	//1:default, 2:SCI, 3:no cfg
	int m_machineType;
	WORD m_majorVerion, m_minorVerion;
	int m_currentHopper,m_devOpenFailedCount;
	int m_maxSlot,m_findCard,m_cardPos,m_currentFSMState,m_maxRetainCount, m_eacQueryFlag/*accout query*/
		,m_ICRetryTimes;
	CSimpleStringA m_CardBoxNoEx[HOPPER_NUM], m_PsbCodeEx[HOPPER_NUM], m_PsbNameEx[HOPPER_NUM], m_MaintainerEx[HOPPER_NUM],m_csMaintainTimeEx[HOPPER_NUM];
	int m_CardInitEx[HOPPER_NUM], m_CardPercentEx[HOPPER_NUM], m_remainsEx[HOPPER_NUM], m_issuedEx[HOPPER_NUM], m_mixedEx[HOPPER_NUM],m_hopperNum;
	DWORD m_MaintainTimeEx[HOPPER_NUM];
	BYTE m_connectType, m_r1[128], m_r2[128], m_r3[128], m_priKey[ONE_K / 2], m_devPubKey[ONE_K / 2];
	CardIssuerStatus m_devStatus;
	DevStateEnum m_eDevState;
	CCardProcess *m_pCardProcess;
	CAutoArray<CSimpleStringA> m_aidList;

	char *m_pDataToARQC;
	long xxTest;
	CSimpleStringA m_currCardNo, m_captureReason, m_csMachineType, m_csSite, m_terminalNo, m_addCardNo, m_addCardSerial
		, m_csCM, m_rfVendorList, m_csRF;
	char m_AuthCode[2];
	vector<CMBBin> m_vBin;
	int SplitTrack2(CSimpleStringA pTrack2,Track2Data &decodeData);
	bool JustReadCardNo();
	bool IsValidCardNo(const char*,int);
	void GetVendorDllName(CSimpleStringA &dllName);
	bool AccountExchange(const char *origAcc, CSimpleStringA &acc,int dir=1);
	bool LoadCMBPrint(CSimpleStringA csBinPath);
	DevCategoryInfo m_devCat;
	bool ToRegistCaptureCardInfo();
	bool IfUseRf();
	CSimpleStringA m_EacQueryHost, m_csSwallowCardUrl, m_csSyncMaterialUrl;
	MagTracks m_magTracks;
};
struct InitTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	InitTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_INITFINISHED);
		e->param1 = fsm->Initial();
		fsm->PostEventFIFO(e);
	}
};
struct AcceptTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx;
	AcceptTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_ACCEPTFINISHED);
		e->param1 = fsm->AcceptCard(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct IssueTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx;
	SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctxEx;
	IssueTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e;
		if (ctx != NULL)
			e = new FSMEvent(USER_EVT_ISSUE_FINISHED);
		else if (ctxEx != NULL)
			e = new FSMEvent(USER_EVT_ISSUE_EX_FINISHED);
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("IssueTask:ctx is null");
			return;
		}
		e->param1 = fsm->IssueCard(ctx,ctxEx);
		fsm->PostEventFIFO(e);
	}
};

struct ReadTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerStandService_Read_Req,CardIssuerStandService_Read_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	ReadTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		CardReadFinishedEvent *e = new CardReadFinishedEvent();
		e->ctx = ctx;
		e->param1 = fsm->ReadCard(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct PreOnlineTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	PreOnlineTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_PREONLINEFINISHED);
		e->param1 = fsm->PreOnline(ctx);//oilyang@20220611 实际上，为简化处理，PreOnline函数默认返回0
		fsm->PostEventFIFO(e);
	}
};
struct PostOnlineTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	PostOnlineTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_POSTONLINEFINISHED);
		e->param1 = fsm->PostOnline(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct CaptureTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>::Pointer ctx;
	CaptureTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_CAPTUREFINISHED);
		e->param1 = fsm->CaptureCard(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct EjectTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	EjectTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_EJECTFINISHED);
		e->param1 = fsm->EjectCard(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct WaitFetchingTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	WaitFetchingTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_WAITFINISHED);
		e->param1 = fsm->WaitFetchingCard();
		fsm->PostEventFIFO(e);
	}
};
struct ResetTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	ResetTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		ResetFinishedEvent *e = new ResetFinishedEvent();
		e->param1 = fsm->Reset();
		fsm->PostEventFIFO(e);
	}
};
struct WriteTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerStandService_WriteTrack_Req,CardIssuerStandService_WriteTrack_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	WriteTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		CardWriteFinishedEvent *e = new CardWriteFinishedEvent();
		e->ctx = ctx;
		e->param1 = fsm->WriteCard(ctx);
		fsm->PostEventFIFO(e);
	}
};

struct DoExitWhenIdleTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	DoExitWhenIdleTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->DoExitWhenIdle();
	}
};
struct SAMICCommandTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx;
	SAMICCommandTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_SAM_IC_FINISHED);
		e->param1 = fsm->SAMICCommand(ctx);
		fsm->PostEventFIFO(e);
	}
};


struct RegistCaptureCardInfoTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	CSimpleStringA cardno;
	RegistCaptureCardInfoTask(CCardIssuerFSM* f, CSimpleStringA cardno) : fsm(f),cardno(cardno) {}
	void Process()
	{
		fsm->RegistCardWhileCaptureCard(cardno);
	}
};
struct SyncMaterialCountTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SyncMaterialCountInfo syncInfo;
	SyncMaterialCountTask(CCardIssuerFSM* f, SyncMaterialCountInfo syncMaterialInfo){
		fsm = f;
		syncInfo = syncMaterialInfo;
	}
	void Process()
	{
		LOG_FUNCTION();
		//同步物料信息
		IHttpFunc* client;
		client = create_http(fsm->HttpsLogCallBack);
		bool ret = fsm->SyncMaterialCount(client,syncInfo);
		client->Destory();
	}
};

#endif //__CARD_ISSUER_FSM_H