myvtm/Module/mod_CardIssuerStand/CardIssuerStandFSM.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "SpHelper.h"
#include "CardIssuerStandFSM.h"
#include "EventCode.h"
#include "RVCEventCode.h"
#include "RVCComm.h"
#include "CardIssuerStand_UserErrorCode.h"
#include "CardIssuerStand_msg_g.h"

#include "publicFunExport.h"
#include <algorithm>
#include <map>
#ifdef RVC_OS_WIN
#define _ATL_NO_AUTOMATIC_NAMESPACE
#include <atltime.h>
#endif //RVC_OS_WIN

#include "CardIssuerClass.h"
#include "mod_cardissuerStand.h"
#include "stdafx.h"
#include <regex>

//TODO: CrossPlaform  [Gifur@2025730]
#ifdef RVC_OS_WIN
#define _ATL_NO_AUTOMATIC_NAMESPACE
#else
#include<sys/time.h>
#include <dlfcn.h>
#endif //RVC_OS_WIN
unsigned long long GetTickCountRVC() {
#ifdef RVC_OS_WIN
	return GetTickCount64();
#else
	struct timespec ts;

	clock_gettime(CLOCK_MONOTONIC, &ts);

	return (ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
#endif //RVC_OS_WIN
}

#define CARDREADER_INIT_COUNT 3
#define GET_DEV_STATUS_COUNT 1//oilyang@20180104 change from 3 to 1,no need to test 3 times

//const int TIMER1 = 1;
//const int TIMER_EJECT = 2;
//const int INSERT_INTERVAL = 300;
//const int EJECT_INTERVAL = 300;
//const int INSERT_TRY_NUM = 200;
const int READ_TRY_NUM = 1;//oiltmp
//const int RESET_TRY_NUM = 3;
const int WAIT_TRY_NUM = 120;
const int WAIT_INTERVAL = 500;
const int MAX_RESET_TIMEROUT = 5000;
const int MAX_RESET_TIMES_PERIOD = 0;//oiltmp configure to ini file?

const int READ_TRY_INTERVAL = 300;
const int INIT_TRY_NUM = 1;
const int ACCEPT_TRY_INTERVAL = 200;
const int ACCEPT_TRY_NUM = 110;

class CCardIssuerEntity;
void CCardIssuerFSM::s0_on_entry()
{
	LOG_FUNCTION();
	SetDevState(DEVICE_STATUS_NOT_READY);
	FSMEvent* e;
	e = new FSMEvent(USER_EVT_INIT);
	PostEventFIFO(e);
}

void CCardIssuerFSM::s0_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CCardIssuerFSM::s0_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);

	switch (pEvt->iEvt)
	{
	case USER_EVT_INIT:
	{
		InitTask* task = new InitTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
		return 0;
	}
		break;
	case USER_EVT_QUIT:
		break;
	case USER_EVT_TEST:
		break;
	default:
		break;
	}
	return 0;
}
//Initializing
void CCardIssuerFSM::s1_on_entry()
{
	LOG_FUNCTION();
}
void CCardIssuerFSM::s1_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s1_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);

	if (pEvt->iEvt == USER_EVT_INITFINISHED) {
		pEvt->SetHandled();
		int err = pEvt->param1;
		if (err == 0) {
			return 0;
		} else {
			return 1;
		}
	}else if (pEvt->iEvt == USER_EVT_QUIT) {
		pEvt->SetHandled();
		return 0;
	}
	return 0;
}
//Idle
void CCardIssuerFSM::s2_on_entry()
{
	LOG_FUNCTION();
	SetDevState(DEVICE_STATUS_NORMAL);
	
	m_resetTimes = 0;
	m_testResult = Error_Succeed;
}

void CCardIssuerFSM::s2_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CCardIssuerFSM::s2_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);

	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_ACCEPT:
	{
		CardAcceptEvent *cae = dynamic_cast<CardAcceptEvent*>(pEvt);
		m_bCancelAccept = false;
		AcceptTask* task = new AcceptTask(this);
		task->ctx = cae->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_ISSUE_EX:
	{
		IssueTask* task = new IssueTask(this);
		CardIssueExEvent* ciee = NULL;
		ciee = dynamic_cast<CardIssueExEvent*>(pEvt);
		task->ctxEx = ciee->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		break;
	case USER_EVT_GET_MATERIAL_EX:
	{
		pEvt->SetHandled();
		GetMaterialExEvent *pGMEE = dynamic_cast<GetMaterialExEvent*>(pEvt);
		pGMEE->ctx->Ans.captured = m_CardCaptured;
		pGMEE->ctx->Ans.hasHopper.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardBoxNo.Init(m_hopperNum);
		pGMEE->ctx->Ans.PsbCode.Init(m_hopperNum);
		pGMEE->ctx->Ans.PsbName.Init(m_hopperNum);
		pGMEE->ctx->Ans.Maintainer.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardInit.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardPercent.Init(m_hopperNum);
		pGMEE->ctx->Ans.remains.Init(m_hopperNum);
		pGMEE->ctx->Ans.issued.Init(m_hopperNum);
		pGMEE->ctx->Ans.mixed.Init(m_hopperNum);
		pGMEE->ctx->Ans.MaintainTime.Init(m_hopperNum);
		pGMEE->ctx->Ans.reserved1.Init(m_hopperNum);
		pGMEE->ctx->Ans.reserved2.Init(m_hopperNum);
		for (int i = 0; i < m_hopperNum; ++i)
		{
			pGMEE->ctx->Ans.hasHopper[i] = m_bHasHopper[i];
			if (m_bHasHopper[i])
			{
				pGMEE->ctx->Ans.CardBoxNo[i] = m_CardBoxNoEx[i];
				pGMEE->ctx->Ans.PsbCode[i] = m_PsbCodeEx[i];
				pGMEE->ctx->Ans.PsbName[i] = m_PsbNameEx[i];
				pGMEE->ctx->Ans.Maintainer[i] = m_MaintainerEx[i];
				pGMEE->ctx->Ans.CardInit[i] = m_CardInitEx[i];
				pGMEE->ctx->Ans.CardPercent[i] = m_CardPercentEx[i];
				pGMEE->ctx->Ans.remains[i] = m_remainsEx[i];
				pGMEE->ctx->Ans.issued[i] = m_issuedEx[i];
				pGMEE->ctx->Ans.mixed[i] = m_mixedEx[i];
				pGMEE->ctx->Ans.MaintainTime[i] = "";
				pGMEE->ctx->Ans.reserved1[i] = 0;
				pGMEE->ctx->Ans.reserved2[i] = "";
			}
			else
			{
				pGMEE->ctx->Ans.CardBoxNo[i] = "";
				pGMEE->ctx->Ans.PsbCode[i] = "";
				pGMEE->ctx->Ans.PsbName[i] = "";
				pGMEE->ctx->Ans.Maintainer[i] = "";
				pGMEE->ctx->Ans.CardInit[i] = 0;
				pGMEE->ctx->Ans.CardPercent[i] = 0;
				pGMEE->ctx->Ans.remains[i] = 0;
				pGMEE->ctx->Ans.issued[i] = 0;
				pGMEE->ctx->Ans.mixed[i] = 0;
				pGMEE->ctx->Ans.MaintainTime[i] = "";
				pGMEE->ctx->Ans.reserved1[i] = 0;
				pGMEE->ctx->Ans.reserved2[i] = "";
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("GetMaterial CardBoxNo (%d):%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",i,
				pGMEE->ctx->Ans.CardBoxNo[i].GetData(),
				pGMEE->ctx->Ans.PsbCode[i].GetData(),
				pGMEE->ctx->Ans.PsbName[i].GetData(),
				pGMEE->ctx->Ans.CardInit[i],
				pGMEE->ctx->Ans.remains[i],
				pGMEE->ctx->Ans.issued[i],
				pGMEE->ctx->Ans.mixed[i]);
		}
		pGMEE->ctx->Ans.reserved2[0] = m_devCat.szVendor;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("captured:%d, szVendor:%s", m_CardCaptured, m_devCat.szVendor);
		pGMEE->ctx->Answer(Error_Succeed);
	}
		break;
	case USER_EVT_SET_MATERIAL_EX:
	{
		m_bSettingMaterial = true;
		pEvt->SetHandled();
		
		CSmallDateTime currTime = CSmallDateTime::GetNow();
		SetMaterialExEvent *pSMEE = dynamic_cast<SetMaterialExEvent*>(pEvt);
		bool bSetCapture = false;
		if (pSMEE->ctx->Req.SetCaptured == 1)
		{
			m_CardCaptured = pSMEE->ctx->Req.captured;
			m_MaintainerEx[0] = pSMEE->ctx->Req.Maintainer[0];
			m_MaintainTimeEx[0] = (DWORD)currTime;
			bSetCapture = SetCardCaptured(pSMEE->ctx->Req.captured,true);
										 
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("bSetCapture:%d, Req.SetCaptured:%d, Req.captured:%d, Req.Maintainer[0]:%s, Req.SetHopper.GetCount:%d",
			bSetCapture, pSMEE->ctx->Req.SetCaptured, pSMEE->ctx->Req.captured, pSMEE->ctx->Req.Maintainer[0].GetData(), pSMEE->ctx->Req.SetHopper.GetCount());
		bool bMaintain[12];
		memset(bMaintain, 0, 12);
		bool bNeedToSyncData = false;
		for (int i = 0; i < pSMEE->ctx->Req.SetHopper.GetCount(); ++i)
		{
			bMaintain[i] = false;
			if (pSMEE->ctx->Req.SetHopper[i] == 1)
			{
				bMaintain[i] = true;
				bNeedToSyncData = true;
				m_CardBoxNoEx[i] = pSMEE->ctx->Req.CardBoxNo[i];
				m_PsbCodeEx[i] = pSMEE->ctx->Req.PsbCode[i];
				m_PsbNameEx[i] = pSMEE->ctx->Req.PsbName[i];
				m_MaintainerEx[i] = pSMEE->ctx->Req.Maintainer[i];
				m_CardInitEx[i] = pSMEE->ctx->Req.CardInit[i];
				m_CardPercentEx[i] = pSMEE->ctx->Req.CardPercent[i];
				m_remainsEx[i] = pSMEE->ctx->Req.remains[i];
				m_issuedEx[i] = pSMEE->ctx->Req.issued[i];
				m_mixedEx[i] = pSMEE->ctx->Req.mixed[i];
				m_MaintainTimeEx[i] = (DWORD)currTime;
				m_csMaintainTimeEx[i] = currTime.GetNow().ToTimeString();

				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetMaterial, CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
					pSMEE->ctx->Req.CardBoxNo[i].GetData(),
					pSMEE->ctx->Req.PsbCode[i].GetData(),
					pSMEE->ctx->Req.PsbName[i].GetData(),
					pSMEE->ctx->Req.CardInit[i],
					pSMEE->ctx->Req.remains[i],
					pSMEE->ctx->Req.issued[i],
					pSMEE->ctx->Req.mixed[i]);
			}
		}
		pSMEE->ctx->Ans.reserved1.Init(1);
		pSMEE->ctx->Ans.reserved2.Init(1);
		pSMEE->ctx->Ans.reserved1[0] = 1;
		pSMEE->ctx->Ans.reserved2[0] = "";
		UpdateLocalRunCfg(pSMEE->ctx->Req.SetHopper);
		pSMEE->ctx->Answer(Error_Succeed);
		m_bSettingMaterial = false;
		if (bNeedToSyncData)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetMaterial, need to SyncDataToDB.");
			if (pSMEE->ctx->Req.SetCaptured == 1)
				SyncDataToDB(bMaintain);
			else
				SyncDataToDB(bMaintain, false);
		}
	}
		break;
	case USER_EVT_JS_INSERT:
	{
		InsertJSEvent* ise = dynamic_cast<InsertJSEvent*>(pEvt);
		m_bCancelInsert = false;
		m_bExit = false;
		InsertJSTask* task = new InsertJSTask(this);
		task->ctx = ise->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_JS_ISSUE_FROM_BOX:
	{
		IssueFromBoxJSTask* task = new IssueFromBoxJSTask(this);
		IssueFromBoxJSEvent* ife = dynamic_cast<IssueFromBoxJSEvent*>(pEvt);;
		task->ctx = ife->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
	}
		break;
	default:
		FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_IDLE);
		break;
	}
	return ret;
}
//Accepting
void CCardIssuerFSM::s3_on_entry()
{
	LOG_FUNCTION();
	m_bMainPageWhileWorking = false;
}
void CCardIssuerFSM::s3_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s3_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_ACCEPTFINISHED:
		{
			pEvt->SetHandled();
			switch(pEvt->param1)
			{
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
				ret = pEvt->param1;
				break;
			default:
				ret = 1;
				break;
			}
		}
		break;
	case USER_EVT_ACCEPT_CANCEL:
		m_bCancelAccept = true;
		pEvt->SetHandled();
		ret = 3;
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		break;
	case USER_EVT_JS_INSERT_FINISHED:
		{
			ret = pEvt->param1;
			if (ret == 1) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("插卡时查询设备状态故障");
			}
			else if (ret == 4) {
				//吐卡
				EjectJSEvent* eje = dynamic_cast<EjectJSEvent*>(pEvt);
				EjectJSTask* task = new EjectJSTask(this);
				task->ctx = NULL;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			}
			pEvt->SetHandled();
		}
		break;
	case USER_EVT_JS_INSERT_CANCEL:
		{
			m_bCancelInsert = true;
			pEvt->SetHandled();
			ret = 0;
		}
		break;
	case EVT_MAINPAGE_DISPLAY:
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("accepting...receive event of enter to main page");
		m_captureReason = "4001";
		m_bExit = true;
		m_bMainPageWhileWorking = true;
		pEvt->SetHandled();
		ret = 0;
	}
		break;
	default:
		FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_ACCEPT);
		break;
	}
	return ret;
}
//Hold
void CCardIssuerFSM::s4_on_entry()
{
	LOG_FUNCTION();
	if (m_bMainPageWhileWorking)
	{
		DoCheckCardTask* pTask = new DoCheckCardTask(this, CheckCard_OnMainPage);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
}
void CCardIssuerFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s4_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);

	switch(pEvt->iEvt){
		case USER_EVT_JS_READ:
			{
				ReadJSEvent* rje = dynamic_cast<ReadJSEvent*>(pEvt);
				ReadJSTask* task = new ReadJSTask(this);
				task->ctx = rje->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_POSTONLINE:
			{
				PostOnlineJSEvent* poe = dynamic_cast<PostOnlineJSEvent*>(pEvt);
				PostOnlineJSTask* task = new PostOnlineJSTask(this);
				task->ctx = poe->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_EJECT:
			{
				EjectJSEvent* eje = dynamic_cast<EjectJSEvent*>(pEvt);
				EjectJSTask* task = new EjectJSTask(this);
				task->ctx = eje->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_CAPTURE:
			{
				CaptureJSEvent* cje = dynamic_cast<CaptureJSEvent*>(pEvt);
				CaptureJSTask* task = new CaptureJSTask(this);
				task->ctx = cje->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case EVT_MAINPAGE_DISPLAY:
			{
				if (m_issueStatus) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("S4 receive exception exit to main page, begin capture card");
					m_captureReason = "4001";
					CaptureJSTask* task = new CaptureJSTask(this);
					task->ctx = NULL;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
					pEvt->SetHandled();
					return 1;
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("S4 receive exception exit to main page,begin eject card");
					EjectJSTask* task = new EjectJSTask(this);
					task->ctx = NULL;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
					pEvt->SetHandled();
					return 0;
				}
			}
		case USER_EVT_READ:
			{
				CardReadEvent* crne = dynamic_cast<CardReadEvent*>(pEvt);
				ReadTask* task = new ReadTask(this);
				task->ctx = crne->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_PREONLINE:
			{
				PreOnlineEvent* poe = dynamic_cast<PreOnlineEvent*>(pEvt);
				PreOnlineTask* task = new PreOnlineTask(this);
				task->ctx = poe->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_POSTONLINE:
			{
				PostOnlineEvent* poe = dynamic_cast<PostOnlineEvent*>(pEvt);
				PostOnlineTask* task = new PostOnlineTask(this);
				task->ctx = poe->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_CAPTURE:
			{
				CardCaptureEvent *cce = dynamic_cast<CardCaptureEvent*>(pEvt);
				CaptureTask *task=  new CaptureTask(this);
				task->ctx = cce->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				//oilyang@20171215 经与郭丹汪磊东宋锐讨论，目前不存在4022的情况，暂时以4019代替
				//m_captureReason = "4022";
				m_captureReason = "4019";
				return 0;
			}
		case USER_EVT_EJECT:
			{
				CardEjectEvent *cee;
				if (pEvt->iEvt == USER_EVT_EJECT)
					cee = dynamic_cast<CardEjectEvent*>(pEvt);
				EjectTask *task=  new EjectTask(this);
				if (pEvt->iEvt == USER_EVT_EJECT)
					task->ctx = cee->ctx;
				else
					task->ctx = NULL;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_QUIT:
			{
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_GET_MATERIAL_EX:
		{
			pEvt->SetHandled();
			GetMaterialExEvent *pGMEE = dynamic_cast<GetMaterialExEvent*>(pEvt);
			pGMEE->ctx->Ans.captured = m_CardCaptured;
			pGMEE->ctx->Ans.hasHopper.Init(m_hopperNum);
			pGMEE->ctx->Ans.CardBoxNo.Init(m_hopperNum);
			pGMEE->ctx->Ans.PsbCode.Init(m_hopperNum);
			pGMEE->ctx->Ans.PsbName.Init(m_hopperNum);
			pGMEE->ctx->Ans.Maintainer.Init(m_hopperNum);
			pGMEE->ctx->Ans.CardInit.Init(m_hopperNum);
			pGMEE->ctx->Ans.CardPercent.Init(m_hopperNum);
			pGMEE->ctx->Ans.remains.Init(m_hopperNum);
			pGMEE->ctx->Ans.issued.Init(m_hopperNum);
			pGMEE->ctx->Ans.mixed.Init(m_hopperNum);
			pGMEE->ctx->Ans.MaintainTime.Init(m_hopperNum);
			pGMEE->ctx->Ans.reserved1.Init(m_hopperNum);
			pGMEE->ctx->Ans.reserved2.Init(m_hopperNum);
			for (int i = 0; i < m_hopperNum; ++i)
			{
				pGMEE->ctx->Ans.hasHopper[i] = m_bHasHopper[i];
				if (m_bHasHopper[i])
				{
					pGMEE->ctx->Ans.CardBoxNo[i] = m_CardBoxNoEx[i];
					pGMEE->ctx->Ans.PsbCode[i] = m_PsbCodeEx[i];
					pGMEE->ctx->Ans.PsbName[i] = m_PsbNameEx[i];
					pGMEE->ctx->Ans.Maintainer[i] = m_MaintainerEx[i];
					pGMEE->ctx->Ans.CardInit[i] = m_CardInitEx[i];
					pGMEE->ctx->Ans.CardPercent[i] = m_CardPercentEx[i];
					pGMEE->ctx->Ans.remains[i] = m_remainsEx[i];
					pGMEE->ctx->Ans.issued[i] = m_issuedEx[i];
					pGMEE->ctx->Ans.mixed[i] = m_mixedEx[i];
					//to be added maintain time oiltmp
					pGMEE->ctx->Ans.MaintainTime[i] = "";
					pGMEE->ctx->Ans.reserved1[i] = 0;
					pGMEE->ctx->Ans.reserved2[i] = "";
				}
				else
				{
					pGMEE->ctx->Ans.CardBoxNo[i] = "";
					pGMEE->ctx->Ans.PsbCode[i] = "";
					pGMEE->ctx->Ans.PsbName[i] = "";
					pGMEE->ctx->Ans.Maintainer[i] = "";
					pGMEE->ctx->Ans.CardInit[i] = 0;
					pGMEE->ctx->Ans.CardPercent[i] = 0;
					pGMEE->ctx->Ans.remains[i] = 0;
					pGMEE->ctx->Ans.issued[i] = 0;
					pGMEE->ctx->Ans.mixed[i] = 0;
					pGMEE->ctx->Ans.MaintainTime[i] = "";
					pGMEE->ctx->Ans.reserved1[i] = 0;
					pGMEE->ctx->Ans.reserved2[i] = "";
				}
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("GetMaterial, CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
					pGMEE->ctx->Ans.CardBoxNo[i].GetData(),
					pGMEE->ctx->Ans.PsbCode[i].GetData(),
					pGMEE->ctx->Ans.PsbName[i].GetData(),
					pGMEE->ctx->Ans.CardInit[i],
					pGMEE->ctx->Ans.remains[i],
					pGMEE->ctx->Ans.issued[i],
					pGMEE->ctx->Ans.mixed[i]));
			}
			pGMEE->ctx->Ans.reserved2[0] = m_devCat.szVendor;
			pGMEE->ctx->Answer(Error_Succeed);
		}
			break;
		case USER_EVT_SET_MATERIAL_EX:
		{
			m_bSettingMaterial = true;
			pEvt->SetHandled();
			//SetCardRemains???oiltmp
			CSmallDateTime currTime = CSmallDateTime::GetNow();
			SetMaterialExEvent *pSMEE = dynamic_cast<SetMaterialExEvent*>(pEvt);
			bool bSetCapture = false;
			if (pSMEE->ctx->Req.SetCaptured == 1)
			{
				m_CardCaptured = pSMEE->ctx->Req.captured;
				m_MaintainerEx[0] = pSMEE->ctx->Req.Maintainer[0];
				m_MaintainTimeEx[0] = (DWORD)currTime;
				bSetCapture = SetCardCaptured(pSMEE->ctx->Req.captured,true);
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("bSetCapture:%d, Req.SetCaptured:%d, Req.captured:%d, Req.Maintainer[0]:%s, Req.SetHopper.GetCount:%d",
				bSetCapture, pSMEE->ctx->Req.SetCaptured, pSMEE->ctx->Req.captured, pSMEE->ctx->Req.Maintainer[0].GetData(), pSMEE->ctx->Req.SetHopper.GetCount()));
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			bool bNeedToSyncData = false;
			for (int i = 0; i < pSMEE->ctx->Req.SetHopper.GetCount(); ++i)
			{
				bMaintain[i] = false;
				if (pSMEE->ctx->Req.SetHopper[i] == 1)
				{
					bMaintain[i] = true;
					bNeedToSyncData = true;
					m_CardBoxNoEx[i] = pSMEE->ctx->Req.CardBoxNo[i];
					m_PsbCodeEx[i] = pSMEE->ctx->Req.PsbCode[i];
					m_PsbNameEx[i] = pSMEE->ctx->Req.PsbName[i];
					m_MaintainerEx[i] = pSMEE->ctx->Req.Maintainer[i];
					m_CardInitEx[i] = pSMEE->ctx->Req.CardInit[i];
					m_CardPercentEx[i] = pSMEE->ctx->Req.CardPercent[i];
					m_remainsEx[i] = pSMEE->ctx->Req.remains[i];
					m_issuedEx[i] = pSMEE->ctx->Req.issued[i];
					m_mixedEx[i] = pSMEE->ctx->Req.mixed[i];
					m_MaintainTimeEx[i] = (DWORD)currTime;
					m_csMaintainTimeEx[i] = currTime.GetNow().ToTimeString();

					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("SetMaterial, CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
						pSMEE->ctx->Req.CardBoxNo[i].GetData(),
						pSMEE->ctx->Req.PsbCode[i].GetData(),
						pSMEE->ctx->Req.PsbName[i].GetData(),
						pSMEE->ctx->Req.CardInit[i],
						pSMEE->ctx->Req.remains[i],
						pSMEE->ctx->Req.issued[i],
						pSMEE->ctx->Req.mixed[i]));
				}
			}
			pSMEE->ctx->Ans.reserved1.Init(1);
			pSMEE->ctx->Ans.reserved2.Init(1);
			pSMEE->ctx->Ans.reserved1[0] = 0;
			pSMEE->ctx->Ans.reserved2[0] = "";
			UpdateLocalRunCfg(pSMEE->ctx->Req.SetHopper);
			pSMEE->ctx->Answer(Error_Succeed);
			m_bSettingMaterial = false;
			if (bNeedToSyncData)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetMaterial, need to SyncDataToDB.");
				if (pSMEE->ctx->Req.SetCaptured == 1)
					SyncDataToDB(bMaintain);
				else
					SyncDataToDB(bMaintain, false);
			}
		}
			break;
		case USER_EVT_CHECK_CARD_FINISHED:
			return pEvt->param1;
		default:
			FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_HOLD);
			break;
	}
	return 0;
}
//Reading
void CCardIssuerFSM::s5_on_entry()
{
	LOG_FUNCTION();
	m_bMainPageWhileWorking = false;
}
void CCardIssuerFSM::s5_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s5_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_READ_FINISHED:
		{
			pEvt->SetHandled();
			CardReadFinishedEvent *pCRNFE = dynamic_cast<CardReadFinishedEvent *>(pEvt);
			ret = pCRNFE->param1;
		}
		break;
	case EVT_MAINPAGE_DISPLAY:
		{
			pEvt->SetHandled();
			m_captureReason = "4001";
			m_bMainPageWhileWorking = true;
		}
		break;
	case USER_EVT_QUIT:
		{
			pEvt->SetHandled();
			ret = 0;
		}
	case USER_EVT_PREONLINEFINISHED:
		pEvt->SetHandled();
		ret = 0;
		break;
	default:
		FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_READ);
		break;
	}
	return ret;
}
//Ejecting
void CCardIssuerFSM::s6_on_entry()
{
	LOG_FUNCTION();
}
void CCardIssuerFSM::s6_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s6_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);
	switch (pEvt->iEvt)
	{
	case USER_EVT_EJECTFINISHED:
	{
		pEvt->SetHandled();
		if (pEvt->param1 == 0)
			return 0;
		else
			return 1;
	}
	case USER_EVT_QUIT:
	{
		pEvt->SetHandled();
		return 0;
	}
	case USER_EVT_JS_EJECT_FINISHED:
	{
		pEvt->SetHandled();
		if (pEvt->param1 == 0) {
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand op.");
			m_currCardNo = "";
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("客户取走卡片");
			return 0;
		}
		else if (pEvt->param1 == 1) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("取卡时设备故障");
			return 1;
		}
	}
	default:
		FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_EJECT);
		break;
	}
	return 0;
}
//Waiting fetch
void CCardIssuerFSM::s7_on_entry()
{
	LOG_FUNCTION();
	WaitFetchingTask* task = new WaitFetchingTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
}
void CCardIssuerFSM::s7_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s7_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);
	switch (pEvt->iEvt)
	{
	case USER_EVT_WAITFINISHED:
	{
		pEvt->SetHandled();
		if (pEvt->param1 == 0) {
			FetchCard evt;
			evt.status = 0;
			SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(FetchCard), SP_MSG_SIG_OF(FetchCard), evt);
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand op.");
			m_currCardNo = "";
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("客户取走卡片msg发送");
			return 0;
		}
		else if (pEvt->param1 == 1) {
			FetchCard evt;
			evt.status = 1;
			SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(FetchCard), SP_MSG_SIG_OF(FetchCard), evt);
			return 1;
		}
		else {
			FetchCard evt;
			evt.status = 2;
			SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(FetchCard), SP_MSG_SIG_OF(FetchCard), evt);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("客户未取卡超时msg发送");
			m_captureReason = "4019";
			LogWarn(Severity_Low, Error_NotInit, CardIssuer_UserErrorCode_Customer_Forget_Fectch_Card, "Customer forget fetch card.");
			CaptureTask* task = new CaptureTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 2;
		}
	}
	case USER_EVT_QUIT:
	{
		pEvt->SetHandled();
		return 0;
	}
	case USER_EVT_GET_MATERIAL_EX:
	{
		pEvt->SetHandled();
		GetMaterialExEvent *pGMEE = dynamic_cast<GetMaterialExEvent*>(pEvt);
		pGMEE->ctx->Ans.captured = m_CardCaptured;
		pGMEE->ctx->Ans.hasHopper.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardBoxNo.Init(m_hopperNum);
		pGMEE->ctx->Ans.PsbCode.Init(m_hopperNum);
		pGMEE->ctx->Ans.PsbName.Init(m_hopperNum);
		pGMEE->ctx->Ans.Maintainer.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardInit.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardPercent.Init(m_hopperNum);
		pGMEE->ctx->Ans.remains.Init(m_hopperNum);
		pGMEE->ctx->Ans.issued.Init(m_hopperNum);
		pGMEE->ctx->Ans.mixed.Init(m_hopperNum);
		pGMEE->ctx->Ans.MaintainTime.Init(m_hopperNum);
		pGMEE->ctx->Ans.reserved1.Init(m_hopperNum);
		pGMEE->ctx->Ans.reserved2.Init(m_hopperNum);
		for (int i = 0; i < m_hopperNum; ++i)
		{
			pGMEE->ctx->Ans.hasHopper[i] = m_bHasHopper[i];
			if (m_bHasHopper[i])
			{
				pGMEE->ctx->Ans.CardBoxNo[i] = m_CardBoxNoEx[i];
				pGMEE->ctx->Ans.PsbCode[i] = m_PsbCodeEx[i];
				pGMEE->ctx->Ans.PsbName[i] = m_PsbNameEx[i];
				pGMEE->ctx->Ans.Maintainer[i] = m_MaintainerEx[i];
				pGMEE->ctx->Ans.CardInit[i] = m_CardInitEx[i];
				pGMEE->ctx->Ans.CardPercent[i] = m_CardPercentEx[i];
				pGMEE->ctx->Ans.remains[i] = m_remainsEx[i];
				pGMEE->ctx->Ans.issued[i] = m_issuedEx[i];
				pGMEE->ctx->Ans.mixed[i] = m_mixedEx[i];
				//to be added maintain time oiltmp
				pGMEE->ctx->Ans.MaintainTime[i] = "";
				pGMEE->ctx->Ans.reserved1[i] = 0;
				pGMEE->ctx->Ans.reserved2[i] = "";
			}
			else
			{
				pGMEE->ctx->Ans.CardBoxNo[i] = "";
				pGMEE->ctx->Ans.PsbCode[i] = "";
				pGMEE->ctx->Ans.PsbName[i] = "";
				pGMEE->ctx->Ans.Maintainer[i] = "";
				pGMEE->ctx->Ans.CardInit[i] = 0;
				pGMEE->ctx->Ans.CardPercent[i] = 0;
				pGMEE->ctx->Ans.remains[i] = 0;
				pGMEE->ctx->Ans.issued[i] = 0;
				pGMEE->ctx->Ans.mixed[i] = 0;
				pGMEE->ctx->Ans.MaintainTime[i] = "";
				pGMEE->ctx->Ans.reserved1[i] = 0;
				pGMEE->ctx->Ans.reserved2[i] = "";
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("GetMaterial, CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
				pGMEE->ctx->Ans.CardBoxNo[i].GetData(),
				pGMEE->ctx->Ans.PsbCode[i].GetData(),
				pGMEE->ctx->Ans.PsbName[i].GetData(),
				pGMEE->ctx->Ans.CardInit[i],
				pGMEE->ctx->Ans.remains[i],
				pGMEE->ctx->Ans.issued[i],
				pGMEE->ctx->Ans.mixed[i]);
		}
		pGMEE->ctx->Ans.reserved2[0] = m_devCat.szVendor;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("captured:%d, szVendor:%s", m_CardCaptured, m_devCat.szVendor);
		pGMEE->ctx->Answer(Error_Succeed);
	}
		break;
	case USER_EVT_SET_MATERIAL_EX:
	{
		m_bSettingMaterial = true;
		pEvt->SetHandled();
		//SetCardRemains???oiltmp
		CSmallDateTime currTime = CSmallDateTime::GetNow();
		SetMaterialExEvent *pSMEE = dynamic_cast<SetMaterialExEvent*>(pEvt);
		bool bSetCapture = false;
		if (pSMEE->ctx->Req.SetCaptured == 1)
		{
			m_CardCaptured = pSMEE->ctx->Req.captured;
			m_MaintainerEx[0] = pSMEE->ctx->Req.Maintainer[0];
			m_MaintainTimeEx[0] = (DWORD)currTime;
			bSetCapture = SetCardCaptured(pSMEE->ctx->Req.captured,true);
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("bSetCapture:%d, Req.SetCaptured:%d, Req.captured:%d, Req.Maintainer[0]:%s, Req.SetHopper.GetCount:%d",
			bSetCapture, pSMEE->ctx->Req.SetCaptured, pSMEE->ctx->Req.captured, pSMEE->ctx->Req.Maintainer[0].GetData(), pSMEE->ctx->Req.SetHopper.GetCount());
		bool bMaintain[12];
		memset(bMaintain, 0, 12);
		bool bNeedToSyncData = false;
		for (int i = 0; i < pSMEE->ctx->Req.SetHopper.GetCount(); ++i)
		{
			bMaintain[i] = false;
			if (pSMEE->ctx->Req.SetHopper[i] == 1)
			{
				bMaintain[i] = true;
				bNeedToSyncData = true;
				m_CardBoxNoEx[i] = pSMEE->ctx->Req.CardBoxNo[i];
				m_PsbCodeEx[i] = pSMEE->ctx->Req.PsbCode[i];
				m_PsbNameEx[i] = pSMEE->ctx->Req.PsbName[i];
				m_MaintainerEx[i] = pSMEE->ctx->Req.Maintainer[i];
				m_CardInitEx[i] = pSMEE->ctx->Req.CardInit[i];
				m_CardPercentEx[i] = pSMEE->ctx->Req.CardPercent[i];
				m_remainsEx[i] = pSMEE->ctx->Req.remains[i];
				m_issuedEx[i] = pSMEE->ctx->Req.issued[i];
				m_mixedEx[i] = pSMEE->ctx->Req.mixed[i];
				m_MaintainTimeEx[i] = (DWORD)currTime;
				m_csMaintainTimeEx[i] = currTime.GetNow().ToTimeString();

				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetMaterial, CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
					pSMEE->ctx->Req.CardBoxNo[i].GetData(),
					pSMEE->ctx->Req.PsbCode[i].GetData(),
					pSMEE->ctx->Req.PsbName[i].GetData(),
					pSMEE->ctx->Req.CardInit[i],
					pSMEE->ctx->Req.remains[i],
					pSMEE->ctx->Req.issued[i],
					pSMEE->ctx->Req.mixed[i]);
			}
		}
		pSMEE->ctx->Ans.reserved1.Init(1);
		pSMEE->ctx->Ans.reserved2.Init(1);
		pSMEE->ctx->Ans.reserved1[0] = 0;
		pSMEE->ctx->Ans.reserved2[0] = "";
		UpdateLocalRunCfg(pSMEE->ctx->Req.SetHopper);
		pSMEE->ctx->Answer(Error_Succeed);
		m_bSettingMaterial = false;
		if (bNeedToSyncData)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetMaterial, need to SyncDataToDB.");
			if (pSMEE->ctx->Req.SetCaptured == 1)
				SyncDataToDB(bMaintain);
			else
				SyncDataToDB(bMaintain, false);
		}				 
	}
		break;

	default:
		FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_WAIT_FETCH);
		break;
	}
	return 0;
}
void CCardIssuerFSM::s8_on_entry()
{
	LOG_FUNCTION();
}
void CCardIssuerFSM::s8_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s8_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);
	switch (pEvt->iEvt)
	{
	case USER_EVT_CAPTUREFINISHED:
	{
		pEvt->SetHandled();
		if (pEvt->param1 == 0)
			return 0;
		else
			return 1;
	}
	case USER_EVT_JS_CAPTURE_FINISHED:
	{
		pEvt->SetHandled();
		if (pEvt->param1 == 0) {
			return 0;
		}
		else {
			return 1;
		}
	}
	case USER_EVT_QUIT:
	{
		pEvt->SetHandled();
		return 0;
	}
	default:
		FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_CAPTURE);
		break;
	}
	return 0;
}
//Failed
void CCardIssuerFSM::s9_on_entry()
{
	LOG_FUNCTION();
	if (GetDevInitFlag())
	{
		DoCheckCardTask* pTask = NULL;
		if (m_iInWhatPage == PageType_MainPage)
			pTask = new DoCheckCardTask(this, CheckCard_OnMainPage);
		else
			pTask = new DoCheckCardTask(this, CheckCard_OnFail);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
}
void CCardIssuerFSM::s9_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s9_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		return 0;
	case USER_EVT_CHECK_CARD_FINISHED:
		return pEvt->param1;
	case USER_EVT_ACCEPT_CANCEL:
		m_bCancelAccept = true;
		pEvt->SetHandled();
		break;
	default:
		FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_FAULT);
		break;
	}

	return 0;
}
//Issuing
void CCardIssuerFSM::s10_on_entry()
{
	LOG_FUNCTION();
	m_bMainPageWhileWorking = false;
}
void CCardIssuerFSM::s10_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s10_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_ISSUE_EX_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case EVT_MAINPAGE_DISPLAY:
		pEvt->SetHandled();
		m_captureReason = "4001";
		m_bMainPageWhileWorking = true;
		break;
	case USER_EVT_ACCEPT_CANCEL:
		pEvt->SetHandled();
		break;
	default:
		FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_ISSUE);
		break;
	}
	return ret;
}
//ReadJSing
void CCardIssuerFSM::s11_on_entry()
{
	LOG_FUNCTION();
	m_bMainPageWhileWorking = false;
}
void CCardIssuerFSM::s11_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s11_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_JS_POSTONLINE_FINISHED:
	{
		pEvt->SetHandled();
		ret = 0;
	}
	break;
	case USER_EVT_JS_READ_FINISHED:
	{
		pEvt->SetHandled();
		if (pEvt->param1 == 0) {
			ret = 0;
		}
		else if (pEvt->param1 == 1) {
			ret = 1;
		}
	}
	break;
	case EVT_MAINPAGE_DISPLAY:
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ReadJSing...receive event of enter to main page");
		pEvt->SetHandled();
		m_captureReason = "4001";
		m_bMainPageWhileWorking = true;
		ret = 0;
	}
	break;
	default:
		FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_READ);
		break;
	}
	return ret;
}
//IssueJSing
void CCardIssuerFSM::s12_on_entry()
{
	LOG_FUNCTION();
	m_bMainPageWhileWorking = false;
}
void CCardIssuerFSM::s12_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s12_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s evt (%d,%d)", GetCurrStateName(), pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_JS_ISSUE_FROM_BOX_FINISHED:
	{
		pEvt->SetHandled();
		ret = pEvt->param1;
		if (ret == 2) {
		}
		else if (ret == 1) {
		}
	}
	break;
	case EVT_MAINPAGE_DISPLAY:
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IssueJSing...receive event of enter to main page");
		pEvt->SetHandled();
		m_captureReason = "4001";
		m_bMainPageWhileWorking = true;
	}
	break;
	default:
		FSMEventDefaultProcess(pEvt, CardIssuer_UserErrorCode_PROCESS_ISSUE);
		break;
	}
	return ret;
}

