myvtm/Module/mod_cardissuerstore/CardIssuerStoreFSM.h

#ifndef __CARD_ISSUER_FSM_H
#define __CARD_ISSUER_FSM_H

#pragma once

#include "SpFSM.h"
#include "CardIssuerStore_server_g.h"
#include "HeartBeat_client_g.h"
#include "AccessAuthorization_client_g.h"
#include "HealthManager_client_g.h"
#include "DevFSMCommBase.hpp"
#include "CardIssuerClass.h"
#include "CardAssist.h"
#include "ICDataElement.h"
#include "IHttpFunc.h"
//#include "publicFunExport.h"
#include "json/json.h"
#include "CardIssuerStore_UserErrorCode.h"	//后续替代EventCode.h，暂时混合使用，时间太紧
#define REFLECTION(var) #var
using namespace CardIssuerStore;
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_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_QUERY_PRINT_STATUS,
	USER_EVT_QUERY_PRINT_STATUS_FINISHED,
	USER_EVT_BACK_TO_INIT,
	USER_EVT_QUERYCARDINFO_ON_STORE,
	USER_EVT_QUERYCARDINFO_ON_STORE_FINISHED,
	USER_EVT_PRINT_CARD_IM,
	USER_EVT_PRINT_CARD_IM_FINISHED,
	//新定义JS状态机事件枚举
	USER_EVT_JS_READ_BATCHCARDINFO_IN_RANGE = EVT_USER + 38,
	USER_EVT_JS_READ_BATCHCARDINFO_IN_RANGE_FINISHED,
	USER_EVT_JS_CAPTURE,
	USER_EVT_JS_CAPTURE_FINISHED,
	USER_EVT_JS_ADD_AND_READ_CRAD_FROMBOX,
	USER_EVT_JS_ADD_AND_READ_CRAD_FROMBOX_FINISHED,
	USER_EVT_JS_MOVE_AND_READ_CARD_FROMSLOT,
	USER_EVT_JS_MOVE_AND_READ_CARD_FROMSLOT_FINISHED,
	USER_EVT_JS_MOVEBACK_TO_SLOT,
	USER_EVT_JS_MOVEBACK_TO_SLOT_FINISHED,
	USER_EVT_JS_ISSUE_FROM_SLOT,
	USER_EVT_JS_ISSUE_FROM_SLOT_FINISHED,
	USER_EVT_JS_EJECT,
	USER_EVT_JS_EJECT_FINISHED,
	USER_EVT_JS_WRITE_TRACK,
	USER_EVT_JS_WRITE_TRACK_FINISHED,
	USER_EVT_JS_PRINT_CARD,
	USER_EVT_JS_PRINT_CARD_FINISHED,
	USER_EVT_JS_SAM_IC_COMMAND,
	USER_EVT_JS_SAM_IC_COMMAND_FINISHED,
	USER_EVT_JS_POSTONLINE,
	USER_EVT_JS_POSTONLINE_FINISHED,
	USER_EVT_JS_ISSUE_FROM_BOX,
	USER_EVT_JS_ISSUE_FROM_BOX_FINISHED,
	USER_EVT_JS_PREONLINE_CROSS,
	USER_EVT_JS_PREONLINE_CROSS_FINISHED,
	USER_EVT_QUICK_SELF_CHECK,
	USER_EVT_QUICK_SELF_CHECK_FINISHED,
	USER_EVT_JS_READ,
	USER_EVT_JS_READ_FINISHED,
	USER_EVT_JS_ADD_CRAD_FROMBOX,
	USER_EVT_JS_ADD_CRAD_FROMBOX_FINISHED,
	USER_EVT_JS_MOVE_CARD_FROMSLOT,
	USER_EVT_JS_MOVE_CARD_FROMSLOT_FINISHED,
};
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,
};

enum CardResultType
{
	CardResult_Invalid_Slot = 1,
	CardResult_HaveNoCardInTheSlot,
	CardResult_Account_MisMatch,
	CardResult_ReadAccount_Fail,
	CardResult_CanNotFindEmptySlot,
	CardResult_MoveToCardReader_Fail,
	CardResult_MoveToSlot_Fail
};
enum CardPositionType
{
	CardPos_KeepInCardReader = 0,
	CardPos_HaveMovedToSlot = 1,
	CardPos_HaveCapturedCard =3,
	CardPos_HaveEjectedCard =4
};
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
};

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

protected:
private:
};

class QueryCardInfoOnStoreEvent : public FSMEvent
{
public:
	QueryCardInfoOnStoreEvent() : FSMEvent(USER_EVT_QUERYCARDINFO_ON_STORE) {}
	~QueryCardInfoOnStoreEvent() {}
	SpReqAnsContext<CardIssuerStoreService_QueryCardInfoOnStore_Req, CardIssuerStoreService_QueryCardInfoOnStore_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("Operate CardStore unhandled");
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class CardReadEvent : public FSMEvent
{
public:
	CardReadEvent() : FSMEvent(USER_EVT_READ) {}
	~CardReadEvent() {}
	SpReqAnsContext<CardIssuerStoreService_Read_Req, CardIssuerStoreService_Read_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("card read unhandled");
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
protected:
private:
};
class CardReadFinishedEvent : public FSMEvent
{
public:
	CardReadFinishedEvent() : FSMEvent(USER_EVT_READ_FINISHED) {}
	~CardReadFinishedEvent() {}
	SpReqAnsContext<CardIssuerStoreService_Read_Req, CardIssuerStoreService_Read_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("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<CardIssuerStoreService_PreOnline_Req,CardIssuerStoreService_PreOnline_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
	}
protected:
private:
};
class PostOnlineEvent : public FSMEvent
{
public:
	PostOnlineEvent() : FSMEvent(USER_EVT_POSTONLINE){}
	~PostOnlineEvent(){}
	SpReqAnsContext<CardIssuerStoreService_PostOnline_Req,CardIssuerStoreService_PostOnline_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
	}
protected:
private:
};
class CardCaptureEvent : public FSMEvent
{
public:
	CardCaptureEvent() : FSMEvent(USER_EVT_CAPTURE){}
	~CardCaptureEvent(){}
	SpReqAnsContext<CardIssuerStoreService_Capture_Req,CardIssuerStoreService_Capture_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
	}

protected:
private:
};
class CardEjectEvent : public FSMEvent
{
public:
	CardEjectEvent() : FSMEvent(USER_EVT_EJECT){}
	~CardEjectEvent(){}
	SpReqAnsContext<CardIssuerStoreService_Eject_Req,CardIssuerStoreService_Eject_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
	}
