myvtm/Module/mod_CardIssuerStand/mod_cardissuerStand.h

#include "CardIssuerStand_server_g.h"
#include "CardIssuerStand_def_g.h"
#include "CardIssuerStandFSM.h"
#include "DevEntityCommBase.hpp"
using namespace CardIssuerStand;

class CCardIssuerEntity;

class CardIssuerServerSession : public CardIssuerStandService_ServerSessionBase
{
public:
	CardIssuerServerSession(CCardIssuerEntity* pEntity):m_pEntity(pEntity){}
	virtual ~CardIssuerServerSession(){}
	virtual void Handle_Insert(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx);
	virtual void Handle_Read(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx);
	virtual void Handle_Capture(SpReqAnsContext<CardIssuerStandService_Capture_Req, CardIssuerStandService_Capture_Ans>::Pointer ctx);
	virtual void Handle_Eject(SpReqAnsContext<CardIssuerStandService_Eject_Req, CardIssuerStandService_Eject_Ans>::Pointer ctx);
	virtual void Handle_CancelInsert(SpOnewayCallContext<CardIssuerStandService_CancelInsert_Info>::Pointer ctx);
	virtual void Handle_InsertWaitMore(SpOnewayCallContext<CardIssuerStandService_InsertWaitMore_Info>::Pointer ctx);
	virtual void Handle_PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx);
	virtual void Handle_PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx);
	virtual void Handle_Exit(SpOnewayCallContext<CardIssuerStandService_Exit_Info>::Pointer ctx);
	virtual void Handle_SetIssueFlag(SpOnewayCallContext<CardIssuerStandService_SetIssueFlag_Info>::Pointer ctx);
	virtual void Handle_QueryCardInfo(SpReqAnsContext<CardIssuerStandService_QueryCardInfo_Req, CardIssuerStandService_QueryCardInfo_Ans>::Pointer ctx);
	virtual void Handle_WriteTrack(SpReqAnsContext<CardIssuerStandService_WriteTrack_Req, CardIssuerStandService_WriteTrack_Ans>::Pointer ctx);
	virtual void Handle_GetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_GetMaterialCountEx_Req, CardIssuerStandService_GetMaterialCountEx_Ans>::Pointer ctx);
	virtual void Handle_SetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_SetMaterialCountEx_Req, CardIssuerStandService_SetMaterialCountEx_Ans>::Pointer ctx);
	virtual void Handle_SetSomeFlag(SpReqAnsContext<CardIssuerStandService_SetSomeFlag_Req, CardIssuerStandService_SetSomeFlag_Ans>::Pointer ctx);
	virtual void Handle_IssueEx(SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctx);
	virtual void Handle_SAMICCommand(SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx);
	virtual void Handle_QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx);
	virtual void Handle_GetDevInfo(SpReqAnsContext<CardIssuerStandService_GetDevInfo_Req, CardIssuerStandService_GetDevInfo_Ans>::Pointer ctx);

	//JS接口定义
	virtual void Handle_ReadJS(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx);
	virtual void Handle_PostOnlineJS(SpReqAnsContext<CardIssuerStandService_PostOnlineJS_Req, CardIssuerStandService_PostOnlineJS_Ans>::Pointer ctx);
	virtual void Handle_EjectJS(SpReqAnsContext<CardIssuerStandService_EjectJS_Req, CardIssuerStandService_EjectJS_Ans>::Pointer ctx);
	virtual void Handle_CaptureJS(SpReqAnsContext<CardIssuerStandService_CaptureJS_Req, CardIssuerStandService_CaptureJS_Ans>::Pointer ctx);
	virtual void Handle_QueryHasCardJS(SpReqAnsContext<CardIssuerStandService_QueryHasCardJS_Req, CardIssuerStandService_QueryHasCardJS_Ans>::Pointer ctx);
	virtual void Handle_IssueFromBoxJS(SpReqAnsContext<CardIssuerStandService_IssueFromBoxJS_Req, CardIssuerStandService_IssueFromBoxJS_Ans>::Pointer ctx);
	virtual void Handle_InsertJS(SpReqAnsContext<CardIssuerStandService_InsertJS_Req, CardIssuerStandService_InsertJS_Ans>::Pointer ctx);
	virtual void Handle_CancelInsertJS(SpOnewayCallContext<CardIssuerStandService_CancelInsertJS_Info>::Pointer ctx);

private:
	CCardIssuerEntity* m_pEntity;
};