ErrorCodeEnum CCardIssuerFSM::OnInit()
{
	LOG_FUNCTION();
	AddStateHooker(this);
	m_pCardProcess = new CCardProcess();
	if (m_pCardProcess == NULL)//almost no use...
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CY")("create card process failed.");
		return Error_Resource;
	}
	CSystemStaticInfo sysInfo;
	//oilyang 20160331
	//so many function always return Error_Succeed,so is useless to process it.
	m_csMachineType = m_terminalNo = "";
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	m_csMachineType = sysInfo.strMachineType;
	m_terminalNo = sysInfo.strTerminalID;

	m_devStatus.eMedia = CI_MEDIA_NOTPRESENT;
	m_bHasHopper[0] = false;
	m_bHasHopper[1] = false;
	m_bHasHopper[2] = false;

	m_bSupportRF = false;
	return Error_Succeed;
}
ErrorCodeEnum CCardIssuerFSM::OnExit()
{
	FSMImpl<CCardIssuerFSM>::OnExit();
	return Error_Succeed;
}


void TestShowRecvData(PBYTE hexBuf,DWORD len)
{
	char* show = new char[MAX_TEST_SHOW];
	ZeroMemory(show,MAX_TEST_SHOW);
	HexBuf2StrBuf(hexBuf,&show,len);
	delete[] show;
}

int FindHexCharPosition(LPBYTE data, BYTE hexChar, int len)
{
	int notExist = -1,ret = 1,pos = 0;
	for (; pos < len; ++pos)
	{

		BYTE high = (*(data+pos))&0xf0;
		BYTE low = (*(data+pos))&0x0f;

		if ((high>>4) != hexChar)
			ret++;
		else
			return ret;

		if (low != hexChar)
			ret++;
		else
			return ret;
	}
	ret = notExist;
	return ret;
}

bool CCardIssuerFSM::LoadCMBPrint(CSimpleStringA csBinPath)
{
	if (cmdDecodeEx == NULL) {
		CSimpleStringA csCMBPrint("");
		//TODO: CrossPlaform  [Gifur@2025730]
#ifdef RVC_OS_LINUX
		csCMBPrint = "libCMBPrint.so";
		csCMBPrint = csBinPath + "/" + csCMBPrint;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("cmbpath %s", (const char*)csCMBPrint);
		void* hr = NULL;
		hr = dlopen(csCMBPrint, RTLD_LAZY);
		if (hr == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Load CMBPrint failed(%s).", dlerror());
			return false;
		}
		//pfunc_unpack = (PF_unpack)dlsym(hLib, "_Z6unpackPcS_i");
		if ((cmdDecodeMag2 = (lpCMBdecodeMag2)dlsym(hr, "CMBdecodeMag2")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Get Mag2 address failed.");
			return false;
		}
		if ((cmdDecodeEx = (lpCMBdecodeEx)dlsym(hr, "CMBdecodeEx")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Get Mag23Ex address failed.");
			cmdDecodeMag2 = NULL;
			return false;
		}
#else
		csCMBPrint = "CMBPrint.dll";
		csCMBPrint = csBinPath + SPLIT_SLASH_STR + csCMBPrint;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("cmbpath %s", (const char*)csCMBPrint);
		HMODULE hr = LoadLibraryA(csCMBPrint);
		if (hr == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Load CMBPrint failed(%d).", hr);
			return false;
		}
		if ((cmdDecodeMag2 = (lpCMBdecodeMag2)GetProcAddress(hr, "CMBdecodeMag2")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Get Mag2 address failed.");
			return false;
		}
		if ((cmdDecodeEx = (lpCMBdecodeEx)GetProcAddress(hr, "CMBdecodeEx")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Get Mag23Ex address failed.");
			cmdDecodeMag2 = NULL;
			return false;
		}
#endif
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Load %s suc.", (const char*)csCMBPrint);
	}

	return true;
}
ErrorCodeEnum CCardIssuerFSM::OpenDevice(BYTE btOpenType, const char* pDevSN)
{
	LOG_FUNCTION();
	m_devOpenFailedCount++;
	ErrorCodeEnum eErrDev;
	CSimpleString errMsg(true);

	CSimpleStringA dllName;
	GetVendorDllName(dllName);

	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig, spConfigCS;

	CSimpleStringA csBinPath, csBackslash("\\");
	ErrorCodeEnum eErrPath = spEntityFunction->GetPath("Bin", csBinPath);
	if (eErrPath != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("GetPath(bin) failed (%d) in OpenDevice.", eErrPath));
		return Error_Param;
	}
	//  [9/29/2019 14:13 @Gifur]
	CloseAndClearDevObj(false);
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->InitializeVendorLogSwitch();

	eErrDev = LoadUpAdapterLibrary(dllName);
	if (!IS_SUCCEED(eErrDev))
	{
		errMsg = CSimpleStringA::Format("Load vendor adapter failed.%d", GetLastError());
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_LoadLibraryA_Failed, errMsg.GetData());
		GetEntityBase()->GetFunction()->ShowFatalError("加载厂商适配器失败！请检查root.ini配置是否正确。");
		return Error_DevLoadFileFailed;
	}

	for (int i = 0; i < HOPPER_NUM; ++i)
	{
		m_CardBoxNoEx[i] = "";
		m_PsbCodeEx[i] = "";
		m_PsbNameEx[i] = "";
		m_MaintainerEx[i] = "";
		m_CardInitEx[i] = 0;
		m_CardPercentEx[i] = 0;
		m_remainsEx[i] = 0;
		m_issuedEx[i] = 0;
		m_mixedEx[i] = 0;
		m_csMaintainTimeEx[i] = "";
		m_MaintainTimeEx[i] = 0;
	}
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	eErrDev = m_hDevHelper->DevOpenEx(m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt(), btOpenType, pDevSN, m_connectType);
	l_endTime = GetTickCountRVC();

	if (eErrDev == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpenEx").setCostTime(l_endTime - l_beginTime)("OpenDevice::DevOpenEx succ, port:%d, baudRate:%d, openType:%d, connectType:%d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt(), btOpenType, m_connectType);
		m_devOpenFailedCount = 0;
		ZeroMemory(m_devCat.szModel, sizeof(m_devCat.szModel));
		ZeroMemory(m_devCat.szType, sizeof(m_devCat.szType));
		ZeroMemory(m_devCat.szVendor, sizeof(m_devCat.szVendor));
		l_beginTime = GetTickCountRVC();
		eErrDev = m_hDevHelper->GetDevCategory(m_devCat);
		l_endTime = GetTickCountRVC();

		if (eErrDev == Error_Succeed)
		{
			int ret = SplitDevModelInfo();
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevCategory").setCostTime(l_endTime - l_beginTime)("OpenDevice::GetDevCategory SplitDevModelInfo=%d", ret);
			m_adapterInfo.FulfillCategoryInfo(m_devCat);
		}
		else
		{
			SetErrorAndLog(eErrDev, MEC_DEVAPI_CARDISSUER_GetDevCategory, "DevAdapter::GetDevCategory", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
			return Error_Unexpect;
		}

		if (!LoadCMBPrint(csBinPath))
		{
			errMsg = CSimpleStringA::Format("CardIssuerStand启动失败:Load CMBPrint failed.");
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_LoadLibraryA_CMBPrint_Failed, errMsg.GetData());
			return Error_DevLoadFileFailed;
		}
	}
	else {
		errMsg = CSimpleStringA::Format("OpenDevice::DevOpenEx err, port:%d, baudRate:%d, openType:%d, connectType:%d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt(), btOpenType, m_connectType);
		SetErrorAndLog(eErrDev, MEC_DEVAPI_CARDISSUER_DevOpenEx, "DevAdapter::DevOpenEx", __FUNCTION__, false, l_endTime - l_beginTime, "", errMsg.GetData());
		return Error_DevCommFailed;
	}

	eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("CardIssuerStand启动失败:open run cfg file failed in OpenDevice."));
		CloseAndClearDevObj(false);
		return eErrDev;
	}
	int ret = 0;
	spConfig->ReadConfigValueInt("all", "HopperNum", m_hopperNum);
	spConfig->ReadConfigValueInt("all", "CardCaptured", m_CardCaptured);

	if (btOpenType == DEV_OPEN_TYPE_COM)
	{
		//oiltest@20201118 for songrui 
		if (m_csMachineType.Compare("RVC.CardPrinter") == 0)
			m_hopperNum = 5;
		else
		{
			if (m_connectType >= 1 && m_connectType <= 3)
				m_hopperNum = m_connectType;
			else
			{
				//oiltmp if "RVC.CardPrinter" the m_hopperNum is 6,where can this num come from?
				if (m_csMachineType.Compare("RVC.CardPrinter") == 0)
					m_hopperNum = 5;
				else
					m_hopperNum = 3;
			}
		}
		for (int i = 0; i < m_hopperNum; ++i)
			m_bHasHopper[i] = true;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("has %d hopper.", m_hopperNum));
	char sec[2];
	for (int i = 0; i < m_hopperNum; ++i)
	{
		ZeroMemory(sec, 2);
		_itoa(i + 1, (char*)sec, 10);
		spConfig->ReadConfigValue(sec, "CardBoxNo", m_CardBoxNoEx[i]);
		spConfig->ReadConfigValue(sec, "PsbCode", m_PsbCodeEx[i]);
		spConfig->ReadConfigValue(sec, "PsbName", m_PsbNameEx[i]);
		spConfig->ReadConfigValueInt(sec, "CardInit", m_CardInitEx[i]);
		spConfig->ReadConfigValueInt(sec, "CardRemains", m_remainsEx[i]);
		spConfig->ReadConfigValueInt(sec, "CardIssued", m_issuedEx[i]);
		spConfig->ReadConfigValueInt(sec, "CardMixed", m_mixedEx[i]);
		spConfig->ReadConfigValueInt(sec, "CardPercent", m_CardPercentEx[i]);
		spConfig->ReadConfigValue(sec, "Maintainer", m_MaintainerEx[i]);
		spConfig->ReadConfigValue(sec, "MaintainTime", m_csMaintainTimeEx[i]);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("init cardbox, CardBoxNo:%s, PsbCodeEx:%s, PsbNameEx:%s, CardInit:%d, CardRemains:%d, CardIssued:%d, CardMixed:%d",
			m_CardBoxNoEx[i].GetData(),
			m_PsbCodeEx[i].GetData(),
			m_PsbNameEx[i].GetData(),
			m_CardInitEx[i],
			m_remainsEx[i],
			m_issuedEx[i],
			m_mixedEx[i]));
	}
	if (m_hopperNum == 1 && btOpenType == DEV_OPEN_TYPE_COM)//oilyang 如果没有配置，使用原来的配置
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("use new hopper cfg record"));
	}
	//oilyang 回写卡机配置
	spConfig->WriteConfigValueInt("all", "HopperNum", m_hopperNum);
	spConfig->WriteConfigValueInt("1", "CardPercent", m_CardPercentEx[0]);
	spEntityFunction->OpenConfig(Config_CenterSetting, spConfigCS);

	int tmpCheckInterval = 200;

	spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "CheckCardInInterval", tmpCheckInterval);
	spConfigCS->ReadConfigValue(GetEntityBase()->GetEntityName(), "RFVendorList", m_rfVendorList);
	spConfigCS->ReadConfigValue(GetEntityBase()->GetEntityName(), "SwallowCardUrl", m_csSwallowCardUrl);
	spConfigCS->ReadConfigValue(GetEntityBase()->GetEntityName(), "SyncMaterialUrl", m_csSyncMaterialUrl);

	if (tmpCheckInterval >= 100 && tmpCheckInterval <= 1000)
		m_iCheckCardInInterval = tmpCheckInterval;


	ret = CheckIfHasCardOnCase(CheckCard_OnOpen);

	if (ret == 0)
	{
		//oilyang@20191219 获取吞卡箱容量，目前有便携卡机，大机
		//超过5，认为是脏数据，用默认值3
		CardIssuerStatus cis;
		l_beginTime = GetTickCountRVC();
		eErrDev = m_hDevHelper->GetDevStatus(cis);
		l_endTime = GetTickCountRVC();

		if (eErrDev != Error_Succeed) {
			SetErrorAndLog(eErrDev, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("OpenDevice::GetDevStatus device max retain count:%d, cis.eRetainBin:%d", cis.dwRetainCount, cis.eRetainBin);
			if (cis.dwRetainCount > 0 && cis.dwRetainCount <= 5)
				m_maxRetainCount = cis.dwRetainCount;
			else
				m_maxRetainCount = 3;
			if (cis.eRetainBin == CI_RETAINBIN_FULL)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23B8")("sensor say:retain bin is full!回收箱满了，请及时清理！");
			}
		}
		return Error_Succeed;
	}
	else
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Open_Failed, "启动后检查是否有卡或处理吞卡失败");
		return Error_Unexpect;
	}
}

