myvtm/Module/mod_IDCertificate/mod_IDCertificate.h

#ifndef MOD_IDCERTIFICATE_H
#define MOD_IDCERTIFICATE_H

#include "modVer.h"
#include "IDCertFSM.h"
#include "IDCertificate_server_g.h"
#include "SpTest.h"

class CIDCertEntity;

class IDCertServerSession : public IDCertificate::IDCertService_ServerSessionBase
{
public:
	IDCertServerSession(CIDCertEntity* pEntity) : m_pEntity(pEntity){}
	virtual ~IDCertServerSession(){}
	virtual void Handle_Read(SpReqAnsContext<IDCert_Read_Req,IDCert_Read_Ans>::Pointer ctx);
	virtual void Handle_CancelRead(SpOnewayCallContext<IDCert_CancelRead_Info>::Pointer ctx);
	virtual void Handle_GetDevInfo(SpReqAnsContext<IDCert_GetDevInfo_Req, IDCert_GetDevInfo_Ans>::Pointer ctx);
	virtual void Handle_ReadWaitMore(SpOnewayCallContext<IDCert_ReadWaitMore_Info>::Pointer ctx);
	virtual void Handle_Exit(SpOnewayCallContext<IDCert_Exit_Info>::Pointer ctx);
	virtual void Handle_ReadEx(SpReqAnsContext<IDCert_ReadEx_Req, IDCert_ReadEx_Ans>::Pointer ctx);
	virtual void Handle_Eject(SpReqAnsContext<IDCert_Eject_Req, IDCert_Eject_Ans>::Pointer ctx);
	virtual void Handle_ReadAndScan(SpReqAnsContext<IDCert_ReadAndScan_Req, IDCert_ReadAndScan_Ans>::Pointer ctx);
	virtual void Handle_CrossTermCall(SpReqAnsContext<IDCert_CrossTermCall_Req, IDCert_CrossTermCall_Ans>::Pointer ctx);
	virtual void Handle_CrossTermInvokeInfo(SpOnewayCallContext<IDCert_CrossTermInvokeInfo_Info>::Pointer ctx);
private:
	CIDCertEntity* m_pEntity;
};
class CIDCertEntity : public CDevAdptEntityBase
{
public:
	CIDCertEntity(){}
	virtual ~CIDCertEntity(){}
	virtual const char *GetEntityName() const { return "IDCertificate"; }

	const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

	ON_ENTITYT_TEST();

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		LOG_FUNCTION();