protected:
private:
};
class CardWriteEvent : public FSMEvent
{
public:
	CardWriteEvent() : FSMEvent(USER_EVT_WRITE){}
	~CardWriteEvent(){}
	SpReqAnsContext<CardIssuerStoreService_WriteTrack_Req,CardIssuerStoreService_WriteTrack_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("card Write unhandled");
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
protected:
private:
};
class CardWriteFinishedEvent : public FSMEvent
{
public:
	CardWriteFinishedEvent() : FSMEvent(USER_EVT_WRITE_FINISHED){}
	~CardWriteFinishedEvent(){}
	SpReqAnsContext<CardIssuerStoreService_WriteTrack_Req,CardIssuerStoreService_WriteTrack_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("card Write unhandled(new)");
		}
	}
protected:
private:
};
class GetMaterialExEvent : public FSMEvent
{
public:
	GetMaterialExEvent() : FSMEvent(USER_EVT_GET_MATERIAL_EX){}
	~GetMaterialExEvent(){}
	SpReqAnsContext<CardIssuerStoreService_GetMaterialCountEx_Req, CardIssuerStoreService_GetMaterialCountEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
	}
protected:
private:
}; 
class SetMaterialExEvent : public FSMEvent
{
public:
	SetMaterialExEvent() : FSMEvent(USER_EVT_SET_MATERIAL_EX){}
	~SetMaterialExEvent(){}
	SpReqAnsContext<CardIssuerStoreService_SetMaterialCountEx_Req, CardIssuerStoreService_SetMaterialCountEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
	}
protected:
private:
};
class CardIssueExEvent : public FSMEvent
{
public:
	CardIssueExEvent() : FSMEvent(USER_EVT_ISSUE_EX){}
	~CardIssueExEvent(){}
	SpReqAnsContext<CardIssuerStoreService_IssueEx_Req, CardIssuerStoreService_IssueEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("card issue ex unhandled");
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};
class SAMICCommandEvent : public FSMEvent
{
public:
	SAMICCommandEvent() : FSMEvent(USER_EVT_SAM_IC){}
	~SAMICCommandEvent(){}
	SpReqAnsContext<CardIssuerStoreService_SAMICCommand_Req, CardIssuerStoreService_SAMICCommand_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("sam/ic unhandled");
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};
class PrintCardImEvent : public FSMEvent
{
public:
	PrintCardImEvent() : FSMEvent(USER_EVT_PRINT_CARD_IM) {}
	~PrintCardImEvent() {}
	SpReqAnsContext<CardIssuerStoreService_PrintCardImmediately_Req, CardIssuerStoreService_PrintCardImmediately_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("PrintCardIm unhandled");
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};
class PrintCardImFinishedEvent : public FSMEvent
{
public:
	PrintCardImFinishedEvent() : FSMEvent(USER_EVT_PRINT_CARD_IM_FINISHED) {}
	~PrintCardImFinishedEvent() {}
	SpReqAnsContext<CardIssuerStoreService_PrintCardImmediately_Req, CardIssuerStoreService_PrintCardImmediately_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
	}
};
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_DEBUG, 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;
	}
};

struct JsonElem
{
	JsonElem() { type = -1; }
	JsonElem(int iVal) {
		type = 0;
		iValue = iVal;
	}
	JsonElem(string str) {
		type = 1;
		strValue = str;
	}
	int type;//0:int value; 1:string value
	int iValue;
	string strValue;
};



