#pragma once

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

CCustMngrAuthEntity::CCustMngrAuthEntity()
{

}

const char* CCustMngrAuthEntity::GetEntityName() const
{
	return "CustMngrAuth";
}

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)
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("m_fsm.Init failed");
	}
	return eStart;
}

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

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)
{
}


CServerSessionBase* CCustMngrAuthEntity::OnNewSession(const char*,const char*)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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::QueryAuthorInfo(SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	if (m_fsm.qaInfoCtx == NULL) m_fsm.qaInfoCtx = ctx;
	QueryAuthorInfoEvent* e = new QueryAuthorInfoEvent();
	e->ctx = ctx;
	m_fsm.PostEventFIFO(e);
}
//使用
void CCustMngrAuthEntity::StopAuthorizeEx(SpReqAnsContext<CustMngrAuthService_StopAuthorizeEx_Req, CustMngrAuthService_StopAuthorizeEx_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	AuthorizeCancelExEvent* e = new AuthorizeCancelExEvent();
	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::CollectFingerPrintEx(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	CollectFingerPrintExStartEvent* pEvt = new CollectFingerPrintExStartEvent();
	pEvt->ctx = ctx;
	m_fsm.PostEventFIFO(pEvt);
}
//使用
void CCustMngrAuthEntity::CollectFingerPrintInfo(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	CollectFingerPrintInfoEvent *pEvt = new CollectFingerPrintInfoEvent();
	pEvt->ctx = ctx;
	m_fsm.PostEventFIFO(pEvt);
}
//使用
void CCustMngrAuthEntity::GenerateTemplate(SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	GenerateTemplateEvent* gtEvt = new GenerateTemplateEvent();
	gtEvt->ctx = ctx;
	m_fsm.PostEventFIFO(gtEvt);
}
//废弃
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();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("StartAuthorize")("Invoke StartAuthorize");
	m_pEntity->StartAuthorize(ctx);
}
//使用
void CustMngrAuthServerSession::Handle_QueryAuthorInfo(SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("QueryAuthorInfo")("TimeLimit:%d, WayofFinger:%d, WayofKey:%d",
				ctx->Req.TimeLimit, ctx->Req.WayofFinger, ctx->Req.WayofKey);
	if (ctx->Req.WayofFinger != 1) {
		ctx->Answer(Error_Param);//uos中只通过指纹授权
		return;
	}
	m_pEntity->QueryAuthorInfo(ctx);
}
//废弃
void CustMngrAuthServerSession::Handle_StopAuthorize(SpReqAnsContext<CustMngrAuthService_StopAuthorize_Req, CustMngrAuthService_StopAuthorize_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("StopAuthorize")("Invoke StopAuthorize");
	m_pEntity->StopAuthorize(ctx);
}

//使用
void CustMngrAuthServerSession::Handle_StopAuthorizeEx(SpReqAnsContext<CustMngrAuthService_StopAuthorizeEx_Req, CustMngrAuthService_StopAuthorizeEx_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("StopAuthorizeEx")("Invoke StopAuthorizeEx");
	m_pEntity->StopAuthorizeEx(ctx);
}
//废弃
void CustMngrAuthServerSession::Handle_CollectFingerPrint(SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("CollectFingerPrint")("Invoke CollectFingerPrint");
	m_pEntity->CollectFingerPrint(ctx);
}
//使用
void CustMngrAuthServerSession::Handle_StopCollect(SpReqAnsContext<CustMngrAuthService_StopCollect_Req, CustMngrAuthService_StopCollect_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("StopCollect")("Invoke StopCollect");
	m_pEntity->StopCollect(ctx);
}
//废弃
void CustMngrAuthServerSession::Handle_CollectFingerPrintEx(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("CollectFingerPrintEx")("Invoke CollectFingerPrintEx");
	m_pEntity->CollectFingerPrintEx(ctx);
}
//使用
void CustMngrAuthServerSession::Handle_CollectFingerPrintInfo(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("CollectFingerPrintInfo")("Invoke CollectFingerPrintInfo");
	m_pEntity->CollectFingerPrintInfo(ctx);
}
//使用
void CustMngrAuthServerSession::Handle_GenerateTemplate(SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("GenerateTemplate")("Invoke GenerateTemplate");
	m_pEntity->GenerateTemplate(ctx);
}
//废弃
void CustMngrAuthServerSession::Handle_SaveFingerPrint(SpReqAnsContext<CustMngrAuthService_SaveFingerPrint_Req, CustMngrAuthService_SaveFingerPrint_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("SaveFingerPrint")("Invoke SaveFingerPrint");
	m_pEntity->SaveFingerPrint(ctx);
}
//废弃
void CustMngrAuthServerSession::Handle_CheckUkey(SpReqAnsContext<CustMngrAuthService_CheckUkey_Req, CustMngrAuthService_CheckUkey_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("CheckUkey")("Invoke CheckUkey");
	m_pEntity->CheckUkey(ctx);
}
//废弃
void CustMngrAuthServerSession::Handle_HoldOn(SpReqAnsContext<CustMngrAuthService_HoldOn_Req, CustMngrAuthService_HoldOn_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("HoldOn")("Invoke HoldOn");
	m_pEntity->HoldOn(ctx);
}






SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CCustMngrAuthEntity)
SP_END_ENTITY_MAP()