myvtm/Module/mod_IDCertificate/IDCertFSM.h

#ifndef IDCERTFSM_H
#define IDCERTFSM_H

#pragma once

#include "SpFSM.h"
#ifdef RVC_OS_LINUX
#include "SpTest.h"
#else //windows
#include "json/json.h"
#include <xstring>
#include "IHttpFunc.h"
#endif

#include <unordered_map>
#include "DevFSMCommBase.hpp"

#ifdef RVC_OS_WIN
#define REFLECTION(var) #var
typedef struct ImgCheckReq : CHTTPReq {
	string terminalNo;
	string name;
	string idNo;
	string nationality;
	string idType;
	string imageBase64;
	string fspId;
	int topN;
	int returnImgBase64;

	string ToJson() {
		Json::Value value;
		value[REFLECTION(terminalNo)] = terminalNo;
		value[REFLECTION(name)] = name;
		value[REFLECTION(idNo)] = idNo;
		value[REFLECTION(nationality)] = nationality;
		value[REFLECTION(idType)] = idType;
		value[REFLECTION(imageBase64)] = imageBase64;
		value[REFLECTION(fspId)] = fspId;
		value[REFLECTION(topN)] = topN;
		value[REFLECTION(returnImgBase64)] = returnImgBase64;
		Json::FastWriter writer;
		string strData = writer.write(value);

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("ImgCheckReq")
			("req=%s at ImgCheckReq", strData.c_str());

		return strData;
	}
} ImgCheckReq;

typedef struct ImgCheckRet : CHTTPRet {
	bool m_success;
	bool Parse(string strData) {
		Dbg("ImgCheckRet = %s", strData.c_str());
		Json::Value root;
		Json::Reader reader;
		reader.parse(strData, root, false);

		if (root["success"].isBool()) {
			m_success = root["success"].asBool();
		}
		else
		{
			m_success = false;
		}

		return true;
	}
} ImgCheckRet;
#endif

enum EvtType
{
	USER_EVT_TEST = EVT_USER + 1,
	USER_EVT_QUIT,
	USER_EVT_CANCEL_READ,
	USER_EVT_EXIT,
	USER_EVT_GET_DEVINFO,
	USER_EVT_ERROR,
	USER_EVT_EJECT,
	USER_EVT_WAIT_FETCH_IDCARD_FINISHED,
	USER_EVT_READ_AND_SCAN,
	USER_EVT_READ_AND_SCAN_FINISHED,
	USER_EVT_INIT_FINISHED,
	USER_EVT_TODO_INIT,
	USER_EVT_TODO_INIT_FINISHED,
	USER_EVT_READ_AND_SCAN_UTF8,             //ex1
	USER_EVT_READ_AND_SCAN_UTF8_FINISHED,
};
enum BmpType
{
	Bmp_ZP = 1,
	Bmp_SCAN = 2,
};

#include "IDCerClass.h"
#include "IDCertificate_def_g.h"
#pragma region forsonar
typedef IDCertificate::IDCertService_CancelRead_Info IDCert_CancelRead_Info;
typedef IDCertificate::IDCertService_ReadWaitMore_Info IDCert_ReadWaitMore_Info;
typedef IDCertificate::IDCertService_Exit_Info IDCert_Exit_Info;
typedef IDCertificate::IDCertService_Eject_Req IDCert_Eject_Req;
typedef IDCertificate::IDCertService_Eject_Ans IDCert_Eject_Ans;
typedef IDCertificate::IDCertService_ReadAndScan_Req IDCert_ReadAndScan_Req;
typedef IDCertificate::IDCertService_ReadAndScan_Ans IDCert_ReadAndScan_Ans;
typedef IDCertificate::IDCertService_ReadAndScanUTF8_Req IDCert_ReadAndScanUTF8_Req; //ex2
typedef IDCertificate::IDCertService_ReadAndScanUTF8_Ans IDCert_ReadAndScanUTF8_Ans;
typedef IDCertificate::IDCertService_GetDevInfo_Req IDCert_GetDevInfo_Req;
typedef IDCertificate::IDCertService_GetDevInfo_Ans IDCert_GetDevInfo_Ans;
#pragma endregion forsonar

#include <map>
using namespace std;

typedef ErrorCodeEnum ( *lpCreateDevCom)(DeviceBaseClass *&baseObj);
typedef ErrorCodeEnum ( *lpReleaseDevCom)(DeviceBaseClass *&pBaseObj);

