myvtm/Module/mod_CustMngrAuth/CustMngrAuthFSM.h

#ifndef __CUSTMNGRAUTH_FSM_H
#define __CUSTMNGRAUTH_FSM_H

#pragma once
#include "stdafx.h"
#include "SpFSM.h"
#include "SpSecureClient.h"

#include "CustMngrAuth_server_g.h"
#include "CustMngrAuth_msg_g.h"
#include "json/json.h"
#include "FingerPrint_client_g.h"
#include "CommEntityUtil.hpp"

using namespace CustMngrAuth;



using namespace std;
using namespace FingerPrint;


enum EvtType{
	USER_EVT_TEST = EVT_USER + 1,
	USER_EVT_QUIT,
	USER_EVT_INIT,
	USER_EVT_INIT_FINISHED,
	USER_EVT_AUTHORIZE_START,
	USER_EVT_AUTHORIZE_FINISHED,
	USER_EVT_AUTHORIZE_CANCEL,
	USER_EVT_QUERYAUTHORINFO,
	USER_EVT_QUERYAUTHORINFO_FINISHED,
	USER_EVT_QUERYAUTHORINFO_CANCEL,
	USER_EVT_COLLECTFINGERPRINT_START,
	USER_EVT_COLLECTFINGERPRINTEX_START,
	USER_EVT_COLLECTFINGERPRINTINFO,
	USER_EVT_GENERATE_TEMPLATE,
	USER_EVT_GENERATE_TEMPLATE_FINISHED,
	USER_EVT_COLLECTFINGERPRINT_FINISHED,
	USER_EVT_COLLECTFINGERPRINTEX_FINISHED,
	USER_EVT_COLLECTFINGERPRINTINFO_FINISHED,
	USER_EVT_COLLECTFINGERPRINT_CANCEL,
	USER_EVT_COLLECTFINGERPRINTEX_CANCEL,
	USER_EVT_SAVEFINGERPRINT_START,
	USER_EVT_SAVEFINGERPRINT_FINISHED,
	USER_EVT_CHECKUKEY,
	USER_EVT_CHECKUKEY_FINISHED,
	USER_EVT_HOLDON,

	USER_EVT_EXIT,
};

enum AuthByWhich//授权结果
{
	AuthByNone = 0,
	AuthByFngPrnt = 1,
	AuthByUkey = 2,
};

enum BmpType
{
	BmpImage = 1,
	TestImage
};

struct AuthContext
{
	AuthByWhich eAuthByWhich;
	CSimpleStringA UkeyID;
	CSimpleStringA CustomerID;
	CSimpleStringA Feature;
	CBlob FingerImg;
};

class CCustMngrAuthEntity;
class CCustMngrAuthFSM;

class AuthorizeStartEvent : public FSMEvent
{
public:
	AuthorizeStartEvent() : FSMEvent(USER_EVT_AUTHORIZE_START){}
	~AuthorizeStartEvent(){}
	SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("authorize_start unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class AuthorizeCancelExEvent : public FSMEvent
{
public:
	AuthorizeCancelExEvent() : FSMEvent(USER_EVT_QUERYAUTHORINFO_CANCEL) {}
	~AuthorizeCancelExEvent() {}
	SpReqAnsContext<CustMngrAuthService_StopAuthorizeEx_Req, CustMngrAuthService_StopAuthorizeEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("cancel QueryAuthorInfo unhandled");
		}
	}
protected:
private:
};

class AuthorizeFinishedEvent : public FSMEvent
{
public:
	AuthorizeFinishedEvent() : FSMEvent(USER_EVT_AUTHORIZE_FINISHED){}
	~AuthorizeFinishedEvent(){}
	SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("authorize_finished unhandled");
		}
	}
protected:
private:
};

class AuthorizeCancelEvent : public FSMEvent
{
public:
	AuthorizeCancelEvent() : FSMEvent(USER_EVT_AUTHORIZE_CANCEL){}
	~AuthorizeCancelEvent(){}
	SpReqAnsContext<CustMngrAuthService_StopAuthorize_Req, CustMngrAuthService_StopAuthorize_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("authorize_cancel unhandled");	
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class QueryAuthorInfoEvent : public FSMEvent
{
public:
	QueryAuthorInfoEvent() : FSMEvent(USER_EVT_QUERYAUTHORINFO) {}
	~QueryAuthorInfoEvent() {}
	SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryAuthorInfo unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class QueryAuthorInfoFinishedEvent : public FSMEvent
{
public:
	QueryAuthorInfoFinishedEvent() : FSMEvent(USER_EVT_QUERYAUTHORINFO_FINISHED) {}
	~QueryAuthorInfoFinishedEvent() {}
	SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryAuthorInfo_finished unhandled");
		}
	}
protected:
private:
};