int CCardIssuerFSM::Initial()
{
	m_bOpening = true;
	ErrorCodeEnum errCode = OpenDevice(DEV_OPEN_TYPE_COM,"");
	if (errCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("OpenDevice in Initial return failed with errCode:%d(0x%x)", errCode, errCode);
		CloseAndClearDevObj(false);
		SetDevInitFlag(false);
	}
	else
		SetDevInitFlag(true);
	m_bOpening = false;
	return errCode;
}

int CCardIssuerFSM::CheckIfHasCardOnCase(CheckCardCase eCase)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	CSimpleStringA errMsg(true);

	m_ullBeginTime = GetTickCountRVC();
	eErr = m_hDevHelper->GetDevStatus(m_devStatus);
	m_ullEndTime = GetTickCountRVC();

	if (Error_Succeed == eErr)
	{
		switch (m_devStatus.eMedia)
		{
		case CI_MEDIA_PRESENT:
		{
			if (eCase == CheckCard_OnFail)
				return 2;

			if (m_currCardNo.GetLength() > 1)
			{
				m_captureReason = "4014";
			}
			else
			{
				m_captureReason = "0000";
				JustReadCardNo();
			}

			//oilyang@20230313 根据卡片异常处理沟通会议（业务、深圳开发），实体启动发现有卡，一律吞卡
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402203Z01").setResultCode("RTA23A1")("非业务状态时卡机有卡片，吞卡");
			errMsg = CSimpleStringA::Format("读卡器有卡（吞卡）:%d, CardNoLength:%d, CardNo:%s", m_issueStatus, m_currCardNo.GetLength()
				, SP::Module::Util::DataMask(SP::Module::Util::DataMask_CardAccount, m_currCardNo).GetData());
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard_EntityOnStart, errMsg.GetData());
			return CaptureCard(NULL);
		}
		case CI_MEDIA_JAMMED:
		case CI_MEDIA_ENTERING:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CardPosUnexpectedOnDevOpen, CSimpleStringA::Format("Unexpected CardStatusEnum:%d", m_devStatus.eMedia));
			break;
		case CI_MEDIA_NOTPRESENT:
			return 0;
		default:
			break;
		}
	}
	else
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, m_ullEndTime - m_ullBeginTime);
	return 1;
}
int CCardIssuerFSM::IssueCard(SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctxEx)
{
	LOG_FUNCTION();

	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;

	if (ctxEx != NULL)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("IssueCard, issue type:%d", ctxEx->Req.hopper));
		ctxEx->Ans.reserved1.Init(2);
		
		//param Req.hopper is wrong
		if (ctxEx->Req.hopper < 1 || ctxEx->Req.hopper > 3){
			errMsg = CSimpleStringA::Format("Issuer Card, the hopperNo(%d) is wrong!!!", ctxEx->Req.hopper);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Invalid_Hopper, errMsg.GetData());
			return Error_Param;
		}

		if (!m_bHasHopper[ctxEx->Req.hopper - 1])
		{
			switch (ctxEx->Req.hopper)
			{
			case 1:
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230B")("未检测到卡箱1，请检测卡箱1是否放好");
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper1);
				break;
			case 2:
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230C")("未检测到卡箱2，请检测卡箱2是否放好");
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper2);
				break;
			case 3:
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230D")("未检测到卡箱3，请检测卡箱3是否放好");
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper3);
				break;
			}
			return 2;
		}
		m_currentHopper = ctxEx->Req.hopper;
	}
	else
		m_currentHopper = 1;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("IssueCard, current hopper:%d", m_currentHopper));
	m_pCardProcess->DataInit();
	if (m_mixedEx[m_currentHopper - 1] >= 3)
	{
		//all of the hoppers are wrong
		if (((m_bHasHopper[0] && m_mixedEx[0] >= 3) || !m_bHasHopper[0])
			&& ((m_bHasHopper[1] && m_mixedEx[1] >= 3) || !m_bHasHopper[1])
			&& ((m_bHasHopper[2] && m_mixedEx[2] >= 3) || !m_bHasHopper[2])
			&& ((m_bHasHopper[3] && m_mixedEx[1] >= 3) || !m_bHasHopper[3])
			&& ((m_bHasHopper[4] && m_mixedEx[1] >= 3) || !m_bHasHopper[4])
			&& ((m_bHasHopper[5] && m_mixedEx[1] >= 3) || !m_bHasHopper[5]))
			SetDevState(DEVICE_STATUS_MAINTAINCE);

		errMsg = CSimpleStringA::Format("the current card hopper %d may be wrong.mixedEx:%d",
			m_currentHopper, m_mixedEx[m_currentHopper-1]);
		DWORD dwTmpErrCode = CardIssuer_UserErrorCode_Hopper1_Mixed_Too_Much;
		if (m_currentHopper == 2)
		{
			dwTmpErrCode = CardIssuer_UserErrorCode_Hopper2_Mixed_Too_Much;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230S")("卡箱2连续吞卡超限，请及时执行清机");
		}
		else if (m_currentHopper == 3)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230T")("卡箱3连续吞卡超限，请及时执行清机");
			dwTmpErrCode = CardIssuer_UserErrorCode_Hopper3_Mixed_Too_Much;
		}
		else
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230R")("卡箱1连续吞卡超限，请及时执行清机");

		LogWarn(Severity_Middle, Error_Unexpect, dwTmpErrCode, errMsg.GetData());
		ctxEx->Answer(Error_DevMedia, dwTmpErrCode);
		return 2;
	}
	ErrorCodeEnum errCode;
	CardIssuerStatus cis;
	memset(&cis, 0, sizeof(CardIssuerStatus));
	bool bEmpty = false;

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->GetDevStatus(cis);
	l_endTime = GetTickCountRVC();
	

	if (errCode != Error_Succeed) {
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("%d", cis.eIssuerBin[m_currentHopper - 1]);
		if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_EMPTY || cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_NOTSUPP)
			bEmpty = true;
	}
	if (bEmpty || m_remainsEx[m_currentHopper - 1] <= 0)
	{

		DWORD dwUsrErrCode = 0;
		if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_NOTSUPP)
		{
			if (m_currentHopper == 1)//oiltmp MACRO?
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230B")("未检测到卡箱1，请检测卡箱1是否放好");
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230C")("未检测到卡箱2，请检测卡箱2是否放好");
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230D")("未检测到卡箱3，请检测卡箱3是否放好");
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper3;
			}
		}
		else if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_EMPTY)
		{
			if (m_currentHopper == 1)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230E")("卡箱1未检测到卡片，请检测卡箱1中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230F")("卡箱2未检测到卡片，请检测卡箱2中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230G")("卡箱3未检测到卡片，请检测卡箱3中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper3;
			}
		}
		else if (m_remainsEx[m_currentHopper - 1] <= 0)
		{
			if (m_currentHopper == 1)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230H")("卡箱1本地计数无卡，请执行清机计划");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardRemains_Hopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230J")("卡箱2本地计数无卡，请执行清机计划");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardRemains_Hopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230K")("卡箱3本地计数无卡，请执行清机计划");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardRemains_Hopper3;
			}
		}
		ctxEx->Answer(Error_DevNotAvailable, dwUsrErrCode);

		return 2;
	}
	FSMSetIssueFlag(1);
	//move card to holder

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->MoveCard(CI_MOVECARD_FROM_HOPPER, m_currentHopper);
	l_endTime = GetTickCountRVC();

	
	m_bCardFromHopper = true;
	if (errCode != Error_Succeed)
	{

		CSimpleStringA ErrMsg = CSimpleStringA::Format("m_currentHopper:%d", m_currentHopper);
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FROM_HOPPER, "DevAdapter::MoveCard", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", ErrMsg.GetData());
		ctxEx->Answer(Error_Unexpect, GetAlarmDEC());
		return 1;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320")("IssueCard::MoveCard succ, m_currentHopper:%d", m_currentHopper);
	}
	m_issuedEx[m_currentHopper - 1]++;
	m_remainsEx[m_currentHopper - 1]--;
	m_bSettingMaterial = true;//oilyang 借用于延迟同步，紧接着设置remains时更新到后台数据库
	if (!SetCardIssued(m_issuedEx[m_currentHopper - 1], m_currentHopper))
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IssueCard, Set card issued failed.");
	m_bSettingMaterial = false;
	if (!SetCardRemains(m_remainsEx[m_currentHopper - 1], m_currentHopper))
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IssueCard, Set card remains failed.");
	m_bUseRFTillNext = false;
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220320")("IssueCard success.");
	Sleep(1000);
	ctxEx->Ans.reserved1[0] = ctxEx->Ans.reserved1[1] = 0;

	ctxEx->Answer(Error_Succeed);
	return 0;
}

/** 0:succeed,1:failed [Gifur@2022516]*/
int CCardIssuerFSM::CaptureCard(SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (ctx != NULL)
		LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard_FromBusiness, "CaptureCard called from Business.");
	ErrorCodeEnum eErr;
	long l_beginTime, l_endTime;
	int ret = 0;

	eErr = MachineMoveCardBackNotHold();
	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220304")();
		bool bCaptured = ToRegistCaptureCardInfo();
	}
	else
		ret = 1;
	m_currCardNo = "";
	m_CardCaptured++;
	if (!SetCardCaptured(m_CardCaptured))
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<CaptureCard>, set card captured failed");
	m_pCardProcess->DataInit();
	if (Error_Succeed == eErr){
		if (ctx != NULL)
			ctx->Answer(Error_Succeed);
	}
	else {
		if (ctx != NULL){
			if (IsInBusiness()) {
				LogError(Severity_Middle, Error_Unexpect, 0x20300034, "CaptureCard failed");
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setLogCode("QLR040220304").setResultCode("RTA2307")("吞卡失败，请检查吞卡箱是否已满或联系厂商检查是否有吞卡");
			}
			else {
				LogWarn(Severity_Middle, Error_Unexpect, 0x20300034, "CaptureCard failed");
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setLogCode("QLR040220304").setResultCode("RTA2307")("吞卡失败，请检查吞卡箱是否已满或联系厂商检查是否有吞卡");
			}
			ctx->Answer(Error_Unexpect, 0x20300034);
		}
	}
	if (ret == 0) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setLogCode("QLR040220304")("Captured succ");
	}
	return ret;
}

/** 0:succeed,1:failed [Gifur@2022516]*/
int CCardIssuerFSM::EjectCard(SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	Sleep(300);//oilyang@20230106 for keba said "maybe we need stay for machine to prepare..."
	int ret = 0;
	ErrorCodeEnum eErr;
	eErr = MachineMoveCardFrontGate(ctx != NULL && IsInBusiness());
	m_pCardProcess->DataInit();
	if (Error_Succeed == eErr){
		if (ctx != NULL)
			ctx->Answer(Error_Succeed);
		ret = 0;
	}
	else {
		if (ctx != NULL){
			ctx->Answer(Error_Exception, 0x20300035);
		}
		ret = 1;
	}
	if (ret == 0) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setLogCode("QLR040220305")("EjectCard succ");
	}
	return ret;
}
int CCardIssuerFSM::WaitFetchingCard()
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	DWORD dwStart, dwEnd;
	dwStart = GetTickCountRVC();
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_ON,"CardReader(fetch) warning on");
	do {
		m_ullBeginTime = GetTickCountRVC();
		eErr = m_hDevHelper->GetDevStatus(m_devStatus);
		m_ullEndTime = GetTickCountRVC();
		if (Error_Succeed == eErr){
			dwEnd = GetTickCountRVC();
			if (m_devStatus.eMedia == CI_MEDIA_ENTERING){
				Sleep(WAIT_INTERVAL);
			}
			else{
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader(fetch) warning off");
				return 0;
			}
		}
		else
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader(fetch) warning off");
			SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, "QLR040220305", "取卡时设备故障");
			return 1;
		}
	}while ((dwEnd-dwStart) < 60*1000);
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader(fetch) warning off");
	return 2;
}
int CCardIssuerFSM::AcceptCard(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pCardProcess->DataInit();
	m_bCancelByRFIC = false;
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_ON,"CardReader warning on");
	m_bWaitAccepteMore = false;
	DWORD dwTmpCode;
	ErrorCodeEnum eErr = Error_Unexpect;
	int acceptTries = 0, acceptRet = 2;//2 for timeout
	DWORD64 dwStart = GetTickCountRVC();
	DWORD64 dwEnd = dwStart;
	m_bWaitingAccept = true;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("InternalAcceptCard, m_bExit:%d, m_bCancelAccept:%d, m_bWaitAccepteMore:%d, m_bCancelByRFIC:%d",
		m_bExit, m_bCancelAccept, m_bWaitAccepteMore, m_bCancelByRFIC));
	bool bHasSetCardInType = false;
	do {
		if (m_bExit)
		{
			m_bCancelAccept = true;
			break;
		}
		if (m_bCancelAccept)
		{
			acceptRet = 3;
			goto Err;
		}
		if (m_bWaitAccepteMore)
		{
			acceptTries = 0;
			dwEnd = dwStart = GetTickCountRVC();
			m_bWaitAccepteMore = false;
		}
		m_ullBeginTime = GetTickCountRVC();
		eErr = m_hDevHelper->GetDevStatus(m_devStatus);
		m_ullEndTime = GetTickCountRVC();
		if (Error_Succeed == eErr)
		{
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT)
			{
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand op.");
				acceptRet = 0;
				acceptTries = 0;
				FSMSetIssueFlag(0);
				m_bCardFromHopper = false;
				m_bUseRFTillNext = false;
				goto Err;
			}
			if (m_devStatus.eMedia == CI_MEDIA_NOTPRESENT)
			{
				acceptTries++;
				Sleep(m_iCheckCardInInterval);
				//oilyang@20230609 after sleep,to check if have been canceled in sleeping time
				if (m_bCancelAccept)
				{
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("have been canceled in sleeping time");
					acceptRet = 3;
					goto Err;
				}
				if (!m_bCancelAccept && !bHasSetCardInType) {
					m_ullBeginTime = GetTickCountRVC();
					eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_ALL);
					m_ullEndTime = GetTickCountRVC();
					if (Error_Succeed != eErr) {
						dwTmpCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, "", "InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_ALL err");
						acceptRet = 1;
						goto Err;

					}
					else {
						bHasSetCardInType = true;
					}
				}
			}
		}
		else
		{
			acceptRet = 5;
			if (ctx != NULL) {
				dwTmpCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, "QLR040220303");
			}
			goto Err;
		}
		dwEnd = GetTickCountRVC();
	} while ((dwEnd - dwStart) < 58 * 1000);
Err:
	m_bExit = false;
	m_bWaitingAccept = false;

	if (m_bCancelAccept && acceptRet != 1)
	{
		//oilyang@20181210 add "if (!m_bCancelByRFIC)" 
		//oilyang@20170612
		if (!m_bCancelByRFIC)
			Sleep(500);
		m_ullBeginTime = GetTickCountRVC();
		eErr = m_hDevHelper->GetDevStatus(m_devStatus);
		m_ullEndTime = GetTickCountRVC();
		if (Error_Succeed == eErr)
		{
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT)
			{
				acceptRet = 4;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<InternalAcceptCard>, Cancel InterAccept, eject card.");
				eErr = MachineMoveCardFrontGate(IsInBusiness());

				if (eErr != Error_Succeed)
				{
					//吐卡失败，前面已有告警，这里不再告警
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("InternalAcceptCard::MachineMoveCardFrontGate failed(0x%x)", eErr);
					acceptRet = 5;
				}
			}
		}
		else
		{
			SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, m_ullEndTime - m_ullBeginTime, "QLR040220303");
			acceptRet = 5;
		}
	}
	if (acceptRet != 1)
	{
		m_ullBeginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		m_ullEndTime = GetTickCountRVC();
		if (Error_Succeed != eErr)
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN err");
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, m_ullEndTime - m_ullBeginTime, "", "InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN err");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(m_ullEndTime - m_ullBeginTime)("InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN");
		}
	}
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader warning off");

	switch (acceptRet)
	{
	case 0:
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("AcceptCard, insert succeed");
		ctx->Answer(Error_Succeed);
		break;
	case 1:
	case 5:
		ctx->Answer(Error_Unexpect, dwTmpCode);
		break;
	case 2:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AcceptCard, insert timeout");
		ctx->Answer(Error_TimeOut);
		break;
	case 3:
	case 4:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AcceptCard, insert cancel");
		ctx->Answer(Error_Cancel);
		break;

	default:
		break;
	}
	return acceptRet;
}
static CSimpleStringA GetStrData(TrackInfo trackInfo)
{
	//LOG_FUNCTION();
	CSimpleStringA strRet;
	switch (trackInfo.eStatus) {
		case CI_DATA_OK:
			strRet = (char*)trackInfo.data;
			break;
		case CI_DATA_INVALID:
			strRet = "无效数据";
			break;
		//case CI_DATA_MISSING:
		default:
			strRet = "数据丢失";
	}
	return strRet;
}
int CCardIssuerFSM::SplitTrack2(CSimpleStringA pTrack2,Track2Data &decodeData)
{
	LOG_FUNCTION();

	int dataLen = strlen(pTrack2);
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SplitTrack2>, pTrack2.len:%d", dataLen);

	if (pTrack2.GetLength() == 0) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E2")("<SplitTrack2>, pTrack2.len=0");
		return -1;
	}
	
	switch(dataLen)
	{
	case 28:
		decodeData.t2Region = CSimpleString(pTrack2,4);
		decodeData.t2Account = pTrack2.SubString(4,8);
		decodeData.t2CardSerial = pTrack2.SubString(14,8);//oilyang for 8 onecard
		decodeData.t2CVC = pTrack2.SubString(22,6);
		decodeData.t2ExpireDate = "";
		break;
	case 31:
		decodeData.t2Account = CSimpleString(pTrack2,16);
		decodeData.t2CardSerial = pTrack2.SubString(16,1);
		decodeData.t2CVC = pTrack2.SubString(17,6);
		decodeData.t2Region = pTrack2.SubString(23,4);
		decodeData.t2ExpireDate = pTrack2.SubString(27,4);
		break;
	case 25://AE Card
		decodeData.t2Account = CSimpleString(pTrack2, 15);
		decodeData.t2CardSerial = pTrack2.SubString(15, 1);
		decodeData.t2CVC = pTrack2.SubString(16, 5);
		decodeData.t2ExpireDate = pTrack2.SubString(21, 4);
		decodeData.t2Region = "";
		break;
	case 38:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<SplitTrack2>, pTrack2.len=38 Not implemented ");
		break;
	default:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<SplitTrack2>, pTrack2.len=%d Not implemented ", dataLen);
		return -1;
	}
	decodeData.status = 0;
	return 0;
}