#pragma region JS接口 event
//JS接口
class EjectJSEvent : public FSMEvent
{
public:
	EjectJSEvent() : FSMEvent(USER_EVT_JS_EJECT) {}
	~EjectJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_EjectJS_Req, CardIssuerStoreService_EjectJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("EjectJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class CaptureJSEvent : public FSMEvent
{
public:
	CaptureJSEvent() : FSMEvent(USER_EVT_JS_CAPTURE) {}
	~CaptureJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_CaptureJS_Req, CardIssuerStoreService_CaptureJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("CaptureJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class ReadBatchCardInfoInRangeJSEvent : public FSMEvent
{
public:
	ReadBatchCardInfoInRangeJSEvent() : FSMEvent(USER_EVT_JS_READ_BATCHCARDINFO_IN_RANGE) {}
	~ReadBatchCardInfoInRangeJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_ReadBatchCardInfoInRangeJS_Req, CardIssuerStoreService_ReadBatchCardInfoInRangeJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("ReadBatchCardInfoInRangeJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class AddAndReadCardFromBoxJSEvent : public FSMEvent
{
public:
	AddAndReadCardFromBoxJSEvent() : FSMEvent(USER_EVT_JS_ADD_AND_READ_CRAD_FROMBOX) {}
	~AddAndReadCardFromBoxJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_AddAndReadCardFromBoxJS_Req, CardIssuerStoreService_AddAndReadCardFromBoxJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("AddAndReadCardFromBoxJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class AddCardFromBoxJSEvent : public FSMEvent
{
public:
	AddCardFromBoxJSEvent() : FSMEvent(USER_EVT_JS_ADD_CRAD_FROMBOX) {}
	~AddCardFromBoxJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_AddCardFromBoxJS_Req, CardIssuerStoreService_AddCardFromBoxJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("AddCardFromBoxJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class MoveAndReadCardFromSlotJSEvent : public FSMEvent
{
public:
	MoveAndReadCardFromSlotJSEvent() : FSMEvent(USER_EVT_JS_MOVE_AND_READ_CARD_FROMSLOT) {}
	~MoveAndReadCardFromSlotJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_MoveAndReadCardFromSlotJS_Req, CardIssuerStoreService_MoveAndReadCardFromSlotJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("MoveAndReadCardFromSlotJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class MoveCardFromSlotJSEvent : public FSMEvent
{
public:
	MoveCardFromSlotJSEvent() : FSMEvent(USER_EVT_JS_MOVE_CARD_FROMSLOT) {}
	~MoveCardFromSlotJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_MoveCardFromSlotJS_Req, CardIssuerStoreService_MoveCardFromSlotJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("MoveCardFromSlotJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};


class MoveBacktoSlotJSEvent : public FSMEvent
{
public:
	MoveBacktoSlotJSEvent() : FSMEvent(USER_EVT_JS_MOVEBACK_TO_SLOT) {}
	~MoveBacktoSlotJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_MoveBacktoSlotJS_Req, CardIssuerStoreService_MoveBacktoSlotJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("MoveBacktoSlotJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

//class IssueFromSlotJSEvent : public FSMEvent
//{
//public:
//	IssueFromSlotJSEvent() : FSMEvent(USER_EVT_JS_ISSUE_FROM_SLOT) {}
//	~IssueFromSlotJSEvent() {}
//	SpReqAnsContext<CardIssuerStoreService_IssueFromSlotJS_Req, CardIssuerStoreService_IssueFromSlotJS_Ans>::Pointer ctx;
//	virtual void OnUnhandled()
//	{
//		if (ctx != NULL)
//		{
//			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Operate unhandled");
//			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
//		}
//	}
//};

class ICCommandJSEvent : public FSMEvent
{
public:
	ICCommandJSEvent() : FSMEvent(USER_EVT_JS_SAM_IC_COMMAND) {}
	~ICCommandJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_ICCommandJS_Req, CardIssuerStoreService_ICCommandJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("ICCommandJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class WriteTrackJSEvent : public FSMEvent
{
public:
	WriteTrackJSEvent() : FSMEvent(USER_EVT_JS_WRITE_TRACK) {}
	~WriteTrackJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_WriteTrackJS_Req, CardIssuerStoreService_WriteTrackJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("WriteTrackJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class PrintCardImmediatelyJSEvent : public FSMEvent
{
public:
	PrintCardImmediatelyJSEvent() : FSMEvent(USER_EVT_JS_PRINT_CARD) {}
	~PrintCardImmediatelyJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_PrintCardImmediatelyJS_Req, CardIssuerStoreService_PrintCardImmediatelyJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("PrintCardImmediatelyJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class PostOnlineJSEvent : public FSMEvent
{
public:
	PostOnlineJSEvent() : FSMEvent(USER_EVT_JS_POSTONLINE) {}
	~PostOnlineJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_PostOnlineJS_Req, CardIssuerStoreService_PostOnlineJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("PostOnlineJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class IssueFromBoxJSEvent : public FSMEvent
{
public:
	IssueFromBoxJSEvent() : FSMEvent(USER_EVT_JS_ISSUE_FROM_BOX) {}
	~IssueFromBoxJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_IssueFromBoxJS_Req, CardIssuerStoreService_IssueFromBoxJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("IssueFromBoxJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class PreOnlineCrossJSEvent : public FSMEvent
{
public:
	PreOnlineCrossJSEvent() : FSMEvent(USER_EVT_JS_PREONLINE_CROSS) {}
	~PreOnlineCrossJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_PreOnlineCrossJS_Req, CardIssuerStoreService_PreOnlineCrossJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("PreOnlineCrossJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

class QuickSelfcheckFinishEvent : public FSMEvent
{
public:
	QuickSelfcheckFinishEvent() : FSMEvent(USER_EVT_QUICK_SELF_CHECK_FINISHED) {}
	~QuickSelfcheckFinishEvent() {}
protected:
private:
};

class ReadJSEvent : public FSMEvent
{
public:
	ReadJSEvent() : FSMEvent(USER_EVT_JS_READ) {}
	~ReadJSEvent() {}
	SpReqAnsContext<CardIssuerStoreService_ReadJS_Req, CardIssuerStoreService_ReadJS_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2WCL")("ReadJS Operate unhandled");
			//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_EntityInStateCannotProcess);
		}
	}
};

struct AddCardInfo
{
	int slot;
	string addCardNo;
	string addCardSerial;
};
#pragma endregion JS接口 event

class CCardIssuerFSM : public CCommDevFSM<CCardIssuerFSM, CardIssuerClass>
{
public:
	enum {s0,s1,s2,s4,s5,s6,s7,s8,s9,s10,s11,s14,s17,s18,s19};
	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(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)
		FSM_STATE_ENTRY(s17, "OperateCardStore", s17_on_entry, s17_on_exit, s17_on_event)
		FSM_STATE_ENTRY(s18, "PrintCardIm", s18_on_entry, s18_on_exit, s18_on_event)
		FSM_STATE_ENTRY(s19, "PreonlineCross", s19_on_entry, s19_on_exit, s19_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, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s2, s10, USER_EVT_ISSUE_EX, 0)
		FSM_RULE_ENTRY(s2, s17, USER_EVT_QUERYCARDINFO_ON_STORE, 0)
		FSM_RULE_ENTRY(s2, s17, USER_EVT_JS_READ_BATCHCARDINFO_IN_RANGE, 0)//JS 区间盘库
		FSM_RULE_ENTRY(s2, s19, USER_EVT_JS_PREONLINE_CROSS, 0)//JS 跨机激活
		FSM_RULE_ENTRY(s2, s10, USER_EVT_JS_MOVE_AND_READ_CARD_FROMSLOT, 0)//JS 卡槽移卡读卡
		FSM_RULE_ENTRY(s2, s10, USER_EVT_JS_ADD_AND_READ_CRAD_FROMBOX, 0)//JS 加卡箱移卡读卡
		FSM_RULE_ENTRY(s2, s10, USER_EVT_JS_ISSUE_FROM_BOX, 0)//JS 卡箱发卡
		FSM_RULE_ENTRY(s2, s8,  USER_EVT_JS_CAPTURE, 0)//JS 吞卡
		FSM_RULE_ENTRY(s2, s10, USER_EVT_JS_MOVE_CARD_FROMSLOT, 0)//JS 卡槽移卡
		FSM_RULE_ENTRY(s2, s10, USER_EVT_JS_ADD_CRAD_FROMBOX, 0)//JS 加卡箱移卡
		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_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, s18, USER_EVT_PRINT_CARD_IM, 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(s4, s6, USER_EVT_JS_EJECT, 0)//JS 吐卡
		FSM_RULE_ENTRY(s4, s8, USER_EVT_JS_CAPTURE, 0)//JS 吞卡
		FSM_RULE_ENTRY(s4, s10, USER_EVT_JS_MOVEBACK_TO_SLOT, 0)//JS 移回卡槽
		FSM_RULE_ENTRY(s4, s11, USER_EVT_JS_WRITE_TRACK, 0)//JS 写卡
		FSM_RULE_ENTRY(s4, s14, USER_EVT_JS_SAM_IC_COMMAND, 0)//JS ic交互
		FSM_RULE_ENTRY(s4, s18, USER_EVT_JS_PRINT_CARD, 0)//JS 打印
		FSM_RULE_ENTRY(s4, s5, USER_EVT_JS_POSTONLINE, 0)//JS 联机后处理
		FSM_RULE_ENTRY(s4, s5, USER_EVT_JS_READ, 0)//JS 读卡
		FSM_RULE_ENTRY(s4, s8, EVT_MAINPAGE_DISPLAY, 1)//退到首页事件
		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_ANY(s5, s4, USER_EVT_JS_POSTONLINE_FINISHED)//JS
		FSM_RULE_ENTRY(s5, s4, USER_EVT_JS_READ_FINISHED, 0)//JS
		FSM_RULE_ENTRY(s5, s2, USER_EVT_JS_READ_FINISHED, 1)//JS 无卡
		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(s6, s2, USER_EVT_JS_EJECT_FINISHED, 0)//JS 吐卡且取卡成功，取卡超时吞卡成功
		FSM_RULE_ENTRY(s6, s9, USER_EVT_JS_EJECT_FINISHED, 1)//JS 吐卡失败，取卡超时吞卡失败
		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, s2, USER_EVT_JS_CAPTURE_FINISHED, 0)//JS 
		FSM_RULE_ENTRY(s8, s9, USER_EVT_JS_CAPTURE_FINISHED, 1)//JS 吞卡失败
		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, 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(s10, s4, USER_EVT_JS_MOVE_AND_READ_CARD_FROMSLOT_FINISHED, 0)//JS
		FSM_RULE_ENTRY(s10, s2, USER_EVT_JS_MOVE_AND_READ_CARD_FROMSLOT_FINISHED, 1)//JS
		FSM_RULE_ENTRY(s10, s4, USER_EVT_JS_ADD_AND_READ_CRAD_FROMBOX_FINISHED, 0)//JS
		FSM_RULE_ENTRY(s10, s2, USER_EVT_JS_ADD_AND_READ_CRAD_FROMBOX_FINISHED, 1)//JS
		FSM_RULE_ENTRY(s10, s4, USER_EVT_JS_MOVE_CARD_FROMSLOT_FINISHED, 0)//JS
		FSM_RULE_ENTRY(s10, s2, USER_EVT_JS_MOVE_CARD_FROMSLOT_FINISHED, 1)//JS
		FSM_RULE_ENTRY(s10, s4, USER_EVT_JS_ADD_CRAD_FROMBOX_FINISHED, 0)//JS
		FSM_RULE_ENTRY(s10, s2, USER_EVT_JS_ADD_CRAD_FROMBOX_FINISHED, 1)//JS
		FSM_RULE_ENTRY(s10, s4, USER_EVT_JS_MOVEBACK_TO_SLOT_FINISHED, 0)//JS 
		FSM_RULE_ENTRY(s10, s2, USER_EVT_JS_MOVEBACK_TO_SLOT_FINISHED, 1)//JS
		FSM_RULE_ENTRY(s10, s4, USER_EVT_JS_ISSUE_FROM_BOX_FINISHED, 0)//JS 
		FSM_RULE_ENTRY(s10, s2, USER_EVT_JS_ISSUE_FROM_BOX_FINISHED, 1)//JS
		FSM_RULE_ENTRY(s11,s4,USER_EVT_WRITE_FINISHED,0)
		FSM_RULE_ENTRY(s11,s4,USER_EVT_WRITE_FINISHED,1)
		FSM_RULE_ENTRY_ANY(s11, s4, USER_EVT_JS_WRITE_TRACK_FINISHED)//JS
		FSM_RULE_ENTRY(s14, s4, USER_EVT_SAM_IC_FINISHED, 0)
		FSM_RULE_ENTRY_ANY(s14, s4, USER_EVT_JS_SAM_IC_COMMAND_FINISHED)//JS
		FSM_RULE_ENTRY(s17, s2, USER_EVT_QUERYCARDINFO_ON_STORE_FINISHED, 0)
		FSM_RULE_ENTRY(s17, s2, USER_EVT_QUERYCARDINFO_ON_STORE_FINISHED, 2)
		FSM_RULE_ENTRY(s17, s2, USER_EVT_JS_READ_BATCHCARDINFO_IN_RANGE_FINISHED, 0)//JS 
		FSM_RULE_ENTRY(s17, s4, USER_EVT_JS_READ_BATCHCARDINFO_IN_RANGE_FINISHED, 1)//JS 读卡，移卡失败
		FSM_RULE_ENTRY(s18, s4, USER_EVT_PRINT_CARD_IM_FINISHED, 0)
		FSM_RULE_ENTRY_ANY(s18, s4, USER_EVT_JS_PRINT_CARD_FINISHED)//JS
		FSM_RULE_ENTRY(s19, s2, USER_EVT_JS_PREONLINE_CROSS_FINISHED, 0)//JS
		FSM_RULE_ENTRY(s19, s9, USER_EVT_JS_PREONLINE_CROSS_FINISHED, 1)//JS 吞卡失败
	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), EncypteDukptHSM(NULL)
	, m_bSettingMaterial(false)
	, m_maxSlot(0), m_addCardNo(""), m_addCardSerial(""), m_hasCardWhileDevOpen(false)
	, m_bChannelOK(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(""), m_bNewAnsError(false)
		, m_bCrossPreOnline(false), m_csMagT2Track(""), m_csMagT3Track(""), m_csMagAccout(""), m_csMagRegion(""), m_csMagCardSerial(""), m_csMagCVC(""), m_csMagExpireDate("")
		, m_quickSelfcheck(false), m_SelfcheckSleepTime(0), m_bDoExit(false)
		{
			HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x220);
			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 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);
	void s17_on_entry();
	void s17_on_exit();
	unsigned int s17_on_event(FSMEvent* event);
	void s18_on_entry();
	void s18_on_exit();
	unsigned int s18_on_event(FSMEvent* event);
	void s19_on_entry();
	void s19_on_exit();
	unsigned int s19_on_event(FSMEvent* event);
	
	ErrorCodeEnum OpenDevice(BYTE btOpenType, const char *pDevSN);
	int Initial();
	bool GetDevStatus(bool bPrint=true);
	int UnAcceptCard();
	int CaptureCard(SpReqAnsContext<CardIssuerStoreService_Capture_Req,CardIssuerStoreService_Capture_Ans>::Pointer ctx);
	int EjectCard(SpReqAnsContext<CardIssuerStoreService_Eject_Req,CardIssuerStoreService_Eject_Ans>::Pointer ctx);
	int WaitFetchingCard();
	int ReadCard(SpReqAnsContext<CardIssuerStoreService_Read_Req, CardIssuerStoreService_Read_Ans>::Pointer ctx);
	int PreOnline(SpReqAnsContext<CardIssuerStoreService_PreOnline_Req, CardIssuerStoreService_PreOnline_Ans>::Pointer ctx);
	int PostOnline(SpReqAnsContext<CardIssuerStoreService_PostOnline_Req, CardIssuerStoreService_PostOnline_Ans>::Pointer ctx);
	int ReadCard_Contact(SpReqAnsContext<CardIssuerStoreService_Read_Req,CardIssuerStoreService_Read_Ans>::Pointer ctx, bool& bICOK);
	int PreOnline_Contact(SpReqAnsContext<CardIssuerStoreService_PreOnline_Req,CardIssuerStoreService_PreOnline_Ans>::Pointer ctx, bool& bICOK, bool& bContinue);
	int PostOnline_Contact(SpReqAnsContext<CardIssuerStoreService_PostOnline_Req,CardIssuerStoreService_PostOnline_Ans>::Pointer ctx, bool& bICOK);
	int ReadCard_RF(SpReqAnsContext<CardIssuerStoreService_Read_Req, CardIssuerStoreService_Read_Ans>::Pointer ctx);
	int PreOnline_RF(SpReqAnsContext<CardIssuerStoreService_PreOnline_Req, CardIssuerStoreService_PreOnline_Ans>::Pointer ctx);
	int PostOnline_RF(SpReqAnsContext<CardIssuerStoreService_PostOnline_Req, CardIssuerStoreService_PostOnline_Ans>::Pointer ctx);
	int Reset();
	int InternalAcceptCard();
	int AcceptCard(SpReqAnsContext<CardIssuerStoreService_Insert_Req, CardIssuerStoreService_Insert_Ans>::Pointer ctx);
	int IssueCard(SpReqAnsContext<CardIssuerStoreService_IssueEx_Req, CardIssuerStoreService_IssueEx_Ans>::Pointer ctxEx);
	int WriteCard(SpReqAnsContext<CardIssuerStoreService_WriteTrack_Req,CardIssuerStoreService_WriteTrack_Ans>::Pointer ctx);


	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() const
	{
		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 UpdateLocalRunCfg(CAutoArray<int> hopperArr);
	int SyncDataToDB(bool bMaintain[12],bool bSetCaptured=true);//同步物料计数
	void SetHopperNum(int hopperNum);
	void DoExitWhenIdle();
	int SAMICCommand(SpReqAnsContext<CardIssuerStoreService_SAMICCommand_Req, CardIssuerStoreService_SAMICCommand_Ans>::Pointer ctx);
	bool WriteSlotInfo(CSmartPointer<IConfigInfo> &cfgRun, const char *acc, const char *cardSerial,int slot,bool bClear=false);
	bool ReadSlotInfo(CSmartPointer<IConfigInfo> &cfgRun, CSimpleStringA &acc, CSimpleStringA &cardSerial, int slot, int &hasCard);
	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);
	int IssueCardFromStore(SpReqAnsContext<CardIssuerStoreService_IssueEx_Req, CardIssuerStoreService_IssueEx_Ans>::Pointer ctx,bool isSpec=false);
	int AddCardToStoreStepFirst(SpReqAnsContext<CardIssuerStoreService_IssueEx_Req, CardIssuerStoreService_IssueEx_Ans>::Pointer ctx);
	int AddCardToStoreStepLast(SpReqAnsContext<CardIssuerStoreService_IssueEx_Req, CardIssuerStoreService_IssueEx_Ans>::Pointer ctx);
	int FindFirstEmptySlot();
	bool IsValidSlotNum(const int slot);
	bool IsSlotHasCard(const int slot);
	bool OperateCardStore(CSmartPointer<IConfigInfo>&spConfigRun, int slot, int& status);
	void ReturnCardInfo(int slotNum, int status, CSmartPointer<IConfigInfo>&spConfigRun, SpReqAnsContext<CardIssuerStoreService_QueryCardInfoOnStore_Req, CardIssuerStoreService_QueryCardInfoOnStore_Ans>::Pointer ctx);
	void ClearLocalRecord(CSmartPointer<IConfigInfo>&spConfigRun);
	bool CheckHasPanKuRecord(CSmartPointer<IConfigInfo>&spConfigRun);
	void AfterPreOnlineOnStore(ErrorCodeEnum eErr,const int slot);
	int QueryCardInfoOnStore(SpReqAnsContext<CardIssuerStoreService_QueryCardInfoOnStore_Req, CardIssuerStoreService_QueryCardInfoOnStore_Ans>::Pointer ctx);
	void GetAddCardInfo(SpReqAnsContext<CardIssuerStoreService_GetAddCardInfo_Req, CardIssuerStoreService_GetAddCardInfo_Ans>::Pointer ctx);
	int PrintCardIm(SpReqAnsContext<CardIssuerStoreService_PrintCardImmediately_Req, CardIssuerStoreService_PrintCardImmediately_Ans>::Pointer ctx);
	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)("m_currentFSMState:%d", m_currentFSMState);
		return m_currentFSMState;
	}
	void GetCardInfo(int &findCard, int &cardPos)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<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);

	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<CardIssuerStoreService_QueryCIStatus_Req, CardIssuerStoreService_QueryCIStatus_Ans>::Pointer ctx);
	bool RegistCardWhileCaptureCard(CSimpleStringA cardno);
	bool SyncMaterialCount(IHttpFunc* client,SyncMaterialCountInfo syncInfo);
	bool CheckIsCrossPreOnline() { return m_bCrossPreOnline; }
	void ClearCrossPreOnlineFlag() { m_bCrossPreOnline = false; }
	bool IsInMainPage() {
		if (m_iInWhatPage == PageType_MainPage) {
			return true;
		}
		else {
			return false;
		}
	}
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_bChannelOK, m_bCancelByRFIC
		, m_bCardActiveNotify, m_bCardFromHopper, m_bUseCardnoMismatch, m_bStopUseRF, m_bNewAnsError;
	bool m_bUseRFTillNext;//if ReadCard by RF,the following PreOnline & PostOnline always use RF till the next card(insert/issue)
	bool m_bCrossPreOnline;
	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;
	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], m_bdk[64], m_ksn[64];
	CardIssuerStatus m_devStatus;
	CCardProcess *m_pCardProcess;
	CAutoArray<CSimpleStringA> m_aidList;
	pfEncryptDukptHSM EncypteDukptHSM;
	pfGetEncrypedData GetEncrypedData;
	char *m_pDataToARQC;
	long xxTest;
	CSimpleStringA m_currCardNo, m_captureReason, m_csMachineType, m_terminalNo,m_addCardNo,m_addCardSerial, m_rfVendorList, m_csRF;
	char m_AuthCode[2];
	vector<CMBBin> m_vBin;

	UINT64 m_crossStart;
	int m_bBTChecking;
	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 SetSlotFlag(int slot,bool bReset=false,bool bClear=false);
	void ClearAllLocalSlotInfo();
	bool LoadCMBPrint(CSimpleStringA csBinPath);
	DevCategoryInfo m_devCat;
	bool ToRegistCaptureCardInfo(CSimpleStringA currCardNo="");
	bool IfUseRf();
	CSimpleStringA m_csMagT2Track, m_csMagT3Track, m_csMagAccout, m_csMagRegion, m_csMagCardSerial, m_csMagCVC, m_csMagExpireDate;
	
	CSimpleStringA m_EacQueryHost, m_csSwallowCardUrl, m_csSyncMaterialUrl;
	MagTracks m_magTracks;
	vector<int> m_badSlot;
	std::map<std::string, JsonElem> m_mapJsonErr;
	//oilyang@20230504 尝试对厂商api返回的eErr做映射转换，如果在列表则用转换值，如果不再则保持原有厂商api转换逻辑
	DWORD TryMapAPIRetToUEC(ErrorCodeEnum eErr, DWORD dwApiCode, bool &bTrans)
	{
		bTrans = true;
		switch (eErr)
		{
		case Error_Dev_HopperHasNoCard:
			return CardIssuerStore_UserErrorCode_Dev_HopperHasNoCard;
		case Error_Dev_HopperMissing:
			return CardIssuerStore_UserErrorCode_Dev_HopperMissing;
		case Error_Dev_TransCarJammed:
			return CardIssuerStore_UserErrorCode_Dev_TransCarJammed;
		case Error_Dev_RetainBinFull:
			return CardIssuerStore_UserErrorCode_Dev_RetainBinFull;
		case Error_Dev_RetainBinMissing:
			return CardIssuerStore_UserErrorCode_Dev_RetainBinMissing;
		case Error_Dev_CardInReader:
			return CardIssuerStore_UserErrorCode_Dev_CardInReader;
		case Error_Dev_SlotHasNoCard:
			return CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard;
		case Error_Dev_CardInSlot:
			return CardIssuerStore_UserErrorCode_Dev_CardInSlot;
		case Error_Dev_NoCardInReader:
			return CardIssuerStore_UserErrorCode_Dev_NoCardInReader;
		case Error_Dev_CardJammed:
			return CardIssuerStore_UserErrorCode_Dev_CardJammed;
		case Error_Dev_SlotJammed:
			return CardIssuerStore_UserErrorCode_Dev_SlotJammed;
		case Error_Dev_SlotInvalid:
			return CardIssuerStore_UserErrorCode_Dev_SlotInvalid;
		default:
			bTrans = false;
			return dwApiCode;
		}
	}
	CSimpleStringA generateJsonString(std::map<std::string, JsonElem>& objectArr);
	bool IsInBusiness() const
	{
		return (m_bCrossPreOnline || m_iInWhatPage == PageType_Other);
	}

	void GetCardProcessLastErr(ErrorCodeEnum& eErrCode, CSimpleStringA& lastApiName,CSimpleStringA& alarmMsg,CSimpleStringA& csErrMsgWithReturnCode);

#pragma region JS接口具体实现方法
public:
	int EjectJS(SpReqAnsContext<CardIssuerStoreService_EjectJS_Req, CardIssuerStoreService_EjectJS_Ans>::Pointer ctx);

	int CaptureJS(SpReqAnsContext<CardIssuerStoreService_CaptureJS_Req, CardIssuerStoreService_CaptureJS_Ans>::Pointer ctx);

	int ReadBatchCardInfoInRangeJS(SpReqAnsContext<CardIssuerStoreService_ReadBatchCardInfoInRangeJS_Req, CardIssuerStoreService_ReadBatchCardInfoInRangeJS_Ans>::Pointer ctx);

	int GetCardInStoreJS(SpReqAnsContext<CardIssuerStoreService_GetCardInStoreJS_Req, CardIssuerStoreService_GetCardInStoreJS_Ans>::Pointer ctx);

	int AddAndReadCardFromBoxJS(SpReqAnsContext<CardIssuerStoreService_AddAndReadCardFromBoxJS_Req, CardIssuerStoreService_AddAndReadCardFromBoxJS_Ans>::Pointer ctx);

	int AddCardFromBoxJS(SpReqAnsContext<CardIssuerStoreService_AddCardFromBoxJS_Req, CardIssuerStoreService_AddCardFromBoxJS_Ans>::Pointer ctx);

	int MoveAndReadCardFromSlotJS(SpReqAnsContext<CardIssuerStoreService_MoveAndReadCardFromSlotJS_Req, CardIssuerStoreService_MoveAndReadCardFromSlotJS_Ans>::Pointer ctx);

	int MoveCardFromSlotJS(SpReqAnsContext<CardIssuerStoreService_MoveCardFromSlotJS_Req, CardIssuerStoreService_MoveCardFromSlotJS_Ans>::Pointer ctx);

	int MoveBacktoSlotJS(SpReqAnsContext<CardIssuerStoreService_MoveBacktoSlotJS_Req, CardIssuerStoreService_MoveBacktoSlotJS_Ans>::Pointer ctx);

	bool OperateNewCardStore(int slot, CSimpleStringA& addCardNo, CSimpleStringA& addCardSerial, int& status);

	//int IssueFromSlotJS(SpReqAnsContext<CardIssuerStoreService_IssueFromSlotJS_Req, CardIssuerStoreService_IssueFromSlotJS_Ans>::Pointer ctx);

	//void QueryInternalHasCardJS(SpReqAnsContext<CardIssuerStoreService_QueryInternalHasCardJS_Req, CardIssuerStoreService_QueryInternalHasCardJS_Ans>::Pointer ctx);
	void QueryHasCardJS(SpReqAnsContext<CardIssuerStoreService_QueryHasCardJS_Req, CardIssuerStoreService_QueryHasCardJS_Ans>::Pointer ctx);

	int WriteTrackJS(SpReqAnsContext<CardIssuerStoreService_WriteTrackJS_Req, CardIssuerStoreService_WriteTrackJS_Ans>::Pointer ctx);

	int PrintCardImmediatelyJS(SpReqAnsContext<CardIssuerStoreService_PrintCardImmediatelyJS_Req, CardIssuerStoreService_PrintCardImmediatelyJS_Ans>::Pointer ctx);

	//int SAMICCommandJS(SpReqAnsContext<CardIssuerStoreService_SAMICCommandJS_Req, CardIssuerStoreService_SAMICCommandJS_Ans>::Pointer ctx);

	int ICCommandJS(SpReqAnsContext<CardIssuerStoreService_ICCommandJS_Req, CardIssuerStoreService_ICCommandJS_Ans>::Pointer ctx);

	int PostOnlineJS(SpReqAnsContext<CardIssuerStoreService_PostOnlineJS_Req, CardIssuerStoreService_PostOnlineJS_Ans>::Pointer ctx);

	int IssueFromBoxJS(SpReqAnsContext<CardIssuerStoreService_IssueFromBoxJS_Req, CardIssuerStoreService_IssueFromBoxJS_Ans>::Pointer ctx);

	int PreOnlineCrossJS(SpReqAnsContext<CardIssuerStoreService_PreOnlineCrossJS_Req, CardIssuerStoreService_PreOnlineCrossJS_Ans>::Pointer ctx);

	int ReadJS(SpReqAnsContext<CardIssuerStoreService_ReadJS_Req, CardIssuerStoreService_ReadJS_Ans>::Pointer ctx);

#pragma endregion JS接口具体实现方法

#pragma region JS新增接口
	DWORD GetFsmStateErrCode();
	CSimpleStringA MaskCardno(const char* cardno);
	int PostOnlineJS_Contact(SpReqAnsContext<CardIssuerStoreService_PostOnlineJS_Req, CardIssuerStoreService_PostOnlineJS_Ans>::Pointer ctx, bool& bICOK);
	int PostOnlineJS_RF(SpReqAnsContext<CardIssuerStoreService_PostOnlineJS_Req, CardIssuerStoreService_PostOnlineJS_Ans>::Pointer ctx);

	int ReadMag(SpReqAnsContext<CardIssuerStoreService_ReadJS_Req, CardIssuerStoreService_ReadJS_Ans>::Pointer ctx,bool& bReadCardInfo,bool& bReadMag,CSimpleStringA& t2Account);
	int CheckCardType(CSimpleStringA cardNo,bool bReadMag, int& ICtype);
	int PreOnlineJS_Contact(SpReqAnsContext<CardIssuerStoreService_ReadJS_Req, CardIssuerStoreService_ReadJS_Ans>::Pointer ctx, bool& bICOK, bool& bContinue);
	int PreOnlineJS_RF(SpReqAnsContext<CardIssuerStoreService_ReadJS_Req, CardIssuerStoreService_ReadJS_Ans>::Pointer ctx);

	bool AfterPreOnlineCrossJS(const int slot, CSimpleStringA cardNo);
	int PreOnlineCrossJS_Contact(SpReqAnsContext<CardIssuerStoreService_PreOnlineCrossJS_Req, CardIssuerStoreService_PreOnlineCrossJS_Ans>::Pointer ctx, bool& bICOK, bool& bContinue, bool& CaptureResult);
	int PreOnlineCrossJS_RF(SpReqAnsContext<CardIssuerStoreService_PreOnlineCrossJS_Req, CardIssuerStoreService_PreOnlineCrossJS_Ans>::Pointer ctx, bool& CaptureResult);

	int QuickSelfCheckImpl();
	void setQuickSelfCheck() {
		m_quickSelfcheck = true;
	}
	bool SetCardCapturedJS(const int num, bool bNewClear = false);
	void SetDoExitFlag(bool bFlag) { m_bDoExit = bFlag; }

	virtual void OnStateTrans(int iSrcState, int iDstState);

	CSimpleStringA getRTACode(DWORD dwUserCode) {
		CSimpleStringA rtaMsg = this->GetEntityBase()->GetFunction()->UserCodeToRTACode(dwUserCode);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("rtaMsg=%s", rtaMsg.GetData());
		return rtaMsg;
	}
#pragma endregion JS新增接口

#pragma region JS新增字段
private:
	bool m_quickSelfcheck;
	bool m_bDoExit;
public:
	int  m_SelfcheckSleepTime;
#pragma endregion JS新增字段

};
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 IssueTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_IssueEx_Req, CardIssuerStoreService_IssueEx_Ans>::Pointer ctxEx;
	IssueTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent* e;
		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(ctxEx);
		fsm->PostEventFIFO(e);
	}
};
struct QueryCardInfoOnStoreTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_QueryCardInfoOnStore_Req, CardIssuerStoreService_QueryCardInfoOnStore_Ans>::Pointer ctx;
	QueryCardInfoOnStoreTask(CCardIssuerFSM* f) : fsm(f){}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent* e;
		if(ctx != NULL)
			e = new FSMEvent(USER_EVT_QUERYCARDINFO_ON_STORE_FINISHED);
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("QueryCardInfoOnStoreTask: ctx is null");
			return;
		}
		e->param1 = fsm->QueryCardInfoOnStore(ctx);
		fsm->PostEventFIFO(e);
	}
};

struct ReadTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerStoreService_Read_Req,CardIssuerStoreService_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<CardIssuerStoreService_PreOnline_Req,CardIssuerStoreService_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->ClearCrossPreOnlineFlag();//清除联机状态
		fsm->PostEventFIFO(e);
	}
};
struct PostOnlineTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerStoreService_PostOnline_Req,CardIssuerStoreService_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<CardIssuerStoreService_Capture_Req,CardIssuerStoreService_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<CardIssuerStoreService_Eject_Req,CardIssuerStoreService_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<CardIssuerStoreService_WriteTrack_Req,CardIssuerStoreService_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();
		fsm->SetDoExitFlag(false);
	}
};
struct SAMICCommandTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_SAMICCommand_Req, CardIssuerStoreService_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 PrintCardImTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_PrintCardImmediately_Req, CardIssuerStoreService_PrintCardImmediately_Ans>::Pointer ctx;
	PrintCardImTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_PRINT_CARD_IM_FINISHED);
		e->param1 = fsm->PrintCardIm(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();
	}
};

#pragma region JS接口 工作线程
//吐卡
struct EjectJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_EjectJS_Req, CardIssuerStoreService_EjectJS_Ans>::Pointer ctx;
	EjectJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_EJECT_FINISHED);
		e->param1 = fsm->EjectJS(ctx);
		fsm->PostEventFIFO(e);
	}
};
//吞卡
struct CaptureJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_CaptureJS_Req, CardIssuerStoreService_CaptureJS_Ans>::Pointer ctx;
	CaptureJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_CAPTURE_FINISHED);
		e->param1 = fsm->CaptureJS(ctx);
		fsm->PostEventFIFO(e);
	}
};
//盘库
struct ReadBatchCardInfoInRangeJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_ReadBatchCardInfoInRangeJS_Req, CardIssuerStoreService_ReadBatchCardInfoInRangeJS_Ans>::Pointer ctx;
	ReadBatchCardInfoInRangeJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_READ_BATCHCARDINFO_IN_RANGE_FINISHED);
		e->param1 = fsm->ReadBatchCardInfoInRangeJS(ctx);
		fsm->PostEventFIFO(e);
	}
};
//加卡读卡
struct AddAndReadCardFromBoxJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_AddAndReadCardFromBoxJS_Req, CardIssuerStoreService_AddAndReadCardFromBoxJS_Ans>::Pointer ctx;
	AddAndReadCardFromBoxJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_ADD_AND_READ_CRAD_FROMBOX_FINISHED);
		e->param1 = fsm->AddAndReadCardFromBoxJS(ctx);
		fsm->PostEventFIFO(e);
	}
};
//加卡箱移卡
struct AddCardFromBoxJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_AddCardFromBoxJS_Req, CardIssuerStoreService_AddCardFromBoxJS_Ans>::Pointer ctx;
	AddCardFromBoxJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_ADD_CRAD_FROMBOX_FINISHED);
		e->param1 = fsm->AddCardFromBoxJS(ctx);
		fsm->PostEventFIFO(e);
	}
};