		ErrorCodeEnum rt = m_fsm.Init(this);
		Dbg("Init FSM:%s", SpStrError(rt));
		pTransactionContext->SendAnswer(rt);
	}

	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		m_fsm.OnExit();
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	virtual void OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		m_fsm.SelfTest(eTestType,pTransactionContext);
	}

	virtual CServerSessionBase* OnNewSession(const char*,const char*)
	{
		return new IDCertServerSession(this);
	}
	void Read(SpReqAnsContext<IDCert_Read_Req, IDCert_Read_Ans>::Pointer ctx)
	{
		if (m_fsm.IsRVCIL())
		{
			CBlob bbSend;
			ErrorCodeEnum eErr = SpObject2Blob(ctx->Req, bbSend);
			Dbg("GetRequestId:%d,SpObject2Blob %x,len:%d", ctx->GetRequestId(), eErr, bbSend.m_iLength);
			m_fsm.SaveCtx(IDCertService_Method_Read, ctx);
			ctx.AddRef();
			m_fsm.LocalCallHeartBeat(IDCertService_Method_Read, bbSend,true);
		}
		else
		{
			ReadEvent* e = new ReadEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}

	}
	void CancelRead(SpOnewayCallContext<IDCert_CancelRead_Info>::Pointer ctx)
	{
		if (m_fsm.IsRVCIL())
		{
			CBlob bbSend;
			m_fsm.LocalCallHeartBeat(IDCertService_Method_CancelRead, bbSend);
		}
		else
		{
			CancelReadEvent* e = new CancelReadEvent();
			m_fsm.PostEventFIFO(e);
		}
	}
	void ReadWaitMore(SpOnewayCallContext<IDCert_ReadWaitMore_Info>::Pointer ctx)
	{
		if (m_fsm.IsRVCIL())
		{
			CBlob bbSend;
			m_fsm.LocalCallHeartBeat(IDCertService_Method_ReadWaitMore, bbSend);
		}
		else
		{
			if (m_fsm.GetReadFlag())
				m_fsm.SetReadMore();
		}
	}
	void Exit(SpOnewayCallContext<IDCert_Exit_Info>::Pointer ctx)
	{
		if (m_fsm.IsRVCIL())
		{
			CBlob bbSend;
			m_fsm.LocalCallHeartBeat(IDCertService_Method_Exit, bbSend);
		}
		else
		{
			FSMEvent *evt = new FSMEvent(USER_EVT_EXIT);
			m_fsm.PostEventFIFO(evt);
		}
	}
	void ReadEx(SpReqAnsContext<IDCert_ReadEx_Req, IDCert_ReadEx_Ans>::Pointer ctx)
	{
		if (m_fsm.GetDevInitFlag())
		{
			ReadExEvent* e = new ReadExEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}
		else
		{
			CBlob bbSend;
			ErrorCodeEnum eErr = SpObject2Blob(ctx->Req, bbSend);
			Dbg("GetRequestId:%d,SpObject2Blob %x,len:%d", ctx->GetRequestId(), eErr, bbSend.m_iLength);
			m_fsm.LocalCallHeartBeat(IDCertService_Method_ReadEx, bbSend,true);
		}
	}
	void Eject(SpReqAnsContext<IDCert_Eject_Req, IDCert_Eject_Ans>::Pointer ctx)
	{
		EjectEvent* e = new EjectEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}
	void ReadAndScan(SpReqAnsContext<IDCert_ReadAndScan_Req, IDCert_ReadAndScan_Ans>::Pointer ctx)
	{
		if (m_fsm.IsRVCIL())
		{
			CBlob bbSend;
			ErrorCodeEnum eErr = SpObject2Blob(ctx->Req, bbSend);
			Dbg("GetRequestId:%d,SpObject2Blob %x,len:%d", ctx->GetRequestId(), eErr, bbSend.m_iLength);
			m_fsm.SaveCtx(IDCertService_Method_ReadAndScan, ctx);
			ctx.AddRef();
			m_fsm.LocalCallHeartBeat(IDCertService_Method_ReadAndScan, bbSend,true);
		}
		else
		{
			ReadAndScanEvent* e = new ReadAndScanEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}

	}
	void CrossTermCall(SpReqAnsContext<IDCert_CrossTermCall_Req, IDCert_CrossTermCall_Ans>::Pointer ctx)
	{
		m_fsm.CrossTermCall(ctx);
	}
	void CrossTermInvokeInfo(SpOnewayCallContext<IDCert_CrossTermInvokeInfo_Info>::Pointer ctx)
	{
		m_fsm.CrossTermInvokeInfo(ctx);

	}
	void GetDevInfo(SpReqAnsContext<IDCert_GetDevInfo_Req, IDCert_GetDevInfo_Ans>::Pointer ctx)
	{
		DevCategoryInfo devCatInfo;
		CSimpleStringA devType = "";
		m_fsm.GetDevCatInfo(devCatInfo, devType);
		Dbg("devType:%s",(const char*)devType);
		ctx->Ans.model = devCatInfo.szModel;
		//oiltest
		//ctx->Ans.model = "idversion=2.0";
		Dbg("szModel:%s", (const char*)devCatInfo.szModel);
		ctx->Ans.type = devCatInfo.szType;
		Dbg("szType:%s", (const char*)devCatInfo.szType);
		ctx->Ans.type += ((devType == "4") ? "#IG" : "#");//如果版本号为4，说明是嵌入式多合一(目前也有可能是新大机20190910@zjw)，郭丹再判断机型是PAD，说明是PAD+嵌入式多合一，则读完证后不调用吐卡操作
		Dbg("%s", (const char*)ctx->Ans.type);
		if (ctx->Ans.model.GetLength() < 256)
			Dbg("%s", (const char*)ctx->Ans.model);
		ctx->Answer(Error_Succeed);
	}

	virtual bool IsService()const{return true;}
	virtual bool IsMultiThread()const{return false;}
protected:
	CIDCertFSM m_fsm;
};

#endif // MOD_IDCERTIFICATE_H