struct CtxInfo
{
	int dataSize;
	LPVOID pCtx;
};

class CancelReadEvent : public FSMEvent
{
public:
	CancelReadEvent() : FSMEvent(USER_EVT_CANCEL_READ){}
	virtual ~CancelReadEvent(){}
	virtual void OnUnhandled()
	{
		LOG_TRACE("idcer cancel read not handled");
	}
};
class GetDevInfoEvent : public FSMEvent
{
public:
	GetDevInfoEvent() : FSMEvent(USER_EVT_GET_DEVINFO){}
	virtual ~GetDevInfoEvent(){}
	SpReqAnsContext<IDCert_GetDevInfo_Req, IDCert_GetDevInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class EjectEvent : public FSMEvent
{
public:
	EjectEvent() : FSMEvent(USER_EVT_EJECT){}
	virtual ~EjectEvent(){}
	SpReqAnsContext<IDCert_Eject_Req, IDCert_Eject_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class ReadAndScanEvent : public FSMEvent
{
public:
	ReadAndScanEvent() : FSMEvent(USER_EVT_READ_AND_SCAN) {}
	virtual ~ReadAndScanEvent() {}
	SpReqAnsContext<IDCert_ReadAndScan_Req, IDCert_ReadAndScan_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};

class ReadAndScanUTF8Event : public FSMEvent //ex3
{
public:
	ReadAndScanUTF8Event() : FSMEvent(USER_EVT_READ_AND_SCAN_UTF8) {}
	virtual ~ReadAndScanUTF8Event() {}
	SpReqAnsContext<IDCert_ReadAndScanUTF8_Req, IDCert_ReadAndScanUTF8_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};

class CIDCertFSM : public CCommDevFSM<CIDCertFSM, IDCerClass>
{
public:
	enum {s0,s1,s2,s3,s4,s5};

	BEGIN_FSM_STATE(CIDCertFSM)
		FSM_STATE_ENTRY(s0,"Normal",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1,"Reading",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2,"Fail",s2_on_entry,s2_on_exit,s2_on_event)
		FSM_STATE_ENTRY(s3, "Eject", s3_on_entry, s3_on_exit, s3_on_event)
		FSM_STATE_ENTRY(s4, "WaitingFetch", s4_on_entry, s4_on_exit, s4_on_event)
		FSM_STATE_ENTRY(s5, "Init", s5_on_entry, s5_on_exit, s5_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CIDCertFSM, s5)
		FSM_RULE_ENTRY(s0, s2, USER_EVT_ERROR, 0)
		FSM_RULE_ENTRY(s0, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_READ_AND_SCAN, 0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_READ_AND_SCAN_UTF8, 0) //ex4
		FSM_RULE_ENTRY(s0, s5, USER_EVT_TODO_INIT_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_READ_AND_SCAN_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_READ_AND_SCAN_FINISHED, 1)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_READ_AND_SCAN_FINISHED, 2)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_READ_AND_SCAN_FINISHED, 3)
		FSM_RULE_ENTRY(s1, s4, USER_EVT_READ_AND_SCAN_FINISHED, 4)
		FSM_RULE_ENTRY(s1, s5, USER_EVT_READ_AND_SCAN_FINISHED, 5)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_READ_AND_SCAN_UTF8_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_READ_AND_SCAN_UTF8_FINISHED, 1)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_READ_AND_SCAN_UTF8_FINISHED, 2)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_READ_AND_SCAN_UTF8_FINISHED, 3)
		FSM_RULE_ENTRY(s1, s4, USER_EVT_READ_AND_SCAN_UTF8_FINISHED, 4)
		FSM_RULE_ENTRY(s1, s5, USER_EVT_READ_AND_SCAN_UTF8_FINISHED, 5)
		FSM_RULE_ENTRY(s1, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_CANCEL_READ, 2)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_EXIT, 3)
		FSM_RULE_ENTRY(s2, s5, USER_EVT_TODO_INIT_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s0, USER_EVT_WAIT_FETCH_IDCARD_FINISHED, 0)
		FSM_RULE_ENTRY(s5, s0, USER_EVT_INIT_FINISHED, 0)
		FSM_RULE_ENTRY(s5, s2, USER_EVT_INIT_FINISHED, 2)
	END_FSM_RULE()

