myvtm/Module/mod_CardReadAdapter/mod_CardReadAdapter.cpp

// mod_CardReadAdapter.cpp : Defines the exported functions for the DLL application.
//

#include "stdafx.h"

#pragma once

#include "SpBase.h"
#include "mod_CardReadAdapter.h"


void CardReadAdapterServerSession::Handle_Read(SpReqAnsContext<CardReadAdapterService_Read_Req, CardReadAdapterService_Read_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("Read")("Invoke Read");
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("Module:%d,lightPos:%d,bus data size:%d",ctx->Req.module,ctx->Req.lightPos,ctx->Req.businessData.GetLength());
	if (ctx->Req.reserved1.GetCount() > 0)
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("reserved1[0]:%d",ctx->Req.reserved1[0]);
	m_pEntity->Read(ctx);
}

void CardReadAdapterServerSession::Handle_Capture(SpReqAnsContext<CardReadAdapterService_Capture_Req, CardReadAdapterService_Capture_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("Capture")("Invoke Capture");
	m_pEntity->Capture(ctx);
}

void CardReadAdapterServerSession::Handle_Eject(SpReqAnsContext<CardReadAdapterService_Eject_Req, CardReadAdapterService_Eject_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("Eject")("Invoke Eject");
	m_pEntity->Eject(ctx);
}

void CardReadAdapterServerSession::Handle_CancelRead(SpOnewayCallContext<CardReadAdapterService_CancelRead_Info>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("CancelRead")("Invoke CancelRead");
	m_pEntity->CancelRead(ctx);
}
void CardReadAdapterServerSession::Handle_ReadWaitMore(SpOnewayCallContext<CardReadAdapterService_ReadWaitMore_Info>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("ReadWaitMore")("Invoke ReadWaitMore");
	m_pEntity->ReadWaitMore(ctx);
}
void CardReadAdapterServerSession::Handle_Issue(SpReqAnsContext<CardReadAdapterService_Issue_Req, CardReadAdapterService_Issue_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("Issue")("Invoke Issue");
	m_pEntity->Issue(ctx);
}
void CardReadAdapterServerSession::Handle_PreOnline(SpReqAnsContext<CardReadAdapterService_PreOnline_Req, CardReadAdapterService_PreOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("PreOnline")("Invoke PreOnline");
	if (ctx->Req.reserved2.GetCount() > 0 && !ctx->Req.reserved2[0].IsNullOrEmpty() && _strnicmp("kaku#", (const char*)ctx->Req.reserved2[0], 5) == 0)
		m_pEntity->PreOnline(ctx);
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("except for kaku,other can't use preonline directly.");
		ctx->Answer(Error_Unexpect);
	}
}
void CardReadAdapterServerSession::Handle_PostOnline(SpReqAnsContext<CardReadAdapterService_PostOnline_Req, CardReadAdapterService_PostOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("PostOnline")("Invoke PostOnline");
	m_pEntity->PostOnline(ctx);
}
void CardReadAdapterServerSession::Handle_Exit(SpOnewayCallContext<CardReadAdapterService_Exit_Info>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pEntity->Exit(ctx);
}

void CardReadAdapterServerSession::Handle_QueryCardInfo(SpReqAnsContext<CardReadAdapterService_QueryCardInfo_Req, CardReadAdapterService_QueryCardInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("QueryCardInfo")("Invoke QueryCardInfo");
	m_pEntity->QueryCardInfo(ctx);
}
void CardReadAdapterServerSession::Handle_WriteTrack(SpReqAnsContext<CardReadAdapterService_WriteTrack_Req, CardReadAdapterService_WriteTrack_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("WriteTrack")("Invoke WriteTrack");
	//Dbg("oiltest %d,%d,t1[%S],t2[%S],t3[%S],[%S]",ctx->Req.co,ctx->Req.mode,(const wchar_t *)ctx->Req.track1,(const wchar_t *)ctx->Req.track2,(const wchar_t *)ctx->Req.track3,(const wchar_t *)ctx->Req.reserved);
	m_pEntity->WriteTrack(ctx);
}
void CardReadAdapterServerSession::Handle_SetSomeFlag(SpReqAnsContext<CardReadAdapterService_SetSomeFlag_Req, CardReadAdapterService_SetSomeFlag_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("SetSomeFlag")("Invoke SetSomeFlag");
	m_pEntity->SetSomeFlag(ctx);
}