class CollectFingerPrintStartEvent : public FSMEvent
{
public:
	CollectFingerPrintStartEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINT_START){}
	~CollectFingerPrintStartEvent(){}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx!=NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("collect_finger_print unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class CollectFingerPrintExStartEvent : public FSMEvent
{
public:
	CollectFingerPrintExStartEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINTEX_START) {}
	~CollectFingerPrintExStartEvent() {}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("collect_fingerEx_print unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class CollectFingerPrintInfoEvent : public FSMEvent
{
public:
	CollectFingerPrintInfoEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINTINFO) {}
	~CollectFingerPrintInfoEvent() {}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Collect FingerPrint info unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class GenerateTemplateEvent : public FSMEvent
{
public:
	GenerateTemplateEvent() : FSMEvent(USER_EVT_GENERATE_TEMPLATE) {}
	~GenerateTemplateEvent() {}
	SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Generate Template unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};

class CollectFingerPrintFinishedEvent : public FSMEvent
{
public:
	CollectFingerPrintFinishedEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINT_FINISHED){}
	~CollectFingerPrintFinishedEvent(){}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx!=NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("collect_finger_print_finished unhandled");
		}
	}
protected:
private:
};

class CollectFingerPrintExFinishedEvent : public FSMEvent
{
public:
	CollectFingerPrintExFinishedEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINTEX_FINISHED) {}
	~CollectFingerPrintExFinishedEvent() {}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("collect_finger_printEx_finished unhandled");
		}
	}
protected:
private:
};

class CollectFingerPrintInfoFinishedEvent : public FSMEvent
{
public:
	CollectFingerPrintInfoFinishedEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINTINFO_FINISHED) {}
	~CollectFingerPrintInfoFinishedEvent() {}
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Collect FingerPrint Info finished unhandled");
		}
	}
protected:
private:
};

class GenerateTemplateFinishedEvent : public FSMEvent
{
public:
	GenerateTemplateFinishedEvent() : FSMEvent(USER_EVT_GENERATE_TEMPLATE_FINISHED) {}
	~GenerateTemplateFinishedEvent() {}
	SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Generate Template finished unhandled");
		}
	}
protected:
private:
};

class CancelCollectFingerPrintEvent : public FSMEvent
{
public:
	CancelCollectFingerPrintEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINT_CANCEL){}
	~CancelCollectFingerPrintEvent(){}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("cancel collect fingerprint unhandled");
	}
};

class CancelCollectFingerPrintExEvent : public FSMEvent
{
public:
	CancelCollectFingerPrintExEvent() : FSMEvent(USER_EVT_COLLECTFINGERPRINTEX_CANCEL) {}
	~CancelCollectFingerPrintExEvent() {}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("cancel collect fingerprintEx unhandled");
	}
};