#ifdef RVC_OS_LINUX
		CIDCertFSM() :m_devInit(false), m_bCancelRead(false), m_bReading(false), m_bWaitReadMore(false),
		m_bExit(false), m_testResult(Error_Succeed), m_csMachineType(""), m_csSite(""), m_terminalNo(""), m_devSN("")
		, m_devVendor(""), m_devVer(""), m_devBatch(""), m_bRVCIL(false){
		HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x201);
		m_FirstStart = TRUE;
		ZeroMemory(&m_adapterInfo, sizeof(m_adapterInfo));
	};
#else
		CIDCertFSM():m_bCancelRead(false),m_bReading(false),m_bWaitReadMore(false),
	m_bExit(false),m_testResult(Error_Succeed), m_csMachineType(""), m_csSite(""), m_terminalNo("")
	,m_devVendor(""), m_devVer(""), m_devBatch(""), invalidBreak(false), m_logBefore(false), transImgMsg("")
	{
		HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x201);
	};
#endif // RVC_OS_LINUX
	virtual ~CIDCertFSM() {};

	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	virtual void s0_on_entry();
	virtual void s0_on_exit();
	virtual unsigned int s0_on_event(FSMEvent* e);

	virtual void s1_on_entry();
	virtual void s1_on_exit();
	virtual unsigned int s1_on_event(FSMEvent* e);

	virtual void s2_on_entry();
	virtual void s2_on_exit();
	virtual unsigned int s2_on_event(FSMEvent* e);
	virtual void s3_on_entry();
	virtual void s3_on_exit();
	virtual unsigned int s3_on_event(FSMEvent* e);
	virtual void s4_on_entry();
	virtual void s4_on_exit();
	virtual unsigned int s4_on_event(FSMEvent* e);
	virtual void s5_on_entry();
	virtual void s5_on_exit();
	virtual unsigned int s5_on_event(FSMEvent* e);

	int ReadAndScan(SpReqAnsContext<IDCert_ReadAndScan_Req, IDCert_ReadAndScan_Ans>::Pointer ctx);
	int ReadAndScanUTF8(SpReqAnsContext<IDCert_ReadAndScanUTF8_Req, IDCert_ReadAndScanUTF8_Ans>::Pointer ctx); 

	int WaitFetchIDCard();
	void SetReadMore(){m_bWaitReadMore = true;}
	void SetExitFlag(){m_bExit = true;}
	bool GetReadFlag(){return m_bReading;}
	ErrorCodeEnum GetDevCatInfo(DevCategoryInfo &devInfo, CSimpleStringA& devType);
	void GetDevState(DevStateEnum &devState){ devState = m_devState; }

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

#ifdef RVC_OS_WIN
	bool GetDevInitFlag() { return m_bOpened; }
	void ResetDevInitFlag() { m_bOpened = false; }
#else
	bool GetDevInitFlag() { return m_devInit; }
#endif

	template <class TReq,class TAns>
	void SaveCtx(int methodID, CSmartPointer<SpReqAnsContext<TReq, TAns> > ctx)
	{
		m_mapCtx[methodID].pCtx = static_cast<void*>(ctx.GetRawPointer());
	}
	void SaveCtxAA(int methodID, SpReqAnsContext<IDCert_ReadAndScan_Req, IDCert_ReadAndScan_Ans>::Pointer ctx)
	{
		m_readAndScanCtx = ctx;
	}
	void SaveCtxAAEx(int methodID, SpReqAnsContext<IDCert_ReadAndScanUTF8_Req, IDCert_ReadAndScanUTF8_Ans>::Pointer ctx)//UTF8
	{
		m_readAndScanUTF8Ctx = ctx;
	}
	LPVOID  GetCtx(int methodID) 
	{ 
		if (m_mapCtx.find(methodID) != m_mapCtx.end())
			return m_mapCtx[methodID].pCtx;
		else
			return NULL;
	}
	int Initial();
	void SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext);
	int ProcFWBReConn();
	bool IsRVCPAD() { return !m_csMachineType.Compare("RVC.PAD", true); }

	static void HttpsLogCallBack(const char* logtxt);
private:
	ErrorCodeEnum GetVendorDllPath(CSimpleStringA &strPath);
	ErrorCodeEnum GetPngBlob(CBlob &data,bool bClear=false);
	ErrorCodeEnum GetPngBlobEx(CBlob &data, CSimpleStringA fileNamePrefix,bool bClear=false);
	//type:1,delete img about zp; type:2,delete img about scan ID;type:3,delete both zp and scan ID
	void DeleteZP(int type);
	ErrorCodeEnum CheckDate(const char* date);
	ErrorCodeEnum CheckDate(const char* startDate, const char* endDate);
	void LogDate(IDCerInfo idInfo);
	void LogDateEx(IDCerInfoEx idInfo);

	//Delete bmp file in dep directory, you should just convey fileName only without paths -Joseph
	ErrorCodeEnum DeleteFileIfExisted(LPCTSTR fileName);