int CCardIssuerFSM::ReadCard(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx)
{
	bool bCtOK = false;
	memset(m_magTracks.track[0].data, 0, sizeof(m_magTracks.track[0].data));
	memset(m_magTracks.track[1].data, 0, sizeof(m_magTracks.track[1].data));
	memset(m_magTracks.track[2].data, 0, sizeof(m_magTracks.track[2].data));
	int ret = ReadCard_Contact(ctx, bCtOK);
	if (ret == 0)
		return ret;
	if (m_bSupportRF)
	{
		m_bUseRFTillNext = true;
		return ReadCard_RF(ctx);
	}
	else
		return ret;
}
int CCardIssuerFSM::ReadCard_Contact(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx, bool bContinue)
{
	m_currCardNo = "";

	ctx->Ans.ICType = 0;
	ErrorCodeEnum eErr, eMagReadErr;
	int activeCardType;
	bool bIC(false), bICSuc(false), bReadCardInfo(false);
	long l_beginTime, l_endTime;
	CSimpleString errMsg("");
	errMsg = CSimpleString::Format("ReadCard, inParam: reserved1 for lightPos:%d, m_issueStatus:%d, m_currentHopper:%d",
		ctx->Req.reserved1, m_issueStatus, m_currentHopper);
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(errMsg.GetData());
	DWORD dwStart = GetTickCountRVC();
	MagTracks magTracks;
	int readTries = 0;
	memset(magTracks.track[0].data, 0, sizeof(magTracks.track[0].data));
	memset(magTracks.track[1].data, 0, sizeof(magTracks.track[1].data));
	memset(magTracks.track[2].data, 0, sizeof(magTracks.track[2].data));
	magTracks.eRange = CI_TRACK_RANGE_2_3;
	do {
		l_beginTime = GetTickCountRVC();
		eMagReadErr = m_hDevHelper->MagRead(magTracks);
		l_endTime = GetTickCountRVC();
		if (Error_Succeed == eMagReadErr) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagRead").setCostTime(l_endTime - l_beginTime)("ReadCard_Contact::MagRead t2Status:%d, t3Status:%d, t2Len:%d, t3Len:%d",
				magTracks.track[1].eStatus, magTracks.track[2].eStatus, magTracks.track[1].dwSize, magTracks.track[2].dwSize);
		}
		else {
			SetErrorAndLog(eMagReadErr, MEC_DEVAPI_CARDISSUER_MagRead, "DevAdapter::MagRead", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadCard_Contact::MagRead err");

		}

		//oilyang@20230204 copy mag data for RF
		m_magTracks.eRange = magTracks.eRange;
		for (int i = 0; i < 3; ++i)
		{
			m_magTracks.track[i].eStatus = magTracks.track[i].eStatus;
			m_magTracks.track[i].eSource = magTracks.track[i].eSource;
			m_magTracks.track[i].dwSize = magTracks.track[i].dwSize;
			memcpy(m_magTracks.track[i].data, magTracks.track[i].data, sizeof(magTracks.track[i].data));
		}

		ctx->Ans.t2Account = ctx->Ans.ICData = "";
		readTries++;
		if (magTracks.track[1].dwSize > sizeof(magTracks.track[1].data) || magTracks.track[2].dwSize > sizeof(magTracks.track[2].data))
		{
			errMsg = CSimpleString::Format("MagRead, trackSize maybe wrong:t2Size:%d(%d), t3Size:%d(%d)",
				magTracks.track[1].dwSize, sizeof(magTracks.track[1].data),
				magTracks.track[2].dwSize, sizeof(magTracks.track[2].data));
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_TrackSize_Wrong, errMsg.GetData());
			break;
		}

		if (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand op.");
			if (magTracks.track[1].dwSize > 40)
			{
				errMsg = CSimpleString::Format("MagRead, track2Size maybe wrong:t2Size:%d", magTracks.track[1].dwSize);
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Track2Size_Wrong, errMsg.GetData());
				ctx->Ans.status = 1;
				break;
			}
			ctx->Ans.track2 = (char*)magTracks.track[1].data;
			bool bT3OK = false;
			if (magTracks.track[2].eStatus == CI_DATA_OK)
			{
				bT3OK = true;
				ctx->Ans.track3 = (char*)magTracks.track[2].data;
			}
			Track2Data track2Data;
			track2Data.status = 0;
			track2Data.t2Account = "";
			char* tmpMag2 = new char[256];
			ZeroMemory(tmpMag2, 256);
			DecodeTracksData((const char*)magTracks.track[1].data, magTracks.track[1].dwSize, (const char*)magTracks.track[2].data, magTracks.track[2].dwSize, tmpMag2, true, bT3OK);

			int pos = 0;
			for (int i = 0; i < magTracks.track[1].dwSize; ++i, ++pos)
			{
				if (magTracks.track[1].data[i] == 0x3d || magTracks.track[1].data[i] == 0x3e || magTracks.track[1].data[i] == 0x44)// fixpoint (3d是=，3e是 >), 运通卡要考虑分隔符为D的情况
					break;
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleString::Format("<ReadCard::MagRead>, split pos:%d", pos));
			if (pos <= 0 || pos == magTracks.track[1].dwSize)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<ReadCard::MagRead>, split track is err, pos:%d", pos);
				ctx->Ans.status = 1;
				if (tmpMag2 != NULL)
				{
					delete[]tmpMag2;
					tmpMag2 = NULL;
				}
				break;
			}

			char* ddd = new char[40];
			memset(ddd, 0, 40);
			memcpy(ddd, magTracks.track[1].data, pos);

			if (SplitTrack2(tmpMag2, track2Data) == 0)
			{
				ctx->Ans.status = track2Data.status;
				ctx->Ans.t2Account = track2Data.t2Account;
				ctx->Ans.t2Region = track2Data.t2Region;
				ctx->Ans.t2CardSerial = track2Data.t2CardSerial;
				ctx->Ans.t2CVC = track2Data.t2CVC;
				ctx->Ans.t2ExpireDate = track2Data.t2ExpireDate;
				bReadCardInfo = true;
				if (m_issueStatus)
				{
					//设置为mixed从读卡失败恢复为成功时才触发同步计数和写运行时
					if (m_mixedEx[m_currentHopper - 1]!= 0) {
						m_mixedEx[m_currentHopper - 1] = 0;
						SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
					}
					else {
						SetDevState(DEVICE_STATUS_NORMAL);
					}
				}
			}
			if (_strnicmp(track2Data.t2Account, ddd, strlen(ddd)) && (track2Data.t2Account.GetLength() != 8))
			{

				ctx->Ans.status = 0;
				ctx->Ans.t2Account = (char*)ddd;
				ctx->Ans.t2Region = "";
				ctx->Ans.t2CardSerial = "";
				ctx->Ans.t2CVC = "";
				ctx->Ans.t2ExpireDate = "";
				bReadCardInfo = true;
				delete[]ddd;

			}
			if (tmpMag2 != NULL)
			{
				delete[]tmpMag2;
				tmpMag2 = NULL;
			}

			CSimpleStringA cardInfo(true);
			cardInfo = CSimpleStringA::Format("%s", SP::Module::Util::DataMask(SP::Module::Util::DataMask_CardAccount, ctx->Ans.t2Account).GetData());
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardBin, cardInfo.GetData());

			break;
		}
	} while (readTries < READ_TRY_NUM);

	m_currCardNo = ctx->Ans.t2Account;

	if (m_issueStatus && (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK))//发卡默认给芯片卡，且读到磁道（考虑卡片放错）
	{
		ctx->Ans.ICType = 1;
	}
	else
	{
		l_beginTime = GetTickCountRVC();
		int retDetect = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER, m_hDevHelper, activeCardType);
		l_endTime = GetTickCountRVC();
		if (retDetect == 0)//oiltmp for simple to not change bIC
			bIC = true;
		else
		{
			bIC = false;
			CSimpleStringA csDevApi("");
			DWORD dwDevApi = 0;
			GetDevApiCodeAndName(retDetect, dwDevApi, csDevApi);
			SetErrorAndLog(Error_Unexpect, dwDevApi, csDevApi, __FUNCTION__, bContinue && IsInBusiness(), l_endTime - l_beginTime);
		}
		
		if (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			if (bIC)
				ctx->Ans.ICType = 1;
			else
			{
				ctx->Ans.ICType = 2;
			}
		}
		else
		{
			if (bIC)
			{
				bReadCardInfo = true;
				ctx->Ans.ICType = 3;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("maybe ic only.");
			}
			else
			{
				//既没有读到磁条，又不是IC，很大概率是插反了
				if (m_issueStatus) {
					LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Maybe_InsertCard_InWrongStyle, "<ReadCard>, 既没读到磁条，又没检测到IC，可能插反了，m_issueStatus=1");
				}
				else {
					LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Maybe_InsertCard_InWrongStyle, "<ReadCard>, 既没读到磁条，又没检测到IC，可能插反了，m_issueStatus=0");
				}
				if (m_issueStatus)
				{
					m_mixedEx[m_currentHopper - 1]++;
					SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
				}
			}
		}
		if (bIC)
		{
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->DeactivateICCard();
			l_endTime = GetTickCountRVC();

			if (eErr != Error_Succeed) {
				SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard, "DevAdapter::DeactivateICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadCard_Contact::DeactivateICCard err");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("ReadCard_Contact::DeactivateICCard");
			}

			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->ReleaseIC();
			l_endTime = GetTickCountRVC();

			if (eErr != Error_Succeed) {
				SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC, "DevAdapter::ReleaseIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadCard_Contact::ReleaseIC err");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("ReadCard_Contact::ReleaseIC");
			}
		}
	}

	DWORD dwEnd = GetTickCountRVC();
	DWORD dwCollapse = dwEnd - dwStart;

	if (!bReadCardInfo)
	{
		ctx->Ans.status = 1;
		m_ullBeginTime = GetTickCountRVC();
		eErr = m_hDevHelper->GetDevStatus(m_devStatus);
		m_ullEndTime = GetTickCountRVC();
		if (eErr != Error_Succeed)
		{
			DWORD dwCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, !bContinue && IsInBusiness(), m_ullEndTime - m_ullBeginTime, "QLR040220303");
			if (!bContinue)
				ctx->Answer(Error_Unexpect, dwCode);
			return 1;
		}
		else
			return -1;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220303")("ReadCard suc. cardType:%d. m_issueStatus:%d", ctx->Ans.ICType, m_issueStatus);
	}
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::ReadCard_RF(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr, eMagReadErr;

	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCard(CI_MOVECARD_RF_POSITION);
	l_endTime = GetTickCountRVC();

	if (eErr != Error_Succeed)
	{
		DWORD dwCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MoveCard, "DevAdapter::MoveCard", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "", "ReadCard_RF::MoveCard err");
		ctx->Answer(Error_Unexpect, dwCode);
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("ReadCard_RF::MoveCard");
	}

	ctx->Ans.ICType = 0;
	
	int activeCardType;
	bool bIC(false), bICSuc(false), bReadCardInfo(false);
	CSimpleString errMsg("");
	errMsg = CSimpleString::Format("ReadCard, inParam: reserved1 for lightPos:%d, m_issueStatus:%d, m_currentHopper:%d",
		ctx->Req.reserved1, m_issueStatus, m_currentHopper);
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(errMsg.GetData());
	DWORD dwStart = GetTickCountRVC();
	MagTracks magTracks;
	int readTries = 0;
	memset(magTracks.track[0].data, 0, sizeof(magTracks.track[0].data));
	memset(magTracks.track[1].data, 0, sizeof(magTracks.track[1].data));
	memset(magTracks.track[2].data, 0, sizeof(magTracks.track[2].data));
	magTracks.eRange = CI_TRACK_RANGE_2_3;
	do {
		//oiltmp tricks...copy mag data
		//need to remove ,just for simple or lazy...

		eMagReadErr = Error_Succeed;
		magTracks.eRange = m_magTracks.eRange;
		for (int i = 0; i < 3; ++i)
		{
			magTracks.track[i].eStatus = m_magTracks.track[i].eStatus;
			magTracks.track[i].eSource = m_magTracks.track[i].eSource;
			magTracks.track[i].dwSize = m_magTracks.track[i].dwSize;
			memcpy(magTracks.track[i].data, m_magTracks.track[i].data, sizeof(m_magTracks.track[i].data));
		}


		ctx->Ans.t2Account = ctx->Ans.ICData = "";
		readTries++;
		if (magTracks.track[1].dwSize > sizeof(magTracks.track[1].data) || magTracks.track[2].dwSize > sizeof(magTracks.track[2].data))
		{
			errMsg = CSimpleString::Format("MagRead, trackSize maybe wrong:t2Size:%d(%d), t3Size:%d(%d)",
				magTracks.track[1].dwSize, sizeof(magTracks.track[1].data),
				magTracks.track[2].dwSize, sizeof(magTracks.track[2].data));
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_TrackSize_Wrong, errMsg.GetData());
			break;
		}

		if (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand op.");
			if (magTracks.track[1].dwSize > 40)
			{
				errMsg = CSimpleString::Format("MagRead, track2Size maybe wrong:t2Size:%d", magTracks.track[1].dwSize);
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Track2Size_Wrong, errMsg.GetData());
				ctx->Ans.status = 1;
				break;
			}
			ctx->Ans.track2 = (char*)magTracks.track[1].data;
			bool bT3OK = false;
			if (magTracks.track[2].eStatus == CI_DATA_OK)
			{
				bT3OK = true;
				ctx->Ans.track3 = (char*)magTracks.track[2].data;
			}
			Track2Data track2Data;
			track2Data.status = 0;
			track2Data.t2Account = "";
			char* tmpMag2 = new char[256];
			ZeroMemory(tmpMag2, 256);
			DecodeTracksData((const char*)magTracks.track[1].data, magTracks.track[1].dwSize, (const char*)magTracks.track[2].data, magTracks.track[2].dwSize, tmpMag2, true, bT3OK);

			int pos = 0;
			for (int i = 0; i < magTracks.track[1].dwSize; ++i, ++pos)
			{
				if (magTracks.track[1].data[i] == 0x3d || magTracks.track[1].data[i] == 0x3e || magTracks.track[1].data[i] == 0x44)// fixpoint (3d是=，3e是 >), 运通卡要考虑分隔符为D的情况
					break;
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleString::Format("<ReadCard::MagRead>, split pos:%d", pos));
			if (pos <= 0 || pos == magTracks.track[1].dwSize)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<ReadCard::MagRead>, split track is err, pos:%d", pos);
				ctx->Ans.status = 1;
				if (tmpMag2 != NULL)
				{
					delete[]tmpMag2;
					tmpMag2 = NULL;
				}
				break;
			}

			char* ddd = new char[40];
			memset(ddd, 0, 40);
			memcpy(ddd, magTracks.track[1].data, pos);

			if (SplitTrack2(tmpMag2, track2Data) == 0)
			{
				ctx->Ans.status = track2Data.status;
				ctx->Ans.t2Account = track2Data.t2Account;
				ctx->Ans.t2Region = track2Data.t2Region;
				ctx->Ans.t2CardSerial = track2Data.t2CardSerial;
				ctx->Ans.t2CVC = track2Data.t2CVC;
				ctx->Ans.t2ExpireDate = track2Data.t2ExpireDate;
				bReadCardInfo = true;
				if (m_issueStatus)
				{
					//设置为mixed从读卡失败恢复为0时才触发同步计数和写运行时
					if (m_mixedEx[m_currentHopper - 1] != 0) {
						m_mixedEx[m_currentHopper - 1] = 0;
						SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
					}
					else {
						SetDevState(DEVICE_STATUS_NORMAL);
					}
				}
			}
			if (_strnicmp(track2Data.t2Account, ddd, strlen(ddd)) && (track2Data.t2Account.GetLength() != 8))
			{

				ctx->Ans.status = 0;
				ctx->Ans.t2Account = (char*)ddd;
				ctx->Ans.t2Region = "";
				ctx->Ans.t2CardSerial = "";
				ctx->Ans.t2CVC = "";
				ctx->Ans.t2ExpireDate = "";
				bReadCardInfo = true;
				delete[]ddd;

			}
			if (tmpMag2 != NULL)
			{
				delete[]tmpMag2;
				tmpMag2 = NULL;
			}

			CSimpleStringA cardInfo(true);
			cardInfo = CSimpleStringA::Format("%s", SP::Module::Util::DataMask(SP::Module::Util::DataMask_CardAccount, ctx->Ans.t2Account).GetData());
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardBin, cardInfo.GetData());

			break;
		}
	} while (readTries < READ_TRY_NUM);
	m_currCardNo = ctx->Ans.t2Account;
	if (m_issueStatus && (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK))//发卡默认给芯片卡，且读到磁道（考虑卡片放错）
	{
		ctx->Ans.ICType = 1;
	}
	else
	{
		l_beginTime = GetTickCountRVC();
		int retDetect = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER_RF, m_hDevHelper, activeCardType);
		l_endTime = GetTickCountRVC();

		if (retDetect == 0)//oiltmp for simple to not change bIC
			bIC = true;
		else
		{
			bIC = false;
			CSimpleStringA csDevApi("");
			DWORD dwDevApi = 0;
			GetDevApiCodeAndName(retDetect, dwDevApi, csDevApi);
			SetErrorAndLog(Error_Unexpect, dwDevApi, csDevApi, __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime);
		}
		if (!(bIC && activeCardType == 'A'))
			bIC = false;
		if (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			if (bIC)
				ctx->Ans.ICType = 1;
			else
			{
				ctx->Ans.ICType = 2;
			}
		}
		else
		{
			if (bIC)
			{
				bReadCardInfo = true;
				ctx->Ans.ICType = 3;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("maybe ic only.");
			}
			else
			{

			}
		}
		if (bIC)
		{
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->DeactContactlessICCard();
			l_endTime = GetTickCountRVC();

			if (eErr != Error_Succeed) {
				SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard, "DevAdapter::DeactContactlessICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadCard_RF::DeactContactlessICCard err");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("ReadCard_RF::DeactContactlessICCard");
			}
		}
	}

	DWORD dwEnd = GetTickCountRVC();
	DWORD dwCollapse = dwEnd - dwStart;

	if (!bReadCardInfo)
	{
		ctx->Ans.status = 1;
		m_ullBeginTime = GetTickCountRVC();
		eErr = m_hDevHelper->GetDevStatus(m_devStatus);
		m_ullEndTime = GetTickCountRVC();
		if (eErr != Error_Succeed)
		{
			DWORD dwCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, "QLR040220303");
			ctx->Answer(Error_Unexpect, dwCode);
			return 1;
		}
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220303")("ReadCard suc. cardType:%d. m_issueStatus:%d", ctx->Ans.ICType, m_issueStatus);
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx)
{
	if (m_bUseRFTillNext)
		return PreOnline_RF(ctx);

	bool bCtOK = false;
	int ret = PreOnline_Contact(ctx, bCtOK);
	if (!bCtOK && m_bSupportRF)
		return PreOnline_RF(ctx);
	else
		return ret;
}
int CCardIssuerFSM::PreOnline_Contact(SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>::Pointer ctx, bool& bICOK)
{
	LOG_FUNCTION();
	//oilyang@20220611 only return 0；if unexpected,process and return 0
	bool bCrossPreOnline = false;
	long l_beginTime, l_endTime;

	CSimpleStringA csMagT2Track(""), csMagT3Track(""), csMagAccout(""), csMagRegion(""), csMagCardSerial(""), csMagCVC(""), csMagExpireDate("");
	int slot = 0;
	m_pCardProcess->SplitBusinessData(ctx->Req.businessData,ctx->Req.businessData.GetLength());
	
	m_pCardProcess->SplitBusinessData("DF690101",strlen("DF690101"));
	int activeCardType;
	//oilyang@20201014 add emv card support
	int retDetectAndRead = -1;
	ICData aidFromBus(false, 0x4f, 0x00);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_BUS, aidFromBus, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline>, the front BusinessData han't provide aid data.");
		l_beginTime = GetTickCountRVC();
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER, m_hDevHelper, m_aidList, activeCardType, m_issueStatus);
		l_endTime = GetTickCountRVC();
	}
	else {
		char* pAIDTmp = new char[64];
		memset(pAIDTmp, 0, 64);
		HexBuf2StrBuf(aidFromBus.value, &pAIDTmp, aidFromBus.lenth);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, the aid from bussiness is[%s],len:%d .", pAIDTmp, strlen(pAIDTmp));
		CAutoArray<CSimpleString> preAIDs;
		preAIDs.Init(1);
		preAIDs[0] = (CSimpleStringA)pAIDTmp;
		l_beginTime = GetTickCountRVC();
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER, m_hDevHelper, preAIDs, activeCardType, m_issueStatus);
		l_endTime = GetTickCountRVC();

		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);
	if (retDetectAndRead < 0)
	{
		DWORD dwDevApiCode = 0;
		CSimpleStringA csDevApiName(""), csLogCode("");
		CSimpleStringA csIssueContext = CSimpleStringA::Format("{\"InIssue\":%d}", m_issueStatus);//oiltmp
		GetDevApiCodeAndName(retDetectAndRead, dwDevApiCode, csDevApiName);
		if (m_issueStatus)
			csLogCode = CardIssuerStandService_LogCode_IssueEx;
		else
			csLogCode = CardIssuerStandService_LogCode_Read;
		if (m_bSupportRF) //support RF, to continue read by RF
			SetErrorAndLog(Error_Unexpect, dwDevApiCode, csDevApiName, __FUNCTION__, false, m_ullEndTime - m_ullBeginTime, csLogCode, csIssueContext);
		else
		{
			DWORD dwCode = SetErrorAndLog(Error_Unexpect, dwDevApiCode, csDevApiName, __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, csLogCode, csIssueContext);
			ctx->Answer(Error_Unexpect, dwCode);
		}
		bICOK = false;
		return 0;
	}

	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	BYTE bt9f27 = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER,m_hDevHelper,taaResult,true,m_bCDA,bt9f27);
	if (retTAA != 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, TermActionAnalyze , retTAA:%d, taaResult:%s", retTAA, taaResult.GetData());
	}
	switch(retTAA)
	{//to be added oiltmp 20140929
	case -1:	//some data may be wrong
		break;
	case 1:		//terminal trans
		break;
	case 2:		//to do trans end "TransEnd"
		break;
	default:
		break;
	}
	ctx->Ans.result = taaResult;

	if (ctx->Ans.result.GetLength() == 0)
	{
		if (!m_bSupportRF)
			ctx->Answer(Error_Succeed);
		return 0;
	}
	
	//char tmpResult[1024,]result[1024];
	//ZeroMemory(tmpResult,sizeof(tmpResult));
	//ZeroMemory(result,sizeof(result));
	//memcpy(tmpResult,ctx->Ans.result,ctx->Ans.result.GetLength());
	string tmpResult,actionType,result = "",baseICData = "";
	tmpResult = ctx->Ans.result;
	char *pSomeICData = new char[ONE_K];
	ZeroMemory(pSomeICData, ONE_K);
	int lenRet = m_pCardProcess->ConstructARQCData(tmpResult.substr(6,4).c_str(),m_pDataToARQC,pSomeICData);
	baseICData = pSomeICData;
	if (pSomeICData != NULL)
		delete []pSomeICData;
	char arqcLen[8];
	ZeroMemory(arqcLen,sizeof(arqcLen));
	_itoa(lenRet,arqcLen,10);
	ICData appExpiryDate(false,0x5f,0x24);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC,appExpiryDate,false,0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline>, can't find expire date");
		if (!m_bSupportRF)//oiltmp@20250807 why?
			ctx->Answer(Error_Succeed);
		return 0;
	}
	char *pExpireDate = new char[12];
	ZeroMemory(pExpireDate,12);
	HexBuf2StrBuf(appExpiryDate.value,&pExpireDate,appExpiryDate.lenth);
	ICData track2(false,0x57,0x00),ICCardSerial(false,0x5f,0x34);
	ErrorCodeEnum eErr = Error_Unexpect;
	string t2ICAccount(""),t2ICCardSerial(""),t2ICCVC(""),t2ICTrack2(""),cardType("0");
	char *pICCardSerial = new char[4];
	ZeroMemory(pICCardSerial,4);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC,ICCardSerial,false) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline>, can't find card serial.");
	}
	else
	{
		HexBuf2StrBuf(ICCardSerial.value,&pICCardSerial,ICCardSerial.lenth);
	}
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC,track2,false,0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline>, [ic]no track2 data");
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReleaseIC();
		l_endTime = GetTickCountRVC();
		if (eErr != Error_Succeed){
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC, "DevAdapter::ReleaseIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("PreOnline::ReleaseIC");
		}
	}
	else
	{
		int pos = FindHexCharPosition(track2.value,0x0d,track2.lenth);
		
		char *pICTrack2 = new char[128];
		ZeroMemory(pICTrack2,128);
		HexBuf2StrBuf(track2.value,&pICTrack2,track2.lenth);
		pICTrack2[37] = '\0';
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<PreOnline>, ic.track2, split pos:%d", pos));

		char *ddd = new char[40];
		memset(ddd,0,40);
		memcpy(ddd,pICTrack2,pos-1);

		char icTrack2Data[128];
		ZeroMemory(icTrack2Data,sizeof(icTrack2Data));

		Track2Data track2Data;
		track2Data.status = 0;
		track2Data.t2Account = "";
		cmdDecodeMag2(pICTrack2,icTrack2Data);
		if (SplitTrack2(icTrack2Data,track2Data) == 0)
		{
			t2ICAccount = track2Data.t2Account;
			//t2ICCardSerial = track2Data.t2CardSerial;
			t2ICCVC = track2Data.t2CVC;
			t2ICTrack2 = pICTrack2;
			if (m_issueStatus)
			{
				//设置为mixed从读卡失败恢复为0时才触发同步计数和写运行时
				if (m_mixedEx[m_currentHopper - 1] != 0) {
					m_mixedEx[m_currentHopper - 1] = 0;
					bool bSetMix = SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, set %d card mixed %d,%d", m_currentHopper, bSetMix, m_mixedEx[m_currentHopper - 1]);
				}
				else {
					SetDevState(DEVICE_STATUS_NORMAL);
				}
			}
		}
		if (_strnicmp(track2Data.t2Account,ddd,strlen(ddd)))
		{
			t2ICCVC = "";
			t2ICTrack2 = pICTrack2;
			t2ICAccount = (char*)ddd;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("count:%s,%s", t2ICAccount.substr(0, 6).c_str(), t2ICAccount.substr(t2ICAccount.length()-4, 4).c_str());
		}
		t2ICCardSerial = pICCardSerial;
		delete []ddd;
		delete []pICTrack2;
	}

	//80 1e 80 0008 328ab54bfc986b85 07010103a0b000010a010000000000754048769000
	if (m_pCardProcess->GetP1() == 0x1) {
		actionType = "ARQC";
	}
	else {
		actionType = "";
	}
	//【55域】
	//	基本域：
	//	9F26	8b	应用密文AC
	//	9F27	1b	密文信息数据
	//	9F10	max.32b	发卡行应用数据IAD
	//	9F37	4b	不可预知数
	//	9F36	2b	应用交易计数器ATC
	//	95	5b	终端验证结果TVR
	//	9A	3cn	交易日期（6位有效数字，YYMMDD）
	//	9C	1cn	交易类型（2位有效数字）
	//	9F02	6cn	授权金额（12位有效数字）
	//	5F2A	2cn	交易货币代码（3位有效数字）
	//	82	2b	应用交互特征AIP
	//	9F1A	2cn	终端国家代码（3位有效数字）
	//	9F03	6cn	其他金额（12位有效数字）
	//	9F33	3b	终端性能 "E0C900"

	//	可选域：
	//添加9F26,9F27,9F10,9F33的数据
	char *pCID = new char[4];
	ZeroMemory(pCID, 4);
	HexBuf2StrBuf(&bt9f27, &pCID, 1);
	char *pIssueBankLen = new char[4];
	ZeroMemory(pIssueBankLen, 4);
	int len9f10 = tmpResult.length() - 26 - 4;
	int lenHigh, lenLow;
	len9f10 = len9f10 / 2;
	lenHigh = len9f10 / 16;
	lenLow = len9f10 % 16;
	BYTE bt9f10;
	bt9f10 = (lenHigh<<4) + lenLow;
	HexBuf2StrBuf(&bt9f10, &pIssueBankLen, 1);
	baseICData += "9F2608" + tmpResult.substr(10, 16) + "9F2701" + pCID +"9F10" + pIssueBankLen + tmpResult.substr(26, tmpResult.length() - 26 - 4) + "9F3303" + "E0C900";
	result = "ACTION," + actionType + "|" + "ATCCODE," + tmpResult.substr(6,4) + "|" + "ARQCCODE," + tmpResult.substr(10,16) + "|"
		+ "MAC," + tmpResult.substr(26,tmpResult.length()-26-4) + "|" + "ARQCSIZE," + string(arqcLen) + "|" 
		+ "ARQCDATA," + m_pDataToARQC + "|EXPIREDATE," + pExpireDate + "|T2ACCOUNT," + t2ICAccount + "|T2CARDSERIAL," + t2ICCardSerial
		+ "|T2CVC," + t2ICCVC + "|T2TRACK2," + t2ICTrack2 + "|CARDCAT," + cardType + "|ICTAGS," + baseICData + "|MAGT2," + (const char*)csMagT2Track
		+ "|MAGT3," + (const char*)csMagT3Track + "|MAGACCOUNT," + (const char*)csMagAccout + "|MAGREGION," + (const char*)csMagRegion
		+ "|MAGCARDSERIAL," + (const char*)csMagCardSerial+ "|MAGCVC," + (const char*)csMagCVC+ "|MAGEXPIREDATAE," + (const char*)csMagExpireDate;
	ctx->Ans.result = result.c_str();
	string txtresult = "";
	txtresult = "ACTION," + actionType + "|" + "ATCCODE," + tmpResult.substr(6,4) + "|" + "ARQCCODE," + tmpResult.substr(10,16) + "|"
		+ "MAC," + tmpResult.substr(26,tmpResult.length()-26-4) + "|" + "ARQCSIZE," + string(arqcLen) + "|" 
		+ "ARQCDATA," + m_pDataToARQC + "|T2ACCOUNT(F6)," + t2ICAccount.substr(0, 6) + "|T2ACCOUNT(L4)," + t2ICAccount.substr(t2ICAccount.length()-4, 4)
		+ "|T2CARDSERIAL(len)," + t2ICCardSerial + "|CARDCAT," + cardType;
	m_currCardNo = t2ICAccount.c_str();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline>, data to host(less)[%s],baseICData length:%d", txtresult.c_str(), baseICData.length());

	if (pCID != NULL)
		delete[]pCID;
	if (pIssueBankLen != NULL)
		delete[]pIssueBankLen;
	if (pExpireDate != NULL)
		delete []pExpireDate;

	if (m_pDataToARQC != NULL)
	{
		delete []m_pDataToARQC;
		m_pDataToARQC = NULL;
	}
	bICOK = true;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220306")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::PreOnline_RF(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	long l_beginTime, l_endTime;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("(PreOnline) use cardissuerStand rf");
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->MoveCard(CI_MOVECARD_RF_POSITION);
	l_endTime = GetTickCountRVC();
	if (eErr == Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("PreOnline_RF::MoveCard, (CI_MOVECARD_RF_POSITION)");
	}
	else {
		DWORD dwCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MoveCard, "DevAdapter::MoveCard", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime);
		ctx->Answer(Error_Unexpect, dwCode);
	}
	bool bCrossPreOnline = false;

	CSimpleStringA csMagT2Track(""), csMagT3Track(""), csMagAccout(""), csMagRegion(""), csMagCardSerial(""), csMagCVC(""), csMagExpireDate("");
	int slot = 0;
	m_pCardProcess->SplitBusinessData(ctx->Req.businessData, ctx->Req.businessData.GetLength());

	m_pCardProcess->SplitBusinessData("DF690101", strlen("DF690101"));
	int activeCardType;
	//oilyang@20201014 add emv card support
	int retDetectAndRead = -1;
	ICData aidFromBus(false, 0x4f, 0x00);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_BUS, aidFromBus, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline_RF>, the front BusinessData han't provide aid data.");
		l_beginTime = GetTickCountRVC();
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_RF, m_hDevHelper, m_aidList, activeCardType, m_issueStatus);
		l_endTime = GetTickCountRVC();
	}
	else {
		char* pAIDTmp = new char[64];
		memset(pAIDTmp, 0, 64);
		HexBuf2StrBuf(aidFromBus.value, &pAIDTmp, aidFromBus.lenth);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline_RF>, the aid from bussiness is[%s],len:%d .", pAIDTmp, strlen(pAIDTmp));
		CAutoArray<CSimpleString> preAIDs;
		preAIDs.Init(1);
		preAIDs[0] = (CSimpleStringA)pAIDTmp;
		l_beginTime = GetTickCountRVC();
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_RF, m_hDevHelper, preAIDs, activeCardType, m_issueStatus);
		l_endTime = GetTickCountRVC();
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline_RF>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);
	if (retDetectAndRead < 0)
	{
		DWORD dwDevApiCode = 0;
		CSimpleStringA csDevApiName(""), csLogCode("");
		CSimpleStringA csIssueContext = CSimpleStringA::Format("{\"InIssue\":%d}", m_issueStatus);//oiltmp
		GetDevApiCodeAndName(retDetectAndRead, dwDevApiCode, csDevApiName);
		if (m_issueStatus)
			csLogCode = CardIssuerStandService_LogCode_IssueEx;
		else
			csLogCode = CardIssuerStandService_LogCode_Read;

		DWORD dwCode = SetErrorAndLog(Error_Unexpect, dwDevApiCode, csDevApiName, __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, csLogCode, csIssueContext);
		ctx->Answer(Error_Unexpect, dwCode);
		return 0;
	}
	
	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	BYTE bt9f27 = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER_RF, m_hDevHelper, taaResult, true, m_bCDA, bt9f27);
	if (retTAA != 0 || taaResult.GetLength() == 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline_RF>, TermActionAnalyze, retTAA:%d, taaResult:%s", retTAA, taaResult.GetData());
	}
	switch (retTAA)
	{//to be added oiltmp 20140929
	case -1:	//some data may be wrong
		break;
	case 1:		//terminal trans
		break;
	case 2:		//to do trans end "TransEnd"
		break;
	default:
		break;
	}
	ctx->Ans.result = taaResult;

	if (ctx->Ans.result.GetLength() == 0)
	{
		ctx->Answer(Error_Succeed);
		return 0;
	}

	string tmpResult, actionType, result = "", baseICData = "";
	tmpResult = ctx->Ans.result;
	char* pSomeICData = new char[ONE_K];
	ZeroMemory(pSomeICData, ONE_K);
	int lenRet = m_pCardProcess->ConstructARQCData(tmpResult.substr(6, 4).c_str(), m_pDataToARQC, pSomeICData);
	baseICData = pSomeICData;
	if (pSomeICData != NULL)
		delete[]pSomeICData;
	char arqcLen[8];
	ZeroMemory(arqcLen, sizeof(arqcLen));
	_itoa(lenRet, arqcLen, 10);
	ICData appExpiryDate(false, 0x5f, 0x24);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, appExpiryDate, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline_RF>, can't find expire date");
		ctx->Answer(Error_Succeed);
		return 0;
	}
	char* pExpireDate = new char[12];
	ZeroMemory(pExpireDate, 12);
	HexBuf2StrBuf(appExpiryDate.value, &pExpireDate, appExpiryDate.lenth);
	ICData track2(false, 0x57, 0x00), ICCardSerial(false, 0x5f, 0x34);
	
	string t2ICAccount(""), t2ICCardSerial(""), t2ICCVC(""), t2ICTrack2(""), cardType("0");
	char* pICCardSerial = new char[4];
	ZeroMemory(pICCardSerial, 4);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, ICCardSerial, false) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline_RF>, can't find card serial.");
	}
	else
	{
		HexBuf2StrBuf(ICCardSerial.value, &pICCardSerial, ICCardSerial.lenth);
	}
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline_RF>, [ic]no track2 data");
	}
	else
	{
		int pos = FindHexCharPosition(track2.value, 0x0d, track2.lenth);

		char* pICTrack2 = new char[128];
		ZeroMemory(pICTrack2, 128);
		HexBuf2StrBuf(track2.value, &pICTrack2, track2.lenth);
		pICTrack2[37] = '\0';
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<PreOnline_RF>, ic.track2, split pos:%d", pos));

		char* ddd = new char[40];
		memset(ddd, 0, 40);
		memcpy(ddd, pICTrack2, pos - 1);

		char icTrack2Data[128];
		ZeroMemory(icTrack2Data, sizeof(icTrack2Data));

		Track2Data track2Data;
		track2Data.status = 0;
		track2Data.t2Account = "";
		cmdDecodeMag2(pICTrack2, icTrack2Data);
		if (SplitTrack2(icTrack2Data, track2Data) == 0)
		{
			t2ICAccount = track2Data.t2Account;
			//t2ICCardSerial = track2Data.t2CardSerial;
			t2ICCVC = track2Data.t2CVC;
			t2ICTrack2 = pICTrack2;
			//oilyang@20230116 if we read by RF,we can't reset card mixed
			//if (m_issueStatus)
			//{
			//	m_mixedEx[m_currentHopper - 1] = 0;
			//	bool bSetMix = SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
			//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, set %d card mixed %d,%d", m_currentHopper, bSetMix, m_mixedEx[m_currentHopper - 1]);
			//}
		}
		if (_strnicmp(track2Data.t2Account, ddd, strlen(ddd)))
		{
			t2ICCVC = "";
			t2ICTrack2 = pICTrack2;
			t2ICAccount = (char*)ddd;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("count:%s,%s", t2ICAccount.substr(0, 6).c_str(), t2ICAccount.substr(t2ICAccount.length() - 4, 4).c_str());
		}
		t2ICCardSerial = pICCardSerial;
		delete[]ddd;
		delete[]pICTrack2;
	}

	//80 1e 80 0008 328ab54bfc986b85 07010103a0b000010a010000000000754048769000
	if (m_pCardProcess->GetP1() == 0x1) {
		actionType = "ARQC";
	}
	else {
		actionType = "";
	}
	//【55域】
	//	基本域：
	//	9F26	8b	应用密文AC
	//	9F27	1b	密文信息数据
	//	9F10	max.32b	发卡行应用数据IAD
	//	9F37	4b	不可预知数
	//	9F36	2b	应用交易计数器ATC
	//	95	5b	终端验证结果TVR
	//	9A	3cn	交易日期（6位有效数字，YYMMDD）
	//	9C	1cn	交易类型（2位有效数字）
	//	9F02	6cn	授权金额（12位有效数字）
	//	5F2A	2cn	交易货币代码（3位有效数字）
	//	82	2b	应用交互特征AIP
	//	9F1A	2cn	终端国家代码（3位有效数字）
	//	9F03	6cn	其他金额（12位有效数字）
	//	9F33	3b	终端性能 "E0C900"

	//	可选域：
	//添加9F26,9F27,9F10,9F33的数据
	char* pCID = new char[4];
	ZeroMemory(pCID, 4);
	HexBuf2StrBuf(&bt9f27, &pCID, 1);
	char* pIssueBankLen = new char[4];
	ZeroMemory(pIssueBankLen, 4);
	int len9f10 = tmpResult.length() - 26 - 4;
	int lenHigh, lenLow;
	len9f10 = len9f10 / 2;
	lenHigh = len9f10 / 16;
	lenLow = len9f10 % 16;
	BYTE bt9f10;
	bt9f10 = (lenHigh << 4) + lenLow;
	HexBuf2StrBuf(&bt9f10, &pIssueBankLen, 1);
	baseICData += "9F2608" + tmpResult.substr(10, 16) + "9F2701" + pCID + "9F10" + pIssueBankLen + tmpResult.substr(26, tmpResult.length() - 26 - 4) + "9F3303" + "E0C900";
	result = "ACTION," + actionType + "|" + "ATCCODE," + tmpResult.substr(6, 4) + "|" + "ARQCCODE," + tmpResult.substr(10, 16) + "|"
		+ "MAC," + tmpResult.substr(26, tmpResult.length() - 26 - 4) + "|" + "ARQCSIZE," + string(arqcLen) + "|"
		+ "ARQCDATA," + m_pDataToARQC + "|EXPIREDATE," + pExpireDate + "|T2ACCOUNT," + t2ICAccount + "|T2CARDSERIAL," + t2ICCardSerial
		+ "|T2CVC," + t2ICCVC + "|T2TRACK2," + t2ICTrack2 + "|CARDCAT," + cardType + "|ICTAGS," + baseICData + "|MAGT2," + (const char*)csMagT2Track
		+ "|MAGT3," + (const char*)csMagT3Track + "|MAGACCOUNT," + (const char*)csMagAccout + "|MAGREGION," + (const char*)csMagRegion
		+ "|MAGCARDSERIAL," + (const char*)csMagCardSerial + "|MAGCVC," + (const char*)csMagCVC + "|MAGEXPIREDATAE," + (const char*)csMagExpireDate;
	ctx->Ans.result = result.c_str();
	string txtresult = "";
	txtresult = "ACTION," + actionType + "|" + "ATCCODE," + tmpResult.substr(6, 4) + "|" + "ARQCCODE," + tmpResult.substr(10, 16) + "|"
		+ "MAC," + tmpResult.substr(26, tmpResult.length() - 26 - 4) + "|" + "ARQCSIZE," + string(arqcLen) + "|"
		+ "ARQCDATA," + m_pDataToARQC + "|T2ACCOUNT(F6)," + t2ICAccount.substr(0, 6) + "|T2ACCOUNT(L4)," + t2ICAccount.substr(t2ICAccount.length() - 4, 4)
		+ "|T2CARDSERIAL(len)," + t2ICCardSerial + "|CARDCAT," + cardType;
	m_currCardNo = t2ICAccount.c_str();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline_RF>, data to host(less)[%s],baseICData length:%d", txtresult.c_str(), baseICData.length());

	if (pCID != NULL)
		delete[]pCID;
	if (pIssueBankLen != NULL)
		delete[]pIssueBankLen;
	if (pExpireDate != NULL)
		delete[]pExpireDate;

	if (m_pDataToARQC != NULL)
	{
		delete[]m_pDataToARQC;
		m_pDataToARQC = NULL;
	}
	LogWarn(Severity_Low, Error_Succeed, CardIssuer_UserErrorCode_ReadByRF, CSimpleStringA::Format("PreOnline_RF ok.iIssue:%d ", m_issueStatus));
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220306")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx)
{
	if (m_bUseRFTillNext)
		return PostOnline_RF(ctx);

	bool bCtOK = false;
	int ret = PostOnline_Contact(ctx, bCtOK);
	if (!bCtOK && m_bSupportRF)
		return PostOnline_RF(ctx);
	else
		return ret;
}
int CCardIssuerFSM::PostOnline_Contact(SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>::Pointer ctx, bool& bICOK)
{
	LOG_FUNCTION();
	m_pCardProcess->DataInit();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PostOnline>, post online data[%s]", (LPCTSTR)ctx->Req.data);
	m_pCardProcess->SplitOnlineReplyData(ctx->Req.data,strlen(ctx->Req.data));
	int issBnkAuth = m_pCardProcess->IssueBankAuth(CARD_MACHINE_ISSUER,m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER,m_hDevHelper,m_bCDA);
		if (transEnd == 0)
			csTransEnd = "TRANSEND,0";
		else if (transEnd == 1)
			csTransEnd = "TRANSEND,1";
	}
	else
		csTransEnd = "TRANSEND,1";
	ctx->Ans.result = csTransEnd;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PostOnline>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220307")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::PostOnline_RF(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pCardProcess->DataInit();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PostOnline>, post online data[%s]", (LPCTSTR)ctx->Req.data);
	m_pCardProcess->SplitOnlineReplyData(ctx->Req.data, strlen(ctx->Req.data));
	int issBnkAuth = m_pCardProcess->IssueBankAuth(CARD_MACHINE_ISSUER_RF, m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER_RF, m_hDevHelper, m_bCDA);
		if (transEnd == 0)
			csTransEnd = "TRANSEND,0";
		else if (transEnd == 1)
			csTransEnd = "TRANSEND,1";
	}
	else
		csTransEnd = "TRANSEND,1";
	ctx->Ans.result = csTransEnd;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PostOnline>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220307")();
	ctx->Answer(Error_Succeed);
	return 0;
}
void CCardIssuerFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	OnHardwareShakeHand(pTransactionContext);
}
bool CCardIssuerFSM::SetCardCaptured(const int num,bool bClear)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SetCardCaptured>, num:%d, bClear:%d, m_maxRetainCount:%d, m_bSettingMaterial:%d",
		num, bClear, m_maxRetainCount, m_bSettingMaterial);
	if (num < 0)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<SetCardCaptured>, wrong reset card captured");
		return false;
	}
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("<SetCardCaptured>, open cfg file failed!");
		return false;
	}
	m_CardCaptured = num;
	if (num >= m_maxRetainCount)
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_RETAIN_BIN_IS_FULL, "<SetCardCaptured>, 回收箱满了，请及时清理!");

	eErrDev = spConfig->WriteConfigValueInt("all", "CardCaptured", num);
	if (eErrDev == Error_Succeed)
	{
		if (bClear && !m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain);
		}
		return true;
	}
	else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("<SetCardCaptured>, write CardCaptured err:%d, num:%d, bClear:%d", eErrDev, num, bClear);
		return false;
	}
}
bool CCardIssuerFSM::SetCardIssued(const int num, const int hopper)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SetCardIssued>, num :%d, hopper: %d, m_bSettingMaterial:%d", num, hopper, m_bSettingMaterial);
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("<SetCardIssued>, open cfg file failed!");
		return false;
	}
	char buf[8];
	memset(buf, 0, 8);
	_itoa(hopper, (char*)buf, 10);
	CSimpleStringA section(buf);
	eErrDev = spConfig->WriteConfigValueInt(section, "CardIssued", num);
	if (eErrDev == Error_Succeed)
	{
		if (hopper == 1)
		{
			int xNum = 0;
			spConfig->ReadConfigValueInt("all", "HopperNum", xNum);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SetCardIssued>, xNum:%d", xNum);
			if (xNum == 0)
				spConfig->WriteConfigValueInt("all", "HopperNum", 1);
		}
		//oilyang@20170428 汪磊东要求单卡箱也要同步数据
		if (!m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain,false);
		}
		return true;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("<SetCardIssued>, write CardIssued err:%d, num :%d, hopper: %d", eErrDev, num, hopper);
		return false;
	}
}
bool CCardIssuerFSM::SetCardRemains(const int num, const int hopper,bool bInit)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SetCardRemains>, num:%d, hopper:%d, bInit:%d, m_currentHopper:%d, m_bSettingMaterial:%d",
		num, hopper, bInit, m_currentHopper, m_bSettingMaterial);
	if (num == 0)
	{
		switch (hopper)
		{
		case 1:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_NoCardRemains_Hopper1, "Hopper 1 No card remains.");
			break;
		case 2:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_NoCardRemains_Hopper2, "Hopper 2 No card remains.");
			break;
		case 3:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_NoCardRemains_Hopper3, "Hopper 3 No card remains.");
			break;
		default:
			break;
		}
		
	}
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("<SetCardRemains>, open cfg file failed!");
		return false;
	}
	char buf[8];
	memset(buf, 0, 8);
	_itoa(hopper, (char*)buf, 10);
	CSimpleStringA section(buf);
	eErrDev = spConfig->WriteConfigValueInt(section, "CardRemains", num);
	if (eErrDev == Error_Succeed)
	{
		if (bInit)
		{

			eErrDev = spConfig->WriteConfigValueInt(section, "CardInit", num);
		}

		if (eErrDev != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("<SetCardRemains>, write CardInit err:%d", eErrDev);
			return false;
		}
		//oilyang@20170428 汪磊东要求单卡箱也要同步数据
		if (!m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain,false);
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("<SetCardRemains>, write CardRemains err:%d, num:%d, hopper:%d, bInit:%d", eErrDev, num, hopper, bInit);
		return false;
	}
	return true;
}
bool CCardIssuerFSM::SetCardMixed(const int num, const int hopper)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SetCardMixed>, num:%d, hopper:%d, m_bSettingMaterial:%d", num, hopper, m_bSettingMaterial);
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("<SetCardMixed>, open cfg file failed!");
		return false;
	}
	if (hopper < 1 || hopper > HOPPER_NUM)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("wrong hopper num:%d .", hopper));
		return false;
	}
	if (num == 0)
		SetDevState(DEVICE_STATUS_NORMAL);
	else
	{
		CSimpleStringA errMsg = CSimpleStringA::Format("the current card hopper %d may be wrong.mixedEx:%d",
			hopper, m_mixedEx[hopper - 1]);
		DWORD dwTmpErrCode = CardIssuer_UserErrorCode_Hopper1_Mixed_Too_Much;
		if (hopper == 2)
			dwTmpErrCode = CardIssuer_UserErrorCode_Hopper2_Mixed_Too_Much;
		else if (hopper == 3)
			dwTmpErrCode = CardIssuer_UserErrorCode_Hopper3_Mixed_Too_Much;

		LogWarn(Severity_Middle, Error_Unexpect, dwTmpErrCode, errMsg.GetData());
	}
	char buf[8];
	memset(buf, 0, 8);
	_itoa(hopper, (char*)buf, 10);
	CSimpleStringA section(buf);
	eErrDev = spConfig->WriteConfigValueInt(section, "CardMixed", num);

	if (eErrDev != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("<SetCardMixed>, write CardMixed err:%d", eErrDev);
		return false;
	}
	//oilyang@20170428 汪磊东要求单卡箱也要同步数据
	if (!m_bSettingMaterial)
	{
		bool bMaintain[12];
		memset(bMaintain, 0, 12);
		SyncDataToDB(bMaintain,false);
	}
	return true;

}
ErrorCodeEnum CCardIssuerFSM::MachineMoveCardBackNotHold()
{
	LOG_FUNCTION();
	long l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eMoveNotHold = m_hDevHelper->MoveCard(CI_MOVECARD_BACK_NOT_HOLD);
	long l_endTime = GetTickCountRVC();

	//2016-11-10 14:30:54 joseph
	if (eMoveNotHold != Error_Succeed)
	{
		SetErrorAndLog(eMoveNotHold, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "MachineMoveCardBackNotHold::MoveCard err");
		return eMoveNotHold;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("MachineMoveCardBackNotHold::MoveCard");
	}
	return eMoveNotHold;
}
ErrorCodeEnum CCardIssuerFSM::MachineMoveCardFrontGate(bool bInBussiness)
{
	LOG_FUNCTION();
	long l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eMoveFrontGate = m_hDevHelper->MoveCard(CI_MOVECARD_FRONT_GATE);
	long l_endTime = GetTickCountRVC();
	

	if (eMoveFrontGate != Error_Succeed){
		if (m_bCardFromHopper)
			SetErrorAndLog(eMoveFrontGate, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FRONT_GATE, "DevAdapter::MoveCard", __FUNCTION__, bInBussiness, l_endTime - l_beginTime, "QLR040220305", "后端发卡，卡片吐出失败");
		else
			SetErrorAndLog(eMoveFrontGate, CardIssuer_UserErrorCode_MoveCardToGate_Failed, "DevAdapter::MoveCard", __FUNCTION__, bInBussiness, l_endTime - l_beginTime, "QLR040220305", "前端进卡，卡片吐出失败");
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220305")("MachineMoveCardFrontGate::MoveCard");
	}
	
	return eMoveFrontGate;
}
int CCardIssuerFSM::QueryCardPos()
{
	int ret;
	if (m_hDevHelper == nullptr)
		ret = 1;
	else {
		m_ullBeginTime = GetTickCountRVC();
		ErrorCodeEnum eErr = m_hDevHelper->GetDevStatus(m_devStatus);
		m_ullEndTime = GetTickCountRVC();
		if (Error_Succeed == eErr)
			ret = (m_devStatus.eMedia == CI_MEDIA_PRESENT) ? 2 : 0;
		else
		{
			SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
			ret = 1;
		}
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("QueryCardPos, ret:%d", ret);
	return ret;
}

static char DecCh2HexCh(BYTE c)
{
	if (c >= 0x0 && c <= 0x9)
		return c + '0';
	else if (c >= 0xa && c <= 0xf)
		return c + 'a' - 10;
	else
		return 0;
}

int CCardIssuerFSM::UpdateLocalRunCfg(CAutoArray<int> hopperArr)
{
	LOG_FUNCTION();
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("(UpdateLocalRunCfg)open cfg file failed!");
		return false;
	}

	char sec[2];
	for (int i = 0; i < hopperArr.GetCount(); ++i)
	{
		ZeroMemory(sec, 2);
		_itoa(i + 1, (char*)sec, 10);
		if (hopperArr[i] == 1)
		{
			spConfig->WriteConfigValue(sec, "CardBoxNo", m_CardBoxNoEx[i]);
			spConfig->WriteConfigValue(sec, "PsbCode", m_PsbCodeEx[i]);
			spConfig->WriteConfigValue(sec, "PsbName", m_PsbNameEx[i]);
			spConfig->WriteConfigValueInt(sec, "CardInit", m_CardInitEx[i]);
			spConfig->WriteConfigValueInt(sec, "CardRemains", m_remainsEx[i]);
			spConfig->WriteConfigValueInt(sec, "CardIssued", m_issuedEx[i]);
			spConfig->WriteConfigValueInt(sec, "CardMixed", m_mixedEx[i]);
			spConfig->WriteConfigValueInt(sec, "CardPercent", m_CardPercentEx[i]);
			spConfig->WriteConfigValue(sec, "Maintainer", m_MaintainerEx[i]);
			spConfig->WriteConfigValue(sec, "MaintainTime", m_csMaintainTimeEx[i]);

			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("UpdateLocalRunCfg, sec:%s,CardBoxNo:%s,CardInit:%d,CardRemains:%d,CardIssued:%d",
				sec, m_CardBoxNoEx[i].GetData(), m_CardInitEx[i], m_remainsEx[i], m_issuedEx[i]);
		}
	}
	return 0;
}
int CCardIssuerFSM::SyncDataToDB(bool bMaintain[12], bool bSetCaptured)
{
	LOG_FUNCTION();

	SyncMaterialCountInfo info = {};
	info.dwCardBoxNum = m_hopperNum;
	info.strDeviceNo = m_terminalNo;

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SyncDataToDB>, to init sync info, CardBox Num:%d, DeviceNo:%s", info.dwCardBoxNum, info.strDeviceNo.GetData());
	info.arrMaintainFlag.Init(m_hopperNum+1);
	info.arrMaintainer.Init(m_hopperNum+1);
	info.arrMaintainTime.Init(m_hopperNum+1);
	info.arrCardBoxNo.Init(m_hopperNum+1);
	info.arrPsbCode.Init(m_hopperNum+1);
	info.arrPsbName.Init(m_hopperNum+1);
	info.arrCardInit.Init(m_hopperNum+1);
	info.arrCardRemains.Init(m_hopperNum+1);
	info.arrCardIssued.Init(m_hopperNum+1);
	info.arrCardMixed.Init(m_hopperNum+1);
	info.arrCardPercent.Init(m_hopperNum+1);
	for (int i = 0; i < m_hopperNum; ++i)
	{
		//[17:36 : 30.353][DEBUG] Debug: {0, SP01010101, 0, NX00000002, 47N2, IC金卡2, 100, 10, 1, 0, 10}
		info.arrMaintainFlag[i] = bMaintain[i];
		info.arrMaintainer[i] = m_MaintainerEx[i];
		info.arrMaintainTime[i] = m_MaintainTimeEx[i];
		info.arrCardBoxNo[i] = m_CardBoxNoEx[i];
		info.arrPsbCode[i] = m_PsbCodeEx[i];
		info.arrPsbName[i] = m_PsbNameEx[i];
		info.arrCardInit[i] = m_CardInitEx[i];
		info.arrCardRemains[i] = m_remainsEx[i];
		info.arrCardIssued[i] = m_issuedEx[i];
		info.arrCardMixed[i] = m_mixedEx[i];
		info.arrCardPercent[i] = m_CardPercentEx[i];

		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("hopper(%d), Maintain:%d, MaintainerEx:%s, MaintainTimeEx:%d, CardBoxNoEx:%s, PsbCodeEx:%s, PsbNameEx:%s, CardInitEx:%d, RemainsEx:%d, IssuedEx:%d, MixedEx:%d, CardPercentEx:%d",
			i, bMaintain[i],
			m_MaintainerEx[i].GetData(),
			m_MaintainTimeEx[i],
			m_CardBoxNoEx[i].GetData(),
			m_PsbCodeEx[i].GetData(),
			m_PsbNameEx[i].GetData(),
			m_CardInitEx[i],
			m_remainsEx[i],
			m_issuedEx[i],
			m_mixedEx[i],
			m_CardPercentEx[i]);
	}
	
	{
		if (bSetCaptured) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SyncDataToDB>, bSetCaptured:%d", bSetCaptured);
			info.arrMaintainFlag[m_hopperNum] = 1;
		}
		else
			info.arrMaintainFlag[m_hopperNum] = 0;
		info.arrCardRemains[m_hopperNum] = m_CardCaptured;
		info.arrMaintainer[m_hopperNum] = m_MaintainerEx[0];
		info.arrMaintainTime[m_hopperNum] = m_MaintainTimeEx[0];

		info.arrCardBoxNo[m_hopperNum] = "";
		info.arrPsbCode[m_hopperNum] = "";
		info.arrPsbName[m_hopperNum] = "";
		info.arrCardInit[m_hopperNum] = 0;
		info.arrCardIssued[m_hopperNum] = 0;
		info.arrCardMixed[m_hopperNum] = 0;
		info.arrCardPercent[m_hopperNum] = 0;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("MaintainFlag:%d, CardRemains:%d, Maintainer:%s, MaintainTime:%d",
			info.arrMaintainFlag[m_hopperNum],
			info.arrCardRemains[m_hopperNum],
			info.arrMaintainer[m_hopperNum].GetData(),
			info.arrMaintainTime[m_hopperNum]);
	}
	
	//修改为起线程同步物料计数
	//判断物料url地址是否存在

	if (m_csSyncMaterialUrl.IsNullOrEmpty())
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, "<SyncDataToDB>, SyncMaterialUrl is empty");
		return -1;
	}
	SyncMaterialCountTask* task = new SyncMaterialCountTask(this, info);
	ErrorCodeEnum err = GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	if (err != Error_Succeed) {
		CSimpleStringA errMsg = CSimpleStringA::Format("<SyncDataToDB>, create SyncMaterialCountTask thread fail. %d", (int)err);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, errMsg.GetData());
		return -2;
	}
	return 0;
}
void CCardIssuerFSM::SetHopperNum(int hopperNum)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("SetHopperNum, hopperNum:%d", hopperNum));
	m_hopperNum = hopperNum;
}