void CardReadAdapterServerSession::Handle_GetMaterialCount(SpReqAnsContext<CardReadAdapterService_GetMaterialCount_Req, CardReadAdapterService_GetMaterialCount_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("GetMaterialCount")("Invoke GetMaterialCount");
	m_pEntity->GetMaterialCount(ctx);
}
void CardReadAdapterServerSession::Handle_SetMaterialCount(SpReqAnsContext<CardReadAdapterService_SetMaterialCount_Req, CardReadAdapterService_SetMaterialCount_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("SetMaterialCount")("Invoke SetMaterialCount");
	m_pEntity->SetMaterialCount(ctx);
}
void CardReadAdapterServerSession::Handle_GetSCIInfo(SpReqAnsContext<CardReadAdapterService_GetSCIInfo_Req, CardReadAdapterService_GetSCIInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("GetSCIInfo")("Invoke GetSCIInfo");
	m_pEntity->GetSCIInfo(ctx);
}
void CardReadAdapterServerSession::Handle_OpenSafeLock(SpReqAnsContext<CardReadAdapterService_OpenSafeLock_Req, CardReadAdapterService_OpenSafeLock_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("OpenSafeLock")("Invoke OpenSafeLock");
	m_pEntity->OpenSafeLock(ctx);
}
void CardReadAdapterServerSession::Handle_MagTransferInit(SpReqAnsContext<CardReadAdapterService_MagTransferInit_Req, CardReadAdapterService_MagTransferInit_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("MagTransferInit")("Invoke MagTransferInit");
	m_pEntity->MagTransferInit(ctx);
}
void CardReadAdapterServerSession::Handle_QueryConnInfo(SpReqAnsContext<CardReadAdapterService_QueryConnInfo_Req, CardReadAdapterService_QueryConnInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("QueryConnInfo")("Invoke QueryConnInfo");
	m_pEntity->QueryConnInfo(ctx);
}
void CardReadAdapterServerSession::Handle_GetDevInfo(SpReqAnsContext<CardReadAdapterService_GetDevInfo_Req, CardReadAdapterService_GetDevInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("GetDevInfo")("Invoke GetDevInfo");
	m_pEntity->GetDevInfo(ctx);
}
void CardReadAdapterServerSession::Handle_SAMICCommand(SpReqAnsContext<CardReadAdapterService_SAMICCommand_Req, CardReadAdapterService_SAMICCommand_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("SAMICCommand")("Invoke SAMICCommand");
	m_pEntity->SAMICCommand(ctx);
}
void CardReadAdapterServerSession::Handle_QueryPrinterStatus(SpReqAnsContext<CardReadAdapterService_QueryPrinterStatus_Req, CardReadAdapterService_QueryPrinterStatus_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("QueryPrinterStatus")("Invoke QueryPrinterStatus");
	m_pEntity->QueryPrinterStatus(ctx);
}
void CardReadAdapterServerSession::Handle_Print(SpReqAnsContext<CardReadAdapterService_Print_Req, CardReadAdapterService_Print_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("Print")("Invoke Print");
	m_pEntity->Print(ctx);
}
void CardReadAdapterServerSession::Handle_QuerySCIList(SpReqAnsContext<CardReadAdapterService_QuerySCIList_Req, CardReadAdapterService_QuerySCIList_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("QuerySCIList")("Invoke QuerySCIList");
	m_pEntity->QuerySCIList(ctx);
}
void CardReadAdapterServerSession::Handle_BindSCI(SpReqAnsContext<CardReadAdapterService_BindSCI_Req, CardReadAdapterService_BindSCI_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("BindSCI")("Invoke BindSCI");
	m_pEntity->BindSCI(ctx);
}
void CardReadAdapterServerSession::Handle_PreOnlineOnStore(SpReqAnsContext<CardReadAdapterService_PreOnlineOnStore_Req, CardReadAdapterService_PreOnlineOnStore_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("PreOnlineOnStore")("Invoke PreOnlineOnStore");
	m_pEntity->PreOnlineOnStore(ctx);
}
void CardReadAdapterServerSession::Handle_NotifyPreonline(SpReqAnsContext<CardReadAdapterService_NotifyPreonline_Req, CardReadAdapterService_NotifyPreonline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("NotifyPreonline")("Invoke NotifyPreonline");
	m_pEntity->NotifyPreonline(ctx);
}
void CardReadAdapterServerSession::Handle_QueryCardInfoOnStore(SpReqAnsContext<CardReadAdapterService_QueryCardInfoOnStore_Req, CardReadAdapterService_QueryCardInfoOnStore_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("QueryCardInfoOnStore")("Invoke QueryCardInfoOnStore");
	m_pEntity->QueryCardInfoOnStore(ctx);
}
void CardReadAdapterServerSession::Handle_GetAddCardInfo(SpReqAnsContext<CardReadAdapterService_GetAddCardInfo_Req, CardReadAdapterService_GetAddCardInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("GetAddCardInfo")("Invoke GetAddCardInfo");
	m_pEntity->GetAddCardInfo(ctx);
}
void CardReadAdapterServerSession::Handle_Test1(SpReqAnsContext<CardReadAdapterService_Test1_Req, CardReadAdapterService_Test1_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	//m_pEntity->Test1(ctx);
}
void CardReadAdapterServerSession::Handle_Test2(SpReqAnsContext<CardReadAdapterService_Test2_Req, CardReadAdapterService_Test2_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	//m_pEntity->Test2(ctx);
}
void CardReadAdapterServerSession::Handle_CrossTermCall(SpReqAnsContext<CardReadAdapterService_CrossTermCall_Req, CardReadAdapterService_CrossTermCall_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("CrossTermCall")("Invoke CrossTermCall");
	m_pEntity->CrossTermCall(ctx);
}
void CardReadAdapterServerSession::Handle_CrossTermInvokeInfo(SpOnewayCallContext<CardReadAdapterService_CrossTermInvokeInfo_Info>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("CrossTermInvokeInfo")("Invoke CrossTermInvokeInfo");
	m_pEntity->CrossTermInvokeInfo(ctx);
}
void CardReadAdapterServerSession::Handle_PrintCardImmediately(SpReqAnsContext<CardReadAdapterService_PrintCardImmediately_Req, CardReadAdapterService_PrintCardImmediately_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("PrintCardImmediately")("Invoke PrintCardImmediately");
	m_pEntity->PrintCardImmediately(ctx);
}
void CardReadAdapterServerSession::Handle_QueryCIStatus(SpReqAnsContext<CardReadAdapterService_QueryCIStatus_Req, CardReadAdapterService_QueryCIStatus_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI("QueryCIStatus")("Invoke QueryCIStatus");
	m_pEntity->QueryCIStatus(ctx);
}
void CCardReadAdapterEntity::OnBroadcastEvent(CUUID SubID, const char *pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, CAutoBuffer Buffer)
{
	if (dwMessageSignature != eMsgSig_FetchCard && dwMessageSignature != eMsgSig_SCIConnect && dwMessageSignature != eMsgSig_ConnectStatus)
		return;

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("OnBroadcastEvent,msg:%s,%d,%d",pszEntityName,dwMessageId,dwMessageSignature);
	if (_strnicmp(pszEntityName, "CardIssuer", strlen("CardIssuer")) == 0)
	{
		if (dwMessageSignature == eMsgSig_FetchCard)
		{
			CardIssuer::FetchCard fc;
			SpBuffer2Object(Buffer, fc);
			CardIsserFetchCard evt;
			evt.status = fc.status;
			SpSendBroadcast(GetFunction(), SP_MSG_OF(CardIsserFetchCard), SP_MSG_SIG_OF(CardIsserFetchCard), evt);
		}
		else if (dwMessageSignature == eMsgSig_SCIConnect)
		{
			CardIssuer::SCIConnect scic;
			SpBuffer2Object(Buffer, scic);
			CardIssuerSCIConnect evt;
			evt.status = scic.status;
			SpSendBroadcast(GetFunction(), SP_MSG_OF(CardIssuerSCIConnect), SP_MSG_SIG_OF(CardIssuerSCIConnect), evt);
		}
	}
	else if (_strnicmp(pszEntityName, "ContactlessCard", strlen("ContactlessCard")) == 0)
	{
		if (dwMessageSignature == eMsgSig_FetchCard)
		{
			ContactlessCard::FetchCard fc;
			SpBuffer2Object(Buffer, fc);

			if (fc.status == 3){//oilyang@20181210 cancel read as have detect card in ContactlessCard
				if(m_fsm.GetMachineType() == MachineType_RVC_DESK2S)
					m_fsm.CancelReadForEntity(Module_CardSwiper);
				else{
					m_fsm.CancelReadForEntity(Module_CardIssuer);
				}
			}
			else
			{
				ContactlessCardFetchCard evt;
				evt.status = fc.status;
				SpSendBroadcast(GetFunction(), SP_MSG_OF(ContactlessCardFetchCard), SP_MSG_SIG_OF(ContactlessCardFetchCard), evt);
			}
		}
	}
	else if (_strnicmp(pszEntityName, "CardSwiper", strlen("CardSwiper")) == 0)
	{
		if (dwMessageSignature == eMsgSig_FetchCard)
		{
			CardSwiper::FetchCard fc;
			SpBuffer2Object(Buffer, fc);
			if (fc.status == 3)//oilyang@20190507 cancel read as have detect card in CardSwiper
				m_fsm.CancelReadForEntity(Module_ContactlessCard);
			else
			{
				CardSwiperFetchCard evt;
				evt.status = fc.status;
				SpSendBroadcast(GetFunction(), SP_MSG_OF(CardSwiperFetchCard), SP_MSG_SIG_OF(CardSwiperFetchCard), evt);
			}
		}
		else if (dwMessageSignature == eMsgSig_ConnectStatus)
		{
			CardSwiper::ConnectStatus cs;
			SpBuffer2Object(Buffer, cs);
			CardSwiperConnectStatus evt;
			evt.status = cs.status;
			SpSendBroadcast(GetFunction(), SP_MSG_OF(CardSwiperConnectStatus), SP_MSG_SIG_OF(CardSwiperConnectStatus), evt);
		}
	}
	
}



SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CCardReadAdapterEntity)
SP_END_ENTITY_MAP()