myvtm/Module/mod_CustMngrAuth/mod_CustMngrAuth.cpp

#pragma once

#include "SpBase.h"
#include "mod_CustMngrAuth.h"

CCustMngrAuthEntity::CCustMngrAuthEntity()
{

}

void CCustMngrAuthEntity::OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = __OnStart(Error_Succeed);
	pTransactionContext->SendAnswer(eErr);
}
ErrorCodeEnum CCustMngrAuthEntity::__OnStart(ErrorCodeEnum preOperationError)
{
	LOG_FUNCTION();
	if (preOperationError != Error_Succeed)
		return preOperationError;
	ErrorCodeEnum eStart = m_fsm.Init(this);
	if (eStart == Error_Succeed)
	{
		//订阅授权实体广播
		/*GetFunction()->SubscribeBroadcast("FaceRecognition", "", this, m_uuidFRMsg);
		GetFunction()->SubscribeBroadcast("MaintainWatcher", "", this, m_uuidUkMsg);*/
		/*CSmartPointer<IEntityFunction> spFunction = GetFunction();
		ErrorCodeEnum eSub;
		eSub = spFunction->SubscribeBroadcast("MaintainWatcher", NULL, this, m_uuidUkMsg);
		if (eSub != Error_Succeed)
		{
			Dbg("subscribe MaintainWatcher broadcast failed");
		}
		else
		{
			Dbg("subscribe MaintainWatcher broadcast succeed");
		}*/
	}
	else
	{
		Dbg("m_fsm.Init failed");
	}
	return eStart;
}

void CCustMngrAuthEntity::OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext> pTransactionContext)
{
	LOG_FUNCTION();
	ErrorCodeEnum Error = __OnClose(Error_Succeed);
	pTransactionContext->SendAnswer(Error);
}
ErrorCodeEnum CCustMngrAuthEntity::__OnClose(ErrorCodeEnum preOperationError)
{
	LOG_FUNCTION();
	if (preOperationError != Error_Succeed)
		return preOperationError;
	return Error_Succeed;
}

void CCustMngrAuthEntity::OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
{
	LOG_FUNCTION();
	pTransactionContext->SendAnswer(Error_Succeed);
}
void CCustMngrAuthEntity::OnContinued()
{
	LOG_FUNCTION();
}

void CCustMngrAuthEntity::OnBroadcastEvent(CUUID SubID, const char *pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, CAutoBuffer Buffer)
{
	if (dwMessageSignature != eMsgSig_UkeyInsert)
		return;

	LOG_FUNCTION();
	Dbg("(ON BROADCASTEVENT) msg:%s,%d,%d",pszEntityName,dwMessageId,dwMessageSignature);
	if (_strnicmp(pszEntityName, "MaintainWatcher", strlen("MaintainWatcher")) == 0)
	{
		if (dwMessageSignature == eMsgSig_UkeyInsert)
		{
			MaintainWatcher::UkeyInsert ui;
			SpBuffer2Object(Buffer, ui);
			if (!ui.UkeyID.IsNullOrEmpty() && strlen(ui.UkeyID)!=0)
			{
				Dbg("receive ukeyinsert event: UkeyID is %s", ui.UkeyID);
				//先发消息再转状态，因为给前端发消息也属于工作中。
				if (m_fsm.GetCurrStateName() == "Authorizing" && m_fsm.m_ctx != NULL)//授权中收到ukey，通过授权
				{
					m_fsm.m_authCtx.UkeyID = ui.UkeyID;
					m_fsm.m_authCtx.eAuthByWhich = AuthByUkey;
					AuthorizeFinishedEvent* e = new AuthorizeFinishedEvent();
					e->ctx = m_fsm.m_ctx;
					e->param1 = Error_Succeed;
					m_fsm.PostEventFIFO(e);
					Dbg("############## Authorized By Ukey ##############");
				}
				else
				{
					Dbg("ERROR: unexpected fsm state!");
				}
			}
			else
			{
				Dbg("unexpected: message UkeyInsert.UkeyID is NULL or empty");
			}
		}
	}
}