//卡槽移卡读卡
struct MoveAndReadCardFromSlotJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_MoveAndReadCardFromSlotJS_Req, CardIssuerStoreService_MoveAndReadCardFromSlotJS_Ans>::Pointer ctx;
	MoveAndReadCardFromSlotJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_MOVE_AND_READ_CARD_FROMSLOT_FINISHED);
		e->param1 = fsm->MoveAndReadCardFromSlotJS(ctx);
		fsm->PostEventFIFO(e);
	}
};

//卡槽移卡
struct MoveCardFromSlotJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_MoveCardFromSlotJS_Req, CardIssuerStoreService_MoveCardFromSlotJS_Ans>::Pointer ctx;
	MoveCardFromSlotJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_MOVE_CARD_FROMSLOT_FINISHED);
		e->param1 = fsm->MoveCardFromSlotJS(ctx);
		fsm->PostEventFIFO(e);
	}
};

//移回卡槽
struct MoveBacktoSlotJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_MoveBacktoSlotJS_Req, CardIssuerStoreService_MoveBacktoSlotJS_Ans>::Pointer ctx;
	MoveBacktoSlotJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_MOVEBACK_TO_SLOT_FINISHED);
		e->param1 = fsm->MoveBacktoSlotJS(ctx);
		fsm->PostEventFIFO(e);
	}
};
//卡库领卡
//struct IssueFromSlotJSTask : public ITaskSp
//{
//	CCardIssuerFSM* fsm;
//	SpReqAnsContext<CardIssuerStoreService_IssueFromSlotJS_Req, CardIssuerStoreService_IssueFromSlotJS_Ans>::Pointer ctx;
//	IssueFromSlotJSTask(CCardIssuerFSM* f) : fsm(f) {}
//	void Process()
//	{
//		FSMEvent* e = new FSMEvent(USER_EVT_JS_ISSUE_FROM_SLOT_FINISHED);
//		e->param1 = fsm->IssueFromSlotJS(ctx);
//		fsm->PostEventFIFO(e);
//	}
//};