bool CCardIssuerFSM::JustReadCardNo()
{
	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;
	m_currCardNo = "";
	bool bHasAccount = false;
	int activeCardType;
	l_beginTime = GetTickCountRVC();
	int retDetect = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER, m_hDevHelper, activeCardType);
	l_endTime = GetTickCountRVC();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("retDetect:%d, activeCardType:%d", retDetect, activeCardType);
	if (retDetect == 0)//oiltmp for simple to not change bIC
	{
		//oilyang@20201014 add emv support
		bool bGetICData = m_pCardProcess->GetICDataFromCard(CARD_MACHINE_ISSUER, m_hDevHelper, m_aidList);
		if (bGetICData != 0)
			SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime);
		ICData track2(false, 0x57, 0x00);
		string t2ICAccount(""), t2ICCardSerial(""), t2ICCVC(""), t2ICTrack2(""), cardType;
		if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("JustReadCardNo::FindTagValue, can't find track2 in ic data");
		}
		else
		{
			int pos = FindHexCharPosition(track2.value, 0x0d, track2.lenth);
			char* pICTrack2 = new char[128];
			ZeroMemory(pICTrack2, 128);
			HexBuf2StrBuf(track2.value, &pICTrack2, track2.lenth);
			pICTrack2[37] = '\0';

			char* ddd = new char[128];
			memset(ddd, 0, 128);
			memcpy(ddd, pICTrack2, pos - 1);
			m_currCardNo = ddd;
			if (m_currCardNo.GetLength() > 1)
				bHasAccount = true;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<JustReadCardNo>, FindHexCharPosition， pos：%d, track2.lenth:%d， m_currCardNo.Len:%d",
				pos, track2.lenth, m_currCardNo.GetLength()));

			delete[]ddd;
			delete[]pICTrack2;
		}

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->DeactivateICCard();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard, "DevAdapter::DeactivateICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("JustReadCardNo::DeactivateICCard");
		}

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReleaseIC();
		l_endTime = GetTickCountRVC();


		if (eErr != Error_Succeed) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC, "DevAdapter::ReleaseIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("JustReadCardNo::ReleaseIC");
		}
	}
	else
	{
		CSimpleStringA csDevApi("");
		DWORD dwDevApi = 0;
		GetDevApiCodeAndName(retDetect, dwDevApi, csDevApi);
		SetErrorAndLog(Error_Unexpect, dwDevApi, csDevApi, __FUNCTION__, false, l_endTime - l_beginTime);
	}

	if (!bHasAccount)
	{
		MagTracks magTracks;
		memset(magTracks.track[0].data, 0, sizeof(magTracks.track[0].data));
		memset(magTracks.track[1].data, 0, sizeof(magTracks.track[1].data));
		memset(magTracks.track[2].data, 0, sizeof(magTracks.track[2].data));

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->MagRead(magTracks);
		l_endTime = GetTickCountRVC();


		if (eErr == Error_Succeed)
		{
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagRead").setCostTime(l_endTime - l_beginTime)("JustReadCardNo::MagRead");

			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagRead").setCostTime(l_endTime - l_beginTime)("JustReadCardNo::MagRead track[1].eStatus:%d, track[2].sStatus:%d, t2.dwSize:%d, t3.dwSize:%d, t2Len:%d, t3Len:%d",
				magTracks.track[1].eStatus, magTracks.track[2].eStatus, magTracks.track[1].dwSize, magTracks.track[2].dwSize,
				strlen((const char*)magTracks.track[1].data), strlen((const char*)magTracks.track[2].data));

			if (magTracks.track[1].eStatus == CI_DATA_OK)
			{
				int pos = 0;
				for (int i = 0; i < magTracks.track[1].dwSize; ++i, ++pos)
				{
					if (magTracks.track[1].data[i] == 0x3d || 
						magTracks.track[1].data[i] == 0x3e || 
						magTracks.track[1].data[i] == 0x44) //fixpoint (=或>)？ 运通卡考虑 = 和 D 
						break;
				}
				char buf[128];
				ZeroMemory(buf, 128);
				strncpy(buf, (char*)magTracks.track[1].data, pos);
				m_currCardNo = buf;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<JustReadCardNo::MagRead>, split pos:%d, m_currCardNo.Len:%d", pos, m_currCardNo.GetLength()));
				if (m_currCardNo.GetLength() > 1)
					bHasAccount = true;
			}
		}
		else {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MagRead, "DevAdapter::MagRead", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
	}
	if (m_currCardNo.GetLength() > 8)
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("JustReadCardNo, record the account (%d):%s", m_currCardNo.GetLength(),
			SP::Module::Util::DataMask(SP::Module::Util::DataMask_CardAccount, m_currCardNo).GetData()));
	else{
		CSimpleStringA errMsg = CSimpleStringA::Format("JustReadCardNo, AccountNo maybe wrong:%s(len:%d)", m_currCardNo.GetData(), m_currCardNo.GetLength());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(errMsg.GetData());
	}
	return true;
}
bool CCardIssuerFSM::RegistCardWhileCaptureCard(CSimpleStringA cardno)
{
	CSmallDateTime currTime;

	CSimpleStringA csCurrTime = currTime.GetNow().ToTimeString();
	CAutoArray<CSimpleStringA> arrTime;
	arrTime = csCurrTime.Split(' ');
	CSimpleStringA csDate, csTime;
	csDate = arrTime[0].SubString(0, 4) + arrTime[0].SubString(5, 2) + arrTime[0].SubString(8, 2);
	csTime = arrTime[1].SubString(0, 2) + arrTime[1].SubString(3, 2) + arrTime[1].SubString(6, 2);

	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);
	CRegistSwallowCardReq qRegistCardReq;
	CRegistSwallowCardRet qRegistCardRet;
	qRegistCardReq.m_timeOut = 15;//15 second

	qRegistCardReq.m_url = m_csSwallowCardUrl.GetData();
	qRegistCardReq.cardNo = cardno;
	if (IsValidCardNo(cardno.GetData(), cardno.GetLength()))
	{
		if (cardno.GetLength() > 0)
			qRegistCardReq.reasonCode = m_captureReason;
		else
			qRegistCardReq.reasonCode = "0000";
	}
	else
		qRegistCardReq.reasonCode = "0001";

	qRegistCardReq.swallowDate = csDate;
	qRegistCardReq.swallowTime = csTime;
	qRegistCardReq.deviceSciNo = "";
	qRegistCardReq.terminalNo = m_terminalNo;
	qRegistCardReq.terminalType = m_csMachineType;
	//qRegistCardReq.m_url = "http://55.13.170.50:8080/defa-gateway/dee1/EacQuery/queryByEac";
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<RegistCardWhileCaptureCard>, 吞卡登记开始, SwallowDate:%s, SwallowTime:%s, cardNoLen:%d, m_currCardNo:%s****%s, m_captureReason:%s",
	//	csDate.GetData(), csTime.GetData(), cardno.GetLength(), cardno.SubString(0, 6).GetData(),
	//	cardno.SubString(cardno.GetLength() - 4, 4).GetData(), m_captureReason.GetData());
	long beg = GetTickCountRVC();
	PROCESS_LINK_CONTEXT("LR0402203RegisterCard")
	bool ret = client->Post(qRegistCardReq, qRegistCardRet, &nextLink);
	long end = GetTickCountRVC();
	if (ret)
	{
		bool bParse = qRegistCardRet.Parse(qRegistCardRet.m_resultData.c_str());
		if (bParse)
		{
			if (qRegistCardRet.returnInfo.returnCode.compare("SUC0000") != 0) {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220304").setResultCode("RTA2341")("登记吞卡信息到后台失败:%s,%s"
					, qRegistCardRet.returnInfo.returnCode.c_str(), qRegistCardRet.returnInfo.errorMsg.c_str());
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220304")("吞卡登记成功: SwallowDate:%s, SwallowTime:%s, cardNoLen:%d, m_currCardNo:%s****%s, m_captureReason:%s",
					csDate.GetData(), csTime.GetData(), cardno.GetLength(), cardno.SubString(0, 6).GetData(),
					cardno.SubString(cardno.GetLength() - 4, 4).GetData(), m_captureReason.GetData());
			}
		}
		else
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220304").setResultCode("RTA2341")("解析返回报文qRegistCardRet失败");
	}
	else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220304").setResultCode("RTA2340")("访问吞卡登记失败");
	}
	client->Destory();
	return true;
}