class CCardIssuerEntity : public CDevAdptEntityBase, public ISysVarListener
{
public:
	CCardIssuerEntity() :bInitialized(false)
	{
	}
	virtual ~CCardIssuerEntity(){}
	virtual const char *GetEntityName() const { return "CardIssuerStand"; }
	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		LOG_FUNCTION();
		ErrorCodeEnum eStart = m_fsm.Init(this);
		if (eStart == Error_Succeed)
		{
		}
		GetFunction()->RegistSysVarEvent("UIState", this);
		pTransactionContext->SendAnswer(eStart);
	}

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		ErrorCodeEnum Error = __OnStart(Error_Succeed);
		pTransactionContext->SendAnswer(Error);
	}

	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		ErrorCodeEnum Error = __OnPause(Error_Succeed,pTransactionContext);
		pTransactionContext->SendAnswer(Error); 
	}
	virtual ErrorCodeEnum __OnStart(ErrorCodeEnum preOperationError)
	{	
		return Error_Succeed;
	}
	virtual ErrorCodeEnum __OnPause(ErrorCodeEnum preOperationError, CSmartPointer<ITransactionContext> pTransactionContext)
	{
		return Error_Succeed;
	}
	virtual ErrorCodeEnum __OnClose(ErrorCodeEnum preOperationError)
	{
		return Error_Succeed;
	}
	virtual void OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		m_fsm.SelfTest(eTestType,pTransactionContext);
	}
	virtual CServerSessionBase* OnNewSession(const char*,const char*)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("A new connecting request arrived.");
		m_bNewSessionInit = true;
		return new CardIssuerServerSession(this);
	}

	void Insert(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if(!m_fsm.GetDevInitFlag()){
			ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
			LogWarn(Severity_Middle, Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed, "Insert but DevOpen failed.");
		}else{
			m_bNewSessionInit = false;
			m_fsm.SetExitFlag(false);
			CardAcceptEvent *e = new CardAcceptEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}
	}

	void Read(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		CardReadEvent* e = new CardReadEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}
	void Capture(SpReqAnsContext<CardIssuerStandService_Capture_Req, CardIssuerStandService_Capture_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		CardCaptureEvent* e = new CardCaptureEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}

	void Eject(SpReqAnsContext<CardIssuerStandService_Eject_Req, CardIssuerStandService_Eject_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		CardEjectEvent* e = new CardEjectEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}
	void CancelInsert(SpOnewayCallContext<CardIssuerStandService_CancelInsert_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		CancelAcceptEvent *e = new CancelAcceptEvent();
		m_fsm.PostEventFIFO(e);
	}
	void InsertWaitMore(SpOnewayCallContext<CardIssuerStandService_InsertWaitMore_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (m_fsm.GetWaitFlag())
			m_fsm.SetWaitMore();
	}
	void Issue(SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		m_bNewSessionInit = false;
		CardIssueEvent *pEvt = new CardIssueEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
		}
		else {
			if (ctx->Req.reserved1.GetLength() > 0 && strnicmp("kaku#", (const char*)ctx->Req.reserved1, 5) == 0)
			{
				int state = m_fsm.GetFSMState();
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("PreOnline m_currentFSMState:%d", state));
				if (state == 9)
				{
					ctx->Answer(Error_BridgeNotOK);
					return;
				}
				else if (state != 2)
				{
					ctx->Answer(Error_InvalidState);
					return;
				}
			}
			PreOnlineEvent* e = new PreOnlineEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}
	}
	void PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		PostOnlineEvent* e = new PostOnlineEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}
	void Exit(SpOnewayCallContext<CardIssuerStandService_Exit_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		m_bNewSessionInit = false;
		FSMEvent *evt = new FSMEvent(USER_EVT_EXIT);
		m_fsm.PostEventFIFO(evt);
	}
	void QueryCardInfo(SpReqAnsContext<CardIssuerStandService_QueryCardInfo_Req, CardIssuerStandService_QueryCardInfo_Ans>::Pointer ctx)
	{
		if (m_bNewSessionInit)
		{
			FSMEvent *pEvt = new FSMEvent(USER_EVT_EXIT);
			m_fsm.PostEventFIFO(pEvt);
			ctx->Ans.position = CI_MEDIA_NOTPRESENT;
			ctx->Answer(Error_Succeed);
		}
		else
		{
			ctx->Ans.position = m_fsm.QueryCardInfo();
			ctx->Answer(Error_Succeed);
		}
	}
	void WriteTrack(SpReqAnsContext<CardIssuerStandService_WriteTrack_Req, CardIssuerStandService_WriteTrack_Ans>::Pointer ctx)
	{
		CardWriteEvent *pEvt = new CardWriteEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void SetIssueFlag(SpOnewayCallContext<CardIssuerStandService_SetIssueFlag_Info>::Pointer ctx){ m_fsm.FrontSetIssueFlag(true); }
	void GetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_GetMaterialCountEx_Req, CardIssuerStandService_GetMaterialCountEx_Ans>::Pointer ctx)
	{
		m_bNewSessionInit = false;
		GetMaterialExEvent *pEvt = new GetMaterialExEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void SetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_SetMaterialCountEx_Req, CardIssuerStandService_SetMaterialCountEx_Ans>::Pointer ctx)
	{
		m_bNewSessionInit = false;
		SetMaterialExEvent *pEvt = new SetMaterialExEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void SetSomeFlag(SpReqAnsContext<CardIssuerStandService_SetSomeFlag_Req, CardIssuerStandService_SetSomeFlag_Ans>::Pointer ctx)
	{
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("set issue flag to %d", ctx->Req.IssueBusiness);
		if (ctx->Req.IssueBusiness == 1)
			m_fsm.FrontSetIssueFlag(true);
		else if (ctx->Req.IssueBusiness == 0)
			m_fsm.FrontSetIssueFlag(false);
		else if (ctx->Req.IssueBusiness == 2)//oilyang@20170621 query issue direction
		{
			ctx->Ans.reserved1.Init(1);
			ctx->Ans.reserved1[0] = (m_fsm.QueryIssueFlag() ? 0 : 1);//according to yzx
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("issue direction:%d",ctx->Ans.reserved1[0]);//if 0 capture card eles eject card
		}
		else if (ctx->Req.IssueBusiness == 3)//oilyang@20181210 
		{
			m_fsm.SetCancelByRFICFlag();
		}
		else if (ctx->Req.IssueBusiness == 4)//oilyang@20181220 get ic card account,for simple/lazy...
		{
			ctx->Ans.reserved2.Init(1);
			ctx->Ans.reserved2[0] = m_fsm.GetPreOnlineICCardNo();
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("GetPreOnlineICCardNo:%d", ctx->Ans.reserved2[0].GetLength());
		}
		if (ctx->Req.reserved1.GetCount() > 0)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("set hopper num:%d",ctx->Req.reserved1[0]);
			if (ctx->Req.reserved1[0] == 1)
				m_fsm.SetHopperNum(1);
			else if (ctx->Req.reserved1[0] == 3)
				m_fsm.SetHopperNum(3);
		}
		ctx->Answer(Error_Succeed);

	}
	void IssueEx(SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		int state = m_fsm.GetFSMState();

		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
		}
		else if (state == 9) {
			ctx->Answer(Error_InvalidState, CardIssuer_UserErrorCode_StandEntityInFailState);
		}
		else {
			m_bNewSessionInit = false;
			CardIssueExEvent* pEvt = new CardIssueExEvent();
			pEvt->ctx = ctx;
			m_fsm.PostEventFIFO(pEvt);
		}
	}
	void SAMICCommand(SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		SAMICCommandEvent *pEvt = new SAMICCommandEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void GetDevInfo(SpReqAnsContext<CardIssuerStandService_GetDevInfo_Req, CardIssuerStandService_GetDevInfo_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		ctx->Ans.state = m_fsm.GetDevState();
		

		if (m_fsm.GetDevInitingFlag()) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevInfo device is opening,state return 0");
			ctx->Ans.state = DEVICE_STATUS_NOT_READY;
			ctx->Answer(Error_NotInit, CardIssuer_UserErrorCode_DevOpen_Failed);
		}
		else {
			//设备未正常打开时，直接报state=0;
			if (!m_fsm.GetDevInitFlag()) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevInfo device is not open,state return 0");
				ctx->Ans.state = DEVICE_STATUS_NOT_READY;
				ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
			}
			else {
				if (ctx->Ans.state != DEVICE_STATUS_NORMAL) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevInfo state=%d", ctx->Ans.state);
				}
				ctx->Answer(Error_Succeed);
			}
		}
	}
	void QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx)
	{
		m_fsm.QueryCIStatus(ctx);
	}
	virtual void OnSysVarEvent(const char* pszKey, const char* pszValue, const char* pszOldValue, const char* pszEntityName);
	virtual bool IsService()const{return true;}
	virtual bool IsMultiThread()const{return true;}

	//JS接口实现
	void ReadJS(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
		}
		else if (_stricmp(m_fsm.GetCurrStateName(), "Hold") != 0) {
			DWORD errCode = m_fsm.GetFsmStateErrCode();
			int state = m_fsm.GetFSMState();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(m_fsm.getRTACode(errCode))("ReadJS req is unhandled ,CurrState=%d", state);
			ctx->Answer(Error_Unexpect, errCode);
		}
		else {
			ReadJSEvent* pEvt = new ReadJSEvent();
			pEvt->ctx = ctx;
			m_fsm.PostEventFIFO(pEvt);
		}

	}
	void PostOnlineJS(SpReqAnsContext<CardIssuerStandService_PostOnlineJS_Req, CardIssuerStandService_PostOnlineJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
		}
		else if (_stricmp(m_fsm.GetCurrStateName(), "Hold") != 0) {
			DWORD errCode = m_fsm.GetFsmStateErrCode();
			int state = m_fsm.GetFSMState();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(m_fsm.getRTACode(errCode))("PostOnlineJS req is unhandled ,CurrState=%d", state);
			ctx->Answer(Error_Unexpect, errCode);
		}
		else {
			PostOnlineJSEvent* pEvt = new PostOnlineJSEvent();
			pEvt->ctx = ctx;
			m_fsm.PostEventFIFO(pEvt);
		}

	}
	void EjectJS(SpReqAnsContext<CardIssuerStandService_EjectJS_Req, CardIssuerStandService_EjectJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
		}
		else if (_stricmp(m_fsm.GetCurrStateName(), "Hold") != 0) {
			DWORD errCode = m_fsm.GetFsmStateErrCode();
			int state = m_fsm.GetFSMState();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(m_fsm.getRTACode(errCode))("EjectJS req is unhandled ,CurrState=%d", state);
			ctx->Answer(Error_Unexpect, errCode);
		}
		else {
			EjectJSEvent* e = new EjectJSEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}

	}
	void CaptureJS(SpReqAnsContext<CardIssuerStandService_CaptureJS_Req, CardIssuerStandService_CaptureJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
		}
		else if (_stricmp(m_fsm.GetCurrStateName(), "Hold") == 0 || _stricmp(m_fsm.GetCurrStateName(), "Idle") == 0) {
			CaptureJSEvent* e = new CaptureJSEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}
		else {
			DWORD errCode = m_fsm.GetFsmStateErrCode();
			int state = m_fsm.GetFSMState();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(m_fsm.getRTACode(errCode))("CaptureJS req is unhandled ,CurrState=%d", state);
			ctx->Answer(Error_Unexpect, errCode);
		}

	}
	void QueryHasCardJS(SpReqAnsContext<CardIssuerStandService_QueryHasCardJS_Req, CardIssuerStandService_QueryHasCardJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
		}
		else {
			m_fsm.QueryHasCardJS(ctx);
		}

	}
	void IssueFromBoxJS(SpReqAnsContext<CardIssuerStandService_IssueFromBoxJS_Req, CardIssuerStandService_IssueFromBoxJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
		}
		else if (_stricmp(m_fsm.GetCurrStateName(), "Idle") != 0) {
			DWORD errCode = m_fsm.GetFsmStateErrCode();
			int state = m_fsm.GetFSMState();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(m_fsm.getRTACode(errCode))("IssueFromBoxJS req is unhandled ,CurrState=%d", state);
			ctx->Answer(Error_Unexpect, errCode);
		}
		else {
			IssueFromBoxJSEvent* pEvt = new IssueFromBoxJSEvent();
			pEvt->ctx = ctx;
			m_fsm.PostEventFIFO(pEvt);
		}
	}
	void InsertJS(SpReqAnsContext<CardIssuerStandService_InsertJS_Req, CardIssuerStandService_InsertJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
		}
		else if (_stricmp(m_fsm.GetCurrStateName(), "Idle") != 0) {
			DWORD errCode = m_fsm.GetFsmStateErrCode();
			int state = m_fsm.GetFSMState();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(m_fsm.getRTACode(errCode))("InsertJS req is unhandled ,CurrState=%d", state);
			ctx->Answer(Error_Unexpect, errCode);
		}
		else {
			InsertJSEvent* pEvt = new InsertJSEvent();
			pEvt->ctx = ctx;
			m_fsm.PostEventFIFO(pEvt);
		}

	}
	void CancelInsertJS(SpOnewayCallContext<CardIssuerStandService_CancelInsertJS_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			LogWarn(Severity_Middle, Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed, "CancelInsertJS but DevOpen failed.");
		}
		else {
			CancelInsertJSEvent* evt = new CancelInsertJSEvent();
			m_fsm.PostEventFIFO(evt);
		}
	}

protected:
private:
	CCardIssuerFSM m_fsm;
	
	bool bInitialized,m_bNewSessionInit;
};