//写卡
struct WriteTrackJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_WriteTrackJS_Req, CardIssuerStoreService_WriteTrackJS_Ans>::Pointer ctx;
	WriteTrackJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_WRITE_TRACK_FINISHED);
		e->param1 = fsm->WriteTrackJS(ctx);
		fsm->PostEventFIFO(e);
	}
};
//打印
struct PrintCardImmediatelyJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_PrintCardImmediatelyJS_Req, CardIssuerStoreService_PrintCardImmediatelyJS_Ans>::Pointer ctx;
	PrintCardImmediatelyJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_WRITE_TRACK_FINISHED);
		e->param1 = fsm->PrintCardImmediatelyJS(ctx);
		fsm->PostEventFIFO(e);
	}
};
//IC交互
//struct SAMICCommandJSTask : public ITaskSp
//{
//	CCardIssuerFSM* fsm;
//	SpReqAnsContext<CardIssuerStoreService_SAMICCommandJS_Req, CardIssuerStoreService_SAMICCommandJS_Ans>::Pointer ctx;
//	SAMICCommandJSTask(CCardIssuerFSM* f) : fsm(f) {}
//	void Process()
//	{
//		FSMEvent* e = new FSMEvent(USER_EVT_JS_WRITE_TRACK_FINISHED);
//		e->param1 = fsm->SAMICCommandJS(ctx);
//		fsm->PostEventFIFO(e);
//	}
//};