class SaveFingerPrintStartEvent : public FSMEvent
{
public:
	SaveFingerPrintStartEvent() : FSMEvent(USER_EVT_SAVEFINGERPRINT_START){}
	~SaveFingerPrintStartEvent(){}
	SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx;
	virtual void OnUnhandled(){
		if (ctx!=NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("save_finger_print_start unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};

class SaveFingerPrintFinishedEvent : public FSMEvent
{
public:
	SaveFingerPrintFinishedEvent() : FSMEvent(USER_EVT_SAVEFINGERPRINT_FINISHED){}
	~SaveFingerPrintFinishedEvent(){}
	SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx;
	virtual void OnUnhandled(){
		if (ctx!=NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("save_finger_print_finished unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class CheckUkeyEvent : public FSMEvent
{
public:
	CheckUkeyEvent() : FSMEvent(USER_EVT_CHECKUKEY){}
	~CheckUkeyEvent(){}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("check_ukey unhandled");
	}
};

class CheckUkeyFinishedEvent : public FSMEvent
{
public:
	CheckUkeyFinishedEvent() : FSMEvent(USER_EVT_CHECKUKEY_FINISHED){}
	~CheckUkeyFinishedEvent(){}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("check_ukey_finished unhandled");
	}
};

class HoldOnEvent : public FSMEvent
{
public:
	HoldOnEvent() : FSMEvent(USER_EVT_HOLDON){}
	~HoldOnEvent(){}
	SpReqAnsContext<CustMngrAuthService_HoldOn_Req, CustMngrAuthService_HoldOn_Ans>::Pointer ctx;
	virtual void OnUnhandled(){
		if (ctx!=NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("holdon unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};

class FeatureUpdateConn;

class CCustMngrAuthFSM : public FSMImpl<CCustMngrAuthFSM>
{
public:
	enum { s0, s1, s2, s3, s4, s5};

	BEGIN_FSM_STATE(CCustMngrAuthFSM)
		FSM_STATE_ENTRY(s0, "Init", s0_on_entry, s0_on_exit, s0_on_event)
		FSM_STATE_ENTRY(s1, "Initializing", s1_on_entry, s1_on_exit, s1_on_event)
		FSM_STATE_ENTRY(s2, "Idle", s2_on_entry, s2_on_exit, s2_on_event)
		FSM_STATE_ENTRY(s3, "Authorizing", s3_on_entry, s3_on_exit, s3_on_event)//QUERYAUTHORINFO请求进入
		FSM_STATE_ENTRY(s4, "Registering", s4_on_entry, s4_on_exit, s4_on_event)//GENERATE_TEMPLATE，CollectFingerPrintInfo请求进入
		FSM_STATE_ENTRY(s5, "Failed", s5_on_entry, s5_on_exit, s5_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CCustMngrAuthFSM, 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_INIT_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s5, USER_EVT_INIT_FINISHED, 1)
		FSM_RULE_ENTRY(s1, FSM_STATE_EXIT, USER_EVT_QUIT, 0)		
		FSM_RULE_ENTRY(s2, s3, USER_EVT_AUTHORIZE_START, 0)
		FSM_RULE_ENTRY(s2, s3, USER_EVT_QUERYAUTHORINFO, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_COLLECTFINGERPRINT_START, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_COLLECTFINGERPRINTEX_START, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_COLLECTFINGERPRINTINFO, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_GENERATE_TEMPLATE, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_CHECKUKEY, 0)
		FSM_RULE_ENTRY(s2, s4, USER_EVT_SAVEFINGERPRINT_START, 0)
		FSM_RULE_ENTRY(s2, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s3, s2, USER_EVT_EXIT, 0)
		FSM_RULE_ENTRY(s3, s2, USER_EVT_AUTHORIZE_FINISHED, 0)
		FSM_RULE_ENTRY(s3, s2, USER_EVT_QUERYAUTHORINFO_FINISHED, 0)
		FSM_RULE_ENTRY(s3, s2, EVT_TIMER, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_COLLECTFINGERPRINT_START, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_COLLECTFINGERPRINTEX_START, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_COLLECTFINGERPRINT_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_COLLECTFINGERPRINTEX_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_COLLECTFINGERPRINTINFO_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_GENERATE_TEMPLATE_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_SAVEFINGERPRINT_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_CHECKUKEY_FINISHED, 0)
		FSM_RULE_ENTRY(s3, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s5, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
	END_FSM_RULE()

	CCustMngrAuthFSM():m_pFingerPrint(NULL),  m_bCancelCollectFP(false)
	, m_bCancelAuthorize(false), m_bAuthorizeTimeout(false) {
		hStopUpdate = ::CreateEventA(NULL, TRUE, FALSE, NULL);
		m_TimeLimit = 55;//默认授权超时秒数
		m_ctx = NULL;
		InitializeCriticalSection(&m_cs);
	}
	~CCustMngrAuthFSM(){
		DeleteCriticalSection(&m_cs);
	}
	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* event);
	void s1_on_entry();
	void s1_on_exit();
	unsigned int s1_on_event(FSMEvent* event);
	void s2_on_entry();
	void s2_on_exit();
	unsigned int s2_on_event(FSMEvent* event);
	void s3_on_entry();
	void s3_on_exit();
	unsigned int s3_on_event(FSMEvent* event);
	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_on_event(FSMEvent* event);
	void s5_on_entry();
	void s5_on_exit();
	unsigned int s5_on_event(FSMEvent* event);

	HANDLE hStopUpdate;
	int Initial();

	SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer m_ctx;
	SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer qaInfoCtx;
	AuthContext m_authCtx;
	CSimpleStringA m_TerminalID;
	CSimpleStringA m_csMachineType;

	
	ErrorCodeEnum MatchFingerPrintEx(SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx, bool& bStopAuthorize, DWORD& dwUserErrCode);
	
	
	void CancelAuthorize();
	void CancelCollect();

	ErrorCodeEnum CollectFingerPrintInfo(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx, DWORD& dwUserErrCode);
	ErrorCodeEnum GenerateTemplate(SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx, DWORD& dwUserErrCode);
	ErrorCodeEnum GetImgBlob(CBlob &data, CSimpleStringA imgPath);
	void BroadcastPressFinger(int times, bool bPressFinger);
	

	void BroadcastGetFinger(int status);
	void DeleteBmp(int type);
	ErrorCodeEnum DeleteFileIfExisted(const char* fileName);

	ErrorCodeEnum OpenRunInfoFile();//Initial使用

	//ErrorCodeEnum WaitForUkey(ErrorCodeEnum eErr);//未使用，废弃
#pragma region 废弃的方法


	ErrorCodeEnum MatchFingerPrint(SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx, bool& bStopAuthorize);//废弃的方法
	ErrorCodeEnum CollectFingerPrint(SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx, DWORD& dwUserErrCode);//废弃的方法
	ErrorCodeEnum CollectFingerPrintEx(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx, DWORD& dwUserErrCode);//废弃的方法
	ErrorCodeEnum SaveFingerPrint(SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx);//废弃的方法

#pragma endregion

private:
	
	FingerPrintService_ClientBase *m_pFingerPrint;


	CSimpleStringA m_FingerSection;//人脸特征路径
	CSimpleStringA m_RunInfoPath;


	bool m_bCancelCollectFP, m_bCancelAuthorize, m_bAuthorizeTimeout;
	int m_TimeLimit;

	CRITICAL_SECTION m_cs;//临界区变量
};


//初始化：检查、配置路径、起特征更新任务（使用）
struct InitTask : public ITaskSp
{
	CCustMngrAuthFSM *fsm;
	InitTask(CCustMngrAuthFSM *f) : fsm(f) {}

	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_INIT_FINISHED);
		e->param1 = fsm->Initial();
		fsm->PostEventFIFO(e);
	}
};

//因QueryAuthorInfo使用（使用）
struct MatchFingerPrintTaskEx : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	MatchFingerPrintTaskEx(CCustMngrAuthFSM* f) : fsm(f) {}
	SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx;
	void Process()
	{
		bool bStopAuthorize = false;
		DWORD dwUserErrorCode = 0;
		//加入指纹交易日志
		ErrorCodeEnum eErr = fsm->MatchFingerPrintEx(ctx, bStopAuthorize, dwUserErrorCode);
		//if (bStopAuthorize)
		//{
		QueryAuthorInfoFinishedEvent* e = new QueryAuthorInfoFinishedEvent();
		e->ctx = ctx;
		e->param1 = eErr;
		e->param2 = dwUserErrorCode;
		fsm->PostEventFIFO(e);//指纹匹配结束，结束授权
	//}
	//else
	//{
	//	QueryAuthorInfoFinishedEvent* e = new QueryAuthorInfoFinishedEvent();
	//	e->ctx = ctx;
	//	e->param1 = fsm->WaitForUkey(eErr);
	//	fsm->PostEventFIFO(e);//指纹匹配异常停止，继续等到超时或ukey插入结束授权，如果是ukey插入，这个event就不会被处理
	//}
	}
};

//因CollectFingerPrintInfo使用（使用）
struct CollectFingerPrintInfoTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx;
	CollectFingerPrintInfoTask(CCustMngrAuthFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		CollectFingerPrintInfoFinishedEvent* e = new CollectFingerPrintInfoFinishedEvent();
		e->ctx = ctx;
		DWORD dwUserErrorCode = 0;
		ErrorCodeEnum eErr = fsm->CollectFingerPrintInfo(ctx, dwUserErrorCode);
		if (eErr == Error_Unexpect && dwUserErrorCode > 0)
			ctx->Answer(eErr, dwUserErrorCode);
		else
			ctx->Answer(eErr);
		fsm->PostEventFIFO(e);
	}
};

//因GenerateTemplate使用（使用）
struct GenerateTemplateTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx;
	GenerateTemplateTask(CCustMngrAuthFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		GenerateTemplateFinishedEvent* e = new GenerateTemplateFinishedEvent();
		e->ctx = ctx;
		DWORD dwUserErrorCode = 0;
		ErrorCodeEnum eErr = fsm->GenerateTemplate(ctx, dwUserErrorCode);
		if (eErr == Error_Unexpect && dwUserErrorCode > 0)
			ctx->Answer(eErr, dwUserErrorCode);
		else
			ctx->Answer(eErr);
		fsm->PostEventFIFO(e);
	}
};

#pragma region 废弃的结构

//因StartAuthorize不使用（废弃）
struct MatchFingerPrintTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	MatchFingerPrintTask(CCustMngrAuthFSM* f) : fsm(f) {}
	SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx;
	void Process()
	{
		//bool bStopAuthorize = false;
		//ErrorCodeEnum eErr = fsm->MatchFingerPrint(ctx, bStopAuthorize);
		////if (bStopAuthorize)
		////{
		//	AuthorizeFinishedEvent *e = new AuthorizeFinishedEvent();
		//	e->ctx = ctx;
		//	e->param1 = eErr;
		//	fsm->PostEventFIFO(e);
		//}
		//else
		//{
		//	AuthorizeFinishedEvent *e = new AuthorizeFinishedEvent();
		//	e->ctx = ctx;
		//	e->param1 = fsm->WaitForUkey(eErr);
		//	fsm->PostEventFIFO(e);//指纹匹配异常停止，继续等到超时或ukey插入结束授权，如果是ukey插入，这个event就不会被处理
		//}
	}
};

//因CollectFingerPrint不使用（废弃）
struct CollectFingerPrintTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx;
	CollectFingerPrintTask(CCustMngrAuthFSM* f) : fsm(f) {}
	void Process()
	{
		//LOG_FUNCTION();
		//CollectFingerPrintFinishedEvent* e = new CollectFingerPrintFinishedEvent();
		//e->ctx = ctx;
		//DWORD dwUserErrorCode = 0;
		//ErrorCodeEnum eErr = fsm->CollectFingerPrint(ctx, dwUserErrorCode);
		//if (eErr == Error_Unexpect && dwUserErrorCode > 0)
		//	ctx->Answer(eErr, dwUserErrorCode);
		//else
		//	ctx->Answer(eErr);
		//fsm->PostEventFIFO(e);
	}
};

//因CollectFingerPrintEx不使用(废弃)
struct CollectFingerPrintExTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx;
	CollectFingerPrintExTask(CCustMngrAuthFSM* f) : fsm(f) {}
	void Process()
	{
		//LOG_FUNCTION();
		//CollectFingerPrintExFinishedEvent* e = new CollectFingerPrintExFinishedEvent();
		//e->ctx = ctx;
		//DWORD dwUserErrorCode = 0;
		//ErrorCodeEnum eErr = fsm->CollectFingerPrintEx(ctx, dwUserErrorCode);
		//if (eErr == Error_Unexpect && dwUserErrorCode > 0)
		//	ctx->Answer(eErr, dwUserErrorCode);
		//else
		//	ctx->Answer(eErr);
		//fsm->PostEventFIFO(e);
	}
};

//因SaveFingerPrint不使用（废弃）
struct SaveFingerPrintTask : public ITaskSp
{
	CCustMngrAuthFSM* fsm;
	SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx;
	SaveFingerPrintTask(CCustMngrAuthFSM* f) : fsm(f) {}
	void Process()
	{
		//LOG_FUNCTION();
		//SaveFingerPrintFinishedEvent* e = new SaveFingerPrintFinishedEvent();
		//e->ctx = ctx;
		//ErrorCodeEnum eErr = fsm->SaveFingerPrint(ctx);
		//ctx->Answer(eErr);
		//fsm->PostEventFIFO(e);
	}
};
#pragma endregion






#endif //__CUSTMNGRAUTH_FSM_H