bool CCardIssuerFSM::SyncMaterialCount(IHttpFunc* client,SyncMaterialCountInfo syncInfo) {

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<SyncMaterialCount>, 同步物料计数开始, DeviceNo = %s, CardBoxNum = %d", syncInfo.strDeviceNo.GetData(), syncInfo.dwCardBoxNum);

	if (syncInfo.strDeviceNo == NULL || strlen(syncInfo.strDeviceNo) == 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<SyncMaterialCount>, param [DeviceNo] invalid");
		return false;
	}

	if (syncInfo.dwCardBoxNum <= 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<SyncMaterialCount>, param [CardBoxNum] invalid");
		return false;
	}

	if (m_csSyncMaterialUrl.GetLength() == 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<SyncMaterialCount>, m_csSyncMaterialUrl is null");
		return false;
	}

	CSystemStaticInfo info;
	m_pEntity->GetFunction()->GetSystemStaticInfo(info);

	SyncMaterialCountHTTPReq qTempReq;
	SyncMaterialCountHTTPRet qTempRet;

	qTempReq.m_url = m_csSyncMaterialUrl.GetData();
	qTempReq.m_headers.emplace(std::make_pair("Content-Type", "application/json"));
	SyncMaterialCountReq1& req1 = qTempReq.reqInfo;

	//TODO: CrossPlaform  [Gifur@2025730]
#ifdef RVC_OS_WIN
	strncpy_s(req1.TerminalNo, sizeof(req1.TerminalNo), info.strTerminalID, _TRUNCATE);
	strncpy_s(req1.DeviceNo, sizeof(req1.DeviceNo), syncInfo.strDeviceNo, _TRUNCATE);
	strncpy_s(req1.Material, sizeof(req1.Material), "DebitCard", _TRUNCATE);
#else
	strncpy(req1.TerminalNo, info.strTerminalID, sizeof(req1.TerminalNo));
	strncpy(req1.DeviceNo, syncInfo.strDeviceNo, sizeof(req1.DeviceNo));
	strncpy(req1.Material, "DebitCard", sizeof(req1.Material));	
#endif //RVC_OS_WIN
	req1.CardBoxNum = syncInfo.dwCardBoxNum;
	for (int i = 0; i <= syncInfo.dwCardBoxNum; i++)
	{
		SyncMaterialCountReq2 pReq2;
		memset(&pReq2, 0, sizeof(SyncMaterialCountReq2));
		pReq2.bMaintain = syncInfo.arrMaintainFlag[i];
		if (syncInfo.arrMaintainFlag[i])
		{

		//TODO: CrossPlaform  [Gifur@2025730]
#ifdef RVC_OS_WIN		
			strncpy_s(pReq2.Maintainer, sizeof(pReq2.Maintainer), syncInfo.arrMaintainer[i], _TRUNCATE);
#else
			strncpy(pReq2.Maintainer, syncInfo.arrMaintainer[i], sizeof(pReq2.Maintainer));
#endif //RVC_OS_WIN
			pReq2.MaintainTime = syncInfo.arrMaintainTime[i];
		}

//TODO: CrossPlaform  [Gifur@2025730]
#ifdef RVC_OS_WIN
		strncpy_s(pReq2.CardBoxNo, sizeof(pReq2.CardBoxNo), syncInfo.arrCardBoxNo[i], _TRUNCATE);
		strncpy_s(pReq2.PsbCode, sizeof(pReq2.PsbCode), syncInfo.arrPsbCode[i], _TRUNCATE);
		strncpy_s(pReq2.PsbName, sizeof(pReq2.PsbName), syncInfo.arrPsbName[i], _TRUNCATE);
#else
		strncpy(pReq2.CardBoxNo, syncInfo.arrCardBoxNo[i], sizeof(pReq2.CardBoxNo));
		strncpy(pReq2.PsbCode, syncInfo.arrPsbCode[i], sizeof(pReq2.PsbCode));
		strncpy(pReq2.PsbName, syncInfo.arrPsbName[i], sizeof(pReq2.PsbName));
#endif //RVC_OS_WIN
		pReq2.CardInit = syncInfo.arrCardInit[i];
		pReq2.CardRemains = syncInfo.arrCardRemains[i];
		pReq2.CardIssued = syncInfo.arrCardIssued[i];
		pReq2.CardMixed = syncInfo.arrCardMixed[i];
		pReq2.CardPercent = syncInfo.arrCardPercent[i];
		qTempReq.reqData.push_back(pReq2);
	}
	PROCESS_LINK_CONTEXT("LR0402203SyncMaterialCount")
	if (!client->Post(qTempReq, qTempRet, &nextLink)) {
		LogWarn(Severity_Middle, Error_Exception, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, CSimpleStringA::Format("<SyncMaterialCount>, http req fail,url=%s, err=%s", qTempReq.m_url.c_str(), qTempRet.m_errMsg.c_str()).GetData());
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402203Z02").setResultCode("RTA2330")("同步物料计数通讯失败");
		return false;//通讯失败
	}

	Json::Reader reader;
	Json::Value rootRet;
	if (!reader.parse(qTempRet.m_retStr, rootRet, false))
	{
		LogWarn(Severity_Middle, Error_Exception, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, CSimpleStringA::Format("<SyncMaterialCount>, parse resp is fail, url=%s", qTempReq.m_url.c_str()).GetData());
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402203Z02").setResultCode("RTA2331")("同步物料计数解析返回报文失败");
		return false;//解析失败
	}

	if (rootRet["success"].isBool()) {
		bool isSucc = rootRet["success"].asBool();
		if (isSucc){
			//成功
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("同步物料计数成功");
			return true;
		}
		else {
			//失败
			LogWarn(Severity_Middle, Error_Exception, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, CSimpleStringA::Format("<SyncMaterialCount>, is error, url=%s", qTempReq.m_url.c_str()).GetData());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402203Z02").setResultCode("RTA2332")("同步物料计数失败");
			return false;
		}
	}
	else {
		//参数不符合
		LogWarn(Severity_Middle, Error_Exception, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, CSimpleStringA::Format("<SyncMaterialCount>, resp param is error, url=%s", qTempReq.m_url.c_str()).GetData());
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402203Z02").setResultCode("RTA2333")("同步物料计数返回参数不对");
		return false;
	}
}