#ifdef RVC_OS_LINUX
	bool GetAttachedTerminal(CSimpleStringA& csTerm);
#else
	void ToLogWarnInfoAboutTermCustom();
#endif // RVC_OS_LINUX
	BOOL UCS2_to_UTF8(UINT16* ucs2_code, UINT8* utf8_code);
	BOOL GetSexUTF8String(UINT16* in, UINT8* out);
	BOOL GetNationalUTF8String(UINT16* in, UINT8* out);
	BOOL GetDateStandardFormatUTF8(UINT16* in, UINT8* out);
	BOOL RemoveUCS2Blank(UINT16* ucs2_code);
	void CheckHanZi(UINT16* ucs2_code);

private:
#ifdef RVC_OS_LINUX
	bool m_devInit, m_bRVCIL;
#endif
	bool m_bCancelRead, m_bReading, m_bWaitReadMore, m_bExit;
	ErrorCodeEnum m_testResult;
	DevCategoryInfo m_devCatInfo;
	DevStateEnum m_devState;
	CSimpleStringA m_csMachineType, m_csSite, m_terminalNo;
	CSimpleStringA m_devVendor, m_devVer, m_devBatch, m_devSN/*fwb SN*/;
	CSimpleStringA transImgMsg;
	map<int, CtxInfo> m_mapCtx;
	SpReqAnsContext<IDCert_ReadAndScan_Req, IDCert_ReadAndScan_Ans>::Pointer m_readAndScanCtx;
	SpReqAnsContext<IDCert_ReadAndScanUTF8_Req, IDCert_ReadAndScanUTF8_Ans>::Pointer m_readAndScanUTF8Ctx; //ex7
#ifdef RVC_OS_WIN
	unordered_map<int, wstring> nationalCode; 
#else
	unordered_map<int, string> nationalCode;
#endif
	BOOL supportUCS2; //Ö§³ÖÉúƧ×Ö
	BOOL igestionVer; //ÎüÈëʽÉ豸

	CSimpleStringA m_csAlarmMsg;

	bool invalidBreak;
	bool m_logBefore;
	ULLINT m_ullBeginTime, m_ullEndTime;
};

struct ReadAndScanTask : public ITaskSp
{
	CIDCertFSM* fsm;
	SpReqAnsContext<IDCert_ReadAndScan_Req, IDCert_ReadAndScan_Ans>::Pointer ctx;
	ReadAndScanTask(CIDCertFSM* f) : fsm(f) {}

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_READ_AND_SCAN_FINISHED);
		e->param1 = -1;
		e->param1 = fsm->ReadAndScan(ctx);
		fsm->PostEventFIFO(e);
	}
};

struct ReadAndScanUTF8Task : public ITaskSp  //ex8
{
	CIDCertFSM* fsm;
	SpReqAnsContext<IDCert_ReadAndScanUTF8_Req, IDCert_ReadAndScanUTF8_Ans>::Pointer ctx;
	ReadAndScanUTF8Task(CIDCertFSM* f) : fsm(f) {}

	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_READ_AND_SCAN_UTF8_FINISHED);
		e->param1 = -1;
		e->param1 = fsm->ReadAndScanUTF8(ctx);
		fsm->PostEventFIFO(e);
	}
};

struct WaitFetchIDCardTask : public ITaskSp
{
	CIDCertFSM* fsm;
	WaitFetchIDCardTask(CIDCertFSM* f) : fsm(f) {}

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_WAIT_FETCH_IDCARD_FINISHED);
		e->param1 = fsm->WaitFetchIDCard();
		fsm->PostEventFIFO(e);
	}
};
struct InitTask : public ITaskSp
{
	CIDCertFSM* fsm;
	InitTask(CIDCertFSM* f) : fsm(f) {}

	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_INIT_FINISHED);
		e->param1 = fsm->Initial();
		fsm->PostEventFIFO(e);
	}
};
struct ProcFWBReConnTask : public ITaskSp
{
	CIDCertFSM* fsm;
	ProcFWBReConnTask(CIDCertFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_TODO_INIT_FINISHED);
		e->param1 = fsm->ProcFWBReConn();
		fsm->PostEventFIFO(e);
	}
};
#endif //IDCERTFSM_H