//IC交互
struct ICCommandJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_ICCommandJS_Req, CardIssuerStoreService_ICCommandJS_Ans>::Pointer ctx;
	ICCommandJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_SAM_IC_COMMAND_FINISHED);
		e->param1 = fsm->ICCommandJS(ctx);
		fsm->PostEventFIFO(e);
	}
};

//联机后处理
struct PostOnlineJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_PostOnlineJS_Req, CardIssuerStoreService_PostOnlineJS_Ans>::Pointer ctx;
	PostOnlineJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_POSTONLINE_FINISHED);
		e->param1 = fsm->PostOnlineJS(ctx);
		fsm->PostEventFIFO(e);
	}
};
//卡箱发卡
struct IssueFromBoxJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_IssueFromBoxJS_Req, CardIssuerStoreService_IssueFromBoxJS_Ans>::Pointer ctx;
	IssueFromBoxJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_ISSUE_FROM_BOX_FINISHED);
		e->param1 = fsm->IssueFromBoxJS(ctx);
		fsm->PostEventFIFO(e);
	}
};
//跨机激活
struct PreOnlineCrossJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_PreOnlineCrossJS_Req, CardIssuerStoreService_PreOnlineCrossJS_Ans>::Pointer ctx;
	PreOnlineCrossJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_PREONLINE_CROSS_FINISHED);
		e->param1 = fsm->PreOnlineCrossJS(ctx);
		
		fsm->PostEventFIFO(e);
	}
};
//读卡
struct ReadJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_ReadJS_Req, CardIssuerStoreService_ReadJS_Ans>::Pointer ctx;
	ReadJSTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_JS_READ_FINISHED);
		e->param1 = fsm->ReadJS(ctx);
		fsm->PostEventFIFO(e);
	}
};

//故障自检task
struct QuickSelfcheckTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	QuickSelfcheckTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		QuickSelfcheckFinishEvent* e = new QuickSelfcheckFinishEvent();
		Sleep(fsm->m_SelfcheckSleepTime);
		e->param1 = fsm->QuickSelfCheckImpl();
		fsm->PostEventFIFO(e);
	}
};

struct GetCardInStoreJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_GetCardInStoreJS_Req, CardIssuerStoreService_GetCardInStoreJS_Ans>::Pointer ctx;
	GetCardInStoreJSTask(CCardIssuerFSM* f) : fsm(f) { ctx = NULL; }
	void Process()
	{
		if (ctx != NULL) {
			fsm->GetCardInStoreJS(ctx);
		}
	}
};

struct QueryHasCardJSTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerStoreService_QueryHasCardJS_Req, CardIssuerStoreService_QueryHasCardJS_Ans>::Pointer ctx;
	QueryHasCardJSTask(CCardIssuerFSM* f) : fsm(f) { ctx = NULL; }
	void Process()
	{
		if (ctx != NULL) {
			fsm->QueryHasCardJS(ctx);
		}
	}
};


#pragma endregion JS接口 工作线程

#endif //__CARD_ISSUER_FSM_H