CServerSessionBase* CCustMngrAuthEntity::OnNewSession(const char*,const char*)
{
	Dbg("A new connecting request arrived.");
	m_bNewSessionInit = true;
	return new CustMngrAuthServerSession(this);
}

void CCustMngrAuthEntity::OnTimeout(DWORD dwTimerID)
{
	switch(dwTimerID)
	{
	case 1:
		{

		}
		break;
	default:
		break;

	}
}

void CCustMngrAuthEntity::StartAuthorize(SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (m_fsm.m_ctx == NULL) m_fsm.m_ctx = ctx;
	AuthorizeStartEvent* e = new AuthorizeStartEvent();
	e->ctx = ctx;
	m_fsm.PostEventFIFO(e);
}
void CCustMngrAuthEntity::StopAuthorize(SpReqAnsContext<CustMngrAuthService_StopAuthorize_Req, CustMngrAuthService_StopAuthorize_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	AuthorizeCancelEvent *e = new AuthorizeCancelEvent();
	m_fsm.PostEventFIFO(e);
}

void CCustMngrAuthEntity::CollectFingerPrint(SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	CollectFingerPrintStartEvent *pEvt = new CollectFingerPrintStartEvent();
	pEvt->ctx = ctx;
	m_fsm.PostEventFIFO(pEvt);
}

void CCustMngrAuthEntity::StopCollect(SpReqAnsContext<CustMngrAuthService_StopCollect_Req, CustMngrAuthService_StopCollect_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	
	CancelCollectFingerPrintEvent *pEvt = new CancelCollectFingerPrintEvent();
	m_fsm.PostEventFIFO(pEvt);
}

void CCustMngrAuthEntity::SaveFingerPrint(SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	SaveFingerPrintStartEvent *pEvt = new SaveFingerPrintStartEvent();
	pEvt->ctx = ctx;
	m_fsm.PostEventFIFO(pEvt);
}

void CCustMngrAuthEntity::CheckUkey(SpReqAnsContext<CustMngrAuthService_CheckUkey_Req, CustMngrAuthService_CheckUkey_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	CheckUkeyEvent *pEvt = new CheckUkeyEvent();
	m_fsm.PostEventFIFO(pEvt);
}

void CCustMngrAuthEntity::HoldOn(SpReqAnsContext<CustMngrAuthService_HoldOn_Req, CustMngrAuthService_HoldOn_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	HoldOnEvent *pEvt = new HoldOnEvent();
	pEvt->ctx = ctx;
	m_fsm.PostEventFIFO(pEvt);
}

//对业务接口
void CustMngrAuthServerSession::Handle_StartAuthorize(SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	Dbg("handle_authorize.");
	m_pEntity->StartAuthorize(ctx);
}

void CustMngrAuthServerSession::Handle_StopAuthorize(SpReqAnsContext<CustMngrAuthService_StopAuthorize_Req, CustMngrAuthService_StopAuthorize_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pEntity->StopAuthorize(ctx);
}

void CustMngrAuthServerSession::Handle_CollectFingerPrint(SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pEntity->CollectFingerPrint(ctx);
}

void CustMngrAuthServerSession::Handle_StopCollect(SpReqAnsContext<CustMngrAuthService_StopCollect_Req, CustMngrAuthService_StopCollect_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pEntity->StopCollect(ctx);
}

void CustMngrAuthServerSession::Handle_SaveFingerPrint(SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pEntity->SaveFingerPrint(ctx);
}

void CustMngrAuthServerSession::Handle_CheckUkey(SpReqAnsContext<CustMngrAuthService_CheckUkey_Req, CustMngrAuthService_CheckUkey_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pEntity->CheckUkey(ctx);
}

void CustMngrAuthServerSession::Handle_HoldOn(SpReqAnsContext<CustMngrAuthService_HoldOn_Req, CustMngrAuthService_HoldOn_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pEntity->HoldOn(ctx);
}

SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CCustMngrAuthEntity)
SP_END_ENTITY_MAP()