bool CCardIssuerFSM::IsValidCardNo(const char *pCardNo,int len)
{
	//oilyang@20170207 卡号长度有限
	len = (len > 32) ? 32 : len;
	for (int i = 0; i < len; ++i)
	{
		if (pCardNo[i] < 0x30 || pCardNo[i] > 0x39)
		{
			//not '0'-'9'
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<IsValidCardNo>, CardNo is Invalid with illegal charactor:%c", pCardNo[i]);
			return false;
		}
	}
	return true;
}

int CalcDelayFactor(int failedCount)
{
	if ((failedCount % 7) == 0)
	{
		return 1;
	}
	else
		return 1 << (failedCount % 7);
}
void CCardIssuerFSM::GetVendorDllName(CSimpleStringA& strDevAdaptorPath)
{
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->LoadVendorLibName();
	FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
	strDevAdaptorPath = m_adapterInfo.adapterFilePath;
	return;
}

void CCardIssuerFSM::DecodeTracksData(const char *track2, DWORD dwT2size, const char *track3, DWORD dwT3size, char *&magData, bool bT2OK, bool bT3OK)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<DecodeTracksData>, bT2OK:%d, bT3OK:%d, t2.size:%d(%d), t3.size:%d(%d)",
		bT2OK, bT3OK, dwT2size, strlen(track2), dwT3size, strlen(track3));

	if (!bT2OK)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E3")("<DecodeTracksData>, track2 data isn't ok.");
		return;
	}
	if (dwT2size <= 0 || strlen(track2) < 15)//fixpoint AE card is 15
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E3")("<DecodeTracksData>, track2 size maybe wrong.");
		return;
	}
	
	char tmpMag2_3[512] = { 0 };// , tmpMag2[256] = { 0 };
	memcpy(tmpMag2_3, track2, dwT2size);
	char cardType[8];
	ZeroMemory(cardType, 8);
	if (bT3OK && strlen(track3) > 1)
	{
		memcpy(tmpMag2_3 + dwT2size, "A", 1);
		memcpy(tmpMag2_3 + dwT2size + 1, track3, dwT3size);
		cmdDecodeEx(tmpMag2_3, cardType, magData);
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<DecodeTracksData>，cardType:%s", cardType);

	if (!bT3OK || strlen(cardType) < 4)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E3")("<DecodeTracksData>, track3 data isn't ok or track3 size maybe wrong");
		cmdDecodeMag2(tmpMag2_3, magData);
	}
}
int CCardIssuerFSM::SplitDevModelInfo()
{
	LOG_FUNCTION();
	if (strlen(m_devCat.szModel) < 3)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SplitDevModelInfo>, Wrong szModel:%s", m_devCat.szModel);
		return -1;
	}
	m_csRF = "";
	CSimpleStringA csTmpModel(m_devCat.szModel);
	CAutoArray<CSimpleStringA> arrParam;
	arrParam.Init(16);
	arrParam = csTmpModel.Split('#');
	for (int i = 0; i < arrParam.GetCount(); ++i)
	{
		if (_strnicmp(arrParam[i], "RF", 2) == 0)
		{
			if (arrParam[i].GetLength()>3) {
				m_csRF = arrParam[i].SubString(3, arrParam[i].GetLength() - 3);//获取非接支持的字段值
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("szModel: RF[%s] , m_csRF=%s", arrParam[i].GetData(), m_csRF.GetData());
			
		}
	}
	CheckSupportRf();
	return 0;
}

void CCardIssuerFSM::CloseAndClearDevObj(bool bCheckConnecting, bool bCloseOnly)
{
	LOG_FUNCTION();
	ErrorCodeEnum ec = Error_Unexpect;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<CloseAndClearDevObj>, bCloseOnly:%d, m_bOpened:%d",
		bCloseOnly, m_bOpened);
	if (m_hDevHelper != nullptr && !bCloseOnly)
	{
		m_hDevHelper.TearDown();
		SetDevInitFlag(false);
		//硬件适配器关闭，则设置打开失败
	}
}

void CCardIssuerFSM::HttpsLogCallBack(const char* logtxt) {
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s", logtxt);
}
void CCardIssuerFSM::QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx)
{
	if (m_hDevHelper == nullptr)
		ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
	ErrorCodeEnum errCode;
	CardIssuerStatus cis;
	long l_beginTime, l_endTime;
	memset(&cis, 0, sizeof(CardIssuerStatus));

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->GetDevStatus(cis);
	l_endTime = GetTickCountRVC();

	if (errCode != Error_Succeed) {
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("QueryCIStatus::GetDevStatus");
		ctx->Ans.retainBin = cis.eRetainBin;
		ctx->Ans.hopperNo.Init(m_hopperNum);
		ctx->Ans.hopperStatus.Init(m_hopperNum);
		for (int i = 0; i < m_hopperNum; ++i)
		{
			ctx->Ans.hopperNo[i] = i;
			ctx->Ans.hopperStatus[i] = (int)cis.eIssuerBin[i];
		}
		ctx->Answer(Error_Succeed);
	}
	return;
}
bool CCardIssuerFSM::ToRegistCaptureCardInfo()
{
	//oilyang@20230214 no need to regist swallowed card info to system(according to meeting result,运营&财富平台)

	//to check if url config
	if (m_csSwallowCardUrl.IsNullOrEmpty())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220304").setResultCode("RTA230Z")("m_csSwallowCardUrl is empty. %s", m_csSwallowCardUrl.GetData());
		return false;
	}
	RegistCaptureCardInfoTask* task = new RegistCaptureCardInfoTask(this, m_currCardNo);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	return true;
}
void CCardIssuerFSM::CheckSupportRf()
{
	//加入szmodel非接字段属性判断
	if (m_csRF.Compare("Y") == 0) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("szModel,RF=%s", m_csRF.GetData());
		m_bSupportRF = true;
		return;
	}	

	CAutoArray<CSimpleStringA> arr = m_rfVendorList.Split('|');
	for (int i = 0; i < arr.GetCount(); ++i)
	{
		if (m_adapterInfo.adapterFilePath.IndexOf(arr[i].GetData()) > 0) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s,%s", arr[i].GetData(), m_adapterInfo.adapterFilePath.GetData());
			m_bSupportRF = true;
		}
	}
	return;
}

int CCardIssuerFSM::EjectJS(SpReqAnsContext<CardIssuerStandService_EjectJS_Req, CardIssuerStandService_EjectJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("吐卡开始");
	long l_beginTime, l_endTime;
	Sleep(300);//oilyang@20230106 for keba said "maybe we need stay for machine to prepare..."
	int ret = 0;
	ErrorCodeEnum eErr;
	m_pCardProcess->DataInit();
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCard(CI_MOVECARD_FRONT_GATE);
	l_endTime = GetTickCountRVC();
	DWORD dwTmpUserErrCode = 0;
	if (eErr != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE) err");
		if (m_bCardFromHopper) 
			dwTmpUserErrCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FRONT_GATE, "DevAdapter::MoveCard", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220342", "EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE) err");
		else 
			dwTmpUserErrCode = SetErrorAndLog(eErr, CardIssuer_UserErrorCode_MoveCardToGate_Failed, "DevAdapter::MoveCard", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220342", "EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE) err");
		if (ctx != NULL) {
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		}
		return 1;//S9
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220342")("EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE)");
		//等待取卡
		DWORD dwStart, dwEnd;
		dwStart = GetTickCountRVC();
		ErrorCodeEnum errState = Error_Succeed;
		long l_beginTime, l_endTime;
		DWORD dwTmpUserErrCode = 0;
		LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_ON, "CardReader(fetch) warning on");
		do {

			l_beginTime = GetTickCountRVC();
			errState = m_hDevHelper->GetDevStatus(m_devStatus);
			l_endTime = GetTickCountRVC();

			if (Error_Succeed == errState) {
				dwEnd = GetTickCountRVC();
				if (m_devStatus.eMedia == CI_MEDIA_ENTERING) {
					Sleep(WAIT_INTERVAL);
				}
				else {
					LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF, "CardReader(fetch) warning off");
					if (ctx != NULL) {
						ctx->Answer(Error_Succeed);
					}
					return 0;//成功取走
				}
			}
			else
			{
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF, "CardReader(fetch) warning off");
				dwTmpUserErrCode = SetErrorAndLog(errState, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220342");
				if (ctx != NULL)
				{
					ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
				}
				return 1;//S9
			}
		} while ((dwEnd - dwStart) < 55 * 1000);//预留5秒给吞卡操作
		LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF, "CardReader(fetch) warning off");
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("客户未取卡超时");

		//超时未取卡进行吞卡操作
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->MoveCard(CI_MOVECARD_BACK_NOT_HOLD);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("EjectJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD)");
			m_CardCaptured++;
			m_captureReason = "4998";//超时未取卡引起吞卡
			ToRegistCaptureCardInfo();//登记吞卡记录
			m_currCardNo = "";

			//超时吞卡成功
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Forget_Fetch_Card_Capture_Succ, "forget fetch card ,capture succ");
			if (ctx != NULL) {
				ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_Forget_Fetch_Card_Capture_Succ);
			}
			return 0;//超时吞卡成功
		}
		else {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("EjectJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD) err");
			
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220342", "EjectJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD) err");
			
			//超时吞卡失败
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Forget_Fetch_Card_Capture_Fail, "forget fetch card ,capture fail");
			if (ctx != NULL) {
				ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_Forget_Fetch_Card_Capture_Fail);
			}
			return 1;//S9 超时吞卡失败
		}

	}
}

int CCardIssuerFSM::CaptureJS(SpReqAnsContext<CardIssuerStandService_CaptureJS_Req, CardIssuerStandService_CaptureJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DWORD dwTmpUserErrCode = 0;
	long l_beginTime, l_endTime;
	int ret = 0;
	if (ctx != NULL) {
		if (!ctx->Req.captureCode.IsNullOrEmpty()) {
			m_captureReason = ctx->Req.captureCode;
		}
		else {
			m_captureReason = "9999";//默认值，未分类的业务吞卡
		}
		LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard_FromBusiness, CSimpleStringA::Format("CaptureCard called from Business. captureReason=%s", ctx->Req.captureCode.GetData()));
	}
	m_pCardProcess->DataInit();

	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->MoveCard(CI_MOVECARD_BACK_NOT_HOLD);
	l_endTime = GetTickCountRVC();

	if (eErr == Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("CaptureJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD)");
		m_CardCaptured++;
		ToRegistCaptureCardInfo();//登记吞卡记录
		m_currCardNo = "";
	}
	else {
		dwTmpUserErrCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD, "DevAdapter::MoveCard", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220343");
		ret = 1;
	}
	//业务返回
	if (ctx != NULL) {
		if (Error_Succeed == eErr) {
			ctx->Answer(Error_Succeed);
		}
		else {
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		}
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CapturedJS, ret:%d", ret);
	return ret;
}

void CCardIssuerFSM::QueryHasCardJS(SpReqAnsContext<CardIssuerStandService_QueryHasCardJS_Req, CardIssuerStandService_QueryHasCardJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	int ret = 0;
	if (m_hDevHelper == nullptr) {
		ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_DevOpen_Failed);
	}
	else {
		ErrorCodeEnum errCode;
		long l_beginTime, l_endTime;
		l_beginTime = GetTickCountRVC();
		errCode = m_hDevHelper->GetDevStatus(m_devStatus);
		l_endTime = GetTickCountRVC();

		if (Error_Succeed == errCode)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("QueryHasCardJS::GetDevStatus, m_devStatus.eMedia:%d", m_devStatus.eMedia);
			//ret = (m_devStatus.eMedia == CI_MEDIA_PRESENT) ? 1 : 0;
			ret = (int)m_devStatus.eMedia;
			ctx->Ans.position = ret;
			ctx->Answer(Error_Succeed);
		}
		else
		{
			DWORD dwTmpUserErrCode = SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		}

	}
}

int CCardIssuerFSM::IssueFromBoxJS(SpReqAnsContext<CardIssuerStandService_IssueFromBoxJS_Req, CardIssuerStandService_IssueFromBoxJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("卡箱发卡");
	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;

	//Req.hopper
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IssueCard, issue hopper:%d", ctx->Req.hopper);
	ctx->Ans.reserved1.Init(2);

	//param Req.hopper is wrong
	if (ctx->Req.hopper < 1 || ctx->Req.hopper > 6) {
		errMsg = CSimpleStringA::Format("Issuer Card, the hopperNo(%d) is wrong!!!", ctx->Req.hopper);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Invalid_Hopper, errMsg.GetData());
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA23CW")(errMsg.GetData());
		ctx->Answer(Error_Param, CardIssuer_UserErrorCode_Invalid_Hopper);
		return 1;
	}
	m_currentHopper = ctx->Req.hopper;//设置发送的卡箱号
	m_pCardProcess->DataInit();

	ErrorCodeEnum errCode;
	CardIssuerStatus cis;
	memset(&cis, 0, sizeof(CardIssuerStatus));
	bool bEmpty = false;

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->GetDevStatus(cis);
	l_endTime = GetTickCountRVC();

	if (errCode != Error_Succeed) {
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("%d", cis.eIssuerBin[m_currentHopper - 1]);
		if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_EMPTY || cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_NOTSUPP) {
			bEmpty = true;
		}
	}

	if (bEmpty)
	{

		DWORD dwUsrErrCode = 0;
		if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_NOTSUPP)
		{
			if (m_currentHopper == 1)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230B")("未检测到卡箱1，请检测卡箱1是否放好");
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230C")("未检测到卡箱2，请检测卡箱2是否放好");
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230D")("未检测到卡箱3，请检测卡箱3是否放好");
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper3;
			}
		}
		else if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_EMPTY)
		{
			if (m_currentHopper == 1)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230E")("卡箱1未检测到卡片，请检测卡箱1中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230F")("卡箱2未检测到卡片，请检测卡箱2中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230G")("卡箱3未检测到卡片，请检测卡箱3中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper3;
			}
		}
		ctx->Answer(Error_DevNotAvailable, dwUsrErrCode);
		return 1;
	}

	FSMSetIssueFlag(1);
	//move card to holder

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->MoveCard(CI_MOVECARD_FROM_HOPPER, m_currentHopper);
	l_endTime = GetTickCountRVC();

	m_bCardFromHopper = true;//用于区分吐卡报错不同
	if (errCode != Error_Succeed)
	{
		CSimpleStringA errMsg = CSimpleStringA::Format("m_currentHopper:%d", m_currentHopper);
		DWORD dwTmpUserErrCode = SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FROM_HOPPER, "DevAdapter::MoveCard", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220345", errMsg.GetData());
		ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		return 2;//S9 
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220345")("IssueCard::MoveCard succ, m_currentHopper:%d", m_currentHopper);
	}

	m_bUseRFTillNext = false;
	Sleep(1000);
	ctx->Ans.reserved1[0] = ctx->Ans.reserved1[1] = 0;

	ctx->Answer(Error_Succeed);
	return 0;
}

int CCardIssuerFSM::PostOnlineJS(SpReqAnsContext<CardIssuerStandService_PostOnlineJS_Req, CardIssuerStandService_PostOnlineJS_Ans>::Pointer ctx)
{
	if (m_bUseRFTillNext) {
		return PostOnlineJS_RF(ctx);
	}
	bool bCtOK = false;
	int ret = PostOnlineJS_Contact(ctx, bCtOK);
	if (!bCtOK && m_bSupportRF) {
		return PostOnlineJS_RF(ctx);
	}
	else {
		return ret;
	}
}

int CCardIssuerFSM::PostOnlineJS_Contact(SpReqAnsContext<CardIssuerStandService_PostOnlineJS_Req, CardIssuerStandService_PostOnlineJS_Ans>::Pointer ctx, bool& bICOK)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("(PostOnlineJS_Contact) 联机后IC接触处理");
	m_pCardProcess->DataInit();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PostOnlineJS_Contact>, postOnLine data[%s]", ctx->Req.data.GetData());
	m_pCardProcess->SplitOnlineReplyData(ctx->Req.data.GetData(), strlen(ctx->Req.data));
	int issBnkAuth = m_pCardProcess->IssueBankAuth(CARD_MACHINE_ISSUER, m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER, m_hDevHelper, m_bCDA);
		if (transEnd == 0) {
			csTransEnd = "TRANSEND,0";
		}
		else if (transEnd == 1) {
			csTransEnd = "TRANSEND,1";
		}
	}
	else {
		csTransEnd = "TRANSEND,1";
	}
	ctx->Ans.result = csTransEnd;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220341")("<PostOnlineJS_Contact>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());
	ctx->Answer(Error_Succeed);
	return 0;
}

int CCardIssuerFSM::PostOnlineJS_RF(SpReqAnsContext<CardIssuerStandService_PostOnlineJS_Req, CardIssuerStandService_PostOnlineJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("(PostOnlineJS_RF) 联机后IC非接处理");
	m_pCardProcess->DataInit();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PostOnlineJS_RF>, postOnLine data[%s]", ctx->Req.data.GetData());
	m_pCardProcess->SplitOnlineReplyData(ctx->Req.data.GetData(), strlen(ctx->Req.data));
	int issBnkAuth = m_pCardProcess->IssueBankAuth(CARD_MACHINE_ISSUER_RF, m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER_RF, m_hDevHelper, m_bCDA);
		if (transEnd == 0) {
			csTransEnd = "TRANSEND,0";
		}
		else if (transEnd == 1) {
			csTransEnd = "TRANSEND,1";
		}
	}
	else {
		csTransEnd = "TRANSEND,1";
	}
	ctx->Ans.result = csTransEnd;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220341")("<PostOnlineJS_RF>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());
	ctx->Answer(Error_Succeed);
	return 0;
}

void CCardIssuerFSM::ReadMag(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx)
{
	m_currCardNo = "";
	MagTracks magTracks;
	memset(magTracks.track[0].data, 0, sizeof(magTracks.track[0].data));
	memset(magTracks.track[1].data, 0, sizeof(magTracks.track[1].data));
	memset(magTracks.track[2].data, 0, sizeof(magTracks.track[2].data));
	magTracks.eRange = CI_TRACK_RANGE_2_3;

	ErrorCodeEnum eMagReadErr;
	m_ullBeginTime = GetTickCountRVC();
	eMagReadErr = m_hDevHelper->MagRead(magTracks);
	m_ullEndTime = GetTickCountRVC();
	if (Error_Succeed == eMagReadErr) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagRead").setCostTime(m_ullEndTime - m_ullBeginTime)("ReadMag::MagRead t1Status:%d, t2Status:%d, t3Status:%d, t1Len:%d, t2Len:%d, t3Len:%d",
			magTracks.track[0].eStatus, magTracks.track[1].eStatus, magTracks.track[2].eStatus, magTracks.track[0].dwSize, magTracks.track[1].dwSize, magTracks.track[2].dwSize);
		ctx->Ans.magStatus = 0;
		//json格式返回
		std::map<std::string, std::string> magInfo;
		if (magTracks.track[0].eStatus == CI_DATA_OK)
			magInfo["track1"] = (char*)magTracks.track[0].data;
		else
			magInfo["track1"] = "";
		if (magTracks.track[1].eStatus == CI_DATA_OK)
			magInfo["track2"] = (char*)magTracks.track[1].data;
		else
			magInfo["track2"] = "";
		if (magTracks.track[2].eStatus == CI_DATA_OK)
			magInfo["track3"] = (char*)magTracks.track[2].data;
		else
			magInfo["track3"] = "";


		std::pair<bool, std::string> strResult;
		strResult = generateJsonStr(magInfo);
		ctx->Ans.magData = strResult.second.c_str();

		//oiltmp what's this???
		if (m_issueStatus)
			SetDevState(DEVICE_STATUS_NORMAL);//设置为mixed从读卡失败恢复为成功时才触发同步计数和写运行时
		if (m_bSingleMagOrIC)
			ctx->Answer(Error_Succeed);
	}
	else {
		DWORD dwCode = SetErrorAndLog(eMagReadErr, MEC_DEVAPI_CARDISSUER_MagRead, "DevAdapter::MagRead", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, "", "ReadMag::MagRead fail");
		if (m_bSingleMagOrIC)
			ctx->Answer(Error_Unexpect, dwCode);
		else
		{
			ctx->Ans.magStatus = 1;
			ctx->Ans.magData = "";
			ctx->Ans.magMsg = GetErrMsgByCode(dwCode);
		}
	}
	return;
}

int CCardIssuerFSM::PreOnlineJS_ReadViaContact(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx, bool bContinue)
{
	LOG_FUNCTION();
	ctx->Ans.icStatus = 1;
	ctx->Ans.icMode = 0;
	m_ullBeginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->MoveCard(CI_MOVECARD_IC_POSITION);
	m_ullEndTime = GetTickCountRVC();
	if (eErr == Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(m_ullEndTime - m_ullBeginTime)("MoveCard to CI_MOVECARD_IC_POSITION");
	}
	else {
		DWORD dwTmpUserErrCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MoveCard, "DevAdapter::MoveCard", __FUNCTION__, !bContinue && IsInBusiness(), m_ullEndTime - m_ullBeginTime);
		ctx->Ans.icMsg = GetErrMsgByCode(dwTmpUserErrCode);
		if (bContinue)
			return -1;
		else
		{
			if (m_bSingleMagOrIC)
				ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
			else
				ctx->Answer(Error_Succeed);
			return -1;
		}
	}

	m_pCardProcess->DataInit();
	//split the business data for pboc process
	//JR/T 0025.5—2013:终端发送SELECT命令选择应用，卡片返回文件控制信息（FCI），如果卡片支持SM算法，则其中应包括PDOL，PDOL中应含有SM算法支持指示器（DF69）
	m_pCardProcess->SplitBusinessData(ctx->Req.businessData, ctx->Req.businessData.GetLength());
	m_pCardProcess->SplitBusinessData("DF690101", strlen("DF690101"));
	
	int activeCardType;
	int retDetectAndRead = -1;
	ICData aidFromBus(false, 0x4f, 0x00);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_BUS, aidFromBus, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, the front BusinessData have not provide aid data.");
		m_ullBeginTime = GetTickCountRVC();
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER, m_hDevHelper, m_aidList, activeCardType, m_issueStatus);
		m_ullEndTime = GetTickCountRVC();
	}
	else {
		char* pAIDTmp = new char[64];
		memset(pAIDTmp, 0, 64);
		HexBuf2StrBuf(aidFromBus.value, &pAIDTmp, aidFromBus.lenth);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, the aid from business is[%s],len:%d .", pAIDTmp, strlen(pAIDTmp));
		CAutoArray<CSimpleString> preAIDs;
		preAIDs.Init(1);
		preAIDs[0] = (CSimpleStringA)pAIDTmp;

		m_ullBeginTime = GetTickCountRVC();
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER, m_hDevHelper, preAIDs, activeCardType, m_issueStatus);
		m_ullEndTime = GetTickCountRVC();
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);

	if (retDetectAndRead < 0)
	{
		DWORD dwDevApiCode = 0;
		CSimpleStringA csDevApiName(""), csLogCode("");
		CSimpleStringA csIssueContext = CSimpleStringA::Format("{\"InIssue\":%d}", m_issueStatus);//oiltmp
		GetDevApiCodeAndName(retDetectAndRead, dwDevApiCode, csDevApiName);
		if (m_issueStatus)
			csLogCode = CardIssuerStandService_LogCode_IssueEx;
		else
			csLogCode = CardIssuerStandService_LogCode_Read;
		DWORD dwCode = SetErrorAndLog(Error_Unexpect, dwDevApiCode, csDevApiName, __FUNCTION__, !bContinue && IsInBusiness(), m_ullEndTime - m_ullBeginTime, csLogCode, csIssueContext);
		if (!bContinue) //no need continue
		{
			if (m_bSingleMagOrIC)
				ctx->Answer(Error_Unexpect, dwCode);
			else
			{
				//oilyang@20250828 return ErrorSucceed so that the caller can know the failed reason of both mag&ic
				ctx->Ans.icMsg = GetErrMsgByCode(dwCode);
				ctx->Answer(Error_Succeed);
			}
		}
		return -1;
	}

	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	m_btCID = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER, m_hDevHelper, taaResult, true, m_bCDA, m_btCID);
	if (retTAA != 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, TermActionAnalyze, retTAA:%d, taaResult:%s", retTAA, taaResult.GetData());
	}
	switch (retTAA)
	{//to be added oiltmp 20140929
	case -1:	//some data may be wrong
		break;
	case 1:		//terminal trans
		break;
	case 2:		//to do trans end "TransEnd"
		break;
	default:
		break;
	}
	ctx->Ans.pbocData = taaResult;
	return 0;
}

int CCardIssuerFSM::PreOnlineJS_ReadViaRF(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx, bool bContinue)
{
	LOG_FUNCTION();
	ctx->Ans.icStatus = 1;
	ctx->Ans.icMode = 1;
	m_ullBeginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->MoveCard(CI_MOVECARD_RF_POSITION);
	m_ullEndTime = GetTickCountRVC();
	if (eErr == Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(m_ullEndTime - m_ullBeginTime)("PreOnlineJS_RF::MoveCard, (CI_MOVECARD_RF_POSITION)");
	}
	else {
		DWORD dwTmpUserErrCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MoveCard, "DevAdapter::MoveCard", __FUNCTION__, !bContinue && IsInBusiness(), m_ullEndTime - m_ullBeginTime);
		ctx->Ans.icMsg = GetErrMsgByCode(dwTmpUserErrCode);
		if (bContinue)
			return -1;
		else
		{
			if (m_bSingleMagOrIC)
				ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
			else
				ctx->Answer(Error_Succeed);
			return -1;
		}
	}

	m_pCardProcess->DataInit();
	//数据已读出，开始pmoc流程
	m_pCardProcess->SplitBusinessData(ctx->Req.businessData, ctx->Req.businessData.GetLength());
	m_pCardProcess->SplitBusinessData("DF690101", strlen("DF690101"));

	int activeCardType;
	int retDetectAndRead = -1;
	ICData aidFromBus(false, 0x4f, 0x00);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_BUS, aidFromBus, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_RF>, the front BusinessData have not provide aid data.");
		m_ullBeginTime = GetTickCountRVC();
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_RF, m_hDevHelper, m_aidList, activeCardType, m_issueStatus);
		m_ullEndTime = GetTickCountRVC();
	}
	else {
		char* pAIDTmp = new char[64];
		memset(pAIDTmp, 0, 64);
		HexBuf2StrBuf(aidFromBus.value, &pAIDTmp, aidFromBus.lenth);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnlineJS_RF>, the aid from business is[%s],len:%d .", pAIDTmp, strlen(pAIDTmp));
		CAutoArray<CSimpleString> preAIDs;
		preAIDs.Init(1);
		preAIDs[0] = (CSimpleStringA)pAIDTmp;
		m_ullBeginTime = GetTickCountRVC();
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_RF, m_hDevHelper, preAIDs, activeCardType, m_issueStatus);
		m_ullEndTime = GetTickCountRVC();
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_RF>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);

	if (retDetectAndRead < 0)
	{
		DWORD dwDevApiCode = 0;
		CSimpleStringA csDevApiName(""), csLogCode("");
		CSimpleStringA csIssueContext = CSimpleStringA::Format("{\"InIssue\":%d}", m_issueStatus);//oiltmp
		GetDevApiCodeAndName(retDetectAndRead, dwDevApiCode, csDevApiName);
		if (m_issueStatus)
			csLogCode = CardIssuerStandService_LogCode_IssueEx;
		else
			csLogCode = CardIssuerStandService_LogCode_Read;
		DWORD dwCode = SetErrorAndLog(Error_Unexpect, dwDevApiCode, csDevApiName, __FUNCTION__, !bContinue && IsInBusiness(), m_ullEndTime - m_ullBeginTime, csLogCode, csIssueContext);
		if (!bContinue) //no need continue
		{
			if (m_bSingleMagOrIC)
				ctx->Answer(Error_Unexpect, dwCode);
			else
			{
				//oilyang@20250828 return ErrorSucceed so that the caller can know the failed reason of both mag&ic
				ctx->Ans.icMsg = GetErrMsgByCode(dwCode);
				ctx->Answer(Error_Succeed);
			}
		}
		return -1;
	}

	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	m_btCID = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER_RF, m_hDevHelper, taaResult, true, m_bCDA, m_btCID);
	if (retTAA != 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnlineJS_RF>, TermActionAnalyze, retTAA:%d, taaResult:%s", retTAA, taaResult.GetData());
	}
	switch (retTAA)
	{//to be added oiltmp 20140929
	case -1:	//some data may be wrong
		break;
	case 1:		//terminal trans
		break;
	case 2:		//to do trans end "TransEnd"
		break;
	default:
		break;
	}
	ctx->Ans.pbocData = taaResult;
	LogWarn(Severity_Low, Error_Succeed, CardIssuer_UserErrorCode_ReadByRF, CSimpleStringA::Format("PreOnline_RF ok.iIssue:%d ", m_issueStatus));

	return 0;
}
int CCardIssuerFSM::PreOnlineJS_ICDataProcess(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (ctx->Ans.pbocData.GetLength() == 0)
	{
		ctx->Ans.icStatus = 0;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("no need to pboc?");
		ctx->Answer(Error_Succeed);
		return 0;
	}

	string tmpResult, actionType, result = "", baseICData = "";
	tmpResult = ctx->Ans.pbocData;
	char* pSomeICData = new char[ONE_K];
	ZeroMemory(pSomeICData, ONE_K);
	int lenRet = m_pCardProcess->ConstructARQCData(tmpResult.substr(6, 4).c_str(), m_pDataToARQC, pSomeICData);
	baseICData = pSomeICData;
	if (pSomeICData != NULL) {
		delete[]pSomeICData;
	}
	char arqcLen[8];
	ZeroMemory(arqcLen, sizeof(arqcLen));
	_itoa(lenRet, arqcLen, 10);

	ICData track2(false, 0x57, 0x00), ICCardSerial(false, 0x5f, 0x34), appExpiryDate(false, 0x5f, 0x24), icPAN(false, 0x5a, 0x00);
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA t2ICTrack2(""), cardType("0"), csExpireDate(""), csICCardSerial("");

	char* pExpireDate = new char[12];//获取ic有效期
	ZeroMemory(pExpireDate, 12);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, appExpiryDate, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnlineJS_Contact>, can't find expire date");
	}
	else {
		HexBuf2StrBuf(appExpiryDate.value, &pExpireDate, appExpiryDate.lenth);
		csExpireDate = pExpireDate;
	}
	delete[] pExpireDate;


	char* pICCardSerial = new char[4];//获取ic序号
	ZeroMemory(pICCardSerial, 4);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, ICCardSerial, false) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnlineJS_Contact>, can't find card serial.");
	}
	else
	{
		HexBuf2StrBuf(ICCardSerial.value, &pICCardSerial, ICCardSerial.lenth);
		csICCardSerial = pICCardSerial;
	}
	delete[] pICCardSerial;


	char* pICTrack2 = new char[128];//获取等效磁条2
	ZeroMemory(pICTrack2, 128);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnlineCrossJS_Contact>, ic no track2 data");
		m_ullBeginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReleaseIC();
		m_ullEndTime = GetTickCountRVC();
		if (eErr != Error_Succeed) {
			SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ReleaseIC, "DevAdapter::ReleaseIC", __FUNCTION__, false, m_ullEndTime - m_ullBeginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(m_ullEndTime - m_ullBeginTime)("PreOnlineJS_Contact::ReleaseIC");
		}
	}
	else
	{
		HexBuf2StrBuf(track2.value, &pICTrack2, track2.lenth);
		t2ICTrack2 = pICTrack2;
	}
	delete[]pICTrack2;

	char* pPAN = new char[20];//Primary Account Number. var length, max cn19
	ZeroMemory(pPAN, 20);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, icPAN, false) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setResultCode("RTA23E1")("can't find PAN(tag:5a)");
	}
	else
	{
		HexBuf2StrBuf(icPAN.value, &pPAN, icPAN.lenth);
		m_currCardNo = pPAN;
		LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardBin, SP::Module::Util::DataMask(SP::Module::Util::DataMask_CardAccount, m_currCardNo).GetData());
	}
	delete[] pPAN;

	//80 1e 80 0008 328ab54bfc986b85 07010103a0b000010a010000000000754048769000
	if (m_pCardProcess->GetP1() == 0x1) {
		actionType = "ARQC";
	}
	else {
		actionType = "";
	}
	//【55域】
	//	基本域：
	//	9F26	8b	应用密文AC
	//	9F27	1b	密文信息数据
	//	9F10	max.32b	发卡行应用数据IAD
	//	9F37	4b	不可预知数
	//	9F36	2b	应用交易计数器ATC
	//	95	5b	终端验证结果TVR
	//	9A	3cn	交易日期（6位有效数字，YYMMDD）
	//	9C	1cn	交易类型（2位有效数字）
	//	9F02	6cn	授权金额（12位有效数字）
	//	5F2A	2cn	交易货币代码（3位有效数字）
	//	82	2b	应用交互特征AIP
	//	9F1A	2cn	终端国家代码（3位有效数字）
	//	9F03	6cn	其他金额（12位有效数字）
	//	9F33	3b	终端性能 "E0C900"

	//	可选域：
	//添加9F26,9F27,9F10,9F33的数据
	char* pCID = new char[4];
	ZeroMemory(pCID, 4);
	HexBuf2StrBuf(&m_btCID, &pCID, 1);
	char* pIssueBankLen = new char[4];
	ZeroMemory(pIssueBankLen, 4);
	int len9f10 = tmpResult.length() - 26 - 4;
	int lenHigh, lenLow;
	len9f10 = len9f10 / 2;
	lenHigh = len9f10 / 16;
	lenLow = len9f10 % 16;
	BYTE bt9f10;
	bt9f10 = (lenHigh << 4) + lenLow;
	HexBuf2StrBuf(&bt9f10, &pIssueBankLen, 1);
	baseICData += "9F2608" + tmpResult.substr(10, 16) + "9F2701" + pCID + "9F10" + pIssueBankLen + tmpResult.substr(26, tmpResult.length() - 26 - 4) + "9F3303" + "E0C900";

	//json格式返回
	std::map<std::string, std::string> msgInfo;
	msgInfo["ACTION"] = actionType.c_str();
	msgInfo["ATC_CODE"] = tmpResult.substr(6, 4).c_str();
	msgInfo["ARQC_CODE"] = tmpResult.substr(10, 16).c_str();
	msgInfo["MAC"] = tmpResult.substr(26, tmpResult.length() - 26 - 4).c_str();
	CSimpleStringA arqcLenStr = arqcLen;
	msgInfo["ARQC_SIZE"] = arqcLenStr.GetData();
	CSimpleStringA arqcData = m_pDataToARQC;
	msgInfo["ARQC_DATA"] = arqcData.GetData();
	msgInfo["IC_TRACK2"] = t2ICTrack2;
	msgInfo["EXPIRE_DATE"] = csExpireDate;
	msgInfo["ICCardSerial"] = csICCardSerial;
	msgInfo["IC_TAGS"] = baseICData.c_str();

	std::pair<bool, std::string> strResult;
	strResult = generateJsonStr(msgInfo);
	result = strResult.second.c_str();

	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("data to host result=%s,len=%d", result.c_str(), result.length());

	string txtresult = "ACTION," + actionType + "|" + "ATCCODE," + tmpResult.substr(6, 4) + "|" + "ARQCCODE," + tmpResult.substr(10, 16) + "|"
		+ "MAC," + tmpResult.substr(26, tmpResult.length() - 26 - 4) + "|" + "ARQCSIZE," + string(arqcLen) + "|ARQCDATA, " + m_pDataToARQC + "|"
		+ "T2TRACK2(len)," + CSimpleStringA::Format("%d", t2ICTrack2.GetLength()).GetData() + "|"
		+ "EXPIREDATE(len)," + csExpireDate.GetData() + "|"
		+ "ICTAGS, " + CSimpleStringA::Format("%d", baseICData.length()).GetData();

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, data to host(less)[%s]", txtresult.c_str());

	if (pCID != NULL)
		delete[]pCID;
	if (pIssueBankLen != NULL)
		delete[]pIssueBankLen;

	if (m_pDataToARQC != NULL)
	{
		delete[]m_pDataToARQC;
		m_pDataToARQC = NULL;
	}

	ctx->Ans.pbocData = result.c_str();
	ctx->Ans.icStatus = 0;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220306")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::ReadJS(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx)
{
	//init value, 2 for 
	ctx->Ans.magStatus = 2;
	ctx->Ans.icStatus = 2;
	ctx->Ans.icMode = -1;
	ctx->Ans.magMsg = "";
	ctx->Ans.icMsg = "";
	switch (ctx->Req.mode)
	{
	case ReadMode_MagOnly:
		m_bSingleMagOrIC = true;
		ReadMag(ctx);
		break;
	case ReadMode_ICOnly_ContactICFirst:
	{
		m_bSingleMagOrIC = true;
		//read via contact, if failed and support RF,to read via RF
		int ret = PreOnlineJS_ReadViaContact(ctx, m_bSupportRF);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ret:%d, m_bSupportRF:%d", ret, m_bSupportRF);
		if (ret != 0 && m_bSupportRF)
			ret = PreOnlineJS_ReadViaRF(ctx, false);
		if (ret == 0)
			PreOnlineJS_ICDataProcess(ctx);
	}
		break;
	case ReadMode_ICOnly_RFFirst:
	{
		m_bSingleMagOrIC = true;
		//if support RF, read via RF, if failed then read via contact
		int ret = -1;
		if (m_bSupportRF)
			ret = PreOnlineJS_ReadViaRF(ctx, true);
		if (ret != 0)
			ret = PreOnlineJS_ReadViaContact(ctx, false);
		if (ret == 0)
			PreOnlineJS_ICDataProcess(ctx);
	}
		break;
	case ReadMode_ICOnly_RFOnly:
	{
		m_bSingleMagOrIC = true;
		if (m_bSupportRF)
		{
			if (PreOnlineJS_ReadViaRF(ctx, false) == 0)
				PreOnlineJS_ICDataProcess(ctx);
		}
		else
			ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_NotSupportRF);
	}
		break;
	case ReadMode_MagIC_ContactICFirst:
	{
		m_bSingleMagOrIC = false;
		//first read mag, then read via contact, if failed and support RF,to read via RF
		ReadMag(ctx);
		int ret = PreOnlineJS_ReadViaContact(ctx, m_bSupportRF);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ret:%d, m_bSupportRF:%d", ret, m_bSupportRF);
		if (ret != 0 && m_bSupportRF)
			ret = PreOnlineJS_ReadViaRF(ctx, false);
		if (ret == 0)
			PreOnlineJS_ICDataProcess(ctx);
	}
		break;
	case ReadMode_MagIC_RFFirst:
	{
		m_bSingleMagOrIC = false;
		//first read mag, if support RF, read via RF, if failed then read via contact
		int ret = -1;
		ReadMag(ctx);
		if (m_bSupportRF)
			ret = PreOnlineJS_ReadViaRF(ctx, true);
		if (ret != 0)
			ret = PreOnlineJS_ReadViaContact(ctx, false);
		if (ret == 0)
			PreOnlineJS_ICDataProcess(ctx);
	}
		break;
	case ReadMode_MagIC_RFOnly:
	{
		m_bSingleMagOrIC = false;
		int ret = -1;
		ReadMag(ctx);
		if (m_bSupportRF)
		{
			if (PreOnlineJS_ReadViaRF(ctx, false) == 0)
				PreOnlineJS_ICDataProcess(ctx);
		}
		else
		{
			ctx->Ans.icMsg = GetErrMsgByCode(CardIssuer_UserErrorCode_NotSupportRF);
			ctx->Answer(Error_Succeed);
		}
	}
		break;
	default:
		ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_UnkownReadJSMode);
		break;
	}
	return 0;
}

int CCardIssuerFSM::InsertJS(SpReqAnsContext<CardIssuerStandService_InsertJS_Req, CardIssuerStandService_InsertJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pCardProcess->DataInit();//??是否需要此处就初始化
	//m_bCancelByRFIC = false;//??无用变量
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_ON, "CardReader warning on");
	//等待插卡
	long l_beginTime, l_endTime;
	ErrorCodeEnum eErr = Error_Unexpect;
	int acceptTries = 0, errRet = 0;//0成功，1查询状态失败 2超时 3取消 4取消有卡
	//m_bWaitingAccept = true;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("InternalInsert, m_bExit:%d, m_bCancelInsert:%d, m_bWaitAccepteMore:%d", m_bExit, m_bCancelInsert, m_bWaitAccepteMore));
	bool bHasSetCardInType = false;
	DWORD64 dwStart = GetTickCountRVC();
	DWORD64 dwEnd = dwStart;

	DWORD dwTmpCode;

	errRet = 2;//默认是超时
	do {
		if (m_bExit)
		{	//页面退到首页
			m_bCancelInsert = true;
			errRet = 3;
			break;
		}
		if (m_bCancelInsert)
		{	//取消插卡
			errRet = 3;
			break;
		}

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->GetDevStatus(m_devStatus);
		l_endTime = GetTickCountRVC();

		if (Error_Succeed == eErr)
		{
			//成功
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT)
			{
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand op.insert succeed");
				errRet = 0;
				FSMSetIssueFlag(0);
				m_bCardFromHopper = false;
				m_bUseRFTillNext = false;
				break;//插卡成功
			}
			else if (m_devStatus.eMedia == CI_MEDIA_NOTPRESENT)
			{
				//无卡
				Sleep(ACCEPT_TRY_INTERVAL);
				//打开进口
				if (!m_bCancelInsert) {
					if (!bHasSetCardInType) {
						l_beginTime = GetTickCountRVC();
						eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_ALL);
						l_endTime = GetTickCountRVC();
						if (Error_Succeed == eErr) {
							bHasSetCardInType = true;
						}
						else {
							dwTmpCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "", "InternalInsert::SetCardInType CI_CARD_IN_TYPE_ALL err");
							errRet = 1;
							break;
						}
					}
				}

			}
		}
		else
		{
			dwTmpCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, "QLR040220303");
			errRet = 6;
			break;//查询硬件状态失败。???要退吗
		}
		dwEnd = GetTickCountRVC();
	} while ((dwEnd - dwStart) < 58 * 1000);

	m_bExit = false;

	if (errRet == 3)
	{
		//判定是否有卡，有卡则走吐卡流程
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->GetDevStatus(m_devStatus);
		l_endTime = GetTickCountRVC();
		if (Error_Succeed == eErr) {
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT) {
				errRet = 4;//取消时有卡
			}
			else {
				errRet = 3;//取消无卡
			}
		}
		else {
			dwTmpCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, "QLR040220303");
			errRet = 6;//查询硬件状态失败
		}
	}
	if (errRet != 1)
	{
		//关闭进口
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		l_endTime = GetTickCountRVC();
		if (Error_Succeed != eErr)
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime);
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("%s", __FUNCTION__);
		}
	}
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF, "CardReader warning off");

	switch (errRet)
	{
	case 0:
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("AcceptCard, insert succeed");
		ctx->Answer(Error_Succeed);
		break;
	case 1:
	case 5:
		ctx->Answer(Error_Unexpect, dwTmpCode);
		break;
	case 2:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AcceptCard, insert timeout");
		ctx->Answer(Error_TimeOut, CardIssuer_UserErrorCode_Insert_Card_TimeOut);
		break;
	case 3:
	case 4:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AcceptCard, insert cancel");
		ctx->Answer(Error_Cancel, CardIssuer_UserErrorCode_Insert_Card_Cancel);
		break;
	default:
		break;
	}
	return errRet;
}
CSimpleStringA CCardIssuerFSM::MaskCardno(const char* cardno)
{
	CSimpleStringA maskCardno = "";

	if (cardno == NULL) {
		maskCardno = "(null)****(null)";
	}
	else {
		CSimpleStringA xTestStr(cardno);
		if (xTestStr.GetLength() == 0) {
			maskCardno = "(null)****(null)";
		}
		else if (xTestStr.GetLength() > 6) {
			maskCardno = CSimpleStringA::Format("%s****%s", xTestStr.SubString(0, 6).GetData(), xTestStr.SubString(xTestStr.GetLength() - 4, 4).GetData());
		}
		else {
			maskCardno = CSimpleStringA::Format("%s****", xTestStr.GetData());
		}
	}

	return maskCardno;
}

void CCardIssuerFSM::OnStateTrans(int iSrcState, int iDstState)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("trans from %s to %s", GetStateName(iSrcState), GetStateName(iDstState));
}
void CCardIssuerFSM::FSMEventDefaultProcess(FSMEvent* pEvt, DWORD dwUserCode)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("iEvt:%d,dwUserCode:%x", pEvt->iEvt, dwUserCode);
	switch (pEvt->iEvt)
	{
	case USER_EVT_JS_INSERT:
	{
		InsertJSEvent* ise = dynamic_cast<InsertJSEvent*>(pEvt);
		pEvt->SetHandled();
		ise->ctx->Answer(Error_InvalidState, dwUserCode);
	}
	break;
	case USER_EVT_JS_READ:
	{
		ReadJSEvent* rje = dynamic_cast<ReadJSEvent*>(pEvt);
		pEvt->SetHandled();
		rje->ctx->Answer(Error_InvalidState, dwUserCode);
	}
	break;
	case USER_EVT_JS_ISSUE_FROM_BOX:
	{
		IssueFromBoxJSEvent* ife = dynamic_cast<IssueFromBoxJSEvent*>(pEvt);;
		pEvt->SetHandled();
		ife->ctx->Answer(Error_InvalidState, dwUserCode);
	}
	break;
	case USER_EVT_JS_EJECT:
	{
		EjectJSEvent* eje = dynamic_cast<EjectJSEvent*>(pEvt);
		pEvt->SetHandled();
		eje->ctx->Answer(Error_InvalidState, dwUserCode);
	}
	break;
	case USER_EVT_JS_POSTONLINE:
	{
		PostOnlineJSEvent* poe = dynamic_cast<PostOnlineJSEvent*>(pEvt);
		pEvt->SetHandled();
		poe->ctx->Answer(Error_InvalidState, dwUserCode);
	}
	break;
	case USER_EVT_JS_CAPTURE:
	{
		CaptureJSEvent* cje = dynamic_cast<CaptureJSEvent*>(pEvt);
		pEvt->SetHandled();
		cje->ctx->Answer(Error_InvalidState, dwUserCode);
	}
	break;
	default:
		break;
	}
	return;
}
CSimpleStringA CCardIssuerFSM::GetErrMsgByCode(DWORD dwCode)
{
	CSimpleStringA tmpRTA(true), tmpDesc(true);
	GetEntityBase()->GetFunction()->GetVTMErrMsg(dwCode, tmpDesc, tmpRTA);
	return CSimpleStringA::Format("[%s]%s", tmpRTA.GetData(), tmpDesc.GetData());
}
void CCardIssuerFSM::GetDevApiCodeAndName(int retValue, DWORD& dwDevApiCode, CSimpleStringA& csDevApiName)
{
	switch (retValue)
	{
	case -1:
		dwDevApiCode = MEC_DEVAPI_CARDISSUER_ContactIC;
		csDevApiName = "DevAdapter::ContactIC";
		break;
	case -2:
		dwDevApiCode = MEC_DEVAPI_CARDISSUER_ActiveICCard;
		csDevApiName = "DevAdapter::ActiveICCard";
		break;
	case -3:
		dwDevApiCode = MEC_DEVAPI_CARDISSUER_ActiveContactlessICCard;
		csDevApiName = "DevAdapter::ActiveContactlessICCard";
		break;
	case -4:
		dwDevApiCode = MEC_DEVAPI_CARDISSUER_ICCommand;
		csDevApiName = "DevAdapter::ICCommand";
		break;
	case -5:
		dwDevApiCode = MEC_DEVAPI_CARDISSUER_RFTypeABCommand;
		csDevApiName = "DevAdapter::RFTypeABCommand";
		break;
	default:
		dwDevApiCode = DEC_NO_E_CARDISSUER_START;
		csDevApiName = "DevAdapter::SthWrong";
		break;
	}
	return;
}