myvtm/Module/mod_cardissuerstore/CardIssuerFSM.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "SpHelper.h"
#include "CardIssuerFSM.h"
#include "GetDevInfoHelper.h"
#include "EventCode.h"
#include "RVCComm.h"
//oilyang@20200522 go on using
// deprecated!! [4/17/2020 16:15 @Gifur]
#include "CardIssuerStore_msg_g.h"
#include "ModuleMix.h"

#include "publicFunExport.h"
#pragma comment(lib, "libpublicFun.lib")
#include <algorithm>
#include <map>
#ifdef RVC_OS_WIN
#define _ATL_NO_AUTOMATIC_NAMESPACE
#include <atltime.h>
#endif //RVC_OS_WIN

char tmpxx[1024];
char testIC[1024];

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

//oiltest@20200915 temp for GetTickCount
#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 = 3;
const int ACCEPT_TRY_INTERVAL = 500;
const int ACCEPT_TRY_NUM = 110;

class CCardIssuerEntity;
void CCardIssuerFSM::s0_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 0;
	SetDevStateAndSendMsg(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)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s0 evt (%d,%d)", 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();
	m_currentFSMState = 1;
	GetEntityBase()->GetFunction()->SetSysVar("CardStoreInUse", "N");
}
void CCardIssuerFSM::s1_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s1_on_event(FSMEvent* event)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s1 evt (%d,%d)", event->iEvt, event->param1);

	if (event->iEvt == USER_EVT_INITFINISHED) {
		event->SetHandled();
		int err = event->param1;
		if (err == 0) {
			return 0;
		} else {
			return 1;
		}
	}else if (event->iEvt == USER_EVT_QUIT) {
		event->SetHandled();
		return 0;
	}
	return 0;
}
//Idle
void CCardIssuerFSM::s2_on_entry()
{
	LOG_FUNCTION();

	ToLogWarnInfoAboutTerm();
	m_currentFSMState = 2;
	SetDevStateAndSendMsg(DEVICE_STATUS_NORMAL, false);
	
	m_resetTimes = 0;
	m_testResult = Error_Succeed;
	m_bIssuingExit = false;
}

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

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

	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_JS_READ_BATCHCARDINFO_IN_RANGE:
	{
		ReadBatchCardInfoInRangeJSEvent* rcr = dynamic_cast<ReadBatchCardInfoInRangeJSEvent*>(pEvt);
		ReadBatchCardInfoInRangeJSTask* rTask = new ReadBatchCardInfoInRangeJSTask(this);
		rTask->ctx = rcr->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(rTask);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_JS_MOVE_AND_READ_CARD_FROMSLOT:
	{
		MoveAndReadCardFromSlotJSEvent* mcs = dynamic_cast<MoveAndReadCardFromSlotJSEvent*>(pEvt);
		MoveAndReadCardFromSlotJSTask* mTask = new MoveAndReadCardFromSlotJSTask(this);
		mTask->ctx = mcs->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(mTask);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_JS_ADD_AND_READ_CRAD_FROMBOX:
	{
		AddAndReadCardFromBoxJSEvent* acb = dynamic_cast<AddAndReadCardFromBoxJSEvent*>(pEvt);
		AddAndReadCardFromBoxJSTask* mTask = new AddAndReadCardFromBoxJSTask(this);
		mTask->ctx = acb->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(mTask);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_JS_ISSUE_FROM_SLOT:
	{
		IssueFromSlotJSEvent* ifs = dynamic_cast<IssueFromSlotJSEvent*>(pEvt);
		IssueFromSlotJSTask* mTask = new IssueFromSlotJSTask(this);
		mTask->ctx = ifs->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(mTask);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_JS_ISSUE_FROM_BOX:
		{
			IssueFromBoxJSEvent* ifs = dynamic_cast<IssueFromBoxJSEvent*>(pEvt);
			IssueFromBoxJSTask* mTask = new IssueFromBoxJSTask(this);
			mTask->ctx = ifs->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(mTask);
			pEvt->SetHandled();
		}
		break;
	case USER_EVT_JS_CAPTURE:
	{
		CaptureJSEvent* cejs = dynamic_cast<CaptureJSEvent*>(pEvt);
		CaptureJSTask* task = new CaptureJSTask(this);
		task->ctx = cejs->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_EXIT:
	{
		m_captureReason = "4001";
		m_bExit = true;
		pEvt->SetHandled();
		DoExitWhenIdleTask *task = new DoExitWhenIdleTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		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_INFO, LOG_TYPE_USER)("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_INFO, 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_PREONLINE:
	{
		pEvt->SetHandled();
		PreOnlineEvent* poe = dynamic_cast<PreOnlineEvent*>(pEvt);
		if (poe->ctx->Req.reserved1.GetLength() > 0 && _strnicmp("kaku#", (const char*)poe->ctx->Req.reserved1, 5) == 0)
		{
			PreOnlineTask* task = new PreOnlineTask(this);
			task->ctx = poe->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			ret = 16;
		}
		break;
	}
	case USER_EVT_QUERYCARDINFO_ON_STORE:
	{
		pEvt->SetHandled();
		QueryCardInfoOnStoreEvent* qce = dynamic_cast<QueryCardInfoOnStoreEvent*>(pEvt);
		QueryCardInfoOnStoreTask* qTask = new QueryCardInfoOnStoreTask(this);
		qTask->ctx = qce->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(qTask);
	}
	break;
	default:
		break;
	}
	return ret;
}
//Hold
void CCardIssuerFSM::s4_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 4;
}
void CCardIssuerFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s4_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s4 evt (%d,%d)", pEvt->iEvt, pEvt->param1);

	switch(pEvt->iEvt){
		case USER_EVT_JS_CAPTURE:
			{
				CaptureJSEvent* cejs = dynamic_cast<CaptureJSEvent*>(pEvt);
				CaptureJSTask* task = new CaptureJSTask(this);
				task->ctx = cejs->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_MOVEBACK_TO_SLOT:
			{
				MoveBacktoSlotJSEvent* msjs = dynamic_cast<MoveBacktoSlotJSEvent*>(pEvt);
				MoveBacktoSlotJSTask* task = new MoveBacktoSlotJSTask(this);
				task->ctx = msjs->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_EJECT:
			{
				EjectJSEvent* ejs = dynamic_cast<EjectJSEvent*>(pEvt);
				EjectJSTask* task = new EjectJSTask(this);
				task->ctx = ejs->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_WRITE_TRACK:
			{
				WriteTrackJSEvent* wjs = dynamic_cast<WriteTrackJSEvent*>(pEvt);
				WriteTrackJSTask* task = new WriteTrackJSTask(this);
				task->ctx = wjs->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_PRINT_CARD:
			{
				PrintCardImmediatelyJSEvent* pjs = dynamic_cast<PrintCardImmediatelyJSEvent*>(pEvt);
				PrintCardImmediatelyJSTask* task = new PrintCardImmediatelyJSTask(this);
				task->ctx = pjs->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_SAM_IC_COMMAND:
			{
				SAMICCommandJSEvent* sjs = dynamic_cast<SAMICCommandJSEvent*>(pEvt);
				SAMICCommandJSTask* task = new SAMICCommandJSTask(this);
				task->ctx = sjs->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_POSTONLINE:
			{
				PostOnlineJSEvent* pjs = dynamic_cast<PostOnlineJSEvent*>(pEvt);
				PostOnlineJSTask* task = new PostOnlineJSTask(this);
				task->ctx = pjs->ctx;
				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_EXIT:
		case USER_EVT_EJECT:
			{
				if ((pEvt->iEvt == USER_EVT_EXIT) && m_issueStatus)
				{				
					m_captureReason = "4001";
					CardCaptureEvent *cce = dynamic_cast<CardCaptureEvent*>(pEvt);
					CaptureTask *task=  new CaptureTask(this);
					task->ctx = NULL;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
					pEvt->SetHandled();
					return 1;
				}
				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_INFO, 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;
			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;
		case USER_EVT_WRITE:
			{
				CardWriteEvent* cwe = dynamic_cast<CardWriteEvent*>(pEvt);
				WriteTask* task = new WriteTask(this);
				task->ctx = cwe->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
			}
			break;
		case USER_EVT_SAM_IC:
		{
			SAMICCommandEvent* sice = dynamic_cast<SAMICCommandEvent*>(pEvt);
			SAMICCommandTask* task = new SAMICCommandTask(this);
			task->ctx = sice->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();
			return pEvt->param1;
		}
			break;
		case USER_EVT_ISSUE_EX_FINISHED:
			pEvt->SetHandled();
			return pEvt->param1;
		case USER_EVT_PRINT_CARD_IM:
		{
			pEvt->SetHandled();
			PrintCardImEvent* pcie = dynamic_cast<PrintCardImEvent*>(pEvt);
			PrintCardImTask* qTask = new PrintCardImTask(this);
			qTask->ctx = pcie->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(qTask);
		}
		break;
		default:
			break;
	}
	return 0;
}
//Reading
void CCardIssuerFSM::s5_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 5;
}
void CCardIssuerFSM::s5_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s5_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s5 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_JS_POSTONLINE_FINISHED:
		{
			pEvt->SetHandled();
			ret = 0;
		}
		break;
	case USER_EVT_READ_FINISHED:
		{
			pEvt->SetHandled();
			CardReadFinishedEvent *pCRNFE = dynamic_cast<CardReadFinishedEvent *>(pEvt);
			if (pCRNFE->param1 == 0)
			{
				pCRNFE->ctx->Answer(Error_Succeed);
				ret = 0;
			}else if (pCRNFE->param1 == 2)
			{
				pCRNFE->ctx->Answer(Error_DevMedia);
				ret = 2;
			}
			else
			{
				SetErrPackage("Read finished", m_csDevSN, Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus);
				pCRNFE->ctx->Answer(Error_Unexpect, AlarmDEC());
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222003").setResultCode("RTA2W22")("获取设备状态GetDevStatus失败");
				ret = 1;
			}
		}
		break;
	case USER_EVT_EXIT:
		{
			pEvt->SetHandled();
			m_captureReason = "4001";
		}
		break;
	case USER_EVT_QUIT:
		{
			pEvt->SetHandled();
			ret = 0;
		}
	default:
		break;
	}
	return ret;
}
//Ejecting
void CCardIssuerFSM::s6_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 6;
}
void CCardIssuerFSM::s6_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s6_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s6 evt (%d,%d)", pEvt->iEvt, pEvt->param1);

	if (pEvt->iEvt == USER_EVT_EJECTFINISHED){
		pEvt->SetHandled();
		if (pEvt->param1 == 0)
			return 0;
		else
			return 1;
	}else if (pEvt->iEvt == USER_EVT_QUIT) {
		pEvt->SetHandled();
		return 0;
	}
	else if (pEvt->iEvt == USER_EVT_JS_EJECT_FINISHED) {
		pEvt->SetHandled();
		if (pEvt->param1 == 0) {
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuer op.");
			m_currCardNo =  "";
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("客户取走卡片");
			return 0;
		}
		else if (pEvt->param1 == 1) {
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER)("取卡时设备故障");
			return 1;
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("客户未取卡超时");
			m_captureReason = "4019";
			LogWarn(Severity_Low, Error_NotInit, CardIssuerStore_UserErrorCode_Customer_Forget_Fectch_Card, "Customer forget fetch card.");
			CaptureJSTask* task = new CaptureJSTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 2;
		}
	}
	return 0;
}
//Waiting fetch
void CCardIssuerFSM::s7_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 7;
	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)("s7 evt (%d, %d)", 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, "CardIssuer 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);
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER)("取卡时设备故障");
			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_WARN, LOG_TYPE_USER)("客户未取卡超时msg发送");
			m_captureReason = "4019";
			LogWarn(Severity_Low, Error_NotInit, CardIssuerStore_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_INFO, 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_INFO, 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], 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:
		break;
	}
	return 0;
}
void CCardIssuerFSM::s8_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 8;
}
void CCardIssuerFSM::s8_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s8_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s8 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	if (pEvt->iEvt == USER_EVT_CAPTUREFINISHED){
		pEvt->SetHandled();
		if (pEvt->param1 == 0)
			return 0;
		else
			return 1;
	}else if (pEvt->iEvt == USER_EVT_JS_CAPTURE_FINISHED) {
		pEvt->SetHandled();
		if (pEvt->param1 == 0){
			return 0;
		}
		else {
			return 1;
		}
	}else if (pEvt->iEvt == USER_EVT_QUIT) {
		pEvt->SetHandled();
		return 0;
	}
	return 0;
}
//Failed
void CCardIssuerFSM::s9_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 9;
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CardIssuer in fault state, need to reset.");
	SetDevStateAndSendMsg(DEVICE_STATUS_FAULT);
	FSMEvent *e = new FSMEvent(USER_EVT_RESET);
	PostEventFIFO(e);
}
void CCardIssuerFSM::s9_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s9_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s9 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_RESET:
		{
			pEvt->SetHandled();
			m_resetTimes++;
			if (_strnicmp("RVC.Stand2S", m_csMachineType, strlen("RVC.Stand2S")) == 0 && m_resetTimes > MAX_RESET_TIMES_PERIOD)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("restart tried %d times, give up",m_resetTimes);
				m_testResult = Error_InvalidState;
				return 0;
			}
			ResetDeviceEvent* rde = dynamic_cast<ResetDeviceEvent*>(pEvt);
			ResetTask* task = new ResetTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);

			return 0;
		}
		break;
	case USER_EVT_RESETFINISHED:
		{
			ResetFinishedEvent *rfe = dynamic_cast<ResetFinishedEvent*>(pEvt);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("reset finished, result:%d", rfe->param1);
			if (rfe->param1 == 0)
				return 0;
			else
			{
				m_testResult = Error_InvalidState;
				return 1;
			}
				
		}
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		return 0;
	default:
		break;
	}

	return 0;
}
//Issuing
void CCardIssuerFSM::s10_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 10;
}
void CCardIssuerFSM::s10_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s10_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s10 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_JS_MOVE_AND_READ_CARD_FROMSLOT_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_JS_ADD_AND_READ_CRAD_FROMBOX_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_JS_MOVEBACK_TO_SLOT_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_JS_ISSUE_FROM_SLOT_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_JS_ISSUE_FROM_BOX_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_ISSUE_EX_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_EXIT:
		pEvt->SetHandled();
		m_captureReason = "4001";
		m_bIssuingExit = true;
		break;
	case USER_EVT_QUERYCARDINFO_ON_STORE://while THE CardStore is in using,another request arrived
	case USER_EVT_PREONLINE:
	{
		pEvt->SetHandled();
		if (pEvt->iEvt == USER_EVT_PREONLINE)
		{
			PreOnlineEvent* poe = dynamic_cast<PreOnlineEvent*>(pEvt);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222027").setResultCode("RTA2W0Q")("卡库正在被其他机器跨机使用中");
			poe->ctx->Answer(Error_Duplication, CardIssuerStore_UserErrorCode_DupCallPreOnline_WhileInWorking);
		}
		else
		{
			QueryCardInfoOnStoreEvent* qciose = dynamic_cast<QueryCardInfoOnStoreEvent*>(pEvt);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222027").setResultCode("RTA2W0Q")("卡库正在被其他机器跨机使用中");
			qciose->ctx->Answer(Error_Duplication, CardIssuerStore_UserErrorCode_DupCallPreOnline_WhileInWorking);
		}
	}
		break;
	default:
		break;
	}
	return ret;
}
//Writing
void CCardIssuerFSM::s11_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 11;
}
void CCardIssuerFSM::s11_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s11_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s11(writing) evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_JS_WRITE_TRACK_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_WRITE_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_EXIT:
		pEvt->SetHandled();
		m_captureReason = "4001";
		m_bIssuingExit = true;
		break;
	default:
		break;
	}
	return ret;
}
//SAMIC
void CCardIssuerFSM::s14_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 14;
}
void CCardIssuerFSM::s14_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s14_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s14 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_JS_SAM_IC_COMMAND_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_SAM_IC_FINISHED:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}

void CCardIssuerFSM::s17_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 17;
}
void CCardIssuerFSM::s17_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s17_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s17 evt (%d,%d)", pEvt->iEvt, pEvt->param1);

	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_JS_READ_BATCHCARDINFO_IN_RANGE_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_QUERYCARDINFO_ON_STORE_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	default:
		break;
	}
	return ret;
}
//PrintCardIm
void CCardIssuerFSM::s18_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 18;
}
void CCardIssuerFSM::s18_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s18_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s18 evt (%d,%d)", pEvt->iEvt, pEvt->param1);

	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_JS_PRINT_CARD_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_PRINT_CARD_IM_FINISHED:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}
ErrorCodeEnum CCardIssuerFSM::OnInit()
{
	LOG_FUNCTION();

	m_pCardProcess = new CCardProcess();
	if (m_pCardProcess == NULL)//almost no use...
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("create card process failed.");
		return Error_Resource;
	}
	Load();
	CSystemStaticInfo sysInfo;
	//oilyang 20160331
	//so many function always return Error_Succeed,so is useless to process it.
	m_csMachineType = m_csSite = m_terminalNo = "";
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	m_csMachineType = sysInfo.strMachineType;
	m_csSite = sysInfo.strSite;
	m_terminalNo = sysInfo.strTerminalID;
	m_majorVerion = sysInfo.MachineVersion.GetMajor();
	m_minorVerion = sysInfo.MachineVersion.GetMinor();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuer, MachineType:%s, Site:%s, TerminalNo:%s, MachineVersion:%d.%d",
		m_csMachineType.GetData(), m_csSite.GetData(), m_terminalNo.GetData(), m_majorVerion, m_minorVerion);
#ifdef RVC_OS_WIN
	//如果是东信卡库，将CardLibDB_CMB.db3文件拷贝到运行时中，若运行时已存在该文件，不再拷贝
	if(!m_csMachineType.Compare("RVC.CardStore", true))
	{
		CSmartPointer<IConfigInfo> spConfig;
		GetEntityBase()->GetFunction()->OpenConfig(Config_Root, spConfig);
		
		CSimpleStringA csVendor("");
		spConfig->ReadConfigValue("Device.CardIssuer", "Vendor", csVendor);

		if(!csVendor.Compare("Eastcom", true))
		{
			CSimpleStringA runinfoPath(true);
			CSimpleStringA depPath(true);
			GetEntityBase()->GetFunction()->GetPath("RunInfo", runinfoPath);
			GetEntityBase()->GetFunction()->GetPath("Dep", depPath);
			CSimpleStringA runinfodbFile = runinfoPath + "\\runcfg\\CardLibDB_CMB.db3";
			CSimpleStringA depdbFile = depPath + "\\CardLibDB_CMB.db3";

			WIN32_FIND_DATA findData;
			if (FindFirstFileA((LPCTSTR)runinfodbFile, &findData) == INVALID_HANDLE_VALUE
				&& FindFirstFileA((LPCTSTR)depdbFile, &findData) != INVALID_HANDLE_VALUE)	
			{
				//如果运行时不存在该文件,则拷贝
				LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_EastCom_Not_Exist_DataFile, "runinfo has no CardLibDB_CMB.db3 file.");
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start copy file CardLibDB_CMB.db3 to runinfo.");
				CopyFile(depdbFile.GetData(), runinfodbFile.GetData(), FALSE);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("end copy file CardLibDB_CMB.db3 to runinfo.");
			}
			else if(FindFirstFileA((LPCTSTR)runinfodbFile, &findData) != INVALID_HANDLE_VALUE){
				LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_EastCom_Exist_DataFile, "runinfo has CardLibDB_CMB.db3 file.");
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("has exist CardLibDB_CMB.db3 in runinfo");
			}else if(FindFirstFileA((LPCTSTR)depdbFile, &findData) == INVALID_HANDLE_VALUE){
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("no CardLibDB_CMB.db3 in dep");
			}else{
				
			}
		}
	}

	//因替换实体名，需要兼容把以前旧的运行时文件拷贝成新的实体名运行文件
	CSimpleStringA runinfoPath(true);
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum  err = GetEntityBase()->GetFunction()->GetPath("RunInfo", runinfoPath);
	if (err != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("get system RunInfo value failed.");
		return Error_Exception;
	}
	err = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfig);
	if (err != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("get cfg file failed ");
		return err;
	}

	CSimpleStringA runinfoOldFile = runinfoPath + SPLIT_SLASH_STR + "runcfg" + SPLIT_SLASH_STR + "CardIssuer.ini";
	CSimpleStringA runinfoNewFile = runinfoPath + SPLIT_SLASH_STR + "runcfg" + SPLIT_SLASH_STR + "CardIssuerStore.ini";

	int enterMainPageInt = 0;

	if (ExistsFile(runinfoNewFile.GetData())) {
		if (ExistsFile(runinfoOldFile)) {
			//新在，旧也在，新进入首页则不拷贝，否则重新拷贝
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStore.ini is Exist. CardIssuer.ini is Exist");
			spConfig->ReadConfigValueInt("all", "enterMainPage", enterMainPageInt);
			if (enterMainPageInt == 2) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStore.ini is Exist. enterMainPage=%d, no recopy", enterMainPageInt);
			}
			else if (enterMainPageInt == 1) {
				//先删再拷贝
				if (RemoveFileA(runinfoNewFile.GetData())) {
					if (CopyFileA(runinfoOldFile.GetData(), runinfoNewFile.GetData(), FALSE)) {
						LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_CopyRuncfg, "Recopy old CardIssuer.ini succ");
						spConfig->WriteConfigValueInt("all", "enterMainPage", 1);//写入初值
					}
					else {
#ifdef RVC_OS_WIN
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Recopy old CardIssuer.ini failed.err=%d", (int)GetLastError());
#else
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Recopy old CardIssuer.ini failed.err=%d", errno);
#endif
						return Error_Exception;
					}
				}
				else {
#ifdef RVC_OS_WIN
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("remove CardIssuerStore.ini failed.err=%d", (int)GetLastError());
#else
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("remove CardIssuerStore.ini failed.err=%d", errno);
#endif
					return Error_Exception;
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CardIssuerStore.ini is Exist. but enterMainPage=%d is invalid, continued use CardIssuerStore.ini", enterMainPageInt);
			}

		}
		else {
			//新在，旧不在，不处理
			spConfig->ReadConfigValueInt("all", "enterMainPage", enterMainPageInt);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStore.ini is Exist. CardIssuer.ini not Exist .enterMainPage=%d", enterMainPageInt);
		}
	}
	else {
		if (ExistsFile(runinfoOldFile)) {
			//新不在，旧在，拷贝，附初值
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStore.ini is not Exist. CardIssuer.ini is Exist");
			if (CopyFileA(runinfoOldFile.GetData(), runinfoNewFile.GetData(), FALSE)) {
				LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_CopyRuncfg, "copy old CardIssuer.ini succ.");
				spConfig->WriteConfigValueInt("all", "enterMainPage", 1);//写入初值
			}
			else {
#ifdef RVC_OS_WIN
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("copy old CardIssuer.ini failed.err=%d", (int)GetLastError());
#else
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("copy old CardIssuer.ini failed.err=%d", errno);
#endif
				return Error_Exception;
			}

		}
		else {
			//新旧都不在，附初值
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStore.ini is not Exist. CardIssuer.ini is not Exist");
			spConfig->WriteConfigValueInt("all", "enterMainPage", 1);//写入初值
		}
	}
	


#endif //RVC_OS_WIN
	m_devStatus.eMedia = CI_MEDIA_NOTPRESENT;
	m_bHasHopper[0] = false;
	m_bHasHopper[1] = false;
	m_bHasHopper[2] = false;
	return Error_Succeed;
}
ErrorCodeEnum CCardIssuerFSM::OnExit()
{
	LOG_FUNCTION();
	//ErrorCodeEnum eExit;
	//long l_beginTime, l_endTime;
	//if (m_hDevHelper != nullptr)
	//{
	//	l_beginTime = GetTickCountRVC();
	//	eExit = m_hDevHelper->GetDevStatus(m_devStatus);
	//	l_endTime = GetTickCountRVC();
	//	

	//	if (eExit == Error_Succeed)
	//	{
	//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("OnExit::GetDevStatus, m_devStatus.eMedia:%d, m_issueStatus:%d", m_devStatus.eMedia, m_issueStatus);
	//		if (m_devStatus.eMedia == CI_MEDIA_PRESENT){
	//			if (m_issueStatus)
	//			{
	//				LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_OnExit, "OnExit, issue flag is 1, to capture card");
	//				eExit = MachineMoveCardBackNotHold();
	//				m_CardCaptured++;
	//				SetCardCaptured(m_CardCaptured);
	//			}
	//			else
	//			{
	//				LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_EjectCard_ByTerminal, "OnExit, issue flag is 0, to eject card");
	//				MachineMoveCardFrontGate();
	//			}
	//		}
	//	}
	//	else {
	//		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W22")("OnExit::GetDevStatus err=%s", SpStrError(eExit));
	//	}
	//	l_beginTime = GetTickCountRVC();
	//	eExit = m_hDevHelper->DevClose();
	//	l_endTime = GetTickCountRVC();
	//	
	//	if (eExit == Error_Succeed) {
	//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevClose").setCostTime(l_endTime - l_beginTime)("OnExit,读卡器关闭DevClose成功");
	//	}
	//	else {
	//		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevClose").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCJ")("OnExit,读卡器关闭DevClose失败 eErr:%d", eExit);
	//	}
	//}
	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::GetDevStatus(bool bPrint)
{
	int getDevInfoCount = 0;
	static unsigned int lightStatus = 0;
	ErrorCodeEnum errCode;
	long l_beginTime, l_endTime;
	do{
		l_beginTime = GetTickCountRVC();
		errCode = m_hDevHelper->GetDevStatus(m_devStatus);
		l_endTime = GetTickCountRVC();
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("GetDevStatus::GetDevStatus");

		if (bPrint)
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevStatus, GetDevStatus::eMedia: %d,errCode:%d", m_devStatus.eMedia, errCode);
		if (Error_Succeed == errCode) 
		{
			if (_strnicmp("RVC.CardPrinter", m_csMachineType, strlen("RVC.CardPrinter")) == 0)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("kaku tape(flat%d,concave:%d,gold:%d,silver:%d",
						m_devStatus.eKakuTape[0], m_devStatus.eKakuTape[1], m_devStatus.eKakuTape[2], m_devStatus.eKakuTape[3]);
			}
			return true;
		}
		else
		{
			DevErrorInfo devErrInfo;
			m_hDevHelper->GetLastErr(devErrInfo);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevStatus errMsg:%s", devErrInfo.szErrMsg);
			getDevInfoCount++;
			Sleep(3000);
		}
	} while (getDevInfoCount < GET_DEV_STATUS_COUNT);
	return false;
}
int CCardIssuerFSM::Reset()
{
	LOG_FUNCTION();
	if (m_hDevHelper == nullptr)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Maybe the m_hDevHelper have been released,switch to s0 to restart.");
		return 2;
	}
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum ec = m_hDevHelper->Reset();
	l_endTime = GetTickCountRVC();
	if (ec == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Reset").setCostTime(l_endTime - l_beginTime)("Reset::Reset");
		if(GetDevStatus())
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_issueStatus: %d, m_CardCaptured:%d, m_devStatus.eMedia:%d, in Reset.",
											m_issueStatus, m_CardCaptured, m_devStatus.eMedia);
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT || m_devStatus.eMedia == CI_MEDIA_ENTERING)
			{
				ErrorCodeEnum eMoveErr;
				if (m_issueStatus)
				{
					//oiltmp to add 20131212
					eMoveErr = MachineMoveCardBackNotHold();
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_Reset, "issue flag is 1, to capture card.");
					m_CardCaptured++;
					if (!SetCardCaptured(m_CardCaptured))
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("set card captured failed.");
				}
				else
				{
					//oiltmp to add 20131212
					eMoveErr = MachineMoveCardFrontGate();
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_EjectCard_ByTerminal, "issue flag is 0, to eject card.");
				}
				if (eMoveErr == Error_Succeed)
				{
					return 0;
				}
			}
			else if (m_devStatus.eMedia == CI_MEDIA_NOTPRESENT) {
				return 0;
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("media position %d",m_devStatus.eMedia);
				return 1;
			}
		}
		else
		{
			return 1;
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Reset").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WA6")("Reset::Reset err=%s", SpStrError(ec));
		SetErrPackage("Reset::Reset", m_csDevSN, ec, MEC_DEVAPI_CARDISSUER_Reset);
		AlarmDEC();
		return 1;
	}
	return 0;
}


bool CCardIssuerFSM::LoadCMBPrint(CSimpleStringA csBinPath)
{
	if (cmdDecodeEx == NULL) {
		CSimpleStringA csCMBPrint("");
#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)("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)("Get Mag2 address failed.");
			return false;
		}
		if ((cmdDecodeEx = (lpCMBdecodeEx)dlsym(hr, "CMBdecodeEx")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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)("Load CMBPrint failed(%d).", hr);
			return false;
		}
		if ((cmdDecodeMag2 = (lpCMBdecodeMag2)GetProcAddress(hr, "CMBdecodeMag2")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get Mag2 address failed.");
			return false;
		}
		if ((cmdDecodeEx = (lpCMBdecodeEx)GetProcAddress(hr, "CMBdecodeEx")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get Mag23Ex address failed.");
			cmdDecodeMag2 = NULL;
			return false;
		}
#endif
		DbgWithLink(LOG_LEVEL_INFO, 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);

	int initTries = 0;
	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_WARN, LOG_TYPE_SYSTEM)("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 = m_hDevHelper.LoadUp(dllName);
	if (!IS_SUCCEED(eErrDev))
	{
		errMsg = CSimpleStringA::Format("Load vendor adapter failed.%d", GetLastError());
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_LoadLibraryA_Failed, errMsg.GetData());
		GetEntityBase()->GetFunction()->ShowFatalError("加载厂商适配器失败！请检查root.ini配置是否正确。");
		return Error_DevLoadFileFailed;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Get ReleGet vendor function suc.");
	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;
	do {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CreateDevComponent suc. m_port:%d, m_baudRate:%d, pDevSN:%s",
			m_port, m_baudRate, pDevSN);

		l_beginTime = GetTickCountRVC();
		eErrDev = m_hDevHelper->DevOpenEx(m_port, m_baudRate, 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, openType:%d, connectType:%d", btOpenType, m_connectType);
			ToLogRootINIInfo();
			m_bOpened = true;
			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)
			{
				CSimpleStringA tmpVersion = CSimpleStringA::Format("%d.%d.%d.%d", m_devCat.version.wMajor, m_devCat.version.wMinor, m_devCat.version.wRevision, m_devCat.version.wBuild);
				int ret = SplitDevModelInfo();
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevCategory").setCostTime(l_endTime - l_beginTime)("OpenDevice, szVendor:%s, szType:%s, szModel:%s, version:%s, ret:%d",
						m_devCat.szVendor, m_devCat.szType, m_devCat.szModel, tmpVersion.GetData(), ret);
				m_adapterInfo.FulfillCategoryInfo(m_devCat);
			}
			else
			{
				SetErrPackage("OpenDevice::GetDevCategory", m_csDevSN, eErrDev, MEC_DEVAPI_CARDISSUER_GetDevCategory);
				AlarmDEC();
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevCategory").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCH")("CardIssuer启动失败(GetDevCategory failed.)");
				///*TODO: need to clear adapter object? (80374374@4/4/2023)*/
				return Error_Unexpect;
			}

			l_beginTime = GetTickCountRVC();
			eErrDev = m_hDevHelper->GetSlotSum(m_maxSlot);
			l_endTime = GetTickCountRVC();
			if (eErrDev == Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetSlotSum").setCostTime(l_endTime - l_beginTime)("OpenDevice::GetSlotSum");
			}
			else
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetSlotSum").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCK")("OpenDevice::GetSlotSum err=%s", SpStrError(eErrDev));
				SetErrPackage("OpenDevice::GetSlotSum", m_csDevSN, eErrDev, MEC_DEVAPI_CARDISSUER_GetSlotSum);
				AlarmDEC();
			}

			errMsg = CSimpleStringA::Format("max slot num:%d", m_maxSlot);
			LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_CardStore_SlotNum, errMsg.GetData());

			m_maxSlot = (m_maxSlot < 0) ? 0 : m_maxSlot;

			if (!LoadCMBPrint(csBinPath))
			{
				errMsg = CSimpleStringA::Format("CardIssuer启动失败:Load CMBPrint failed.");
				//LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_LoadLibraryA_CMBPrint_Failed, errMsg.GetData());
				return Error_DevLoadFileFailed;
			}
			initTries = 0;
			break;
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpenEx").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WAE")("OpenDevice::DevOpenEx, openType:%d, connectType:%d", btOpenType, m_connectType);
			SetErrPackage("OpenDevice::DevOpenEx", m_csDevSN, eErrDev, MEC_DEVAPI_CARDISSUER_DevOpenEx);
			AlarmDEC();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CardIssuer启动失败:DevOpenEx failed.重试:%d", initTries);
			Sleep(200);
			initTries++;
		}
	} while (initTries < INIT_TRY_NUM);

	if (initTries != 0)
	{
		errMsg = CSimpleStringA::Format("CardIssuer启动失败，have tried %d times!!!", initTries);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_DevOpen_Failed, errMsg.GetData());
		return Error_DevCommFailed;
	}
	else
	{
		eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
		if (eErrDev != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CardIssuer启动失败:open run cfg file failed in OpenDevice.");
			CloseAndClearDevObj(false);
			return eErrDev;
		}
		int ret = 0, isIssue = 99;
		spConfig->ReadConfigValueInt("all", "IsIssue", isIssue);
		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_INFO, LOG_TYPE_SYSTEM)("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_INFO, LOG_TYPE_SYSTEM)("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 如果没有配置，使用原来的配置
		{
			//spConfig->ReadConfigValueInt("RunInfo", "CardRemains", m_remainsEx[0]);
			//spConfig->ReadConfigValueInt("RunInfo", "CardIssued", m_issuedEx[0]);
			//spConfig->ReadConfigValueInt("RunInfo", "CardCaptured", m_CardCaptured);
			//spConfig->ReadConfigValueInt("RunInfo", "IsIssue", isIssue);
			//spConfig->ReadConfigValueInt("RunInfo", "CardMixed", m_mixedEx[0]);
			//spConfig->ReadConfigValueInt("RunInfo", "CardInit", m_CardInitEx[0]);
			//spConfig->ReadConfigValueInt("RunInfo", "CardPercent", m_CardPercentEx[0]);
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("use old record, CardRemains:%d, CardIssued:%d, CardCaptured:%d, IsIssue:%d, CardMixed:%d, CardInit:%d",
			//	m_remainsEx[0], m_issuedEx[0], m_CardCaptured, isIssue, m_mixedEx[0], m_CardInitEx[0]);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("use new hopper cfg record");
		}
		//oilyang 回写卡机配置
		spConfig->WriteConfigValueInt("all", "IsIssue", isIssue);
		spConfig->WriteConfigValueInt("all", "HopperNum", m_hopperNum);
		spConfig->WriteConfigValueInt("1", "CardPercent", m_CardPercentEx[0]);
		spEntityFunction->OpenConfig(Config_CenterSetting, spConfigCS);

		int tmpCardnoMismatch = 0, tmpICRetryTimes = 1, tmpStopUseRF = 0, tmpUseNewAnswer = 0;

		spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "EacQueryFlag", m_eacQueryFlag);
		spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "UseCardnoMismatch", tmpCardnoMismatch);
		spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "ICRetryTimes", tmpICRetryTimes);
		spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "StopUseRF", tmpStopUseRF);

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("StopUseRF:%d", tmpStopUseRF);

		//spConfigCS->ReadConfigValue(GetEntityBase()->GetEntityName(), "RFVendorList", m_rfVendorList);
		spConfigCS->ReadConfigValue(GetEntityBase()->GetEntityName(), "RFVendorListStore", m_rfVendorList);//区分大机的非接厂商配置

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RFVendorListStore=%s", m_rfVendorList);

		spConfigCS->ReadConfigValue(GetEntityBase()->GetEntityName(), "SwallowCardUrl", m_csSwallowCardUrl);

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_csSwallowCardUrl:%s", m_csSwallowCardUrl.GetData());

		spConfigCS->ReadConfigValue(GetEntityBase()->GetEntityName(), "SyncMaterialUrl", m_csSyncMaterialUrl);

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_csSyncMaterialUrl:%s", m_csSyncMaterialUrl.GetData());

		spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "UseNewAnsError", tmpUseNewAnswer);

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("UseNewAnsError:%d", tmpUseNewAnswer);

		spConfigCS->ReadConfigValue("Common", "EacQueryHost", m_EacQueryHost);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("EacQueryFlag:%d,EacQueryHost:%s,UseCardnoMismatch:%d,ICRetryTimes:%d"
			, m_eacQueryFlag, m_EacQueryHost.GetData(), tmpCardnoMismatch, tmpICRetryTimes);

		if (tmpCardnoMismatch == 1)
			m_bUseCardnoMismatch = true;
		if (tmpICRetryTimes > 0 && tmpICRetryTimes < 4)
			m_ICRetryTimes = tmpICRetryTimes;
		if (tmpStopUseRF == 1)
			m_bStopUseRF = true;
		if (tmpUseNewAnswer == 1)
			m_bNewAnsError = true;

		m_issueStatusFromFile = m_issueStatus = isIssue;
		if (m_issueStatusFromFile == 0)
			m_bCardFromHopper = false;
		ret = UnAcceptCard();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ret: %d, isIssue: %d, m_hasCardWhileDevOpen:%d, m_issueStatusFromFile:%d",
			ret, isIssue, m_hasCardWhileDevOpen, m_issueStatusFromFile);

		if (ret == 0)
		{
			FSMSetIssueFlag(0);//oiltmp@20230713 发现卡片一律吞卡策略生效后，这个逻辑实际上不必要了，待后续整体改造
			if (m_hasCardWhileDevOpen && m_issueStatusFromFile > 0)
			{
				//oilyang@20171220 遗留卡片已经被吞，重置数据
				m_issueStatusFromFile = 0;
				m_currCardNo = m_addCardNo = "";
				FSMSetIssueFlag(0);
			}
			
			//oilyang@20191219 获取吞卡箱容量，目前有便携卡机，大机
			//超过5，认为是脏数据，用默认值3
			CardIssuerStatus cis;
			l_beginTime = GetTickCountRVC();
			eErrDev = m_hDevHelper->GetDevStatus(cis);
			l_endTime = GetTickCountRVC();

			if (eErrDev != Error_Succeed) {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W22")("OpenDevice::GetDevStatus err=%s", SpStrError(eErrDev));
				SetErrPackage("OpenDevice::GetDevStatus", m_csDevSN, eErrDev, MEC_DEVAPI_CARDISSUER_GetDevStatus);
				AlarmDEC();
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("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)
				{
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_RETAIN_BIN_IS_FULL_SENSOR, "(sensor)retain bin is full!回收箱满了，请及时清理！");
				}
			}
			LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_Open_Success, "读卡器打开成功");
			return Error_Succeed;
		}
		else
		{
			m_bOpened = false;
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Open_Failed, "启动后检查卡机状态失败");
			return Error_Unexpect;
		}
	}
}
void CCardIssuerFSM::Load()
{
	LOG_FUNCTION();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = GetEntityBase()->GetFunction()->OpenConfig(Config_Root, spConfig);
	if (spConfig == NULL)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<Load>, open root.ini failed");
		return;
	}
	CSimpleStringA csVendor("");
	spConfig->ReadConfigValueInt("Device.CardIssuer", "Baudrate", m_baudRate);
	spConfig->ReadConfigValueInt("Device.CardIssuer", "Port", m_port);
	spConfig->ReadConfigValue("Device.CardIssuer", "Vendor", csVendor);
	HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, csVendor);	

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_baudRate:%d, m_port:%d, csVendor:%s,",
			m_baudRate, m_port, csVendor.GetData());

	m_csDevSN = "";
}
int CCardIssuerFSM::Initial()
{
	ErrorCodeEnum errCode = OpenDevice(DEV_OPEN_TYPE_COM,"");
	if (errCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("OpenDevice in Initial return failed with errCode:%d(0x%x)", errCode, errCode);
		CloseAndClearDevObj(false);
		m_bOpened = false;
		return 1;
	}
	return 0;
}

int CCardIssuerFSM::UnAcceptCard()
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	CSimpleStringA errMsg(true);
	if (GetDevStatus())
	{
		switch (m_devStatus.eMedia)
		{
		case CI_MEDIA_PRESENT:
		{
			m_hasCardWhileDevOpen = true;
			JustReadCardNo();
			CSimpleStringA preFixNo("");
			CSimpleStringA suffixNo("");
			if (!m_currCardNo.IsNullOrEmpty() && m_currCardNo.GetLength() > 10)
			{
				preFixNo = m_currCardNo.SubString(0, 6);
				suffixNo = m_currCardNo.SubString(m_currCardNo.GetLength() - 4, 4);
			}

			if (m_currCardNo.GetLength() > 1)
				m_captureReason = "4014";
			else
				m_captureReason = "0000";
			//oilyang@20230313 根据卡片异常处理沟通会议（业务、深圳开发），实体启动发现有卡，一律吞卡
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402220Z01").setResultCode("RTA2WA1")("读卡器打开时，卡机有卡片，吞卡");
			errMsg = CSimpleStringA::Format("读卡器有卡（吞卡）:%d, CardNoLength:%d, CardNo:%s****%s",
				m_issueStatus, m_currCardNo.GetLength(), preFixNo.GetData(), suffixNo.GetData());
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_EntityOnStart, errMsg.GetData());
			return CaptureCard(NULL);
		}
		case CI_MEDIA_JAMMED:
		case CI_MEDIA_ENTERING:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CardPosUnexpectedOnDevOpen, CSimpleStringA::Format("Unexpected CardStatusEnum:%d", m_devStatus.eMedia));
			break;
		case CI_MEDIA_NOTPRESENT:
			return 0;
		default:
			break;
		}

		//oilyang@20230612 delete the following lines,as no need to GetDevStatus twice
		//long l_beginTime, l_endTime;
		//l_beginTime = GetTickCountRVC();
		//eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		//l_endTime = GetTickCountRVC();

		//if (Error_Succeed != eErr){
		//	SetErrPackage("UnAcceptCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
		//	AlarmDEC();
		//} 
		//if (GetDevStatus())
		//	return 0;
		//else
		//	return 1;
	}
	else
	{
		DevErrorInfo devErrorInfo;
		m_hDevHelper->GetLastErr(devErrorInfo);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("UnAcceptCard, GetDevStatus failed errMsg:%s", devErrorInfo.szErrMsg);
	}
	return 1;
}
int CCardIssuerFSM::IssueCard(SpReqAnsContext<CardIssuerStoreService_IssueEx_Req, CardIssuerStoreService_IssueEx_Ans>::Pointer ctxEx)
{
	LOG_FUNCTION();
	//如果有盘库记录则清理掉（@zjw20190809）
	if (m_csMachineType.Compare("RVC.CardStore") == 0
		|| m_csMachineType.Compare("RVC.CardPrinter") == 0)
	{
		ErrorCodeEnum eErr = Error_Succeed;
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if (eErr != Error_Succeed)
		{
			LogError(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Open_RunCfgFile_Failed, "IssueCard::OpenConfig failed.");
			ctxEx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Open_RunCfgFile_Failed);
			return 2;
		}
		if (CheckHasPanKuRecord(spConfigRun))
		{
			ClearLocalRecord(spConfigRun);
		}
	}

	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;

	if (ctxEx != NULL)
	{
		//Req.hopper
		//89:从加卡箱移卡读卡
		//88:卡片加到卡槽
		//87:吞卡
		//99:从卡槽移卡 吞卡
		//98:手工取卡（不检查卡号是否匹配）
		//100:清空卡库、卡库盘库吞到吞卡箱
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IssueCard, issue type:%d", ctxEx->Req.hopper);
		ctxEx->Ans.reserved1.Init(2);
		
		if (ctxEx->Req.hopper == 100 || ctxEx->Req.hopper == 99 || ctxEx->Req.hopper == 98)//卡库
		{
			m_mapJsonErr.clear();
			if (!IsValidSlotNum(ctxEx->Req.reserved1[0]))
			{
				errMsg = CSimpleStringA::Format("Invalid slot(%d), req.hopper=%d", ctxEx->Req.reserved1[0], ctxEx->Req.hopper);
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotInvalid, errMsg.GetData());
				m_mapJsonErr["userCode"] = JsonElem(CardIssuerStore_UserErrorCode_Dev_SlotInvalid);
				m_mapJsonErr["cardResult"] = JsonElem(CardResult_Invalid_Slot);
				m_mapJsonErr["tips"] = JsonElem("[RTA2W8B] 卡槽地址非法，请联系行内开发人员排查");//oiltmp need 配置后置后从集中配置读取
				if (m_bNewAnsError)
					ctxEx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotInvalid, generateJsonString(m_mapJsonErr));
				else
				{
					ctxEx->Ans.reserved1[0] = 1;
					ctxEx->Answer(Error_Succeed);
				}
				return 2;
			}
			if (!IsSlotHasCard(ctxEx->Req.reserved1[0]))
			{
				errMsg = CSimpleStringA::Format("slot %d has no card, req.hopper=%d", ctxEx->Req.reserved1[0], ctxEx->Req.hopper);
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard, errMsg.GetData());
				m_mapJsonErr["userCode"] = JsonElem(CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard);
				m_mapJsonErr["cardResult"] = JsonElem(CardResult_HaveNoCardInTheSlot);
				m_mapJsonErr["tips"] = JsonElem("[RTA2W86] 卡槽内无卡，请联系厂商排查");
				if (m_bNewAnsError)
					ctxEx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard, generateJsonString(m_mapJsonErr));
				else
				{
					ctxEx->Ans.reserved1[0] = 2;
					ctxEx->Answer(Error_Succeed);
				}
				return 2;
			}
			FSMSetIssueFlag(1);
			bool bSpec = false;
			if (ctxEx->Req.hopper == 98 || ctxEx->Req.hopper == 100)
				bSpec = true;
			return IssueCardFromStore(ctxEx, bSpec);
		}
		else if (ctxEx->Req.hopper == 89)//加卡步骤一
		{
			m_mapJsonErr.clear();
			FSMSetIssueFlag(1);
			return AddCardToStoreStepFirst(ctxEx);
		}
		else if (ctxEx->Req.hopper == 88)//加卡步骤二
		{
			m_mapJsonErr.clear();
			return AddCardToStoreStepLast(ctxEx);
		}
		else if (ctxEx->Req.hopper == 87)//签发失败，吞卡
		{
			m_mapJsonErr.clear();
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_SignFailed, "sign failed, to capture card.");
			ToRegistCaptureCardInfo();
			MachineMoveCardBackNotHold();
			ctxEx->Answer(Error_Succeed);
			return 2;
		}
		//param Req.hopper is wrong
		if (ctxEx->Req.hopper < 1 || ctxEx->Req.hopper > 6){
			errMsg = CSimpleStringA::Format("Issuer Card, the hopperNo(%d) is wrong!!!", ctxEx->Req.hopper);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Invalid_Hopper, errMsg.GetData());
			return Error_Param;
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IssueCard, m_bHasHopper[ctxEx->Req.hopper - 1]:%d", m_bHasHopper[ctxEx->Req.hopper - 1]);
		if (!m_bHasHopper[ctxEx->Req.hopper - 1])
		{
			switch (ctxEx->Req.hopper)
			{
			case 1:
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0B")("未检测到卡箱1，请检测卡箱1是否放好");
				ctxEx->Answer(Error_DevMedia, CardIssuerStore_UserErrorCode_NotHas_Hopper1);
				break;
			case 2:
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0C")("未检测到卡箱2，请检测卡箱2是否放好");
				ctxEx->Answer(Error_DevMedia, CardIssuerStore_UserErrorCode_NotHas_Hopper2);
				break;
			case 3:
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0D")("未检测到卡箱3，请检测卡箱3是否放好");
				ctxEx->Answer(Error_DevMedia, CardIssuerStore_UserErrorCode_NotHas_Hopper3);
				break;
			case 4:
				ctxEx->Answer(Error_DevMedia, CardIssuerStore_UserErrorCode_NotHas_Hopper4);
				break;
			case 5:
				ctxEx->Answer(Error_DevMedia, CardIssuerStore_UserErrorCode_NotHas_Hopper5);
				break;
			case 6:
				ctxEx->Answer(Error_DevMedia, CardIssuerStore_UserErrorCode_NotHas_Hopper6);
				break;
			}
			return 2;
		}
		m_currentHopper = ctxEx->Req.hopper;
	}
	else
		m_currentHopper = 1;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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]))
			SetDevStateAndSendMsg(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 = CardIssuerStore_UserErrorCode_Hopper1_Mixed_Too_Much;
		if (m_currentHopper == 2)
		{
			dwTmpErrCode = CardIssuerStore_UserErrorCode_Hopper2_Mixed_Too_Much;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0S")("卡箱2连续吞卡超限，请及时执行清机");
		}
		else if (m_currentHopper == 3)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0T")("卡箱3连续吞卡超限，请及时执行清机");
			dwTmpErrCode = CardIssuerStore_UserErrorCode_Hopper3_Mixed_Too_Much;
		}
		else
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0R")("卡箱1连续吞卡超限，请及时执行清机");

		LogWarn(Severity_Middle, Error_Unexpect, dwTmpErrCode, errMsg.GetData());
		ctxEx->Answer(TransECWithRepeat(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) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W22")("IssueCard::GetDevStatus err=%s", SpStrError(errCode));
		SetErrPackage("IssueCard::GetDevStatus", m_csDevSN, errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus);
		AlarmDEC();
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("IssueCard::GetDevStatus");
		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)
	{
		CSimpleStringA warnInfo = CSimpleStringA::Format("IssuerCard, hopper%d no more cards to issue. LocalRecord CardremainsEx:%d, Vendor return:NoCard(%d), CardCount(%d)",
			m_currentHopper, m_remainsEx[m_currentHopper - 1], cis.eIssuerBin[m_currentHopper - 1],  cis.dwIssuerCount[m_currentHopper - 1]);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_No_More_Card_Issue, warnInfo.GetData());

		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("QLR040222020").setResultCode("RTA2W0B")("未检测到卡箱1，请检测卡箱1是否放好");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0C")("未检测到卡箱2，请检测卡箱2是否放好");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0D")("未检测到卡箱3，请检测卡箱3是否放好");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper3;
			}
			else if (m_currentHopper == 4)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper4;
			else if (m_currentHopper == 5)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper5;
			else if (m_currentHopper == 6)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper6;
		}
		else if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_EMPTY)
		{
			if (m_currentHopper == 1)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0E")("卡箱1未检测到卡片，请检测卡箱1中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0F")("卡箱2未检测到卡片，请检测卡箱2中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode("QLR040222020").setResultCode("RTA2W0G")("卡箱3未检测到卡片，请检测卡箱3中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper3;
			}
			else if (m_currentHopper == 4)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper4;
			else if (m_currentHopper == 5)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper5;
			else if (m_currentHopper == 6)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper6;
		}
		else if (m_remainsEx[m_currentHopper - 1] <= 0)
		{
			if (m_currentHopper == 1)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0H")("卡箱1本地计数无卡，请执行清机计划");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardRemains_Hopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0J")("卡箱2本地计数无卡，请执行清机计划");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardRemains_Hopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020").setResultCode("RTA2W0K")("卡箱3本地计数无卡，请执行清机计划");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardRemains_Hopper3;
			}
		}
		ctxEx->Answer(Error_DevNotAvailable, dwUsrErrCode);

		return 2;
	}
	//forbid front enter
	
	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
	l_endTime = GetTickCountRVC();

	if (errCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB5")("IssueCard::SetCardInType err=%s", SpStrError(errCode));
		SetErrPackage("IssueCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, errCode, MEC_DEVAPI_CARDISSUER_SetCardInType);
		AlarmDEC();
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("IssueCard::SetCardInType");
	}

	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)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IssueCard::MoveCard, m_currentHopper:%d", m_currentHopper);
		FSMSetIssueFlag(2);
		bool bTrans = true;
		SetErrPackage("IssueCard::MoveCard", m_csDevSN, errCode, TryMapAPIRetToUEC(errCode,MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FROM_HOPPER,bTrans));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W06")("从卡箱移动卡片到读卡器失败，请重试或检查是否有塞卡");
		ctxEx->Answer(Error_Unexpect, AlarmDEC());
		return 1;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("IssueCard::MoveCard, m_currentHopper:%d", m_currentHopper);
	}
	LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCard_FromHopper, "MoveCard from hopper suc.");

	m_issuedEx[m_currentHopper - 1]++;
	m_remainsEx[m_currentHopper - 1]--;
	//oilyang@20180809 增加对单卡槽多卡槽机器的使用及闲置的适配
	if ((!m_bHasHopper[0] || m_CardPercentEx[0] == 0 || m_CardInitEx[0] == 0 || (100 * m_remainsEx[0] < m_CardPercentEx[0] * m_CardInitEx[0]))
		&& (!m_bHasHopper[1] || m_CardPercentEx[1] == 0 || m_CardInitEx[1] == 0 || (100 * m_remainsEx[1] < m_CardPercentEx[1] * m_CardInitEx[1]))
		&& (!m_bHasHopper[2] || m_CardPercentEx[2] == 0 || m_CardInitEx[2] == 0 || (100 * m_remainsEx[2] < m_CardPercentEx[2] * m_CardInitEx[2])))
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_FEW_CARD_REMAINS, "Few card remains.");
	}
	m_bSettingMaterial = true;//oilyang 借用于延迟同步，紧接着设置remains时更新到后台数据库
	if (!SetCardIssued(m_issuedEx[m_currentHopper - 1], m_currentHopper))
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("IssueCard, Set card issued failed.");
	m_bSettingMaterial = false;
	if (!SetCardRemains(m_remainsEx[m_currentHopper - 1], m_currentHopper))
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("IssueCard, Set card remains failed.");
	m_bUseRFTillNext = false;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222020")("IssueCard success.");
	Sleep(1000);
	ctxEx->Ans.reserved1[0] = ctxEx->Ans.reserved1[1] = 0;
	if (m_bIssuingExit)
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_IssueExit, "Issuing exit, to capture card.");
		CaptureCard(NULL);
	}
	ctxEx->Answer(Error_Succeed);
	return 0;
}

/** 0:succeed,1:failed [Gifur@2022516]*/
int CCardIssuerFSM::CaptureCard(SpReqAnsContext<CardIssuerStoreService_Capture_Req,CardIssuerStoreService_Capture_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (ctx != NULL)
		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_FromBusiness, "CaptureCard called from Business.");
	ErrorCodeEnum eErr;
	long l_beginTime, l_endTime;
	int ret = 0;
	//hr = m_pIDCard->IDC_Capture();
	eErr = MachineMoveCardBackNotHold();
	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222004")();
		bool bCaptured = ToRegistCaptureCardInfo();
		m_currCardNo = m_addCardNo = "";
	}
	else
		ret = 1;
	m_CardCaptured++;
	if (!SetCardCaptured(m_CardCaptured))
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<CaptureCard>, set card captured failed");
	m_pCardProcess->DataInit();
	if (Error_Succeed == eErr){
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		l_endTime = GetTickCountRVC();


		if (eErr != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB5")("CaptureCard::SetCardInType err=%s", SpStrError(eErr));
			SetErrPackage("CaptureCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
			AlarmDEC();
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("CaptureCard::SetCardInType");
		}
		if (ctx != NULL)
			ctx->Answer(Error_Succeed);
	}
	else {
		if (ctx != NULL){
			if (m_iInWhatPage == PageType_Other) {
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setLogCode("QLR040222004").setResultCode("RTA2W07")("吞卡失败，请检查吞卡箱是否已满或联系厂商检查是否有吞卡");
				LogError(Severity_Middle, Error_Unexpect, 0x22000034, "CaptureCard failed");
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setLogCode("QLR040222004").setResultCode("RTA2W07")("吞卡失败，请检查吞卡箱是否已满或联系厂商检查是否有吞卡");
				LogWarn(Severity_Middle, Error_Unexpect, 0x22000034, "CaptureCard failed");
			}
			
			ctx->Answer(Error_Unexpect, 0x22000034);
		}
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Captured, ret:%d", ret);
	return ret;
}

/** 0:succeed,1:failed [Gifur@2022516]*/
int CCardIssuerFSM::EjectCard(SpReqAnsContext<CardIssuerStoreService_Eject_Req,CardIssuerStoreService_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);
	m_pCardProcess->DataInit();
	if (Error_Succeed == eErr){
		if (ctx != NULL)
			ctx->Answer(Error_Succeed);
		ret = 0;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222005")();
	}
	else {
		if (ctx != NULL){
			ctx->Answer(Error_Exception, 0x22000035);
		}
		ret = 1;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("EjectCard, ret: %d", ret);
	return ret;
}
int CCardIssuerFSM::WaitFetchingCard()
{
	LOG_FUNCTION();
	//int waitTries = 0;
	DWORD dwStart, dwEnd;
	dwStart = GetTickCountRVC();
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_STORE_GREEN_ON,"CardReader(fetch) warning on");
	do {
		if (GetDevStatus(false)){
			dwEnd = GetTickCountRVC();
			if (m_devStatus.eMedia == CI_MEDIA_ENTERING){
				Sleep(WAIT_INTERVAL);
			}
			else{
				long l_beginTime, l_endTime;
				l_beginTime = GetTickCountRVC();
				ErrorCodeEnum eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
				l_endTime = GetTickCountRVC();


				if (eErr != Error_Succeed) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB5")("WaitFetchingCard::SetCardInType err=%s", SpStrError(eErr));
					SetErrPackage("WaitFetchingCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
					AlarmDEC();
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("WaitFetchingCard::SetCardInType");
				}
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_STORE_GREEN_OFF,"CardReader(fetch) warning off");
				return 0;
			}
		}else
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_STORE_GREEN_OFF,"CardReader(fetch) warning off");
			return 1;
		}
	}while ((dwEnd-dwStart) < 60*1000);
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_STORE_GREEN_OFF,"CardReader(fetch) warning off");
	return 2;
}
int CCardIssuerFSM::InternalAcceptCard()
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	int acceptTries = 0, err = 0;
	DWORD64 dwStart = GetTickCountRVC();
	DWORD64 dwEnd = dwStart;
	long l_beginTime, l_endTime;
	m_bWaitingAccept = true;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)
		{
			err = 3;
			goto Err;
		}
		if (m_bWaitAccepteMore)
		{
			acceptTries = 0;
			dwEnd = dwStart = GetTickCountRVC();
			m_bWaitAccepteMore = false;
		}
		if (GetDevStatus(false))
		{
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT)
			{
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuer op.");
				acceptTries = 0;
				goto Err;
			}
			if (m_devStatus.eMedia == CI_MEDIA_NOTPRESENT)
			{
				acceptTries++;
				Sleep(ACCEPT_TRY_INTERVAL);
				//hr = m_pIDCard->IDC_Accept(IDC_ALL_CARD,&lpCardData);
				if (!m_bCancelAccept && !bHasSetCardInType) {
					l_beginTime = GetTickCountRVC();
					eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_ALL);
					l_endTime = GetTickCountRVC();
					//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_ALL");

				}
				if (Error_Succeed != eErr) {
					SetErrPackage("InternalAcceptCard::SetCardInType(CI_CARD_IN_TYPE_ALL)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
					AlarmDEC();
				}
				else {
					bHasSetCardInType = true;
				}
			}
		}
		else
		{
			err = 1;
			goto Err;
		}
		dwEnd = GetTickCountRVC();
	} while ((dwEnd - dwStart) < 58 * 1000);
	err = 2;
Err:
	m_bExit = false;
	m_bWaitingAccept = false;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
	l_endTime = GetTickCountRVC();	


	if (Error_Succeed != eErr)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB5")("InternalAcceptCard::SetCardInType err=%s", SpStrError(eErr));
		SetErrPackage("InternalAcceptCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
		AlarmDEC();
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN");
	}
	if (m_bCancelAccept && err != 1)
	{
		//oilyang@20181210 add "if (!m_bCancelByRFIC)" 
		//oilyang@20170612
		if (!m_bCancelByRFIC)
			Sleep(500);
		if (GetDevStatus())
		{
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT)
			{
				err = 4;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<InternalAcceptCard>, Cancel InterAccept, eject card.");
				eErr = MachineMoveCardFrontGate(true);

				if (Error_Succeed == eErr) {
					l_beginTime = GetTickCountRVC();
					eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
					l_endTime = GetTickCountRVC();	

					if (eErr != Error_Succeed) {
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB5")("InternalAcceptCard::SetCardInType err=%s", SpStrError(eErr));
						SetErrPackage("InternalAcceptCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
						AlarmDEC();
					}
					else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("InternalAcceptCard::SetCardInType CI_MEDIA_PRESENT CI_CARD_IN_TYPE_FORBIDDEN");
					}
				}
				else
				{
					//吐卡失败，前面已有告警，这里不再告警
					Dbg("InternalAcceptCard::MachineMoveCardFrontGate failed(0x%x)", eErr);
					err = 2;
				}
			}
		}
		else
			err = 2;
	}
	return err;
}
int CCardIssuerFSM::AcceptCard(SpReqAnsContext<CardIssuerStoreService_Insert_Req, CardIssuerStoreService_Insert_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pCardProcess->DataInit();
	m_bCancelByRFIC = false;
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_STORE_GREEN_ON,"CardReader warning on");
	m_bWaitAccepteMore = false;
	int rc = InternalAcceptCard();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AcceptCard::InternalAcceptCard, result:%d", rc);
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_STORE_GREEN_OFF,"CardReader warning off");
	if (rc == 0) {
		FSMSetIssueFlag(0);
		m_bCardFromHopper = false;
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AcceptCard, insert succeed");
			m_bUseRFTillNext = false;
			ctx->Answer(Error_Succeed);
		}
	}
	else if(rc == 2)
	{
		if (ctx != NULL) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("AcceptCard, insert timeout");
			ctx->Answer(Error_TimeOut);
		}
	}
	else if(rc == 3 || rc == 4)
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AcceptCard, insert cancel");
			ctx->Answer(Error_Cancel);
		}
	}else 
	{
		if (ctx != NULL){
			SetErrPackage("AcceptCard::InternalAcceptCard", m_csDevSN, Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus);
			ctx->Answer(Error_Unexpect, AlarmDEC(true));
		}
	}
	return rc;
}
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_INFO, LOG_TYPE_SYSTEM)("<SplitTrack2>, pTrack2.len:%d", dataLen);

	if (pTrack2.GetLength() == 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:
		break;
	default:
		return -1;
	}
	decodeData.status = 0;
	return 0;
}
int SplitUnionPayTrack2(CSimpleStringA pTrack2,Track2Data &decodeData)
{
	if (strlen(pTrack2) != 37)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("wrong track2 len %d[%s]", strlen(pTrack2), (LPCTSTR)pTrack2);
		return -1;
	}
	//“16位卡号(19A)” + “=” + “expiry_date YYMM(4N)” + 
	//“106(3N，服务代码)” + “PVV(5N)” + “00(2N)” + “CVV(3A)”
	//6225885710172339=49121200541300175361 
	//oiltmp
	//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);
	return 0;
}

int CCardIssuerFSM::ReadCard(SpReqAnsContext<CardIssuerStoreService_Read_Req, CardIssuerStoreService_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 == 2 || bCtOK)
		return ret;
	if (IfUseRf())
	{
		m_bUseRFTillNext = true;
		return ReadCard_RF(ctx);
	}
	else
		return ret;
}
int CCardIssuerFSM::ReadCard_Contact(SpReqAnsContext<CardIssuerStoreService_Read_Req, CardIssuerStoreService_Read_Ans>::Pointer ctx, bool& bICOK)
{
	bICOK = false;
	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);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_ReadCard_Process, 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 {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagRead").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB4")("ReadCard_Contact::MagRead err=%d", eMagReadErr);
			SetErrPackage("ReadCard_Contact::MagRead", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MagRead);
			AlarmDEC();
		}

		//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, CardIssuerStore_UserErrorCode_TrackSize_Wrong, errMsg.GetData());
			break;
		}

		if (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuer 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, CardIssuerStore_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_INFO, LOG_TYPE_SYSTEM)("<ReadCard::MagRead>, split pos:%d", pos);
			if (pos <= 0 || pos == magTracks.track[1].dwSize)
			{
				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 {
						SetDevStateAndSendMsg(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;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<ReadCard::MagRead>, t2Account len:%d, %s****%s", ctx->Ans.t2Account.GetLength(),
				(LPCTSTR)ctx->Ans.t2Account.SubString(0, 6), (LPCTSTR)ctx->Ans.t2Account.SubString(ctx->Ans.t2Account.GetLength() - 4, 4));

			CSimpleStringA cardInfo(true);
			if (!ctx->Ans.track2.IsNullOrEmpty() && (pos + 8) < magTracks.track[1].dwSize)
			{
				cardInfo = CSimpleStringA::Format("cardServiceCode:%s", (ctx->Ans.track2.SubString(pos + 1, 7)).GetData());
				LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_Track2_ServiceCode, cardInfo.GetData());
			}
			cardInfo = CSimpleStringA::Format("cardBin:%s****%s", (LPCTSTR)ctx->Ans.t2Account.SubString(0, 6), (LPCTSTR)ctx->Ans.t2Account.SubString(ctx->Ans.t2Account.GetLength() - 4, 4));
			LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_CardBin, cardInfo.GetData());

			break;
		}
	} while (readTries < READ_TRY_NUM);

	m_currCardNo = ctx->Ans.t2Account;
	//oilyang@20230331
	//1、发卡且读磁成功，不再继续检测IC，一律ICType=1，以便读取IC
	//2、其他情况（发卡未读到磁条或前端插卡），先查询户口系统进行卡片介质判定：
	//	2a：户口系统返回非纯磁条介质类型，ICType以户口为准（ICType影响后续IC读取，即：都会读IC）
	//	2b：其他情况（户口系统访问错（未走户口系统查或访问微服务失败或未返回介质类型或返回纯磁条卡），一律探测是否芯片卡

	if (m_issueStatus && (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK))//发卡默认给芯片卡，且读到磁道（考虑卡片放错）
	{
		ctx->Ans.ICType = 1;
		bICOK = true;
	}
	else
	{
		int cardTypeFromHost = 0;
		bool bMismatch = false;
		if (m_eacQueryFlag == 1)
			cardTypeFromHost = JudgeCardType(m_currCardNo, bMismatch);
		if (cardTypeFromHost > 0 && cardTypeFromHost != 2)//户口系统返回非纯磁条介质类型
		{
			ctx->Ans.ICType = cardTypeFromHost;
			if (m_bUseCardnoMismatch && bMismatch)
			{
				bICOK = true;
				return 2;
			}
		}
		else//未访问户口系统或户口系统访问失败或户口未告知介质类型（包括插反卡）
		{
			int icRetryTimes = 0;
			while (1)
			{//for poor mag only card,we always retry...
			bIC = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER_STORE, m_hDevHelper, activeCardType);
				if (!bIC)
					icRetryTimes++;
				else
					break;
				Sleep(500);
				if (icRetryTimes >= m_ICRetryTimes)
					break;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<ReadCard::DetectIfICCard>, bIC:%d", bIC);
			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;
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_MaybeIC_Only, "<ReadCard>, maybe ic only.");
				}
				else
				{
					//既没有读到磁条，又不是IC，很大概率是插反了
					LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_Maybe_InsertCard_InWrongStyle, "<ReadCard>, 既没读到磁条，又没检测到IC，可能插反了");
					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) {
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WAB")("ReadCard_Contact::DeactivateICCard err=%s", SpStrError(eErr));
					SetErrPackage("ReadCard::DeactivateICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard);
					AlarmDEC();
				}
				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) {
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB6")("ReadCard_Contact::ReleaseIC err=%s", SpStrError(eErr));
					SetErrPackage("ReadCard::ReleaseIC", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC);
					AlarmDEC();
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("ReadCard_Contact::ReleaseIC");
				}
			}
		}
	}
	CSimpleStringA cardType = CSimpleStringA::Format("cardType:%d", ctx->Ans.ICType);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_CardType, cardType.GetData());

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

	if (!bReadCardInfo)
	{
		bICOK = false;
		ctx->Ans.status = 1;
		if (GetDevStatus())
			return 0;
		else
			return 1;
	}
	bICOK = true;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222003")("ReadCard suc.");
	return 0;
}
int CCardIssuerFSM::ReadCard_RF(SpReqAnsContext<CardIssuerStoreService_Read_Req, CardIssuerStoreService_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)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WBE")("ReadCard_RF::MoveCard err=%s", SpStrError(eErr));
		SetErrPackage("ReadCard_RF::MoveCard(CI_MOVECARD_RF_POSITION)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MoveCard);
		AlarmDEC();
	}
	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);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_ReadCard_Process, 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, CardIssuerStore_UserErrorCode_TrackSize_Wrong, errMsg.GetData());
			break;
		}

		if (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuer 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, CardIssuerStore_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_INFO, LOG_TYPE_SYSTEM)("<ReadCard::MagRead>, split pos:%d", pos);
			if (pos <= 0 || pos == magTracks.track[1].dwSize)
			{
				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 {
						SetDevStateAndSendMsg(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;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<ReadCard::MagRead>, t2Account len:%d, %s****%s", ctx->Ans.t2Account.GetLength(),
				(LPCTSTR)ctx->Ans.t2Account.SubString(0, 6), (LPCTSTR)ctx->Ans.t2Account.SubString(ctx->Ans.t2Account.GetLength() - 4, 4));

			CSimpleStringA cardInfo(true);
			if (!ctx->Ans.track2.IsNullOrEmpty() && (pos + 8) < magTracks.track[1].dwSize)
			{
				cardInfo = CSimpleStringA::Format("cardServiceCode:%s", (ctx->Ans.track2.SubString(pos + 1, 7)).GetData());
				LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_Track2_ServiceCode, cardInfo.GetData());
			}
			cardInfo = CSimpleStringA::Format("cardBin:%s****%s", (LPCTSTR)ctx->Ans.t2Account.SubString(0, 6), (LPCTSTR)ctx->Ans.t2Account.SubString(ctx->Ans.t2Account.GetLength() - 4, 4));
			LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_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
	{
		int cardTypeFromHost = 0;
		bool bMismatch = false;
		if (m_eacQueryFlag == 1)
			cardTypeFromHost = JudgeCardType(m_currCardNo, bMismatch);
		if (cardTypeFromHost > 0)//户口系统有返回卡片类型
		{
			ctx->Ans.ICType = cardTypeFromHost;
			if (m_bUseCardnoMismatch && bMismatch)
				return 2;
		}
		else//未访问户口系统或户口系统访问失败（包括插反卡）
		{
			int icRetryTimes = 0;
			while (1)
			{//for poor mag only card,we always retry...
			bIC = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER_STORE_RF, m_hDevHelper, activeCardType);
				if (!bIC)
					icRetryTimes++;
				else
					break;
				Sleep(500);
				if (icRetryTimes >= m_ICRetryTimes)
					break;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<ReadCard::DetectIfICCard>, bIC:%d", bIC);
			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;
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_MaybeIC_Only, "<ReadCard>, maybe ic only.");
				}
				else
				{

				}
			}
			if (bIC)
			{
				l_beginTime = GetTickCountRVC();
				eErr = m_hDevHelper->DeactContactlessICCard();
				l_endTime = GetTickCountRVC();
				
				if (eErr != Error_Succeed) {
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WAB")("ReadCard_RF::DeactContactlessICCard err=%s", SpStrError(eErr));
					SetErrPackage("ReadCard::DeactContactlessICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard);
					AlarmDEC();
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("ReadCard_RF::DeactContactlessICCard");
				}
			}
		}
	}
	CSimpleStringA cardType = CSimpleStringA::Format("cardType:%d", ctx->Ans.ICType);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_CardType, cardType.GetData());

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

	if (!bReadCardInfo)
	{
		ctx->Ans.status = 1;
		if (GetDevStatus())
			return 0;
		else
			return 1;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222003")("ReadCard suc.");
	return 0;
}
int CCardIssuerFSM::PreOnline(SpReqAnsContext<CardIssuerStoreService_PreOnline_Req, CardIssuerStoreService_PreOnline_Ans>::Pointer ctx)
{
	if (m_bUseRFTillNext)
		return PreOnline_RF(ctx);

	bool bCtOK = false;//是否读到芯片
	bool bContinue = false;//是否继续非接流程
	m_csMagT2Track = "";//初始化赋值
	m_csMagT3Track = "";
	m_csMagAccout = "";
	m_csMagRegion = "";
	m_csMagCardSerial = "";
	m_csMagCVC = "";
	m_csMagExpireDate = "";
	int ret = PreOnline_Contact(ctx, bCtOK, bContinue);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PreOnline bCtOK=%d,bContinue=%d", (int)bCtOK, (int)bContinue);
	if (bContinue) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PreOnline 用非接兜底");
		return PreOnline_RF(ctx);
	}
	else {
		return ret;
	}
	//if (!bCtOK && IfUseRf())
	//	return PreOnline_RF(ctx);
	//else
	//	return ret;
}
int CCardIssuerFSM::PreOnline_Contact(SpReqAnsContext<CardIssuerStoreService_PreOnline_Req,CardIssuerStoreService_PreOnline_Ans>::Pointer ctx, bool& bICOK, bool& bContinue)
{
	LOG_FUNCTION();
	//oilyang@20220611 only return 0；if unexpected,process and return 0
	m_findCard = m_cardPos = 0;//just for RVC.CardStore
	m_bCrossPreOnline = false;
	long l_beginTime, l_endTime;
	//如果有盘库记录则清理掉（@zjw20190809）
	if (m_csMachineType.Compare("RVC.CardStore") == 0
		|| m_csMachineType.Compare("RVC.CardPrinter") == 0)
	{
		ErrorCodeEnum eErr = Error_Succeed;
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if(eErr != Error_Succeed)
		{
			LogError(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Open_RunCfgFile_Failed, "PreOnline::OpenConfig failed.");
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Open_RunCfgFile_Failed);
			return 0;//此情况下后续不再读非接
		}
		if(CheckHasPanKuRecord(spConfigRun))
		{
			ClearLocalRecord(spConfigRun);
		}
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PreOnline, bussiness data[%s], req.reserved1:%s", ctx->Req.businessData.GetData(), ctx->Req.reserved1.GetData());
	CSimpleStringA csMagT2Track(""), csMagT3Track(""), csMagAccout(""), csMagRegion(""), csMagCardSerial(""), csMagCVC(""), csMagExpireDate("");
	int slot = 0;
	if (ctx->Req.reserved1.GetLength() > 0 && _strnicmp("kaku#",(const char*)ctx->Req.reserved1,5) == 0)
	{
		DWORD dwTmpUserErrCode = 0;
		m_bCrossPreOnline = true;
		GetEntityBase()->GetFunction()->SetSysVar("CardStoreInUse", "Y");
		CSimpleStringA csSlot("");
		csSlot = ctx->Req.reserved1.SubString(5, ctx->Req.reserved1.GetLength() - 5);
		slot = atoi((const char*)csSlot);
		CSimpleStringA errMsg("");

		if (!IsValidSlotNum(slot))
		{
			errMsg = CSimpleStringA::Format("PreOnline, web give a invalid slot num(%d)", slot);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotInvalid, errMsg.GetData());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("invalid slot:%d", slot);
			m_findCard = 1;
			GetEntityBase()->GetFunction()->SetSysVar("CardStoreInUse", "N");
			if (m_bNewAnsError)
				ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotInvalid);
			else
				ctx->Answer(Error_Succeed);
			return 0;//此情况下后续不再非接流程
		}
		if (!IsSlotHasCard(slot))
		{
			errMsg = CSimpleStringA::Format("PreOnline, the slot(%d) has no card.", slot);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard, errMsg.GetData());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("the slot(%d) has no card", slot);
			m_findCard = 2;
			GetEntityBase()->GetFunction()->SetSysVar("CardStoreInUse", "N");
			if (m_bNewAnsError)
				ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard);
			else
				ctx->Answer(Error_Succeed);
			return 0;//此情况下后续不再非接流程
		}
		ErrorCodeEnum eErr = Error_Unexpect;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->MoveCardFromSlot(slot);
		l_endTime = GetTickCountRVC();
		
		if(eErr != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardFromSlot").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W04")("ReadCard_RF::MoveCard err=%s", SpStrError(eErr));
			bool bTrans = true;
			dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot, bTrans);
			SetErrPackage("PreOnline::MoveCardFromSlot", m_csDevSN, eErr, dwTmpUserErrCode);
			bTrans? AlarmDEC():dwTmpUserErrCode = AlarmDEC();
			m_findCard = 4;
			AfterPreOnlineOnStore(Error_Unexpect, slot);
			if (m_bNewAnsError)
				ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
			else
				ctx->Answer(Error_Succeed);
			return 0;//此情况下后续不再非接流程
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardFromSlot").setCostTime(l_endTime - l_beginTime)("PreOnline_Contact::MoveCardFromSlot");
		}
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardFromSlot, "PreOnline_Contact MoveCardFromSlot suc.");
		CardNo card;
		ZeroMemory(card.account, sizeof(card.account));
		ZeroMemory(card.track2, sizeof(card.track2));
		ZeroMemory(card.track3, sizeof(card.track3));

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReadAccount(card);//读卡（三种方式都要求厂商尝试）
		l_endTime = GetTickCountRVC();

		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_ReadAccount_Cost_Time
			, CSimpleStringA::Format("{\"cost\":%d}", l_endTime - l_beginTime));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ReadAccount t2Size:%d(%d),t3Size:%d(%d), reserved2 len:%d, account len:%d",
				card.dwTrack2Size,strlen(card.track2),card.dwTrack3Size, strlen(card.track3), ctx->Req.reserved2.GetLength(), strlen(card.account));

		if(eErr != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W05")("PreOnline_Contact::ReadAccount err=%s", SpStrError(eErr));
			bool bTrans = true;
			dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_ReadAccount, bTrans);
			SetErrPackage("PreOnline::ReadAccount", m_csDevSN, eErr, dwTmpUserErrCode);
			bTrans ? AlarmDEC() : dwTmpUserErrCode = AlarmDEC();
			m_findCard = 4;
			AfterPreOnlineOnStore(Error_Unexpect, slot);
			if (m_bNewAnsError)
				ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
			else
				ctx->Answer(Error_Succeed);
			return 0;//此情况下后续不再非接流程
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime)("PreOnline_Contact::ReadAccount");
		}

		

		string strAccount = card.account;
		int reserved2Len = ctx->Req.reserved2.GetLength();
		int cardAccountLen = strlen(card.account);
		if(reserved2Len > 10 && cardAccountLen > 10)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline::ReadAccount>, req.reserved2:%s****%s, card.account:%s****%s", (ctx->Req.reserved2.SubString(0, 6)).GetData(), (ctx->Req.reserved2.SubString(reserved2Len-4, 4)).GetData(),
										(strAccount.substr(0, 6)).c_str(), (strAccount.substr(cardAccountLen-4, 4)).c_str());
			LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_CardBin, CSimpleStringA::Format("cardBin:%s****%s", strAccount.substr(0, 6).c_str(), strAccount.substr(cardAccountLen - 4, 4).c_str()));
		}

		if (ctx->Req.reserved2.GetLength() > 0 && ctx->Req.reserved2.Compare(card.account) != 0)
		{
			m_findCard = 3;
			AfterPreOnlineOnStore(Error_Unexpect, slot);
			ctx->Answer(Error_Succeed);
			return 0;//此情况下后续不再非接流程
		}
		if (card.dwTrack2Size > 0 && card.dwTrack2Size < 41)
		{
			if (card.track2[card.dwTrack2Size - 1] == 'F') {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, track2 data has F in the end.");
				card.track2[card.dwTrack2Size - 1] = '\0';
			}
			csMagT2Track = card.track2;
			m_csMagT2Track = csMagT2Track;
		}
		if (card.dwTrack3Size > 0 && card.dwTrack3Size < 108)
		{
			if (card.track3[card.dwTrack3Size - 1] == 'F')
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, track3 data has F in the end.");
				card.track3[card.dwTrack3Size - 1] = '\0';
			}
			csMagT3Track = card.track3;
			m_csMagT3Track = csMagT3Track;
		}
		//oilyang@20180516 add for kaku
		//split track 2&3 data
		char *pTmpMag2 = new char[128];
		ZeroMemory(pTmpMag2, 128);
		Track2Data track2Data;
		bool bT2OK, bT3OK;
		bT2OK = bT3OK = false;
		if (card.dwTrack2Size > 8 && strlen(card.track2) > 8)
			bT2OK = true;
		if (card.dwTrack3Size > 8 && strlen(card.track3) > 8)
			bT3OK = true;
		DecodeTracksData((const char*)csMagT2Track, card.dwTrack2Size, (const char*)csMagT3Track, card.dwTrack3Size, pTmpMag2, bT2OK, bT3OK);
		if ((SplitTrack2(pTmpMag2, track2Data) == 0))
		{
			csMagAccout = track2Data.t2Account;
			m_csMagAccout = csMagAccout;
			csMagRegion = track2Data.t2Region;
			m_csMagRegion = csMagRegion;
			csMagCardSerial = track2Data.t2CardSerial;
			m_csMagCardSerial = csMagCardSerial;
			csMagCVC = track2Data.t2CVC;
			m_csMagCVC = csMagCVC;
			csMagExpireDate = track2Data.t2ExpireDate;
			m_csMagExpireDate = csMagExpireDate;
		}
		delete[]pTmpMag2;
		m_pCardProcess->DataInit();
	}
	//数据已读出，开始pmoc流程
	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_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, the front BusinessData han't provide aid data.");
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_STORE, m_hDevHelper, m_aidList, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
	}
	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;
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_STORE, m_hDevHelper, preAIDs, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);
	if (retDetectAndRead < 0)
	{
		if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0)
			&& m_bCrossPreOnline) {
			if (IfUseRf()) {
				bContinue = true; //继续后面的非接流程
			}
			else {
				AfterPreOnlineOnStore(Error_Unexpect, slot);
			}
		}
		CSimpleStringA xCardName("");
		if (m_issueStatus && m_currentHopper - 1 >= 0)
			xCardName = m_PsbNameEx[m_currentHopper - 1];
		if (retDetectAndRead == -1){
			if (m_issueStatus)
			{
				if (!IfUseRf())
				{
					if (m_bCrossPreOnline || m_iInWhatPage == PageType_Other) {
						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::ActiveICCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W0V")("发卡时，检测卡片类型时上电失败");
						LogError(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_IssueCard_ActiveICCard_Failed, "（IssueCard）PreOnline::DetectAndReadICData:DetectIfICCard");
					}
					else {
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ActiveICCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W0V")("发卡时，检测卡片类型时上电失败");
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_IssueCard_ActiveICCard_Failed, "（IssueCard）PreOnline::DetectAndReadICData:DetectIfICCard");
					}
					ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_IssueCard_ActiveICCard_Failed);
				}
				else {
					//使用非接兜底
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ActiveICCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W0V")("发卡时，检测卡片类型时上电失败");
				}
			}
			else
			{
				
				if (!IfUseRf())
				{
					if (m_bCrossPreOnline || m_iInWhatPage == PageType_Other)
					{
						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::ActiveICCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W0M")("检测卡片类型时上电失败");
						LogError(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_ActiveICCard_Failed, "PreOnline::DetectAndReadICData:DetectIfICCard");
					}
					else
					{
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ActiveICCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W0M")("检测卡片类型时上电失败");
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_ActiveICCard_Failed, "PreOnline::DetectAndReadICData:DetectIfICCard");
					}
					ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_ActiveICCard_Failed);
				}
				else {
					//使用非接兜底
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ActiveICCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W0M")("检测卡片类型时上电失败");
				}
			}
		}
		else if (retDetectAndRead == -2){
			
			if (!IfUseRf())
			{
				SetErrPackage(xCardName + " PreOnline::DetectAndReadICData:GetICDataFromCard(-2)", m_csDevSN, Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand);
				
				if (IsInBusiness()) {
					if (m_issueStatus)
						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W02")("读取IC数据失败");
					else
						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W02")("读取IC数据失败");
					ctx->Answer(Error_Unexpect, AlarmDEC(true));
				}
				else {
					if (m_issueStatus)
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W02")("读取IC数据失败");
					else
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W02")("读取IC数据失败");
					ctx->Answer(Error_Unexpect, AlarmDEC());
				}
			}
			else {
				//使用非接兜底
				if (m_issueStatus)
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W02")("读取IC数据失败");
				else
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W02")("读取IC数据失败");
			}
		}
		else if (retDetectAndRead == -3){

			if (!IfUseRf())
			{
				SetErrPackage(xCardName + " PreOnline::DetectAndReadICData:GetICDataFromCard(-3)", m_csDevSN, Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand);
				
				if (IsInBusiness()) {
					if (m_issueStatus)
						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W02")("IC卡建立应用列表失败");
					else
						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W02")("IC卡建立应用列表失败");
					ctx->Answer(Error_Unexpect, AlarmDEC(true));
				}
				else {
					if (m_issueStatus)
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W02")("IC卡建立应用列表失败");
					else
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W02")("IC卡建立应用列表失败");
					ctx->Answer(Error_Unexpect, AlarmDEC());
				}
			}
			else {
				//使用非接兜底
				if (m_issueStatus)
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W02")("IC卡建立应用列表失败");
				else
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W02")("IC卡建立应用列表失败");
			}

		}
		bICOK = false;
		return 0;//读卡失败
	}

	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	BYTE bt9f27 = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER_STORE,m_hDevHelper,taaResult,true,m_bCDA,bt9f27);
	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;
	//	Dbg("[%d,%d,%d,%d]",m_TVR[0],m_TVR[1],m_TVR[2],m_TVR[3]);
	//}
	if (ctx->Ans.result.GetLength() == 0)
	{
		if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0) && m_bCrossPreOnline) {
			if (IfUseRf()) {
				bContinue = true; //继续后面的非接流程
			}
			else {
				AfterPreOnlineOnStore(Error_Unexpect, slot);
			}
		}
		//	AfterPreOnlineOnStore(Error_Unexpect, slot);
		if (!IfUseRf())
			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)("<PreOnline>, can't find expire date");
		if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0) && m_bCrossPreOnline) {
			if (IfUseRf()) {
				bContinue = true; //继续后面的非接流程
			}
			else {
				AfterPreOnlineOnStore(Error_Unexpect, slot);
			}
		}
		//	AfterPreOnlineOnStore(Error_Unexpect, slot);
		if (!IfUseRf())
			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)("<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)("<PreOnline>, [ic]no track2 data");
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReleaseIC();
		l_endTime = GetTickCountRVC();
		if (eErr != Error_Succeed){
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB6")("PreOnline::ReleaseIC err=%s", SpStrError(eErr));
			SetErrPackage("PreOnline::ReleaseIC", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC);
			AlarmDEC();
		}
		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_INFO, LOG_TYPE_SYSTEM)("<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 {
					SetDevStateAndSendMsg(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) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, actionType:%s", actionType.c_str());
		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_INFO, 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;
	}
	if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0)
		&& m_bCrossPreOnline)
		AfterPreOnlineOnStore(Error_Succeed, slot);
	bICOK = true;
	bContinue = false;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222006")();
	ctx->Answer(Error_Succeed);
	return 0;//不再继续后面的非接流程
}
int CCardIssuerFSM::PreOnline_RF(SpReqAnsContext<CardIssuerStoreService_PreOnline_Req, CardIssuerStoreService_PreOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	long l_beginTime, l_endTime;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("(PreOnline) use cardissuer 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 {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WBE")("PreOnline_RF::MoveCard err=%s", SpStrError(eErr));
		SetErrPackage("PreOnline_RF::MoveCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MoveCard);
		AlarmDEC();
	}
	m_findCard = m_cardPos = 0;//just for RVC.CardStore

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PreOnline, bussiness data[%s], req.reserved1:%s", ctx->Req.businessData.GetData(), ctx->Req.reserved1.GetData());
	CSimpleStringA csMagT2Track(""), csMagT3Track(""), csMagAccout(""), csMagRegion(""), csMagCardSerial(""), csMagCVC(""), csMagExpireDate("");
	csMagT2Track = m_csMagT2Track;//从PreOnline_Contact得到的重新赋值
	csMagT3Track = m_csMagT3Track;
	csMagAccout = m_csMagAccout;
	csMagRegion = m_csMagRegion;
	csMagCardSerial = m_csMagCardSerial;
	csMagCVC = m_csMagCVC;
	csMagExpireDate = m_csMagExpireDate;

	int slot = 0;//请求的卡槽位
	if (ctx->Req.reserved1.GetLength() > 0 && _strnicmp("kaku#", (const char*)ctx->Req.reserved1, 5) == 0)
	{
		CSimpleStringA csSlot("");
		csSlot = ctx->Req.reserved1.SubString(5, ctx->Req.reserved1.GetLength() - 5);
		slot = atoi((const char*)csSlot);
	}


	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_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, the front BusinessData han't provide aid data.");
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_STORE_RF, m_hDevHelper, m_aidList, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
	}
	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;
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_STORE_RF, m_hDevHelper, preAIDs, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);
	
	if (retDetectAndRead < 0)
	{
		//非接兜底需要移回卡槽
		if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0) && m_bCrossPreOnline) {
			AfterPreOnlineOnStore(Error_Unexpect, slot);//移回卡槽
		}
		CSimpleStringA xCardName("");
		if (m_issueStatus && m_currentHopper - 1 >= 0)
			xCardName = m_PsbNameEx[m_currentHopper - 1];
		if (retDetectAndRead == -1) {
			if (m_issueStatus)
			{
				if (IsInBusiness())
				{
					DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::ActiveContactlessICCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W27")("发卡时，检测卡片类型时上电失败（非接）");
					LogError(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_IssueCard_ActiveRF_Failed, "（IssueCard）PreOnline_RF::DetectAndReadICData:DetectIfICCard");
				}
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ActiveContactlessICCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W27")("发卡时，检测卡片类型时上电失败（非接）");
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_IssueCard_ActiveRF_Failed, "（IssueCard）PreOnline_RF::DetectAndReadICData:DetectIfICCard");
				}
				ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_IssueCard_ActiveRF_Failed);
			}
			else
			{
				if (IsInBusiness())
				{
					DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::ActiveContactlessICCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W26")("检测卡片类型时上电失败");
					LogError(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_ActiveContactlessICCard_Failed, "PreOnline_RF::DetectAndReadICData:DetectIfICCard");
				}
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::ActiveContactlessICCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W26")("检测卡片类型时上电失败");
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_ActiveContactlessICCard_Failed, "PreOnline_RF::DetectAndReadICData:DetectIfICCard");
				}
				ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_ActiveContactlessICCard_Failed);
			}
		}
		else if (retDetectAndRead == -2) {
			if (m_issueStatus)
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::RFTypeABCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W02")("读取IC数据失败");
			else
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::RFTypeABCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W02")("读取IC数据失败");
			SetErrPackage(xCardName + " PreOnline::DetectAndReadICData:GetICDataFromCard(-2)", m_csDevSN, Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand);
			ctx->Answer(Error_Unexpect, AlarmDEC(true));
		}
		else if (retDetectAndRead == -3) {
			if (m_issueStatus)
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::RFTypeABCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222020").setResultCode("RTA2W02")("IC卡建立应用列表失败");
			else
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::RFTypeABCommand").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222003").setResultCode("RTA2W02")("IC卡建立应用列表失败");
			SetErrPackage(xCardName + " PreOnline::DetectAndReadICData:GetICDataFromCard(-3)", m_csDevSN, Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand);
			ctx->Answer(Error_Unexpect, AlarmDEC(true));
		}
		return 0;
	}

	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	BYTE bt9f27 = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER_STORE_RF, m_hDevHelper, taaResult, true, m_bCDA, bt9f27);
	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;
	//	Dbg("[%d,%d,%d,%d]",m_TVR[0],m_TVR[1],m_TVR[2],m_TVR[3]);
	//}
	if (ctx->Ans.result.GetLength() == 0)
	{
		if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0) && m_bCrossPreOnline) {
			AfterPreOnlineOnStore(Error_Unexpect, slot);//移回卡槽
		}
		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)("<PreOnline>, can't find expire date");
		if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0) && m_bCrossPreOnline) {
			AfterPreOnlineOnStore(Error_Unexpect, slot);//移回卡槽
		}
		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)("<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)("<PreOnline>, [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_INFO, 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;
			//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) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, actionType:%s", actionType.c_str());
		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_INFO, 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;
	}
	LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_ReadByRF, CSimpleStringA::Format("PreOnline_RF ok.iIssue:%d ", m_issueStatus));
	if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0) && m_bCrossPreOnline) {
		AfterPreOnlineOnStore(Error_Unexpect, slot);//移回卡槽
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222006")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::PostOnline(SpReqAnsContext<CardIssuerStoreService_PostOnline_Req, CardIssuerStoreService_PostOnline_Ans>::Pointer ctx)
{
	if (m_bUseRFTillNext)
		return PostOnline_RF(ctx);

	bool bCtOK = false;
	int ret = PostOnline_Contact(ctx, bCtOK);
	if (!bCtOK && IfUseRf())
		return PostOnline_RF(ctx);
	else
		return ret;
}
int CCardIssuerFSM::PostOnline_Contact(SpReqAnsContext<CardIssuerStoreService_PostOnline_Req,CardIssuerStoreService_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_STORE,m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER_STORE,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("QLR040222007")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::PostOnline_RF(SpReqAnsContext<CardIssuerStoreService_PostOnline_Req, CardIssuerStoreService_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_STORE_RF, m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER_STORE_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("QLR040222007")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::WriteCard(SpReqAnsContext<CardIssuerStoreService_WriteTrack_Req, CardIssuerStoreService_WriteTrack_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	int ret = 0;
	long l_beginTime, l_endTime;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("WriteCard，t1Len:%d, t2Len:%d, t3Len:%d", ctx->Req.track1.GetLength(), ctx->Req.track2.GetLength(), ctx->Req.track3.GetLength());
	if (ctx->Req.track1.GetLength() <= 0 && ctx->Req.track2.GetLength() <= 0 && ctx->Req.track3.GetLength() <= 0)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<WriteCard>, write card param is null.");
		ctx->Answer(Error_Param);
		return ret;
	}
	else
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->MoveCard(CI_MOVECARD_MAG_POSITION);
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed)
		{
			SetErrPackage("WriteCard::MoveCard(CI_MOVECARD_MAG_POSITION)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_MAG_POSITION);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222015").setResultCode("RTA2W09").setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("从卡箱移动卡片到磁条写卡位置失败");
			ctx->Answer(Error_Unexpect, AlarmDEC(true));
			return ret;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222015").setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("WriteCard::MoveCard");
		}
	}
	MagTracks magTrack;
	ZeroMemory(magTrack.track[0].data, MAX_MAG_TRACK_SIZE);
	ZeroMemory(magTrack.track[1].data, MAX_MAG_TRACK_SIZE);
	ZeroMemory(magTrack.track[2].data, MAX_MAG_TRACK_SIZE);
	magTrack.track[0].dwSize = magTrack.track[1].dwSize = magTrack.track[2].dwSize = 0;
	magTrack.track[0].eStatus = magTrack.track[1].eStatus = magTrack.track[2].eStatus = CI_DATA_INVALID;
	TrackRange iT1, iT2, iT3;
	iT1 = iT2 = iT3 = CI_TRACK_RANGE_START;
	if (ctx->Req.track1.GetLength() > 0)
	{
		iT1 = CI_TRACK_RANGE_1;
		CSimpleStringA csT1 = CSimpleStringW2A(ctx->Req.track1);
		strncpy((char*)magTrack.track[0].data, csT1, csT1.GetLength());
		magTrack.track[0].eSource = CI_TRACK_SOURCE_1;
		magTrack.track[0].eStatus = CI_DATA_OK;
		magTrack.track[0].dwSize = csT1.GetLength();
	}
	if (ctx->Req.track2.GetLength() > 0)
	{
		iT2 = CI_TRACK_RANGE_2;
		CSimpleStringA csT2 = CSimpleStringW2A(ctx->Req.track2);
		strncpy((char*)magTrack.track[1].data, csT2, csT2.GetLength());
		magTrack.track[1].eSource = CI_TRACK_SOURCE_2;
		magTrack.track[1].eStatus = CI_DATA_OK;
		magTrack.track[1].dwSize = csT2.GetLength();
	}
	if (ctx->Req.track3.GetLength() > 0)
	{
		iT3 = CI_TRACK_RANGE_3;
		CSimpleStringA csT3 = CSimpleStringW2A(ctx->Req.track3);
		strncpy((char*)magTrack.track[2].data, csT3, csT3.GetLength());
		magTrack.track[2].eSource = CI_TRACK_SOURCE_3;
		magTrack.track[2].eStatus = CI_DATA_OK;
		magTrack.track[2].dwSize = csT3.GetLength();
	}

	//TrackRange eAll = iT2 | iT2;
	magTrack.eRange = TrackRange(iT1 | iT2 | iT3);
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MagWrite(magTrack, AUTO_CO);
	l_endTime = GetTickCountRVC();
	
	if (eErr != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagWrite").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB3")("WriteCard::MagWrite err=%s", SpStrError(eErr));
		SetErrPackage("WriteCard::MagWrite", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MagWrite);
		AlarmDEC();
		ret = 1;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagWrite").setCostTime(l_endTime - l_beginTime)("WriteCard::MagWrite");
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222015")("MagWrite ok");
	ctx->Ans.result = ret;
	ctx->Answer(Error_Succeed);
	return ret;
}
void CCardIssuerFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	//for simple
	pTransactionContext->SendAnswer(m_testResult);
}

bool CCardIssuerFSM::FSMSetIssueFlag(int value)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("FSMSetIssueFlag, value:%d,from file:%d", value, m_issueStatusFromFile);
	if (value == 0 && m_issueStatusFromFile >1)
	{
		//oilyang@20171220 如果曾经卡片卡住，但启动时没有发现卡片，则更新本次发卡方向但不写文件，以防后续卡片被移动到卡槽
		if (!m_hasCardWhileDevOpen)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("card jamed havn't been process.");
			m_issueStatus = 0;
		}
		else
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("insert succeed,but there maybe some card jamed...");
		return true;
	}
	
	m_issueStatus = value;
	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)("(FSMSetIssueFlag)open cfg file failed!");
		return false;
	}
	//if (spConfig->WriteConfigValueInt("RunInfo", "IsIssue", value) == Error_Succeed && spConfig->WriteConfigValueInt("all", "IsIssue", value) == Error_Succeed)
	if (spConfig->WriteConfigValueInt("all", "IsIssue", value) == Error_Succeed)
		return true;
	else
		return false;
}
bool CCardIssuerFSM::SetCardCaptured(const int num,bool bClear)
{
	DbgWithLink(LOG_LEVEL_INFO, 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)("<SetCardCaptured>, open cfg file failed!");
		return false;
	}
	m_CardCaptured = num;
	if (num >= m_maxRetainCount)
	{
		//oilyang@20201223 according to rongyiheng,if is RVC.CardPrinter,no need to judge on retain count
		//zjw@20220128 for RVC.CardStore, no need to give a tip, eg: clear the CardStore(req.hopper=100)
		if (m_csMachineType.Compare("RVC.CardPrinter") != 0 && m_csMachineType.Compare("RVC.CardStore") != 0)
		{
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_RETAIN_BIN_IS_FULL, "<SetCardCaptured>, 回收箱满了，请及时清理!");
		}
	}
	//if (spConfig->WriteConfigValueInt("RunInfo", "CardCaptured", num) == Error_Succeed
	//	&& spConfig->WriteConfigValueInt("all", "CardCaptured", num) == Error_Succeed)
	if (spConfig->WriteConfigValueInt("all", "CardCaptured", num) == Error_Succeed)
	{
		if (bClear && !m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain);
		}
		return true;
	}
	else
		return false;
}
bool CCardIssuerFSM::SetCardIssued(const int num, const int hopper)
{
	DbgWithLink(LOG_LEVEL_INFO, 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)("<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 (section.Compare("1") == 0)
		//	spConfig->WriteConfigValueInt("RunInfo", "CardIssued", num);
		//oilyang 回写新section
		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_hopperNum != 1 && !m_bSettingMaterial)
		if (!m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain,false);
		}
		return true;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<SetCardIssued>, write CardIssued err:%d", eErrDev);
		return false;
	}
}
bool CCardIssuerFSM::SetCardRemains(const int num, const int hopper,bool bInit)
{
	DbgWithLink(LOG_LEVEL_INFO, 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, CardIssuerStore_UserErrorCode_NoCardRemains_Hopper1, "Hopper 1 No card remains.");
			break;
		case 2:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_NoCardRemains_Hopper2, "Hopper 2 No card remains.");
			break;
		case 3:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_NoCardRemains_Hopper3, "Hopper 3 No card remains.");
			break;
		case 4:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_NoCardRemains_Hopper4, "Hopper 4 No card remains.");
			break;
		case 5:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_NoCardRemains_Hopper5, "Hopper 5 No card remains.");
			break;
		case 6:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_NoCardRemains_Hopper6, "Hopper 6 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)("<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)
		{
			//if (section.Compare("1") == 0)
			//	spConfig->WriteConfigValueInt("RunInfo", "CardInit", num);
			eErrDev = spConfig->WriteConfigValueInt(section, "CardInit", num);
		}
		//if (section.Compare("1") == 0)
		//	spConfig->WriteConfigValueInt("RunInfo", "CardRemains", num);
		if (eErrDev != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<SetCardRemains>, write CardInit err:%d", eErrDev);
			return false;
		}
		//oilyang@20170428 汪磊东要求单卡箱也要同步数据
		//if (m_hopperNum != 1 && !m_bSettingMaterial)
		if (!m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain,false);
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<SetCardRemains>, write CardRemains err:%d", eErrDev);
		return false;
	}
	return true;
}
bool CCardIssuerFSM::SetCardMixed(const int num, const int hopper)
{
	DbgWithLink(LOG_LEVEL_INFO, 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)("<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)
		SetDevStateAndSendMsg(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 = CardIssuerStore_UserErrorCode_Hopper1_Mixed_Too_Much;
		if (hopper == 2)
			dwTmpErrCode = CardIssuerStore_UserErrorCode_Hopper2_Mixed_Too_Much;
		else if (hopper == 3)
			dwTmpErrCode = CardIssuerStore_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 (section.Compare("1") == 0)
	//	spConfig->WriteConfigValueInt("RunInfo", "CardMixed", num);
	if (eErrDev != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<SetCardMixed>, write CardMixed err:%d", eErrDev);
		return false;
	}
	//oilyang@20170428 汪磊东要求单卡箱也要同步数据
	//if (m_hopperNum != 1 && !m_bSettingMaterial)
	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)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W07")("MachineMoveCardBackNotHold::MoveCard err=%s", SpStrError(eMoveNotHold));
		SetErrPackage("MachineMoveCardBackNotHold::MoveCard(CI_MOVECARD_BACK_NOT_HOLD)", m_csDevSN, eMoveNotHold, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD);
		AlarmDEC();
		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)
		{
			SetErrPackage("MachineMoveCardFrontGate::MoveCard(CI_MOVECARD_FRONT_GATE)", m_csDevSN, eMoveFrontGate, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FRONT_GATE);
			if (bInBussiness) {
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222005").setResultCode("RTA2W08")("发卡，卡片吐出失败，请联系厂商检查卡嘴是否没对齐或是否有塞卡");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222005").setResultCode("RTA2W08")("发卡，卡片吐出失败，请联系厂商检查卡嘴是否没对齐或是否有塞卡");
			}
		}
		else
		{
			SetErrPackage("MachineMoveCardFrontGate::MoveCard(CI_MOVECARD_FRONT_GATE)", m_csDevSN, eMoveFrontGate, CardIssuerStore_UserErrorCode_MoveCardToGate_Failed);
			if (bInBussiness) {
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222005").setResultCode("RTA2W01")("前端进卡，卡片吐出失败，请确认卡片是否平整");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222005").setResultCode("RTA2W01")("前端进卡，卡片吐出失败，请确认卡片是否平整");
			}

		}
		AlarmDEC(bInBussiness);
			
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("MachineMoveCardFrontGate::MoveCard");
	}
	
	return eMoveFrontGate;
}
int CCardIssuerFSM::QueryCardInfo()
{
	int ret;
	if (m_hDevHelper == nullptr)
		ret = 1;
	else{
		if(GetDevStatus())
			ret = (m_devStatus.eMedia == CI_MEDIA_PRESENT) ? 2 : 0;
		else
			ret = 1;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("QueryCardInfo, ret:%d", ret);
	return ret;
}
int CCardIssuerFSM::SetDevStateAndSendMsg(const DevStateEnum eState, bool bForceSend)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetDevStateAndSendMsg, m_eDevState:%d, eState:%d, bForceSend:%d", m_eDevState, eState, bForceSend);
	if(m_eDevState != eState || bForceSend) {
		m_eDevState = eState;
	}
	return 0;
}
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)("(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]);
			//if (i == 0 && hopperArr[0] == 1)
			//{
			//	spConfig->WriteConfigValueInt("RunInfo", "CardInit", m_CardInitEx[i]);
			//	spConfig->WriteConfigValueInt("RunInfo", "CardRemains", m_remainsEx[i]);
			//	spConfig->WriteConfigValueInt("RunInfo", "CardIssued", m_issuedEx[i]);
			//	spConfig->WriteConfigValueInt("RunInfo", "CardMixed", m_mixedEx[i]);
			//	spConfig->WriteConfigValueInt("RunInfo", "CardPercent", m_CardPercentEx[i]);
			//}
			DbgWithLink(LOG_LEVEL_INFO, 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_WARN, LOG_TYPE_SYSTEM)("<SyncDataToDB>, to init sync info, CardBox Num:%d, m_csDevSN:%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_INFO, 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_INFO, 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]);
	}
	

	if (m_csSyncMaterialUrl.IsNullOrEmpty())
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_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, CardIssuerStore_UserErrorCode_SyncMaterialCount_Failed, errMsg.GetData());
		return -2;
	}
	return 0;
}
void CCardIssuerFSM::SetHopperNum(int hopperNum)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetHopperNum, hopperNum:%d", hopperNum);
	m_hopperNum = hopperNum;
}

void CCardIssuerFSM::DoExitWhenIdle()
{
	ErrorCodeEnum eErr;
	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->GetDevStatus(m_devStatus);
	l_endTime = GetTickCountRVC();

	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("DoExitWhenIdle::GetDevStatus");
		if (m_devStatus.eMedia == CI_MEDIA_PRESENT || m_devStatus.eMedia == CI_MEDIA_ENTERING)
		{
			JustReadCardNo();
			m_captureReason = "4001";
			errMsg = CSimpleStringA::Format("DoExitWhenIdle, has card in machine, to capture card, CardNo:%s****%s",
					m_currCardNo.SubString(0, 6).GetData(), m_currCardNo.SubString(m_currCardNo.GetLength()-4, 4).GetData());
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_IdleExit, errMsg.GetData());

			eErr = MachineMoveCardBackNotHold();
			if (eErr == Error_Succeed)
			{
				bool bCaptured = ToRegistCaptureCardInfo();
				m_CardCaptured++;
				bool bSetCapture = SetCardCaptured(m_CardCaptured);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("DoExitWhenIdle, to capture card. result:%d, m_CardCaptured:%d, bSetCapture:%d",
						bCaptured, m_CardCaptured, bSetCapture));
			}
		}
	}
}

bool CCardIssuerFSM::JustReadCardNo()
{
	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;
	m_currCardNo = "";
	bool bHasAccount = false;
	int activeCardType;
	bool bIC = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER_STORE, m_hDevHelper, activeCardType);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("DetectIfICCard， bIC:%d, activeCardType:%d", bIC, activeCardType);

	if (bIC)
	{
		//oilyang@20201014 add emv support
		int bGetICData = m_pCardProcess->GetICDataFromCard(CARD_MACHINE_ISSUER_STORE, m_hDevHelper, m_aidList);
		if(bGetICData != 0)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<JustReadCardNo::GetICDataFromCard> faile(%d)", bGetICData);
		}
		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)("<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){
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WAB")("JustReadCardNo::DeactivateICCard err=%s", SpStrError(eErr));
			SetErrPackage("JustReadCardNo::DeactivateICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard);
			AlarmDEC();
		}
		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){
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB6")("JustReadCardNo::ReleaseIC err=%s", SpStrError(eErr));
			SetErrPackage("JustReadCardNo::ReleaseIC", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC);
			AlarmDEC();
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("JustReadCardNo::ReleaseIC");
		}
	}
	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)("MagRead JustReadCardNo, 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 {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagRead").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB4")("JustReadCardNo::MagRead err=%s", SpStrError(eErr));
			SetErrPackage("JustReadCardNo::MagRead", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MagRead);
			AlarmDEC();
		}
	}
	if (m_currCardNo.GetLength() > 8)
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("JustReadCardNo, record the account (%d):%s****%s", m_currCardNo.GetLength(),
				m_currCardNo.SubString(0, 6).GetData(), m_currCardNo.SubString(m_currCardNo.GetLength() - 4, 4).GetData());
	else{
		CSimpleStringA errMsg = CSimpleStringA::Format("JustReadCardNo, AccountNo maybe wrong:%s(len:%d)", m_currCardNo.GetData(), m_currCardNo.GetLength());
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CardNo_Maybe_Wrong, errMsg.GetData());
		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 = m_csDevSN;
	qRegistCardReq.terminalNo = m_terminalNo;
	qRegistCardReq.terminalType = m_csMachineType;
	//qRegistCardReq.m_url = "http://55.13.170.50:8080/defa-gateway/dee1/EacQuery/queryByEac";

	CSimpleStringA maskCardno = MaskCardno(cardno.GetData());
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<RegistCardWhileCaptureCard>, 吞卡登记开始, SwallowDate:%s, SwallowTime:%s, cardNoLen:%d, m_currCardNo:%s, m_captureReason:%s",
		csDate.GetData(), csTime.GetData(), cardno.GetLength(), maskCardno.GetData(), m_captureReason.GetData());

	//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();
	bool ret = client->Post(qRegistCardReq, qRegistCardRet);
	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("QLR040222004").setResultCode("RTA2W41")("登记吞卡信息到后台失败:%s,%s"
					, qRegistCardRet.returnInfo.returnCode.c_str(), qRegistCardRet.returnInfo.errorMsg.c_str());
			else
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222004")("吞卡登记成功");
		}
		else
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222004")("解析返回报文qRegistCardRet失败");
	}
	else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222004").setResultCode("RTA2W40")("访问吞卡登记失败");
	}
	client->Destory();
	return true;
}

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

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<SyncMaterialCount>,同步物料计数开始, DeviceNo = %s, CardBoxNum = %d", syncInfo.strDeviceNo, 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;
	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);
	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])
		{
			strncpy_s(pReq2.Maintainer, sizeof(pReq2.Maintainer), syncInfo.arrMaintainer[i], _TRUNCATE);
			pReq2.MaintainTime = syncInfo.arrMaintainTime[i];
		}
		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);
		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);
	}

	if (!client->Post(qTempReq, qTempRet)) {
		LogWarn(Severity_Middle, Error_Exception, CardIssuerStore_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("QLR0402220Z02").setResultCode("RTA2W30")("同步物料计数通讯失败");
		return false;//通讯失败
	}

	Json::Reader reader;
	Json::Value rootRet;
	if (!reader.parse(qTempRet.m_retStr, rootRet, false))
	{
		LogWarn(Severity_Middle, Error_Exception, CardIssuerStore_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("QLR0402220Z02").setResultCode("RTA2W31")("同步物料计数解析返回报文失败");
		return false;//解析失败
	}

	if (rootRet["success"].isBool()) {
		bool isSucc = rootRet["success"].asBool();
		if (isSucc){
			//成功
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<SyncMaterialCount>, succ");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402220Z02")("同步物料计数成功");
			return true;
		}
		else {
			//失败
			LogWarn(Severity_Middle, Error_Exception, CardIssuerStore_UserErrorCode_SyncMaterialCount_Failed, CSimpleStringA::Format("<SyncMaterialCount>, is error, url=%s", qTempReq.m_url.c_str()).GetData());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402220Z02").setResultCode("RTA2W32")("同步物料计数失败");
			return false;
		}
	}
	else {
		//参数不符合
		LogWarn(Severity_Middle, Error_Exception, CardIssuerStore_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("QLR0402220Z02").setResultCode("RTA2W33")("同步物料计数返回参数不对");
		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_WARN, LOG_TYPE_SYSTEM)("<IsValidCardNo>, CardNo is Invalid with illegal charactor:%c", pCardNo[i]);
			return false;
		}
	}
	return true;
}
int CCardIssuerFSM::SAMICCommand(SpReqAnsContext<CardIssuerStoreService_SAMICCommand_Req, CardIssuerStoreService_SAMICCommand_Ans>::Pointer ctx)
{
	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<SAMICCommand, inParam<cmdType:%d>", ctx->Req.cmdType);

	switch (ctx->Req.cmdType)
	{
	case SAMICCommand_SAM_Select:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMSelect(ctx->Req.param1[0]);
		l_endTime = GetTickCountRVC();

		if (eErr) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMSelect").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCA")("SAMICCommand::SAMSelect, req.param1:%d ,err=%s", ctx->Req.param1[0], SpStrError(eErr));
			SetErrPackage("SAMICCommand::SAMSelect", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMSelect);
			
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMSelect").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMSelect, req.param1:%d", ctx->Req.param1[0]);
		}
	}
		break;
	case SAMICCommand_SAM_Active:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMActive(ctx->Req.param1[0]);
		l_endTime = GetTickCountRVC();	

		if (eErr) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMActive").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCB")("SAMICCommand::SAMActive, req.param1:%d ,err=%s", ctx->Req.param1[0], SpStrError(eErr));
			SetErrPackage("SAMICCommand::SAMActive", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMActive);
			
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMActive").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMActive, req.param1:%d", ctx->Req.param1[0]);
		}
	}
		break;
	case SAMICCommand_SAM_Deactivate:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMDeactivate();
		l_endTime = GetTickCountRVC();	

		if (eErr) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMDeactivate").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCC")("SAMICCommand::SAMDeactivate err=%s", SpStrError(eErr));
			SetErrPackage("SAMICCommand::SAMDeactivate", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMDeactivate);
			
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMDeactivate").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMDeactivate");
		}
	}
		break;
	case SAMICCommand_SAM_WarmReset:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMWarmReset();
		l_endTime = GetTickCountRVC();

		if (eErr) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMWarmReset").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCD")("SAMICCommand::SAMWarmReset err=%s", SpStrError(eErr));
			SetErrPackage("SAMICCommand::SAMWarmReset", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMWarmReset);
			
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMWarmReset").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMWarmReset");
		}
	}
		break;
	case SAMICCommand_SAM_QueryStatus:
	{
		SAMStatus samStatus;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMQueryStatus(samStatus);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMQueryStatus").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMQueryStatus");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SAMWarmReset isActive:%d, chosenOfSAM:%d", samStatus.isActive, samStatus.chosenOfSAM);
			ctx->Ans.ret1.Init(2);
			ctx->Ans.ret1[0] = samStatus.isActive;
			ctx->Ans.ret1[1] = samStatus.chosenOfSAM;
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMQueryStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCE")("SAMICCommand::SAMQueryStatus err=%s", SpStrError(eErr));
			SetErrPackage("SAMICCommand::SAMQueryStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMQueryStatus);
			
		}
	}
		break;
	case SAMICCommand_SAM_Command:
	{
		CmdInfo sendBuf, recvBuf;
		BYTE *pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
		ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
		int size = StrBuf2HexBuf(ctx->Req.param2[0], &pTmp);
		memcpy(sendBuf.data, pTmp, size);
		sendBuf.dwSize = size;

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMCommand(sendBuf,recvBuf);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMCommand").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMCommand");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SAMCommand req.param2:%s, recvBuf.dwSize:%d", ctx->Req.param2[0].GetData(), recvBuf.dwSize);
			char *pRet = new char[MAX_IC_BUFFER_SIZE];
			ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
			//Dbg("%d",recvBuf.dwSize);
			HexBuf2StrBuf(recvBuf.data, (char**)&pRet, recvBuf.dwSize);
			ctx->Ans.ret1.Init(1);
			ctx->Ans.ret2.Init(1);
			ctx->Ans.ret1[0] = recvBuf.dwSize * 2;
			ctx->Ans.ret2[0] = pRet;
			delete[]pRet;
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMCommand").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCF")("SAMICCommand::SAMCommand err=%s", SpStrError(eErr));
			SetErrPackage("SAMICCommand::SAMCommand", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMCommand);
			
		}
		delete[]pTmp;
	}
		break;
	case SAMICCommand_IC_Active:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ContactIC();
		l_endTime = GetTickCountRVC();
		

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ContactIC").setCostTime(l_endTime - l_beginTime)("SAMICCommand::ContactIC");
			CmdInfo atrBuf;
			l_beginTime =GetTickCountRVC();
			eErr = m_hDevHelper->ActiveICCardATR(atrBuf);
			l_endTime =GetTickCountRVC();
			
			if (eErr == Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ActiveICCardATR").setCostTime(l_endTime - l_beginTime)("SAMICCommand::ActiveICCardATR");
				BYTE* pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
				if (pTmp == NULL)
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("new MAX_IC_BUFFER_SIZE failed");
					eErr = Error_Unexpect;
					break;
				}
				ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
				HexBuf2StrBuf(atrBuf.data, (char**)&pTmp, atrBuf.dwSize);
				ctx->Ans.ret1.Init(1);
				ctx->Ans.ret2.Init(1);
				ctx->Ans.ret1[0] = atrBuf.dwSize * 2;
				ctx->Ans.ret2[0] = CSimpleStringA((const char*)pTmp);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AtrCtx: size=%d, content=%s, pTmp=%s", ctx->Ans.ret1[0], (LPCTSTR)ctx->Ans.ret2[0], (LPCTSTR)pTmp);
				delete[] pTmp;
				pTmp = NULL;

			}
			else
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ActiveICCardATR").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WB7")("SAMICCommand::ActiveICCardATR err=%s", SpStrError(eErr));
				SetErrPackage("SAMICCommand::ActiveICCardATR", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ActiveICCardATR);
				
			}

		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ContactIC").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WC7")("SAMICCommand::ContactIC err=%s", SpStrError(eErr));
			SetErrPackage("SAMICCommand::ContactIC", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ContactIC);
			
		}
	}
		break;
	case SAMICCommand_IC_Deactivate:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->DeactivateICCard();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->DeactivateICCard();
			l_endTime = GetTickCountRVC();
			
			if (eErr != Error_Stoped)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WAB")("SAMICCommand::DeactivateICCard err=%s", SpStrError(eErr));
				SetErrPackage("SAMICCommand::DeactivateICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard);
				
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommand::DeactivateICCard");
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommand::DeactivateICCard");
		}
	}
		break;
	case SAMICCommand_IC_WarmReset:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->WarmReset();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::WarmReset").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCG")("SAMICCommand::WarmReset err=%s", SpStrError(eErr));
			SetErrPackage("SAMICCommand::WarmReset", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_WarmReset);
			
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::WarmReset").setCostTime(l_endTime - l_beginTime)("SAMICCommand::WarmReset");
		}
	}
		break;
	case SAMICCommand_IC_Command:
	{
		CmdInfo sendBuf, recvBuf;
		BYTE *pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
		ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
		int size = StrBuf2HexBuf(ctx->Req.param2[0], &pTmp);
		memcpy(sendBuf.data, pTmp, size);
		sendBuf.dwSize = size;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ICCommand(sendBuf, recvBuf);
		l_endTime = GetTickCountRVC();

		if(false)//oiltest@20201224 before deploy ,comment loging apdu content
		{
			char *pRet = new char[MAX_IC_BUFFER_SIZE];
			if (pRet != NULL)
			{
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				HexBuf2StrBuf(sendBuf.data, (char**)&pRet, size);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ICCommand return data, %s", (const char*)pRet);
				delete[] pRet;
			}
										
		}

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime)("SAMICCommand::ICCommand");
			if (recvBuf.dwSize > 0 && recvBuf.dwSize < 1024)
			{
				char* pRet = new char[MAX_IC_BUFFER_SIZE];
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ICCommand, recvBuf.dwSize:%d", recvBuf.dwSize);
				HexBuf2StrBuf(recvBuf.data, (char**)&pRet, recvBuf.dwSize);
				ctx->Ans.ret1.Init(1);
				ctx->Ans.ret2.Init(1);
				ctx->Ans.ret1[0] = recvBuf.dwSize * 2;
				ctx->Ans.ret2[0] = pRet;
				delete[]pRet;
			}
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W02")("SAMICCommand::ICCommand err=%s", SpStrError(eErr));
			SetErrPackage("SAMICCommand::ICCommand", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ICCommand);
			
		}
		delete[]pTmp;
	}
		break;
	case SAMICCommand_RFIC_Active:
	{
		char chType = 0;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ActiveContactlessICCard('A', 'B', 'M', chType);
		l_endTime = GetTickCountRVC();
		
		ctx->Ans.ret1.Init(1);
		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ActiveContactlessICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommand::ActiveContactlessICCard, chType:%d", chType);
			ctx->Ans.ret1[0] = chType;
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ActiveContactlessICCard").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WC6")("SAMICCommand::ActiveContactlessICCard, chType:%d, err=%s", chType, SpStrError(eErr));
			SetErrPackage("SAMICCommand::ActiveContactlessICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ActiveContactlessICCard);
			
		}
	}
		break;
	case SAMICCommand_RFIC_Deactivate:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->DeactContactlessICCard();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {

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

			if (eErr != Error_Succeed) {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WC8")("SAMICCommand::DeactContactlessICCard err=%s", SpStrError(eErr));
				SetErrPackage("SAMICCommand::DeactContactlessICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_DeactContactlessICCard);
				
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommand::DeactContactlessICCard");
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommand::DeactContactlessICCard");
		}
	}
		break;
	case SAMICCommand_RFIC_Command:
	{
		CmdInfo sendBuf, recvBuf;
		BYTE* pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
		ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
		int size = StrBuf2HexBuf(ctx->Req.param2[0], &pTmp);
		memcpy(sendBuf.data, pTmp, size);
		sendBuf.dwSize = size;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->RFTypeABCommand(sendBuf, recvBuf);
		l_endTime = GetTickCountRVC();
		if (false)//oiltest@20201224 before deploy ,comment loging apdu content
		{
			char* pRet = new char[MAX_IC_BUFFER_SIZE];
			if (pRet != NULL)
			{
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				HexBuf2StrBuf(sendBuf.data, (char**)&pRet, size);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RFTypeABCommand, return data:%s", (const char*)pRet);
				delete[] pRet;
			}

		}

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::RFTypeABCommand").setCostTime(l_endTime - l_beginTime)("SAMICCommand::RFTypeABCommand");
			if (recvBuf.dwSize > 0 && recvBuf.dwSize < 1024)
			{
				char* pRet = new char[MAX_IC_BUFFER_SIZE];
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RFTypeABCommand, recvBuf.dwSize:%d", recvBuf.dwSize);
				HexBuf2StrBuf(recvBuf.data, (char**)&pRet, recvBuf.dwSize);
				ctx->Ans.ret1.Init(1);
				ctx->Ans.ret2.Init(1);
				ctx->Ans.ret1[0] = recvBuf.dwSize * 2;
				ctx->Ans.ret2[0] = pRet;
				delete[]pRet;
			}
		}
		else{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::RFTypeABCommand").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WC9")("SAMICCommand::RFTypeABCommand err=%s", SpStrError(eErr));
			SetErrPackage("SAMICCommand::RFTypeABCommand", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_RFTypeABCommand);
			
		}
		delete[]pTmp;
	}
	break;
	default:
		break;
	}
	if (eErr != Error_Succeed)
		ctx->Answer(eErr, AlarmDEC());
	else
		ctx->Answer(Error_Succeed);
	return 0;
}
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;
}
bool CCardIssuerFSM::AccountExchange(const char *origAcc, CSimpleStringA &acc, int dir)
{
	int len = strlen(origAcc);
	if (len < 8)
	{
		if (len > 4)//排除掉一些空格或者换行之类的干扰日志
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<AccountExchange>, account size error:%d", len);
		return false;
	}
	CSimpleStringA csTmp(' ',len+1);
	csTmp[len] = '\0';
	
	if (dir)
	{
		int size, max;
		size = max = len / 4;
		if (len < 16)
			max = 4;
		for (int i = 0; i < max; i++)
		{
			csTmp[i * size] = *(origAcc + i);
			csTmp[i * size + 1] = *(origAcc + 4 + i);
			if (8 + i < len)
				csTmp[i * size + 2] = *(origAcc + 8 + i);
			if (12 + i < len)
				csTmp[i * size + 3] = *(origAcc + 12 + i);
		}
		if (len % 4 != 0)
		{
			for (int j = 4 * (len / 4); j < len; j++)
				csTmp[j] = *(origAcc + j);
		}
		acc = csTmp;
	}
	else
	{
		int size, max;
		size = max = len / 4;
		if (len < 16)
			max = 4;
		for (int i = 0; i < size; i++)
		{
			csTmp[i * 4] = *(origAcc + i);
			csTmp[i * 4 + 1] = *(origAcc + size + i);
			csTmp[i * 4 + 2] = *(origAcc + 2*size + i);
			csTmp[i * 4 + 3] = *(origAcc + 3*size + i);
		}
		if (len % 4 != 0)
		{
			for (int j = 4 * (len / 4); j < len; j++)
				csTmp[j] = *(origAcc + j);
		}
		acc = csTmp;
	}
	return true;
}
bool CCardIssuerFSM::WriteSlotInfo(CSmartPointer<IConfigInfo> &cfgRun, const char *acc, const char *cardSerial, int slot, bool bClear)
{
	char buf[8];
	ZeroMemory(buf, 8);
	int sum = 0;
	cfgRun->ReadConfigValueInt("SlotInfo", "count", sum);
	if (bClear)
	{
		cfgRun->WriteConfigValue("SlotInfo", _itoa(slot, buf, 10), "0,0,0");
		return true;
	}

	CSimpleStringA csAcc("");
	if (AccountExchange(acc, csAcc))
	{
		csAcc = csAcc + ",1," + cardSerial;
		cfgRun->WriteConfigValue("SlotInfo", _itoa(slot, buf, 10), csAcc);
		sum++;
		cfgRun->WriteConfigValueInt("SlotInfo", "count", sum);
		return true;
	}
	return false;
}
bool CCardIssuerFSM::ReadSlotInfo(CSmartPointer<IConfigInfo> &cfgRun, CSimpleStringA &acc, CSimpleStringA &cardSerial, int slot, int &hasCard)
{
	char buf[8];
	ZeroMemory(buf, 8);
	CSimpleStringA csAcc("");
	cfgRun->ReadConfigValue("SlotInfo", _itoa(slot, buf, 10), csAcc);
	CAutoArray<CSimpleStringA> arr = csAcc.Split(',');
	if (arr.GetCount() < 3)
	{
		//Dbg("data error.size:%d",arr.GetCount());
		return false;
	}
	if (arr[1].Compare("1") == 0)
		hasCard = 1;
	else
		hasCard = 0;
	csAcc = arr[0];
	cardSerial = arr[2];
	//Dbg("account length: %d", strlen(csAcc));
	if (AccountExchange(csAcc, acc, 0))
	{
		return true;
	}
	return false;
}
bool CCardIssuerFSM::WriteCardInfo(CSmartPointer<IConfigInfo> &cfgRun, const char *acc, const char* serial, int slot, bool bClear, bool bHasCard)
{
	char buf[8];
	ZeroMemory(buf, 8);
	if (bClear || !bHasCard)
	{
		cfgRun->WriteConfigValue("OperateCardStore", _itoa(slot, buf, 10), "0,0,0");
		return true;
	}
	
	CSimpleStringA csAcc("");
	if (AccountExchange(acc, csAcc))
	{
		CSimpleStringA tmp("1,");				
		csAcc = tmp + csAcc + "," + serial;
		cfgRun->WriteConfigValue("OperateCardStore", _itoa(slot, buf, 10), (const char*)csAcc);
		return true;
	}
	return false;
}

bool CCardIssuerFSM::ReadCardInfo(CSmartPointer<IConfigInfo> &cfgRun, CSimpleStringA &acc, CSimpleStringA &serial, int slot)
{
	char buf[8];
	ZeroMemory(buf, 8);
	CSimpleStringA csAcc("");
	cfgRun->ReadConfigValue("OperateCardStore", _itoa(slot, buf, 10), csAcc);
	CAutoArray<CSimpleStringA> arr = csAcc.Split(',');
	if (arr.GetCount() < 3)
	{
		//Dbg("data error.size:%d",arr.GetCount());
		return false;
	}
	csAcc = arr[1];
	serial = arr[2];
	if(strlen(csAcc) < 8 || serial.GetLength() <= 0)
	{
		return false;
	}
	if (AccountExchange(csAcc, acc, 0))
	{
		return true;
	}
	return false;
}
bool CCardIssuerFSM::SetSlotFlag(int slot, bool bReset,bool bClear)
{
	return true;
}
void CCardIssuerFSM::ClearAllLocalSlotInfo()
{
	LOG_FUNCTION();
	CSmartPointer<IConfigInfo> spConfigRun;
	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
	if (eErr != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<ClearAllLocalSlotInfo>, open runcfg failed.%d(0x%x)", eErr, eErr);
		return;
	}
	for (int i = 0; i < m_maxSlot; i++)
	{
		WriteSlotInfo(spConfigRun, "", "",i, true);
	}
}
int CCardIssuerFSM::IssueCardFromStore(SpReqAnsContext<CardIssuerStoreService_IssueEx_Req, CardIssuerStoreService_IssueEx_Ans>::Pointer ctx, bool bSpec)
{//98 100: bspec=true   99: bspec=false
	LOG_FUNCTION();

	CSimpleStringA errMsg(true);
	errMsg = CSimpleStringA::Format("IssueCardFromStore with req.hopper=%d,slot:%d", ctx->Req.hopper, ctx->Req.reserved1[0]);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_IssueCardFromStore, errMsg.GetData());

	long l_beginTime, l_endTime;
	ErrorCodeEnum eErr = Error_Unexpect;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCardFromSlot(ctx->Req.reserved1[0]);
	l_endTime = GetTickCountRVC();

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IssueCardFromStore::MoveCardFromSlot,reserved1:%d, req.hopper:%d", ctx->Req.reserved1[0], ctx->Req.hopper);

	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardFromSlot").setCostTime(l_endTime - l_beginTime)("IssueCardFromStore::MoveCardFromSlot");
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardFromSlot, "IssueCardFromStore MoveCardFromSlot suc.");
		CardNo card;
		memset(&card, 0, sizeof(card));
		ctx->Ans.reserved1.Init(3);
		ctx->Ans.reserved2.Init(2);

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReadAccount(card);
		l_endTime = GetTickCountRVC();
		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime)("IssueCardFromStore::ReadAccount");
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W05")("IssueCardFromStore::ReadAccount err=%s", SpStrError(eErr));
			SetErrPackage("IssueCardFromStore::ReadAccount", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReadAccount);
			AlarmDEC();
		}
		
		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_ReadAccount_Cost_Time, CSimpleStringA::Format("{\"cost\":%d}", l_endTime - l_beginTime));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IssueCardFromStore::ReadAccount, dwSize:%d, t2dwSize:%d, t3dwSize:%d, card.account len:%d, ",
			card.dwSize, card.dwTrack2Size, card.dwTrack3Size, strlen(card.account));

		if (eErr == Error_Succeed && ctx->Req.reserved2.GetCount() > 0 && ctx->Req.reserved2[0].GetLength() == card.dwSize && strncmp(card.account, ctx->Req.reserved2[0], card.dwSize) == 0)
		{
			m_mapJsonErr["cardPos"] = JsonElem(CardPos_KeepInCardReader);//无意义
			m_currCardNo = card.account;
			if (card.dwSize > 6)
			{
				string xTestStr(card.account);
				LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_CardBin, CSimpleStringA::Format("cardBin:%s****%s", xTestStr.substr(0, 6).c_str(), xTestStr.substr(card.dwSize - 4, 4).c_str()));
			}
			ctx->Ans.reserved1[0] = 0;
			ctx->Ans.reserved1[1] = 0;
			if (bSpec)
			{
				m_mapJsonErr["cardPos"] = JsonElem(CardPos_HaveEjectedCard);//无意义
				ctx->Ans.reserved1[1] = 4;
				if (eErr == Error_Succeed && card.dwSize > 0 && card.dwSize < 32)
					ctx->Ans.reserved2[0] = card.account;
				else
					ctx->Ans.reserved2[0] = "";
				//oilyang@20171214 直接吐卡 @宋锐
				EjectTask* task = new EjectTask(this);
				task->ctx = NULL;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				ctx->Answer(Error_Succeed);
				return 6;//跳转到吞卡S6
			}
		}
		else
		{//失败情况
			if (!m_bNewAnsError)
				ctx->Ans.reserved1[0] = 3;
			if (card.dwSize > 6)
			{
				m_currCardNo = CSimpleStringA(card.account,card.dwSize);
				string xTestStr(card.account);
				LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_CardBin, CSimpleStringA::Format("cardBin:%s****%s", xTestStr.substr(0, 6).c_str(), xTestStr.substr(card.dwSize - 4, 4).c_str()));
			}
			m_mapJsonErr["cardResult"] = JsonElem(CardResult_Account_MisMatch);
			if (bSpec)
			{//98 100
				if (eErr == Error_Succeed && card.dwSize > 0 && card.dwSize < 32)
				{
					if (!m_bNewAnsError)
						ctx->Ans.reserved2[0] = card.account;
					m_mapJsonErr["cardNo"] = JsonElem(card.account);
				}
				else
				{
					if (!m_bNewAnsError)
						ctx->Ans.reserved2[0] = "";
					m_mapJsonErr["cardNo"] = JsonElem("");
				}

				if (ctx->Req.hopper == 98)
				{
					if (!m_bNewAnsError)
						ctx->Ans.reserved1[1] = 4;
					m_mapJsonErr["cardPos"] = JsonElem(CardPos_HaveEjectedCard);
					//oilyang@20171214 直接吐卡 @宋锐
					EjectTask* task = new EjectTask(this);
					task->ctx = NULL;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
					m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，已吐卡");
					if (m_bNewAnsError)
						ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Account_NotMatchWithReadAccount, generateJsonString(m_mapJsonErr));
					else
						ctx->Answer(Error_Succeed);
					return 6;//跳转到吐卡S6
				}
				if (ctx->Req.hopper == 100)
				{
					int ret = 2;
					if (!m_bNewAnsError)
						ctx->Ans.reserved1[1] = 5;
					m_mapJsonErr["cardPos"] = JsonElem(CardPos_HaveCapturedCard);
					//zjw@20190506 直接吞卡 @宋锐
					//这里改为同步，因为清卡操作要循环调用，以防本次还未吞卡结束又调用下一次清卡，导致流程混乱
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("clear card in cardstore, normal capture card.");
					eErr = MachineMoveCardBackNotHold();
					if (eErr == Error_Succeed)
					{
						ToRegistCaptureCardInfo();
					}
					else
						ret = 1;
					m_CardCaptured++;
					if (!SetCardCaptured(m_CardCaptured))
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<IssueCardFromStore>, set card captured failed.");
					m_pCardProcess->DataInit();
					if (Error_Succeed != eErr)
					{
						bool bTrans = true;
						DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD, bTrans);
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020Z01").setResultCode("RTA2W07")("吞卡失败");
						SetErrPackage("IssueCardFromStore capture card failed:", m_csDevSN, eErr, dwTmpUserErrCode);
						bTrans ? AlarmDEC() : dwTmpUserErrCode = AlarmDEC();
						m_mapJsonErr["userCode"] = JsonElem(dwTmpUserErrCode);
						m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，吞卡失败，请联系卡库厂商排查");
						if (ctx != NULL)
						{
							if (m_bNewAnsError)
								ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
							else
								ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
						}
					}
					if (ctx != NULL)
					{
						m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，已吞卡");
						if (m_bNewAnsError)
							ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Account_NotMatchWithReadAccount, generateJsonString(m_mapJsonErr));
						else
							ctx->Answer(Error_Succeed);
					}
					//ret =1 返回失败状态S9，卡机此时无法工作  ret=2 返回空闲状态
					return ret;
				}
			}
			else
			{//99
				l_beginTime = GetTickCountRVC();
				eErr = m_hDevHelper->MoveCardToSlot(ctx->Req.reserved1[0]);
				l_endTime = GetTickCountRVC();

				if (eErr == Error_Succeed)
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime)("IssueCardFromStore::MoveCardToSlot, slot:%d", ctx->Req.reserved1[0]);
					LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardToSlot, "IssueCardFromStore MoveCardToSlot suc.");
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<IssueCardFromStore>, accout not eqaul, card have been move back to slot.");
					if (!m_bNewAnsError)
						ctx->Ans.reserved1[1] = 1;
					m_mapJsonErr["cardPos"] = JsonElem(CardPos_HaveMovedToSlot);
					m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，卡片已移回原卡槽");
					if (m_bNewAnsError)
						ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Account_NotMatchWithReadAccount, generateJsonString(m_mapJsonErr));
					else
						ctx->Answer(Error_Succeed);
					return 2;//返回空闲状态
				}
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W03")("IssueCardFromStore::MoveCardToSlot, slot:%d , err=%s", ctx->Req.reserved1[0], SpStrError(eErr));
					bool bTrans = true;
					m_mapJsonErr["cardPos"] = JsonElem(CardPos_HaveCapturedCard);
					DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot, bTrans);
					SetErrPackage("IssueCardFromStore::MoveCardToSlot", m_csDevSN, eErr, dwTmpUserErrCode);
					bTrans ? AlarmDEC() : dwTmpUserErrCode = AlarmDEC();
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_IssueFromCardStore,
						"accout not eqaul,card move back to slot failed, to capture card");

					ToRegistCaptureCardInfo();
					eErr = MachineMoveCardBackNotHold();
					if (!m_bNewAnsError)
					{
						if (eErr == Error_Succeed)
						{
							m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，移回原卡槽失败，已吞卡");
							ctx->Ans.reserved1[1] = 2;
							ctx->Answer(Error_Succeed);
							return 2;//返回空闲状态
						}
						else
						{
							m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，吞卡失败，请联系卡库厂商排查");
							ctx->Ans.reserved1[1] = 3;
							ctx->Answer(Error_Succeed);
							return 0;//返回工作状态S4，卡机此时无法工作
						}
					}
					else {
						//新版
						if (eErr == Error_Succeed)
						{
							m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，移回原卡槽失败，已吞卡");
							ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
							return 2;
						}
						else {
							m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，吞卡失败，请联系卡库厂商排查");
							ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
							return 0;//返回工作状态S4，卡机此时无法工作
						}
					}
					//m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，吞卡失败，请联系卡库厂商排查");
					//if (m_bNewAnsError)
					//	ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
					//else
					//	ctx->Answer(Error_Succeed);
					//return 0;//返回工作状态S4，卡机此时无法工作
				}
			}
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222020Z01")();
		ctx->Answer(Error_Succeed);

	}
	else
	{
		bool bTrans = true;
		DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot, bTrans);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020Z01").setResultCode("RTA2W04").setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("从卡槽移动卡片到读卡器失败");
		SetErrPackage("IssueCardFromStore::MoveCardFromSlot", m_csDevSN, eErr, dwTmpUserErrCode);
		bTrans ? AlarmDEC() : dwTmpUserErrCode = AlarmDEC();

		m_mapJsonErr["cardResult"] = JsonElem(CardResult_MoveToCardReader_Fail);
		m_mapJsonErr["tips"] = JsonElem("[RTA9999] 从卡槽移动卡片到读卡器失败，请联系卡库厂商排查");
		if (m_bNewAnsError)
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
		else
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		return 2;//返回空闲状态
	}
	return 0;
}

int CCardIssuerFSM::AddCardToStoreStepFirst(SpReqAnsContext<CardIssuerStoreService_IssueEx_Req, CardIssuerStoreService_IssueEx_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_addCardNo = "";
	m_addCardSerial = "";
	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;
	LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_AddCardToStoreStepFirst, "AddCardToStoreStepFirst");
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCard(CI_MOVECARD_FROM_HOPPER,99);
	l_endTime = GetTickCountRVC();

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AddCardToStoreStepFirst::MoveCard, CI_MOVECARD_FROM_HOPPER,99");

	ctx->Ans.reserved1.Init(4);
	ctx->Ans.reserved2.Init(2);
	
	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("AddCardToStoreStepFirst::MoveCard");
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCard_FromHopper, "MoveCard from hopper suc.");
		CardNo card;
		memset(&card, 0, sizeof(card));
		ctx->Ans.reserved2[0] = "";
		m_mapJsonErr["cardNo"] = JsonElem("");
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReadAccount(card);
		l_endTime = GetTickCountRVC();
		
		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime)("AddCardToStoreStepFirst::ReadAccount");
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W05")("AddCardToStoreStepFirst::ReadAccount err=%s", SpStrError(eErr));
			SetErrPackage("AddCardToStoreStepFirst::ReadAccount", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReadAccount);
			AlarmDEC();
		}

		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_ReadAccount_Cost_Time, CSimpleStringA::Format("{\"cost\":%d}", l_endTime - l_beginTime));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AddCardToStoreStepFirst, dwSize:%d, t2dwSize:%d, t3dwSize:%d",
										card.dwSize, card.dwTrack2Size, card.dwTrack3Size);

		bool bDataOK = false;//oilyang@20171213 是否读卡失败，是否解析出卡序号，否则吞卡 @宋锐
		if (eErr == Error_Succeed && card.dwSize > 0 && card.dwSize < 64)
		{
			//oilyang@20201217 if only ic 
			if (card.dwTrack3Size == 2)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("maybe only ic card.");
				ctx->Ans.reserved2[1] = m_addCardSerial = (const char*)card.track3;
				m_mapJsonErr["cardSerial"] = JsonElem(ctx->Ans.reserved2[1].GetData());
			}
			else
			{
				Track2Data track2Data;
				track2Data.status = 0;
				track2Data.t2Account = "";
				char* tmpMag2 = new char[256];
				ZeroMemory(tmpMag2, 256);
				bool bT2OK = false, bT3OK = false;
				if (card.dwTrack2Size > 0 && card.dwTrack2Size < 41)
				{
					//oilyang@20171129 IC card track2 maybe has 'F' in the end
					if (card.track2[card.dwTrack2Size - 1] == 'F')
					{
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("track2 has F in the end.");
						card.track2[card.dwTrack2Size - 1] = '\0';
						card.dwTrack2Size--;
					}
					bT2OK = true;
				}
				if (card.dwTrack3Size > 0 && card.dwTrack3Size < 150)
					bT3OK = true;
				DecodeTracksData(card.track2, card.dwTrack2Size, card.track3, card.dwTrack3Size, tmpMag2, bT2OK, bT3OK);
				if (SplitTrack2(tmpMag2, track2Data) == 0)
				{
					ctx->Ans.reserved2[1] = track2Data.t2CardSerial;
					m_mapJsonErr["cardSerial"] = JsonElem(ctx->Ans.reserved2[1].GetData());
					m_addCardSerial = track2Data.t2CardSerial;
				}
			}
			ctx->Ans.reserved1[2] = 0;//oiltmp what's this?
			m_currCardNo = m_addCardNo = ctx->Ans.reserved2[0] = CSimpleStringA(card.account, card.dwSize);
			if (card.dwSize > 6)
			{
				string xTestStr(card.account);
				LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_CardBin, CSimpleStringA::Format("cardBin:%s****%s", xTestStr.substr(0, 6).c_str(), xTestStr.substr(card.dwSize - 4, 4).c_str()));
			}

			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<AddCardToStoreStepFirst>,cardAccount len:%d, CardSerial:%s", m_currCardNo.GetLength(), m_addCardSerial.GetData());
			if (m_addCardSerial.GetLength() > 0)
			{
				bDataOK = true;
				ctx->Answer(Error_Succeed);
			}
		}

		if (!bDataOK)
		{
			bool bTrans = true;
			DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, CardIssuerStore_UserErrorCode_CaptureCard_AddCard_ReadFailed, bTrans);
			SetErrPackage("AddCardToStoreStepFirst::ReadAccount", m_csDevSN, eErr, dwTmpUserErrCode);
			bTrans ? AlarmDEC() : dwTmpUserErrCode = AlarmDEC();
			if (!m_bNewAnsError)
				ctx->Ans.reserved1[2] = 1;//??? oiltmp@20221030
			m_mapJsonErr["tips"] = JsonElem("[RTA9999] 读卡失败，请联系卡库厂商排查");
			m_mapJsonErr["cardResult"] = JsonElem(CardResult_ReadAccount_Fail);
			m_mapJsonErr["cardPos"] = JsonElem(CardPos_HaveCapturedCard);
			////此故障码影响业务流程，业务未改造完前，改回原故障码
			//if (dwTmpUserErrCode == CardIssuerStore_UserErrorCode_CaptureCard_AddCard_ReadFailed) {
			//	dwTmpUserErrCode = CardIssuer_UserErrorCode_CaptureCard_AddCard_ReadFailed;
			//}
			m_mapJsonErr["userCode"] = JsonElem(dwTmpUserErrCode);


			ToRegistCaptureCardInfo();
			eErr = MachineMoveCardBackNotHold();
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("oiltest retStr:%s", generateJsonString(m_mapJsonErr).GetData());
			if (m_bNewAnsError) {
				ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
			}		
			else {
				ctx->Answer(Error_Succeed);
			}
			if (eErr == Error_Succeed)
				return 2;
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WBE")("AddCardToStoreStepFirst::MoveCard err=%s", SpStrError(eErr));
		//TODO oiltest need to add
		bool bTrans = true;
		DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCard, bTrans);
		//加卡移卡时，如果报无卡，则记录日志，否则上送告警
		if (dwTmpUserErrCode == CardIssuerStore_UserErrorCode_Dev_HopperHasNoCard)
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AddCardToStoreStepFirst::MoveCard, Hopper has no card");
		else
		{
			SetErrPackage("AddCardToStoreStepFirst::MoveCard", m_csDevSN, eErr, dwTmpUserErrCode);
			AlarmDEC();
		}
			
		if (!bTrans)//兼容未做卡库api返回故障码细化改造的卡库厂商
			dwTmpUserErrCode = CardIssuerStore_UserErrorCode_Dev_HopperHasNoCard;

		m_mapJsonErr["cardResult"] = JsonElem(CardResult_MoveToCardReader_Fail);
		////此故障码影响业务流程，业务未改造完前，改回原故障码
		//if (dwTmpUserErrCode == CardIssuerStore_UserErrorCode_Dev_HopperHasNoCard) {
		//	dwTmpUserErrCode = CardIssuer_UserErrorCode_Dev_HopperHasNoCard;
		//}
		m_mapJsonErr["userCode"] = JsonElem(dwTmpUserErrCode);
		m_mapJsonErr["tips"] = JsonElem("[RTA9999] 从加卡箱移卡失败，请联系卡库厂商排查");
		//oiltmp@20230506 目前业务端需要知道结果，但是返回失败（非Error_Succeed）又没有结构体返回，待后续优化
		if (m_bNewAnsError) {
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
		}
		else
		{
			ctx->Ans.reserved1[2] = 3;
			ctx->Answer(Error_Succeed);
		}
		return 2;
	}

	return 0;
}
int CCardIssuerFSM::AddCardToStoreStepLast(SpReqAnsContext<CardIssuerStoreService_IssueEx_Req, CardIssuerStoreService_IssueEx_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA errMsg(""), accout("");
	int slot = -1;
	long l_beginTime, l_endTime;
	if (m_currCardNo.GetLength() > 6)
		accout = CSimpleStringA::Format("%s****%s", m_currCardNo.SubString(0, 6).GetData()
			, m_currCardNo.SubString(m_currCardNo.GetLength() - 4, 4).GetData());
	else
		accout = m_currCardNo;
	//oilyang@20230428 加卡多加一次移到卡槽尝试
	//加卡时，如果第一个卡槽加失败，继续尝试下一个空闲卡槽，如果再失败，返回给前端
	//同时记录有问题的卡槽号，后续找空闲卡槽时跳过问题卡槽。在实体未重启时有效
	for (int i = 0; i < 2; i++)
	{
		//实体找到第一个为空的卡槽，进行移卡
		slot = FindFirstEmptySlot();

		if (slot < 0)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020Z02").setResultCode("RTA2W0L")("卡库找不到空闲卡槽");
			errMsg = CSimpleStringA::Format("AddCardToStoreStepLast::FindFirstEmptySlot failed or cannot find a empty slot(%d).", slot);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_KakuFindEmptySlot_Failed, errMsg.GetData());
			m_mapJsonErr["cardResult"] = JsonElem(CardResult_CanNotFindEmptySlot);
			m_mapJsonErr["userCode"] = JsonElem(CardIssuerStore_UserErrorCode_KakuFindEmptySlot_Failed);
			m_mapJsonErr["tips"] = JsonElem("[RTA2W0L] 卡库找不到空闲卡槽，请联系卡库厂商排查");
			if (m_bNewAnsError)
				ctx->Answer(TransECWithRepeat(Error_Unexpect), CardIssuerStore_UserErrorCode_KakuFindEmptySlot_Failed, generateJsonString(m_mapJsonErr));
			else
				ctx->Answer(TransECWithRepeat(Error_Unexpect), CardIssuerStore_UserErrorCode_KakuFindEmptySlot_Failed);
			return 0;
		}
		ctx->Ans.reserved1.Init(4);
		ctx->Ans.reserved2.Init(2);

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->MoveCardToSlot(slot);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed)//一次成功，无需重试
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime)("AddCardToStoreStepLast::MoveCardToSlot, slot:%d", slot);
			LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardToSlot, "AddCardToStoreStepLast MoveCardToSlot suc.");
			break;
		}
		else
		{
			//TODO:登记到后台
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W03")("AddCardToStoreStepLast::MoveCardToSlot, slot:%d , err=%s", slot, SpStrError(eErr));
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_AddCardToStoreStepFirst_Failed, CSimpleStringA::Format("badslot:%d", slot));
			m_badSlot.push_back(slot);
		}
	}

	if (eErr == Error_Succeed)
	{
		errMsg = CSimpleStringA::Format("AddCardToStoreStepLast, slot:%d,account:%s", slot, accout.GetData());
		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_AddCardToStoreStepLast, errMsg.GetData());
		m_currCardNo = "";
		ctx->Ans.reserved1[0] = slot;
		ctx->Ans.reserved1[2] = 0;
		ctx->Ans.reserved2[0] = "";
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if (eErr != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<AddCardToStoreStepLast>, open runcfg to write slot info failed:%d(0x%x)", eErr, eErr));
		}
		else
			WriteSlotInfo(spConfigRun, (const char*)m_addCardNo, (const char*)m_addCardSerial, slot);
		ctx->Answer(Error_Succeed);
		return 2;
	}
	else
	{
		bool bTrans = true;
		DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardToSlot, bTrans);
		errMsg = CSimpleStringA::Format("AddCardToStoreStepLast::MoveCardToSlot(slot:%d)", slot);
		SetErrPackage(errMsg, m_csDevSN, eErr, dwTmpUserErrCode);
		bTrans ? AlarmDEC() : dwTmpUserErrCode = AlarmDEC();
		m_mapJsonErr["cardResult"] = JsonElem(CardResult_MoveToSlot_Fail);
		m_mapJsonErr["cardPos"] = JsonElem(CardPos_HaveCapturedCard);
		m_mapJsonErr["slot"] = JsonElem(slot);
		m_mapJsonErr["userCode"] = JsonElem(dwTmpUserErrCode);
		ToRegistCaptureCardInfo();
		MachineMoveCardBackNotHold();
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222020Z02").setResultCode("RTA2W03")("卡片从读卡器移回到卡槽失败");

		//oiltmp@20230506 目前业务端需要知道结果，但是返回失败（非Error_Succeed）又没有结构体返回，待后续优化
		m_mapJsonErr["tips"] = JsonElem("[RTA2W03] [HW] 卡片从读卡器移回到卡槽失败，请联系卡库厂商排查");
		if (m_bNewAnsError)
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
		else
		{
			ctx->Ans.reserved1[2] = 2;
			ctx->Answer(Error_Succeed);
		}
		return 2;
	}
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::FindFirstEmptySlot()
{
	LOG_FUNCTION();
	SlotStatus status;
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->QuerySlotsStatus(status, 0,true);
	l_endTime = GetTickCountRVC();


	if (eErr != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W20")("FindFirstEmptySlot::QuerySlotsStatus eErr:%s", SpStrError(eErr));
		SetErrPackage("FindFirstEmptySlot::QuerySlotsStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus);
		AlarmDEC();
		return -1;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime)("FindFirstEmptySlot::QuerySlotsStatus");
	}
	for (int i = 0; i < status.dwSize; i++)
	{
		if (status.status[i] == 0)
		{
			//空闲的问题卡槽，跳过，继续找下一个无问题卡槽
			if (std::find(m_badSlot.begin(), m_badSlot.end(), i) != m_badSlot.end())
				continue;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("find an empty slot %d.",i);
			return i;
		}
	}
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("can't find a empty slot");
	return -1;
}
bool CCardIssuerFSM::IsValidSlotNum(const int slot)
{
	if (m_maxSlot == 0 || slot < 0 || slot >= m_maxSlot) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<IsValidSlotNum>, invalid slot:%d", slot);
		return false;
	}
	return true;
}
bool CCardIssuerFSM::IsSlotHasCard(const int slot)
{
	if (m_hDevHelper != nullptr)
	{
		long l_beginTime, l_endTime;
		SlotStatus status;
		l_beginTime = GetTickCountRVC();
		ErrorCodeEnum eErr = m_hDevHelper->QuerySlotsStatus(status, slot);
		l_endTime = GetTickCountRVC();
		

		if(eErr != Error_Succeed){
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W20")("IsSlotHasCard::QuerySlotsStatus, slot:%d, eErr:%s", slot, SpStrError(eErr));
			SetErrPackage("IsSlotHasCard::QuerySlotsStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus);
			AlarmDEC();
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime)("IsSlotHasCard::QuerySlotsStatus, slot:%d, status:%d", slot, status.status[slot]);
		}

		if (eErr == Error_Succeed && status.status[slot] == 1)
			return true;
	}
	return false;
}
void CCardIssuerFSM::AfterPreOnlineOnStore(ErrorCodeEnum err, const int slot)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;
	CSimpleStringA errMsg(true);

	if (err == Error_Param)//oilyang@20171201 暂时不会进这里了，根据郭丹说明，所有跨机操作优先把卡移回卡槽
	{
		ToRegistCaptureCardInfo();
		eErr = MachineMoveCardBackNotHold();
		if (eErr == Error_Succeed)
			m_cardPos = 2;
		else
			m_cardPos = 3;
	}
	else
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->MoveCardToSlot(slot);
		l_endTime = GetTickCountRVC();
		
		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime)("AfterPreOnlineOnStore::MoveCardToSlot, slot:%d", slot);
			LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardToSlot, "AfterPreOnlineOnStore MoveCardToSlot suc.");
			m_cardPos = 1;
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W03")("AfterPreOnlineOnStore::MoveCardToSlot, slot:%d , err=%s", slot, SpStrError(eErr));
			bool bTrans = true;
			errMsg = CSimpleStringA::Format("AfterPreOnlineOnStore::MoveCardToSlot(slot:%d)", slot);
			SetErrPackage(errMsg, m_csDevSN, eErr, TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardToSlot, bTrans));
			AlarmDEC();

			ToRegistCaptureCardInfo();
			eErr = MachineMoveCardBackNotHold();
			if (eErr == Error_Succeed)
				m_cardPos = 2;
			else
				m_cardPos = 3;
		}
	}
	GetEntityBase()->GetFunction()->SetSysVar("CardStoreInUse", "N");//设置卡槽使用状态为N
}

bool CCardIssuerFSM::OperateCardStore(CSmartPointer<IConfigInfo>& spConfigRun, int slot, int& status)
{
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCardFromSlot(slot);
	l_endTime = GetTickCountRVC();
	
	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardFromSlot").setCostTime(l_endTime - l_beginTime)("OperateCardStore::MoveCardFromSlot, slot:%d", slot);
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardFromSlot, "OperateCardStore MoveCardFromSlot suc.");
		CardNo card;
		ZeroMemory(card.account, sizeof(card.account));
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReadAccount(card);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime)("OperateCardStore::ReadAccount");
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W05")("OperateCardStore::ReadAccount err=%s", SpStrError(eErr));
			SetErrPackage("OperateCardStore::ReadAccount", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReadAccount);
			AlarmDEC();
		}

		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_ReadAccount_Cost_Time, CSimpleStringA::Format("{\"cost\":%d}", l_endTime - l_beginTime));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("OperateCardStore::ReadAccount, dwSize:%d, t2Size:%d, t3Size:%d,eErr:%d",
			card.dwSize, card.dwTrack2Size, card.dwTrack3Size, eErr);

		bool bDataOK = true;
		//读卡成功并解析出卡序号，才算成功，卡序号也要返回
		if (eErr == Error_Succeed && card.dwSize > 0 && card.dwSize < 64)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("read account OK.");
			//oilyang@20201217 if only ic 
			if (card.dwTrack3Size == 2)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("maybe only ic card.");
				m_addCardSerial = (const char*)card.track3;
			}
			else
			{
				Track2Data track2Data;
				track2Data.status = 0;
				track2Data.t2Account = "";
				char* tmpMag2 = new char[256];
				ZeroMemory(tmpMag2, 256);
				bool bT2OK = false, bT3OK = false;
				if (card.dwTrack2Size > 0 && card.dwTrack2Size < 41)
				{
					//IC卡等效二磁道数据可能存在补F的情况(参考oilyang@20171129)
					if (card.track2[card.dwTrack2Size - 1] == 'F')
					{
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("track2 has F in the end");
						card.track2[card.dwTrack2Size - 1] = '\0';
						card.dwTrack2Size--;
					}
					bT2OK = true;
				}
				if (card.dwTrack3Size > 0 && card.dwTrack3Size < 150)
					bT3OK = true;
				DecodeTracksData(card.track2, card.dwTrack2Size, card.track3, card.dwTrack3Size, tmpMag2, bT2OK, bT3OK);
				if (SplitTrack2(tmpMag2, track2Data) == 0)
				{
					m_addCardSerial = track2Data.t2CardSerial;
				}
			}
			m_currCardNo = card.account;

			if (card.dwSize > 6)
			{
				string xTestStr(card.account);
				LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_CardBin, CSimpleStringA::Format("cardBin:%s****%s", xTestStr.substr(0, 6).c_str(), xTestStr.substr(card.dwSize - 4, 4).c_str()));
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("card.account:%d, card serial %s", m_currCardNo.GetLength(), m_addCardSerial.GetData());
			if (m_addCardSerial.GetLength() <= 0)
				bDataOK = false;
		}
		else
		{
			bDataOK = false;
		}
		if (!bDataOK)
		{
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_Operate_ReadFailed, "OperateCardStore::ReadAccount failed, to capture card.");
			status = 2;
			ToRegistCaptureCardInfo();
			eErr = MachineMoveCardBackNotHold();
		}
		else
		{
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->MoveCardToSlot(slot);
			l_endTime = GetTickCountRVC();
			

			if (eErr == Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime)("OperateCardStore::MoveCardToSlot, slot:%d", slot);
				LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardToSlot, "OperateCardStore MoveCardToSlot suc.");
				if (WriteCardInfo(spConfigRun, m_currCardNo, m_addCardSerial, slot, false, true))
				{
					spConfigRun->WriteConfigValueInt("OperateCardStore", "SlotNum", slot);//记录已盘库到哪个槽
					status = 0;
					return true;
				}
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("operate slot(%d) success, but write card info to cardissuer.ini failed.", slot);
				}
			}
			else
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W03")("OperateCardStore::MoveCardToSlot, slot:%d , err=%s", slot, SpStrError(eErr));
				//移回卡槽不成功，登记并吞卡
				bool bTrans = true;
				errMsg = CSimpleStringA::Format("OperateCardStore::MoveCardToSlot(slot:%d)", slot);
				SetErrPackage(errMsg, m_csDevSN, eErr, TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardToSlot, bTrans));
				AlarmDEC();
				status = 3;
				ToRegistCaptureCardInfo();
				MachineMoveCardBackNotHold();
			}
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardFromSlot").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W04")("OperateCardStore::MoveCardFromSlot, slot:%d , err=%s", slot, SpStrError(eErr));
		bool bTrans = true;
		SetErrPackage("OperateCardStore::MoveCardFromSlot", m_csDevSN, eErr, TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot, bTrans));
		AlarmDEC();
		status = 1;
	}
	return false;
}

int CCardIssuerFSM::QueryCardInfoOnStore(SpReqAnsContext<CardIssuerStoreService_QueryCardInfoOnStore_Req, CardIssuerStoreService_QueryCardInfoOnStore_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	long l_beginTime, l_endTime;
	CSimpleStringA cardInfo("");

	if(!ctx->Req.reserved1)
	{
		//原有业务
		ctx->Ans.findCard = m_findCard;
		ctx->Ans.cardPos = m_cardPos;
		cardInfo = CSimpleStringA::Format("query findCard:%d,cardPos:%d",ctx->Ans.findCard,ctx->Ans.cardPos);
		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_QueryCardInfoOnStore_JustQueryInfo, cardInfo.GetData());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<QueryCardInfoOnStore>, query findCard:%d, cardPos:%d",ctx->Ans.findCard,ctx->Ans.cardPos);
		ctx->Answer(Error_Succeed);
		return 2;
	}
	else
	{
		//新增盘库操作@20190422 by zjw
		ErrorCodeEnum eErr = Error_Unexpect;
		bool bRet;
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if(eErr != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<QueryCardInfoOnStore>, Open runcfg failed(%d).", eErr);
			ctx->Answer(Error_Unexpect);
			return 2;
		}

		//开始盘库
		CSimpleStringA errMsg = CSimpleStringA::Format("<QueryCardInfoOnStore>, req.reserved[0]:%d", ctx->Req.reserved1[0]);
		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_QueryCardInfoOnStore_Inparam, errMsg.GetData());
		if(ctx->Req.reserved1[0] == 1)
		{
			//检查是否有旧的盘库记录，若有，则返回给业务确定继续盘库or终止盘库；若无，则进行正常盘库
			if(CheckHasPanKuRecord(spConfigRun))
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Has operation cardstore record, please make sure continue or break!");
				ctx->Answer(Error_Param, CardIssuerStore_UserErrorCode_KakuHaveOldPanKuRecord);
				return 2;
			}
			
			//如果没有旧的盘库操作，则重新开始盘库（先清理本地记录）
			ClearLocalRecord(spConfigRun);
			SlotStatus slotstatus;
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->QuerySlotsStatus(slotstatus, 0, true);
			l_endTime = GetTickCountRVC();

			if(eErr != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W20")("QueryCardInfoOnStore::QuerySlotsStatus reserved1=1, err=%s",SpStrError(eErr));
				SetErrPackage("QueryCardInfoOnStore::QuerySlotsStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus);
				ctx->Answer(TransECWithRepeat(Error_Unexpect),AlarmDEC());
				return 2;
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime)("QueryCardInfoOnStore::QuerySlotsStatus reserved1=1");
			}
			spConfigRun->WriteConfigValueInt("OperateCardStore", "OperationFlag", 1);//设置盘库标志
			int i = 0;
			int status = 0;

			for (; i < m_maxSlot; ++i)
			{
				if(slotstatus.status[i] == 1)
				{
					bRet = OperateCardStore(spConfigRun, i, status);
					if(!bRet)
						break;
				}
				else
				{
					//该卡槽无卡
					WriteCardInfo(spConfigRun, "", "", i);
				}
			}
			//将卡信息返回给业务端
			ReturnCardInfo(i, status, spConfigRun, ctx);
		}
		else if(ctx->Req.reserved1[0] == 2)
		{
			//有旧的盘库记录，继续接着盘库
			SlotStatus slotstatus;
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->QuerySlotsStatus(slotstatus,0,true);
			l_endTime = GetTickCountRVC();

			if (eErr != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W20")("QueryCardInfoOnStore::QuerySlotsStatus reserved1=2, err=%s", SpStrError(eErr));
				SetErrPackage("QueryCardInfoOnStore::QuerySlotsStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus);
				AlarmDEC();
				ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuQuerySlot_Failed);
				return 2;
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime)("QueryCardInfoOnStore::QuerySlotsStatus reserved1=2");
			}

			int slotNum;
			spConfigRun->ReadConfigValueInt("OperateCardStore", "SlotNum", slotNum);
			if(slotNum >= 0)
			{
				int status = 0;
				int i = slotNum;

				for(; i < m_maxSlot; ++i)
				{
					if(slotstatus.status[i] == 1)
					{
						bRet = OperateCardStore(spConfigRun, i, status);
						if(!bRet)
							break;
					}
					else
					{
						//该卡槽无卡
						WriteCardInfo(spConfigRun, "", "", i);
					}
				}
				//将卡信息返回给业务端
				ReturnCardInfo(i, status, spConfigRun, ctx);
			}
			else
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("No operate cardstore record, please make sure!");
				ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuHaveNoPanKuRecord);
			}
		}
		else if(ctx->Req.reserved1[0] == 3)
		{
			//有旧的盘库记录，终止盘库(清空本地记录)
			ClearLocalRecord(spConfigRun);
			ctx->Answer(Error_Succeed);
		}
		else if(ctx->Req.reserved1[0] = 4)
		{
			//查询是否有盘库记录
			if(CheckHasPanKuRecord(spConfigRun))
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Has operation cardstore record!");
				ctx->Ans.findCard = 1;
				ctx->Answer(Error_Succeed);
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Has no operation cardstore record!");
				ClearLocalRecord(spConfigRun);
				ctx->Ans.findCard = 0;
				ctx->Answer(Error_Succeed);
			}
		}
	}
	return 2;
}

bool CCardIssuerFSM::CheckHasPanKuRecord(CSmartPointer<IConfigInfo>&spConfigRun)
{
	int operFlag, slotNum;
	spConfigRun->ReadConfigValueInt("OperateCardStore", "OperationFlag", operFlag);
	spConfigRun->ReadConfigValueInt("OperateCardStore", "SlotNum", slotNum);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<CheckHasPanKuRecord>, operFlag:%d, slotNum:%d", operFlag, slotNum);
	if(operFlag == 1 && slotNum >= 0)
	{
		return true;
	}
	return false;
}

void CCardIssuerFSM::ClearLocalRecord(CSmartPointer<IConfigInfo>&spConfigRun)
{
	spConfigRun->WriteConfigValueInt("OperateCardStore", "OperationFlag", 0);
	spConfigRun->WriteConfigValueInt("OperateCardStore", "SlotNum", -1);
	for (int i = 0; i < m_maxSlot; ++i)
	{
		WriteCardInfo(spConfigRun, "", "", i, true);
	}
}

void CCardIssuerFSM::ReturnCardInfo(int slotNum, int status, CSmartPointer<IConfigInfo>&spConfigRun, SpReqAnsContext<CardIssuerStoreService_QueryCardInfoOnStore_Req, CardIssuerStoreService_QueryCardInfoOnStore_Ans>::Pointer ctx)
{
	bool bRet;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<ReturnCardInfo>, slotNum:%d, status:%d", slotNum, status);

	if(slotNum == m_maxSlot && status == 0)
	{
		ctx->Ans.reserved1.Init(1);
		ctx->Ans.reserved3.Init(m_maxSlot);
		ctx->Ans.reserved4.Init(m_maxSlot);
		for (int i = 0; i < m_maxSlot; ++i)
		{
			CSimpleStringA csAcc("");
			CSimpleStringA serial("");
			bRet = ReadCardInfo(spConfigRun, csAcc, serial, i);
			if(bRet)
			{
				ctx->Ans.reserved3[i] = csAcc;
				ctx->Ans.reserved4[i] = serial;
			}
			else
			{
				ctx->Ans.reserved3[i] = "0";
				ctx->Ans.reserved4[i] = "0";
			}
		}
		ctx->Ans.reserved1[0] = m_maxSlot;

		//返回完成，清空本地记录
		spConfigRun->WriteConfigValueInt("OperateCardStore", "OperationFlag", 0);
		spConfigRun->WriteConfigValueInt("OperateCardStore", "SlotNum", -1);
		for (int i = 0; i < m_maxSlot; ++i)
		{
			WriteCardInfo(spConfigRun, "", "", i, true);
		}
		ctx->Answer(Error_Succeed);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("operate cardstore failed in slot(%d).", slotNum);
		ctx->Ans.reserved1.Init(2);
		ctx->Ans.reserved1[0] = slotNum;
		ctx->Ans.reserved1[1] = status;
		//根据返回值返回不同的错误码
		if (status == 1) {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_MoveCardFromSlot_Failed);
		}
		else if (status == 2) {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_ReadAccount_Failed);
		}
		else if (status == 3) {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_MoveCardToSlot_Failed);
		}
		else {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_Failed);
		}
		//ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_Failed);
	}
	return;
}

void CCardIssuerFSM::GetAddCardInfo(SpReqAnsContext<CardIssuerStoreService_GetAddCardInfo_Req, CardIssuerStoreService_GetAddCardInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	long l_beginTime, l_endTime;

	if(!ctx->Req.reserved1)
	{
		//原有业务
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<GetAddCardInfo>, req.reserved1 is null, just get AddCAradInfo, req.isSync:%d", ctx->Req.isSync);
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if (eErr != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<GetAddCardInfo>, open runcfg failed:%d(0x%x)", eErr, eErr);
			ctx->Answer(Error_Unexpect);
			return;
		}

		ctx->Ans.count = 0;
		CSimpleStringA csAcc(""), csCardSerial("");
		int hasCard = 0;
		bool bRet = false;
		
		if (ctx->Req.isSync == 1)//clear local record
		{
			for (int i = 0; i < m_maxSlot; i++)
			{
				bRet = ReadSlotInfo(spConfigRun, csAcc, csCardSerial, i, hasCard);
				if (bRet)
					WriteSlotInfo(spConfigRun, "", "", i, true);
			}
			spConfigRun->WriteConfigValueInt("SlotInfo", "count",0);
			ctx->Answer(Error_Succeed);
			return;
		}
		int sum = 0;
		spConfigRun->ReadConfigValueInt("SlotInfo", "count", sum);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<GetAddCardInfo>, add card num:%d", sum);

		if (sum > 0)
		{
			for (int i = 0; i < m_maxSlot; i++)
			{
				bRet = ReadSlotInfo(spConfigRun, csAcc, csCardSerial, i, hasCard);
				if (bRet)
				{
					ctx->Ans.account.Append(&csAcc, 0, 1);
					ctx->Ans.cardSerial.Append(&csCardSerial, 0, 1);
					ctx->Ans.slot.Append(&i, 0, 1);
				}
			}
			ctx->Ans.count = ctx->Ans.account.GetCount();
			if (ctx->Ans.count != sum)
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<GetAddCardInfo>, actual added card num is:%d, not equals to the runinfo:%d.", ctx->Ans.count, sum);
		}
	}
	else if(ctx->Req.reserved1[0] == 1)
	{
		ctx->Ans.reserved1.Init(1);
		//获取卡库总容量
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<GetAddCardInfo>, CardStore account is:%d", m_maxSlot);
		if(m_maxSlot > 0)
		{
			ctx->Ans.reserved1[0] = m_maxSlot;
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CardStore account is less zero.");
		}

		//卡库数量盘点
		int numOfHasCard = 0;
		vector<int> slotNoOfHasCard;
		SlotStatus slotstatus;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->QuerySlotsStatus(slotstatus,0,true);
		l_endTime = GetTickCountRVC();
		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime)("GetAddCardInfo::QuerySlotsStatus");
			for(int i = 0; i < m_maxSlot; ++i)
			{
				if(slotstatus.status[i] == 1)
				{
					slotNoOfHasCard.push_back(i);
					numOfHasCard++;
				}
			}
			CSimpleStringA cardInfo = CSimpleStringA::Format("num of card in cardstore: %d.", numOfHasCard);
			LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_GetAddCardInfo_CardCount, cardInfo.GetData());
			ctx->Ans.reserved2.Init(numOfHasCard + 1);
			ctx->Ans.reserved2[0] = numOfHasCard;
			for(int j = 0; j < numOfHasCard; ++j)
			{
				ctx->Ans.reserved2[j+1] = slotNoOfHasCard[j];
			}
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W20")("GetAddCardInfo::QuerySlotsStatus, err=%s", SpStrError(eErr));
			SetErrPackage("GetAddCardInfo::QuerySlotsStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus);
			AlarmDEC();
		}
	}

	ctx->Answer(Error_Succeed);
	return;
}
void CCardIssuerFSM::DecodeTracksData(const char *track2, DWORD dwT2size, const char *track3, DWORD dwT3size, char *&magData, bool bT2OK, bool bT3OK)
{
	DbgWithLink(LOG_LEVEL_INFO, 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)("<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)("<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_INFO, LOG_TYPE_SYSTEM)("<DecodeTracksData>，cardType:%s", cardType);

	if (!bT3OK || strlen(cardType) < 4)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<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_WARN, LOG_TYPE_SYSTEM)("<SplitDevModelInfo>, Wrong szModel:%s", m_devCat.szModel);
		return -1;
	}
	m_csCM = "";
	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], "CM", 2) == 0)
		{
			m_csCM = arrParam[i].SubString(3, arrParam[i].GetLength() - 3);
		}
		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());
		}
	}
	return 0;
}

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

int CCardIssuerFSM::PrintCardIm(SpReqAnsContext<CardIssuerStoreService_PrintCardImmediately_Req, CardIssuerStoreService_PrintCardImmediately_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	int ret = 0;
	KakuPrintInfo kakuInfo;
	memset(kakuInfo.formPath, 0, sizeof(kakuInfo.formPath));
	memset(kakuInfo.fields, 0, sizeof(kakuInfo.fields));
	//oiltest where is the file locate?
	CSimpleStringA csDepPath, csBackslash("\\"), filePath;
	ErrorCodeEnum eErrPath = GetEntityBase()->GetFunction()->GetPath("Dep", csDepPath);
	filePath = csDepPath + csBackslash + m_devCat.szVendor + "-" + ctx->Req.formFile;
	strncpy(kakuInfo.formPath,(const char*)filePath, filePath.GetLength());
	strncpy(kakuInfo.fields, (const char*)ctx->Req.printData, ctx->Req.printData.GetLength());
	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->PrintCardFaceRightNow(kakuInfo);
	l_endTime = GetTickCountRVC();

	

	if (eErr != Error_Succeed)
	{
		SetErrPackage("PrintCardIm::PrintCardFaceRightNow", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_PrintCardFaceRightNow);
		if (IsInBusiness())
		{
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode("QLR040222031").setResultCode("RTA2W25").setAPI("DevAdapter::PrintCardFaceRightNow").setCostTime(l_endTime - l_beginTime)("PrintCardFaceRightNow failed.");
			AlarmDEC(true);
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222031").setResultCode("RTA2W25").setAPI("DevAdapter::PrintCardFaceRightNow").setCostTime(l_endTime - l_beginTime)("PrintCardFaceRightNow failed.");
			AlarmDEC();
		}
		ret = 1;
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_PrintCardFaceRightNow, "PrintCardFaceRightNow fail.");
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::PrintCardFaceRightNow").setCostTime(l_endTime - l_beginTime)("PrintCardIm::PrintCardFaceRightNow, formPath:%s", kakuInfo.formPath);
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_PrintCardFaceRightNow, "PrintCardFaceRightNow succ.");
	}
	
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222031")();
	ctx->Ans.ret = ret;
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::JudgeCardType(CSimpleStringA cardno, bool& bMismatch)
{
	if (cardno.GetLength() < 8)
		return 0;
	int cardType = 0;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);
	CQueryCardTypeReq qCardTypeReq;
	CQueryCardTypeRet qCardTypeRet;
	//qCardTypeReq.m_printDbg = true;//oiltest
	qCardTypeReq.m_timeOut = 3;//3 second

	qCardTypeReq.m_url = m_EacQueryHost.GetData();
	//qCardTypeReq.m_url = "http://55.13.170.50:8080/defa-gateway/dee1/EacQuery/queryByEac";
	qCardTypeReq.HEAD.xHdrLen = 203;
	qCardTypeReq.HEAD.xIsuCnl = "X86";
	qCardTypeReq.HEAD.xRtnCod = "SUC0000";
	qCardTypeReq.BODY.x1.xCltNbr = "";
	qCardTypeReq.BODY.x1.xEacNbr = cardno.GetData();
	qCardTypeReq.BODY.x1.xIacNbr = "";
	long beg = GetTickCountRVC();
	bool ret = client->Post(qCardTypeReq, qCardTypeRet);
	long end = GetTickCountRVC();
	if (ret)
	{
		bool bParse = qCardTypeRet.Parse(qCardTypeRet.m_resultData.c_str());
		if (bParse)
		{
			if (qCardTypeRet.BODY.z1.zPsbMdm.compare("C") == 0)
				cardType = 2;
			else if (qCardTypeRet.BODY.z1.zPsbMdm.compare("I") == 0)
				cardType = 3;
			else if (qCardTypeRet.BODY.z1.zPsbMdm.compare("M") == 0)
				cardType = 1;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Query card type from host is:%s,zPsbSeq:%s"
				, qCardTypeRet.BODY.z1.zPsbMdm.c_str(), qCardTypeRet.BODY.z1.zPsbSeq.c_str());
			int eacLen = qCardTypeRet.BODY.z1.zEacNbr.length();
			if (eacLen > 7 && cardno.Compare(qCardTypeRet.BODY.z1.zEacNbr.c_str()) != 0)
			{
				bMismatch = true;
				LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_Account_EAC_Mismatch,
					CSimpleStringA::Format("cardno:%s****%s EAC:%s****%s", cardno.SubString(0,6).GetData(), cardno.SubString(cardno.GetLength()-4, 4).GetData()
						, qCardTypeRet.BODY.z1.zEacNbr.substr(0, 6).c_str(), qCardTypeRet.BODY.z1.zEacNbr.substr(eacLen - 4, 4).c_str()));
			}
		}
		else
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Query card type return false:%s",qCardTypeRet.HEAD.xRtnCod.c_str());//也没必要知道什么错 oilyang@20220829 在功能可用之前，还是有必要的
	}
	else {
	}
	client->Destory();
	//oiltest for stupid http component!!!
	//if (cardno.IsStartWith("622580") || cardno.IsStartWith("622588") || cardno.IsStartWith("622609")
	//	|| cardno.IsStartWith("410062"))
	//	return 3;
	return cardType;
}
void CCardIssuerFSM::SetEnterMainPage()
{
	//设置运行时文件
	CSmartPointer<IConfigInfo> spConfig;
	int enterMainPageInt = 0;
	ErrorCodeEnum err = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfig);
	if (err != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("SetEnterMainPage, get cfg file failed ");
	}
	else {
		//新在，旧也在，新进入首页则不拷贝，否则重新拷贝
		spConfig->ReadConfigValueInt("all", "enterMainPage", enterMainPageInt);
		if (2 != enterMainPageInt) {
			spConfig->WriteConfigValueInt("all", "enterMainPage", 2);//进入首页
			LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_EnterMainPage_SetFlag, "CardIssuerStore enterMainPage set succ");
		}
	}
}

void CCardIssuerFSM::HttpsLogCallBack(const char* logtxt) {
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s", logtxt);
}
void CCardIssuerFSM::QueryCIStatus(SpReqAnsContext<CardIssuerStoreService_QueryCIStatus_Req, CardIssuerStoreService_QueryCIStatus_Ans>::Pointer ctx)
{
	if (m_hDevHelper == nullptr)
		ctx->Answer(Error_DevNotAvailable, CardIssuerStore_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) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2W22")("QueryCIStatus::GetDevStatus err=%s", SpStrError(errCode));
		SetErrPackage("QueryCiStatus::GetDevStatus", m_csDevSN, errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus);
		ctx->Answer(Error_Unexpect, AlarmDEC());
	}
	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(CSimpleStringA currCardNo)
{
	if (m_csSwallowCardUrl.IsNullOrEmpty())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222004").setResultCode("RTA2W0Z")("m_csSwallowCardUrl is empty. %s", m_csSwallowCardUrl.GetData());
		return false;
	}
	RegistCaptureCardInfoTask* task = NULL;
	if (!currCardNo.IsNullOrEmpty()) {
		task = new RegistCaptureCardInfoTask(this, currCardNo);
	}
	else {
		task = new RegistCaptureCardInfoTask(this, m_currCardNo);
	}
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	return true;
}
bool CCardIssuerFSM::IfUseRf()
{
	if (m_bStopUseRF)
		return false;

	//加入szmodel非接字段属性判断
	if (m_csRF.Compare("Y") == 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("szModel,RF=%s", m_csRF.GetData());
		return true;
	}	
	CAutoArray<CSimpleStringA> arr = m_rfVendorList.Split('|');
	//Dbg("%s,%d", m_rfVendorList.GetData(),arr.GetCount());
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", m_adapterInfo.adapterFilePath.GetData());
	for (int i = 0; i < arr.GetCount(); ++i)
	{
		if (m_adapterInfo.adapterFilePath.IndexOf(arr[i].GetData()) > 0) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s,%s", arr[i].GetData(), m_adapterInfo.adapterFilePath.GetData());
			return true;
		}	
	}
	return false;
}
CSimpleStringA CCardIssuerFSM::generateJsonString(std::map<std::string, JsonElem>& objectArr)
{
	if (objectArr.empty())
		return "";
	CSimpleStringA csRet("{");
	for (auto it = objectArr.begin(); it != objectArr.end(); it++)
	{
		if (it->second.type == 0)
			csRet += CSimpleStringA::Format("\"%s\":%d,", it->first.c_str(), it->second.iValue);
		else
			csRet += CSimpleStringA::Format("\"%s\":\"%s\",", it->first.c_str(), it->second.strValue.c_str());
	}
	csRet = csRet.SubString(0, csRet.GetLength() - 1);
	csRet += "}";
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("csRet:%s", csRet.GetData());
	return CSimpleStringA(csRet);
}

int CCardIssuerFSM::EjectJS(SpReqAnsContext<CardIssuerStoreService_EjectJS_Req, CardIssuerStoreService_EjectJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, 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();

	if (eErr != Error_Succeed) {
		if (IsInBusiness() && ctx != NULL ) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FRONT_GATE, "DevAdapter::MoveCard", __FUNCTION__, true, l_endTime - l_beginTime, "QLR040222042", "EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE) err");
		}
		else {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FRONT_GATE, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040222042", "EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE) err");
		}

		if (ctx != NULL) {
			ctx->Answer(Error_Unexpect, GetAlarmDEC());
		}
		return 1;//S9
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222042")("EjectCard, ret: %d", ret);
		//等待取卡
		DWORD dwStart, dwEnd;
		dwStart = GetTickCountRVC();
		LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_STORE_GREEN_ON, "CardReader(fetch) warning on");
		do {
			if (GetDevStatus(false)) {
				dwEnd = GetTickCountRVC();
				if (m_devStatus.eMedia == CI_MEDIA_ENTERING) {
					Sleep(WAIT_INTERVAL);
				}
				else {
					long l_beginTime, l_endTime;
					l_beginTime = GetTickCountRVC();
					ErrorCodeEnum eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
					l_endTime = GetTickCountRVC();


					if (eErr != Error_Succeed) {
						SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040222042", "EjectJS::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN) err");
					}
					else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("EjectJS::SetCardInType");
					}

					LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_STORE_GREEN_OFF, "CardReader(fetch) warning off");
					if (ctx != NULL) {
						ctx->Answer(Error_Succeed);
					}
					return 0;//成功取走
				}
			}
			else
			{
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_STORE_GREEN_OFF, "CardReader(fetch) warning off");
				if (ctx != NULL)
				{
					ctx->Answer(Error_Unexpect, 0x22000002);
				}
				return 1;//S9
			}
		} while ((dwEnd - dwStart) < 60 * 1000);

		LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_STORE_GREEN_OFF, "CardReader(fetch) warning off");
		if (ctx != NULL) {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Customer_Forget_Fectch_Card);
		}
		return 2;//超时未取卡
	}

}

int CCardIssuerFSM::CaptureJS(SpReqAnsContext<CardIssuerStoreService_CaptureJS_Req, CardIssuerStoreService_CaptureJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("吞卡开始");
	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, CardIssuerStore_UserErrorCode_CaptureCard_FromBusiness, CSimpleStringA::Format("CaptureCard called from Business. captureReason=%s", m_captureReason.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).setLogCode(CardIssuerStoreService_LogCode_Capture).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("CaptureJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD)");

		if (ctx != NULL) {
			ToRegistCaptureCardInfo(ctx->Req.cardNo);
		}
		else {
			ToRegistCaptureCardInfo();
		}
		m_currCardNo = m_addCardNo = "";

		l_beginTime = GetTickCountRVC();
		ErrorCodeEnum eErrSet = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		l_endTime = GetTickCountRVC();

		if (eErrSet != Error_Succeed) {
			SetErrorAndLog(eErrSet, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040222043", "CaptureJS::SetCardInType err");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("CaptureJS::SetCardInType");
		}
	}
	else {
		if (ctx != NULL && IsInBusiness()) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD, "DevAdapter::MoveCard", __FUNCTION__, true, l_endTime - l_beginTime, "QLR040222043", "CaptureJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD) err");
		}
		else {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040222043", "CaptureJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD) err");
		}
		ret = 1;
	}

	m_CardCaptured++;
	if (!SetCardCaptured(m_CardCaptured))
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<CaptureJS>, set card captured failed");
	

	//业务返回
	if (ctx != NULL) {
		if (Error_Succeed == eErr) {
			ctx->Answer(Error_Succeed);
		}
		else {
			ctx->Answer(Error_Unexpect, GetAlarmDEC());
		}
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CapturedJS, ret:%d", ret);
	return ret;
}

int CCardIssuerFSM::ReadBatchCardInfoInRangeJS(SpReqAnsContext<CardIssuerStoreService_ReadBatchCardInfoInRangeJS_Req, CardIssuerStoreService_ReadBatchCardInfoInRangeJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("区间盘库开始");
	long l_beginTime, l_endTime;
	CSimpleStringA cardInfo("");
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<ReadBatchCardInfoInRangeJS>, beginSlot=%d, endSlot=%d", ctx->Req.beginSlot, ctx->Req.endSlot);
	//新模式盘库
	if (m_maxSlot == 0) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<ReadBatchCardInfoInRangeJS>, m_maxSlot=0 is wrong");
		ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_QueryCardInfoOnStore_Inparam);
		return 0;
	}
	if (ctx->Req.beginSlot > m_maxSlot || ctx->Req.beginSlot < 0 || ctx->Req.endSlot< 0 || ctx->Req.beginSlot > ctx->Req.endSlot) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<ReadBatchCardInfoInRangeJS>, slot param is wrong");
		ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_QueryCardInfoOnStore_Inparam);
		return 0;
	}
	SlotStatus slotstatus;
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->QuerySlotsStatus(slotstatus, 0, true);
	l_endTime = GetTickCountRVC();

	if (eErr != Error_Succeed)
	{
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus, "DevAdapter::QuerySlotsStatus", __FUNCTION__, false, l_endTime - l_beginTime, "QLR0402220100", "ReadBatchCardInfoInRangeJS::QuerySlotsStatus err");
		ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuQuerySlot_Failed);
		return 0;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime)("ReadBatchCardInfoInRangeJS::QuerySlotsStatus");
	}

	FSMSetIssueFlag(1);
	int beginSlot = ctx->Req.beginSlot;
	int endSlot = ctx->Req.endSlot;
	//判断最大截止卡槽号
	if (endSlot > m_maxSlot-1) {
		endSlot = m_maxSlot-1;
	}
	int status = 0;
	list<AddCardInfo> addCardInfoList;
	CSimpleStringA addCardNo;
	CSimpleStringA addCardSerial;
	int slotNum = 0;//盘库位置
	bool bRet;
	for (int i = beginSlot; i <= endSlot; i++) {
		slotNum = i;
		if (slotstatus.status[i] == 1)
		{
			bRet = OperateNewCardStore(i, addCardNo, addCardSerial, status);
			if (!bRet) {
				break;
			}
			else {
				AddCardInfo aci;
				aci.slot = i;
				aci.addCardNo = addCardNo.GetData();
				aci.addCardSerial = addCardSerial.GetData();
				addCardInfoList.push_back(aci);
				//加入盘库记录
			}
		}
		else
		{
			//该卡槽无卡，加入盘库记录
			AddCardInfo aci;
			aci.slot = i;
			aci.addCardNo = "0";
			aci.addCardSerial = "0";
			addCardInfoList.push_back(aci);
		}
	}
	//返回盘库记录
	if (slotNum == endSlot && status == 0) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("operate cardStore succ in slot(%d).", slotNum);
		ctx->Ans.status = status;
		ctx->Ans.slotNum.Init(endSlot - beginSlot + 1);
		ctx->Ans.cardNo.Init(endSlot - beginSlot + 1);
		ctx->Ans.cardSerial.Init(endSlot - beginSlot + 1);

		int j = 0;
		for (list<AddCardInfo>::iterator it = addCardInfoList.begin(); it != addCardInfoList.end(); ++it) {
			AddCardInfo cardInfo = *it;
			ctx->Ans.slotNum[j] = cardInfo.slot;
			ctx->Ans.cardNo[j] = cardInfo.addCardNo.c_str();
			ctx->Ans.cardSerial[j] = cardInfo.addCardSerial.c_str();
			j++;
		}
		ctx->Answer(Error_Succeed);
	}
	else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("operate cardStore failed in slot(%d).status(%d)", slotNum,status);
		ctx->Ans.status = status;
		//根据返回值返回不同的错误码
		if (status == 1) {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_MoveCardFromSlot_Failed);
		}
		else if (status == 2) {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_ReadAccount_Failed);
		}
		else if (status == 3) {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_MoveCardToSlot_Failed);
		}
		else if (status == 21) {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_ReadAccount_Capture_Failed);
			return 1;
		}else if (status == 31) {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_MoveCardToSlot_Capture_Failed);
			return 1;
		}else {
			ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_KakuPanKu_Failed);
		}
	}
	return 0;
}

int CCardIssuerFSM::GetCardInStoreJS(SpReqAnsContext<CardIssuerStoreService_GetCardInStoreJS_Req, CardIssuerStoreService_GetCardInStoreJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("查询卡库容量及卡槽状态开始");
	long l_beginTime, l_endTime;

	//卡库数量盘点
	int numOfHasCard = 0;
	vector<int> slotNoOfHasCard;
	SlotStatus slotstatus;
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->QuerySlotsStatus(slotstatus, 0, true);
	l_endTime = GetTickCountRVC();
	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetSlotSum").setCostTime(l_endTime - l_beginTime)("<GetCardInStoreJS>, CardStore slot num is:%d", slotstatus.dwSize);
		if (slotstatus.dwSize > 0)
		{
			ctx->Ans.slotSum = slotstatus.dwSize;
		}
		else
		{
			ctx->Ans.slotSum = 0;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<GetCardInStoreJS>, CardStore slot num is zero.");
		}

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::QuerySlotsStatus").setCostTime(l_endTime - l_beginTime)("GetCardInStoreJS::QuerySlotsStatus");

		ctx->Ans.hasCardSlotNum.Init(slotstatus.dwSize);
		for (int i = 0; i < slotstatus.dwSize; ++i)
		{
			if (slotstatus.status[i] == 1)
			{
				slotNoOfHasCard.push_back(i);
				ctx->Ans.hasCardSlotNum[i] = 1;
				numOfHasCard++;
			}
			else {
				ctx->Ans.hasCardSlotNum[i] = 0;
			}
		}
		CSimpleStringA cardInfo = CSimpleStringA::Format("num of card in cardStore: %d.", numOfHasCard);
		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_GetAddCardInfo_CardCount, cardInfo.GetData());
		ctx->Ans.slotHasCardCount = numOfHasCard;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus, "DevAdapter::QuerySlotsStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "GetCardInStoreJS::QuerySlotsStatus err");
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
	}
	return 0;
}

int CCardIssuerFSM::AddAndReadCardFromBoxJS(SpReqAnsContext<CardIssuerStoreService_AddAndReadCardFromBoxJS_Req, CardIssuerStoreService_AddAndReadCardFromBoxJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("加卡箱加卡开始");
	m_mapJsonErr.clear();
	FSMSetIssueFlag(1);

	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;
	CSimpleStringA readCardNo = "";
	LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_AddCardToStoreStepFirst, "AddAndReadCardFromBoxJS");
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCard(CI_MOVECARD_FROM_HOPPER, 99);
	l_endTime = GetTickCountRVC();

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AddAndReadCardFromBoxJS::MoveCard, CI_MOVECARD_FROM_HOPPER,99");

	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("AddAndReadCardFromBoxJS::MoveCard");
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCard_FromHopper, "MoveCard from hopper succ.");
		CardNo card;
		memset(&card, 0, sizeof(card));

		m_mapJsonErr["cardNo"] = JsonElem("");
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReadAccount(card);
		l_endTime = GetTickCountRVC();

		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_ReadAccount_Cost_Time, CSimpleStringA::Format("{\"cost\":%d}", l_endTime - l_beginTime));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AddAndReadCardFromBoxJS, dwSize:%d, t2dwSize:%d, t3dwSize:%d",
			card.dwSize, card.dwTrack2Size, card.dwTrack3Size);

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime)("AddAndReadCardFromBoxJS::ReadAccount");
			ctx->Ans.cardNo = card.account;
			ctx->Ans.track2 = card.track2;
			ctx->Ans.track3 = card.track3;
			if (card.dwTrack3Size == 2)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("maybe only IC card.");

			}
			m_currCardNo = m_addCardNo  = readCardNo = card.account;
			CSimpleStringA maskCardno = MaskCardno(readCardNo.GetData());
			LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_CardBin, CSimpleStringA::Format("cardBin:%s", maskCardno.GetData()));

			ctx->Answer(Error_Succeed);
			return 0;//跳到S4

			////oilyang@20171213 是否读卡失败，是否解析出卡序号，否则吞卡 @宋锐
			//if (eErr == Error_Succeed && card.dwSize > 0 && card.dwSize < 64)
			//{
			//	//oilyang@20201217 if only ic 
			//	if (card.dwTrack3Size == 2)
			//	{
			//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("maybe only ic card.");
			//		ctx->Ans.= m_addCardSerial = (const char*)card.track3;
			//		m_mapJsonErr["cardSerial"] = JsonElem(ctx->Ans.reserved2[1].GetData());
			//	}
			//	else
			//	{
			//		Track2Data track2Data;
			//		track2Data.status = 0;
			//		track2Data.t2Account = "";
			//		char* tmpMag2 = new char[256];
			//		ZeroMemory(tmpMag2, 256);
			//		bool bT2OK = false, bT3OK = false;
			//		if (card.dwTrack2Size > 0 && card.dwTrack2Size < 41)
			//		{
			//			//oilyang@20171129 IC card track2 maybe has 'F' in the end
			//			if (card.track2[card.dwTrack2Size - 1] == 'F')
			//			{
			//				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("track2 has F in the end.");
			//				card.track2[card.dwTrack2Size - 1] = '\0';
			//				card.dwTrack2Size--;
			//			}
			//			bT2OK = true;
			//		}
			//		if (card.dwTrack3Size > 0 && card.dwTrack3Size < 150)
			//			bT3OK = true;
			//		DecodeTracksData(card.track2, card.dwTrack2Size, card.track3, card.dwTrack3Size, tmpMag2, bT2OK, bT3OK);
			//		if (SplitTrack2(tmpMag2, track2Data) == 0)
			//		{
			//			ctx->Ans.reserved2[1] = track2Data.t2CardSerial;
			//			m_mapJsonErr["cardSerial"] = JsonElem(ctx->Ans.reserved2[1].GetData());
			//			m_addCardSerial = track2Data.t2CardSerial;
			//		}
			//	}
			//	ctx->Ans.reserved1[2] = 0;//oiltmp what's this?
			//	m_currCardNo = m_addCardNo = ctx->Ans.reserved2[0] = CSimpleStringA(card.account, card.dwSize);
			//	if (card.dwSize > 6)
			//	{
			//		string xTestStr(card.account);
			//		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_CardBin, CSimpleStringA::Format("cardBin:%s****%s", xTestStr.substr(0, 6).c_str(), xTestStr.substr(card.dwSize - 4, 4).c_str()));
			//	}
			//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<AddCardToStoreStepFirst>,cardAccount len:%d, CardSerial:%s", m_currCardNo.GetLength(), m_addCardSerial.GetData());
			//	if (m_addCardSerial.GetLength() > 0)
			//	{
			//		ctx->Answer(Error_Succeed);
			//	}
			//}
			//else {
			//	//异常情况报错
			//}
			
		}
		else {
			//读卡失败
			bool bTrans = true;
			DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, CardIssuerStore_UserErrorCode_CaptureCard_AddCard_ReadFailed, bTrans);
			SetErrorAndLog(eErr, dwTmpUserErrCode, "DevAdapter::ReadAccount", __FUNCTION__, false, l_endTime - l_beginTime, "QLR0402220102", "AddAndReadCardFromBoxJS::ReadAccount err");
			m_mapJsonErr["tips"] = JsonElem("[RTA9999] 读卡失败，请联系卡库厂商排查");
			m_mapJsonErr["cardResult"] = JsonElem(CardResult_ReadAccount_Fail);
			m_mapJsonErr["cardPos"] = JsonElem(CardPos_HaveCapturedCard);
			m_mapJsonErr["userCode"] = JsonElem(dwTmpUserErrCode);
			ToRegistCaptureCardInfo();
			eErr = MachineMoveCardBackNotHold();
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("oiltest retStr:%s", generateJsonString(m_mapJsonErr).GetData());
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
			if (eErr == Error_Succeed) {
				return 1;//跳到S2
			}
			else {
				return 2;//跳到S9
			}
		}
	}
	else
	{
		//移卡失败
		bool bTrans = true;
		DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCard, bTrans);
		if (dwTmpUserErrCode == CardIssuerStore_UserErrorCode_Dev_HopperHasNoCard) {
			m_mapJsonErr["tips"] = JsonElem("[RTA2W80] 卡箱无卡，请确认卡箱有无卡片或卡片是否放好");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AddAndReadCardFromBoxJS::MoveCard, Hopper has no card");
		}else{
			m_mapJsonErr["tips"] = JsonElem("[RTA9999] 从加卡箱移卡失败，请联系卡库厂商排查");
			SetErrorAndLog(eErr, dwTmpUserErrCode, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR0402220102", "AddAndReadCardFromBoxJS::MoveCard err");
		}
		if (!bTrans) {//兼容未做卡库api返回故障码细化改造的卡库厂商
			dwTmpUserErrCode = CardIssuerStore_UserErrorCode_Dev_HopperHasNoCard;
		}
		m_mapJsonErr["cardResult"] = JsonElem(CardResult_MoveToCardReader_Fail);
		m_mapJsonErr["userCode"] = JsonElem(dwTmpUserErrCode);

		ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
		return 1;//跳到S2
	}
}

int CCardIssuerFSM::MoveAndReadCardFromSlotJS(SpReqAnsContext<CardIssuerStoreService_MoveAndReadCardFromSlotJS_Req, CardIssuerStoreService_MoveAndReadCardFromSlotJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("卡库卡槽移卡读卡开始");
	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;
	CSimpleStringA readCardNo = "";
	m_mapJsonErr.clear();
	errMsg = CSimpleStringA::Format("<MoveAndReadCardFromSlotJS>, slot:%d", ctx->Req.slot);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_IssueCardFromStore, errMsg.GetData());

	if (!IsValidSlotNum(ctx->Req.slot))
	{
		errMsg = CSimpleStringA::Format("<MoveAndReadCardFromSlotJS>, Invalid slot(%d)", ctx->Req.slot);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotInvalid, errMsg.GetData());
		m_mapJsonErr["userCode"] = JsonElem(CardIssuerStore_UserErrorCode_Dev_SlotInvalid);
		m_mapJsonErr["cardResult"] = JsonElem(CardResult_Invalid_Slot);
		m_mapJsonErr["tips"] = JsonElem("[RTA2W8B] 卡槽地址非法，请联系行内开发人员排查");
		ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotInvalid, generateJsonString(m_mapJsonErr));
		return 1;//跳到S2
	}
	if (!IsSlotHasCard(ctx->Req.slot))
	{
		errMsg = CSimpleStringA::Format("<MoveAndReadCardFromSlotJS>, slot %d has no card", ctx->Req.slot);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard, errMsg.GetData());
		m_mapJsonErr["userCode"] = JsonElem(CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard);
		m_mapJsonErr["cardResult"] = JsonElem(CardResult_HaveNoCardInTheSlot);
		m_mapJsonErr["tips"] = JsonElem("[RTA2W86] 卡槽内无卡，请联系厂商排查");
		ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard, generateJsonString(m_mapJsonErr));
		return 1;//跳到S2
	}
	FSMSetIssueFlag(1);
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->MoveCardFromSlot(ctx->Req.slot);
	l_endTime = GetTickCountRVC();

	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardFromSlot").setCostTime(l_endTime - l_beginTime)("MoveAndReadCardFromSlotJS::MoveCardFromSlot");
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardFromSlot, "MoveAndReadCardFromSlotJS MoveCardFromSlot succ.");
		CardNo card;
		memset(&card, 0, sizeof(card));

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReadAccount(card);
		l_endTime = GetTickCountRVC();
		if (eErr == Error_Succeed)
		{
			
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime)("MoveAndReadCardFromSlotJS::ReadAccount");
			LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_ReadAccount_Cost_Time, CSimpleStringA::Format("{\"cost\":%d}", l_endTime - l_beginTime));
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("MoveAndReadCardFromSlotJS::ReadAccount, dwSize:%d, t2dwSize:%d, t3dwSize:%d, card.account len:%d, ",
				card.dwSize, card.dwTrack2Size, card.dwTrack3Size, strlen(card.account));

			m_currCardNo = readCardNo = card.account;
			CSimpleStringA maskCardno = MaskCardno(readCardNo.GetData());
			LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_CardBin, CSimpleStringA::Format("cardBin:%s", maskCardno.GetData()));

			ctx->Ans.cardNo = card.account;
			ctx->Answer(Error_Succeed);
			return 0;//跳到S4
		}
		else {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReadAccount, "DevAdapter::ReadAccount", __FUNCTION__, false, l_endTime - l_beginTime, "QLR0402220104", "MoveAndReadCardFromSlotJS::ReadAccount err");
			DWORD dwTmpUserErrCode = GetAlarmDEC();
			m_mapJsonErr["userCode"] = JsonElem(dwTmpUserErrCode);
			m_mapJsonErr["cardResult"] = JsonElem(CardResult_ReadAccount_Fail);
			m_mapJsonErr["cardPos"] = JsonElem(CardPos_KeepInCardReader);
			m_mapJsonErr["tips"] = JsonElem("[RTA2W05] 读取卡片账户信息失败，请联系卡库厂商排查");
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
			return 0;//跳到S4
		}
	}
	else
	{
		bool bTrans = true;
		DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot, bTrans);
		SetErrorAndLog(eErr, dwTmpUserErrCode, "DevAdapter::MoveCardFromSlot", __FUNCTION__, false, l_endTime - l_beginTime, "QLR0402220104", "MoveAndReadCardFromSlotJS::MoveCardFromSlot err");
		m_mapJsonErr["userCode"] = JsonElem(dwTmpUserErrCode);
		m_mapJsonErr["cardResult"] = JsonElem(CardResult_MoveToCardReader_Fail);
		m_mapJsonErr["tips"] = JsonElem("[RTA2W04] 从卡槽移动卡片到读卡器失败，请联系卡库厂商排查");
		ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
		return 1;//跳到S2
	}
	
}

int CCardIssuerFSM::MoveBacktoSlotJS(SpReqAnsContext<CardIssuerStoreService_MoveBacktoSlotJS_Req, CardIssuerStoreService_MoveBacktoSlotJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("卡库移回卡槽开始");
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA errMsg("");
	m_mapJsonErr.clear();
	long l_beginTime, l_endTime;
	int slot = ctx->Req.slot;
	FSMSetIssueFlag(1);
	CSimpleStringA maskCardno = MaskCardno(ctx->Req.cardNo.GetData());

	if (!IsValidSlotNum(ctx->Req.slot))
	{
		errMsg = CSimpleStringA::Format("Invalid slot(%d), req.hopper=%d", slot);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotInvalid, errMsg.GetData());
		m_mapJsonErr["userCode"] = JsonElem(CardIssuerStore_UserErrorCode_Dev_SlotInvalid);
		m_mapJsonErr["cardResult"] = JsonElem(CardResult_Invalid_Slot);
		m_mapJsonErr["tips"] = JsonElem("[RTA2W8B] 卡槽地址非法，请联系行内开发人员排查");
		ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotInvalid, generateJsonString(m_mapJsonErr));
		return 0;//跳到S4
	}


	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCardToSlot(slot);
	l_endTime = GetTickCountRVC();

	if (eErr == Error_Succeed){

		m_currCardNo = "";
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime)("MoveBacktoSlotJS::MoveCardToSlot, (slot:%d)", slot);
		errMsg = CSimpleStringA::Format("MoveBacktoSlotJS MoveCardToSlot succ, slot:%d,account:%s", slot, maskCardno.GetData());
		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_MoveCardToSlot, errMsg.GetData());
		ctx->Answer(Error_Succeed);
		return 1;//跳到S2
	}
	else {
		//移动失败
		bool bTrans = true;
		DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardToSlot, bTrans);
		SetErrorAndLog(eErr, dwTmpUserErrCode, "DevAdapter::MoveCardToSlot", __FUNCTION__, false, l_endTime - l_beginTime, "QLR0402220105", CSimpleStringA::Format("MoveBacktoSlotJS::MoveCardToSlot (slot:%d)", slot));

		m_mapJsonErr["cardResult"] = JsonElem(CardResult_MoveToSlot_Fail);
		m_mapJsonErr["cardPos"] = JsonElem(CardPos_KeepInCardReader);
		m_mapJsonErr["userCode"] = JsonElem(dwTmpUserErrCode);
		m_mapJsonErr["tips"] = JsonElem("[RTA2W03] 卡片从读卡器移回到卡槽失败，请联系卡库厂商排查");
		ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
		return 0;//跳到S4
	}
}

bool CCardIssuerFSM::OperateNewCardStore(int slot, CSimpleStringA& addCardNo, CSimpleStringA& addCardSerial, int& status)
{
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCardFromSlot(slot);
	l_endTime = GetTickCountRVC();

	CSimpleStringA readCardNo = "";
	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardFromSlot").setCostTime(l_endTime - l_beginTime)("OperateNewCardStore::MoveCardFromSlot, slot:%d", slot);
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardFromSlot, "OperateNewCardStore MoveCardFromSlot succ.");
		CardNo card;
		ZeroMemory(card.account, sizeof(card.account));
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReadAccount(card);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime)("OperateNewCardStore::ReadAccount");
			m_currCardNo = readCardNo = card.account;
		}
		else {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReadAccount, "DevAdapter::ReadAccount", __FUNCTION__, false, l_endTime - l_beginTime, "QLR0402220100", "OperateNewCardStore::ReadAccount err");
		}

		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_ReadAccount_Cost_Time, CSimpleStringA::Format("{\"cost\":%d}", l_endTime - l_beginTime));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("OperateNewCardStore::ReadAccount, dwSize:%d, t2Size:%d, t3Size:%d,eErr:%d",
			card.dwSize, card.dwTrack2Size, card.dwTrack3Size, eErr);

		bool bDataOK = true;
		//读卡成功并解析出卡序号，才算成功，卡序号也要返回
		if (eErr == Error_Succeed && card.dwSize > 0 && card.dwSize < 64)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("read account OK.");
			if (card.dwTrack3Size == 2)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("maybe only IC card.");
				addCardSerial = (const char*)card.track3;
			}
			else
			{
				Track2Data track2Data;
				track2Data.status = 0;
				track2Data.t2Account = "";
				char* tmpMag2 = new char[256];
				ZeroMemory(tmpMag2, 256);
				bool bT2OK = false, bT3OK = false;
				if (card.dwTrack2Size > 0 && card.dwTrack2Size < 41)
				{
					//IC卡等效二磁道数据可能存在补F的情况(参考oilyang@20171129)
					if (card.track2[card.dwTrack2Size - 1] == 'F')
					{
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("track2 has F in the end");
						card.track2[card.dwTrack2Size - 1] = '\0';
						card.dwTrack2Size--;
					}
					bT2OK = true;
				}
				if (card.dwTrack3Size > 0 && card.dwTrack3Size < 150) {
					bT3OK = true;
				}
				DecodeTracksData(card.track2, card.dwTrack2Size, card.track3, card.dwTrack3Size, tmpMag2, bT2OK, bT3OK);
				if (SplitTrack2(tmpMag2, track2Data) == 0)
				{
					addCardSerial = track2Data.t2CardSerial;
				}
			}
			addCardNo = card.account;

			CSimpleStringA maskCardno = MaskCardno(addCardNo.GetData());
			LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_CardBin, CSimpleStringA::Format("cardBin:%s", maskCardno.GetData()));

			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("card.account:%d, card serial %s", addCardNo.GetLength(), addCardSerial.GetData());
			if (addCardSerial.GetLength() <= 0) {
				bDataOK = false;
			}
		}
		else
		{
			bDataOK = false;
		}

		if (!bDataOK)
		{
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_Operate_ReadFailed, "OperateNewCardStore::ReadAccount failed, to capture card");
			
			ToRegistCaptureCardInfo(readCardNo);
			eErr = MachineMoveCardBackNotHold();
			if (eErr==Error_Succeed) {
				m_currCardNo = "";
				status = 2;
			}
			else {
				status = 21;
			}
		}
		else
		{
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->MoveCardToSlot(slot);
			l_endTime = GetTickCountRVC();

			if (eErr == Error_Succeed)
			{
				m_currCardNo = "";
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime)("OperateNewCardStore::MoveCardToSlot, slot:%d", slot);
				LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardToSlot, "OperateNewCardStore MoveCardToSlot succ.");
				//返回盘库成功
				status = 0;
				return true;
			}
			else
			{
				//移回卡槽不成功，登记并吞卡
				bool bTrans = true;
				SetErrorAndLog(eErr, TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardToSlot, bTrans), "DevAdapter::MoveCardToSlot", __FUNCTION__, false, l_endTime - l_beginTime, "QLR0402220100", CSimpleStringA::Format("OperateNewCardStore::MoveCardToSlot err, slot:%d, cardNo:%s", slot,addCardNo));
				ToRegistCaptureCardInfo(readCardNo);
				eErr = MachineMoveCardBackNotHold();
				if (eErr == Error_Succeed) {
					m_currCardNo = "";
					status = 3;
				}
				else {
					status = 31;
				}
			}
		}
	}
	else
	{
		bool bTrans = true;
		SetErrorAndLog(eErr, TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot, bTrans), "DevAdapter::MoveCardFromSlot", __FUNCTION__, false, l_endTime - l_beginTime, "QLR0402220100", CSimpleStringA::Format("OperateNewCardStore::MoveCardFromSlot err, slot:%d",slot));
		status = 1;
	}
	return false;
}

int CCardIssuerFSM::IssueFromSlotJS(SpReqAnsContext<CardIssuerStoreService_IssueFromSlotJS_Req, CardIssuerStoreService_IssueFromSlotJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("卡库领卡读卡开始");
	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;
	m_mapJsonErr.clear();
	errMsg = CSimpleStringA::Format("<IssueFromSlotJS>, slot:%d", ctx->Req.slot);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_IssueCardFromStore, errMsg.GetData());
	CSimpleStringA readCardNo = "";

	if (!IsValidSlotNum(ctx->Req.slot))
	{
		errMsg = CSimpleStringA::Format("<IssueFromSlotJS>, Invalid slot(%d)", ctx->Req.slot);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotInvalid, errMsg.GetData());
		m_mapJsonErr["userCode"] = JsonElem(CardIssuerStore_UserErrorCode_Dev_SlotInvalid);
		m_mapJsonErr["cardResult"] = JsonElem(CardResult_Invalid_Slot);
		m_mapJsonErr["tips"] = JsonElem("[RTA2W8B] 卡槽地址非法，请联系行内开发人员排查");
		ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotInvalid, generateJsonString(m_mapJsonErr));
		return 1;//跳到S2
	}
	if (!IsSlotHasCard(ctx->Req.slot))
	{
		errMsg = CSimpleStringA::Format("<IssueFromSlotJS>, slot %d has no card", ctx->Req.slot);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard, errMsg.GetData());
		m_mapJsonErr["userCode"] = JsonElem(CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard);
		m_mapJsonErr["cardResult"] = JsonElem(CardResult_HaveNoCardInTheSlot);
		m_mapJsonErr["tips"] = JsonElem("[RTA2W86] 卡槽内无卡，请联系厂商排查");
		ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Dev_SlotHasNoCard, generateJsonString(m_mapJsonErr));
		return 1;//跳到S2
	}
	FSMSetIssueFlag(1);
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->MoveCardFromSlot(ctx->Req.slot);
	l_endTime = GetTickCountRVC();

	if (eErr == Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardFromSlot").setCostTime(l_endTime - l_beginTime)("IssueFromSlotJS::MoveCardFromSlot");
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardFromSlot, "IssueFromSlotJS MoveCardFromSlot succ.");
		CardNo card;
		memset(&card, 0, sizeof(card));
		
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReadAccount(card);
		l_endTime = GetTickCountRVC();

		LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_ReadAccount_Cost_Time, CSimpleStringA::Format("{\"cost\":%d}", l_endTime - l_beginTime));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IssueFromSlotJS::ReadAccount, dwSize:%d, t2dwSize:%d, t3dwSize:%d, card.account len:%d, ",
			card.dwSize, card.dwTrack2Size, card.dwTrack3Size, strlen(card.account));

		if (eErr == Error_Succeed)
		{
			m_currCardNo = readCardNo = card.account;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReadAccount").setCostTime(l_endTime - l_beginTime)("IssueFromSlotJS::ReadAccount");
			CSimpleStringA maskReqCardno = MaskCardno(ctx->Req.cardNo.GetData());
			CSimpleStringA maskReadCardno = MaskCardno(card.account);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("req card =%s, read account=%s", maskReqCardno.GetData(), maskReadCardno.GetData());
		}
		else {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReadAccount, "DevAdapter::ReadAccount", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040222046", "IssueFromSlotJS::ReadAccount err");
		}

		if (eErr == Error_Succeed &&  ctx->Req.cardNo.GetLength() == card.dwSize && strncmp(card.account, ctx->Req.cardNo, card.dwSize) == 0){

			CSimpleStringA maskCardno = MaskCardno(card.account);
			LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_CardBin, CSimpleStringA::Format("cardBin:%s", maskCardno.GetData()));
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040222046")();
			ctx->Answer(Error_Succeed);
			return 0;//跳到S4
		}
		else {
			//不匹配
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->MoveCardToSlot(ctx->Req.slot);
			l_endTime = GetTickCountRVC();

			if (eErr == Error_Succeed){
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCardToSlot").setCostTime(l_endTime - l_beginTime)("<IssueFromSlotJS>, accout not equal, card have been move back to slot. slot:%d", ctx->Req.slot);
				LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCardToSlot, "IssueFromSlotJS MoveCardToSlot succ.");
				m_mapJsonErr["cardPos"] = JsonElem(CardPos_HaveMovedToSlot);
				m_mapJsonErr["tips"] = JsonElem("[RTA2WCQ] 卡号不匹配，卡片已移回原卡槽");
				ctx->Answer(Error_Unexpect, CardIssuerStore_UserErrorCode_Account_NotMatchWithReadAccount, generateJsonString(m_mapJsonErr));
				return 1;//跳到S2
			}
			else {
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_IssueFromCardStore,"accout not equal,card move back to slot failed, to capture card");
				bool bTrans = true;
				DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot, bTrans);
				SetErrorAndLog(eErr, dwTmpUserErrCode, "DevAdapter::MoveCardToSlot", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040222046", "IssueFromSlotJS::MoveCardToSlot err");

				m_captureReason = "4001";
				ToRegistCaptureCardInfo(readCardNo);
				eErr = MachineMoveCardBackNotHold();
				m_mapJsonErr["cardPos"] = JsonElem(CardPos_HaveCapturedCard);
				

				if (eErr == Error_Succeed){
					m_currCardNo = "";
					m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，移回原卡槽失败，已吞卡");
					ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
					return 1;//跳到S2
				}
				else {
					m_mapJsonErr["tips"] = JsonElem("[RTA9999] 卡号不匹配，吞卡失败，请联系卡库厂商排查");
					ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
					return 2;//跳到S9
				}

			}

		}

	}
	else {
		bool bTrans = true;
		DWORD dwTmpUserErrCode = TryMapAPIRetToUEC(eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot, bTrans);
		SetErrorAndLog(eErr, dwTmpUserErrCode, "DevAdapter::MoveCardFromSlot", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040222046", "IssueFromSlotJS::MoveCardFromSlot err");
		m_mapJsonErr["userCode"] = JsonElem(dwTmpUserErrCode);
		m_mapJsonErr["cardResult"] = JsonElem(CardResult_MoveToCardReader_Fail);
		m_mapJsonErr["tips"] = JsonElem("[RTA2W04] 从卡槽移动卡片到读卡器失败，请联系卡库厂商排查");
		ctx->Answer(Error_Unexpect, dwTmpUserErrCode, generateJsonString(m_mapJsonErr));
		return 1;//跳到S2
	}
}

void CCardIssuerFSM::QueryInternalHasCardJS(SpReqAnsContext<CardIssuerStoreService_QueryInternalHasCardJS_Req, CardIssuerStoreService_QueryInternalHasCardJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	int ret = 0;
	if (m_hDevHelper == nullptr) {
		ctx->Answer(Error_Unexpect, CardIssuerStore_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)("QueryInternalHasCardJS::GetDevStatus, m_devStatus.eMedia:%d", m_devStatus.eMedia);
			ret = (m_devStatus.eMedia == CI_MEDIA_PRESENT) ? 1 : 0;
			ctx->Ans.position = ret;
			ctx->Answer(Error_Succeed);
		}
		else
		{
			SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "QueryInternalHasCardJS::GetDevStatus err");
			ctx->Answer(Error_Unexpect, GetAlarmDEC());
		}

	}
}

int CCardIssuerFSM::WriteTrackJS(SpReqAnsContext<CardIssuerStoreService_WriteTrackJS_Req, CardIssuerStoreService_WriteTrackJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	int ret = 0;
	long l_beginTime, l_endTime;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("WriteTrackJS，t1Len:%d, t2Len:%d, t3Len:%d", ctx->Req.track1.GetLength(), ctx->Req.track2.GetLength(), ctx->Req.track3.GetLength());
	if (ctx->Req.track1.GetLength() <= 0 && ctx->Req.track2.GetLength() <= 0 && ctx->Req.track3.GetLength() <= 0)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<WriteTrackJS>, write card param is null.");
		ctx->Answer(Error_Param);
		return ret;
	}
	else
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->MoveCard(CI_MOVECARD_MAG_POSITION);
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed)
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_MAG_POSITION, "DevAdapter::MoveCard", __FUNCTION__, true, l_endTime - l_beginTime, "QLR040222050", "WriteTrackJS::MoveCard err");
			ctx->Answer(Error_Unexpect, GetAlarmDEC());
			return ret;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("WriteTrackJS::MoveCard");
		}
	}
	MagTracks magTrack;
	ZeroMemory(magTrack.track[0].data, MAX_MAG_TRACK_SIZE);
	ZeroMemory(magTrack.track[1].data, MAX_MAG_TRACK_SIZE);
	ZeroMemory(magTrack.track[2].data, MAX_MAG_TRACK_SIZE);
	magTrack.track[0].dwSize = magTrack.track[1].dwSize = magTrack.track[2].dwSize = 0;
	magTrack.track[0].eStatus = magTrack.track[1].eStatus = magTrack.track[2].eStatus = CI_DATA_INVALID;
	TrackRange iT1, iT2, iT3;
	iT1 = iT2 = iT3 = CI_TRACK_RANGE_START;
	if (ctx->Req.track1.GetLength() > 0)
	{
		iT1 = CI_TRACK_RANGE_1;
		CSimpleStringA csT1 = CSimpleStringW2A(ctx->Req.track1);
		strncpy((char*)magTrack.track[0].data, csT1, csT1.GetLength());
		magTrack.track[0].eSource = CI_TRACK_SOURCE_1;
		magTrack.track[0].eStatus = CI_DATA_OK;
		magTrack.track[0].dwSize = csT1.GetLength();
	}
	if (ctx->Req.track2.GetLength() > 0)
	{
		iT2 = CI_TRACK_RANGE_2;
		CSimpleStringA csT2 = CSimpleStringW2A(ctx->Req.track2);
		strncpy((char*)magTrack.track[1].data, csT2, csT2.GetLength());
		magTrack.track[1].eSource = CI_TRACK_SOURCE_2;
		magTrack.track[1].eStatus = CI_DATA_OK;
		magTrack.track[1].dwSize = csT2.GetLength();
	}
	if (ctx->Req.track3.GetLength() > 0)
	{
		iT3 = CI_TRACK_RANGE_3;
		CSimpleStringA csT3 = CSimpleStringW2A(ctx->Req.track3);
		strncpy((char*)magTrack.track[2].data, csT3, csT3.GetLength());
		magTrack.track[2].eSource = CI_TRACK_SOURCE_3;
		magTrack.track[2].eStatus = CI_DATA_OK;
		magTrack.track[2].dwSize = csT3.GetLength();
	}

	//TrackRange eAll = iT2 | iT2;
	magTrack.eRange = TrackRange(iT1 | iT2 | iT3);
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MagWrite(magTrack, AUTO_CO);
	l_endTime = GetTickCountRVC();

	if (eErr != Error_Succeed)
	{
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MagWrite, "DevAdapter::MagWrite", __FUNCTION__, true, l_endTime - l_beginTime, "QLR040222050", "WriteTrackJS::MagWrite err");
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagWrite").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222050")("WriteTrackJS::MagWrite ok");
		ctx->Ans.result = 1;//成功
		ctx->Answer(Error_Succeed);
		ret = 1;
	}
	return ret;
}

int CCardIssuerFSM::PrintCardImmediatelyJS(SpReqAnsContext<CardIssuerStoreService_PrintCardImmediatelyJS_Req, CardIssuerStoreService_PrintCardImmediatelyJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	int ret = 0;
	long l_beginTime, l_endTime;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PrintCardImmediatelyJS，formFile:%s, printDataLen:%d, ", ctx->Req.formFile.GetData(), ctx->Req.printData.GetLength());
	KakuPrintInfo kakuInfo;
	memset(kakuInfo.formPath, 0, sizeof(kakuInfo.formPath));
	memset(kakuInfo.fields, 0, sizeof(kakuInfo.fields));
	
	CSimpleStringA csDepPath, csBackslash("\\"), filePath;
	ErrorCodeEnum eErrPath = GetEntityBase()->GetFunction()->GetPath("Dep", csDepPath);
	filePath = csDepPath + csBackslash + m_devCat.szVendor + "-" + ctx->Req.formFile;
	strncpy(kakuInfo.formPath, (const char*)filePath, filePath.GetLength());
	strncpy(kakuInfo.fields, (const char*)ctx->Req.printData, ctx->Req.printData.GetLength());
	ErrorCodeEnum eErr = Error_Unexpect;
	
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->PrintCardFaceRightNow(kakuInfo);
	l_endTime = GetTickCountRVC();

	if (eErr != Error_Succeed)
	{
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_PrintCardFaceRightNow, "PrintCardFaceRightNow fail.");
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_PrintCardFaceRightNow, "DevAdapter::PrintCardFaceRightNow", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040222051", "PrintCardImmediatelyJS::PrintCardFaceRightNow err");
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
		
	}
	else {
		LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_PrintCardFaceRightNow, "PrintCardFaceRightNow succ.");
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::PrintCardFaceRightNow").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222051")("PrintCardImmediatelyJS::PrintCardFaceRightNow ok , formPath:%s", kakuInfo.formPath);
		ctx->Ans.ret = 1;//成功
		ctx->Answer(Error_Succeed);
		ret = 1;
	}
	return ret;
}

int CCardIssuerFSM::SAMICCommandJS(SpReqAnsContext<CardIssuerStoreService_SAMICCommandJS_Req, CardIssuerStoreService_SAMICCommandJS_Ans>::Pointer ctx)
{
	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<SAMICCommandJS, inParam<cmdType:%d>", ctx->Req.cmdType);

	switch (ctx->Req.cmdType)
	{
	//sam卡接口现无人调用，暂不实现
	//case SAMICCommand_SAM_Select:
	//{
	//	l_beginTime = GetTickCountRVC();
	//	eErr = m_hDevHelper->SAMSelect(ctx->Req.param1[0]);
	//	l_endTime = GetTickCountRVC();
	//
	//	if (eErr) {
	//		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMSelect").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCA")("SAMICCommand::SAMSelect, req.param1:%d ,err=%s", ctx->Req.param1[0], SpStrError(eErr));
	//		SetErrPackage("SAMICCommand::SAMSelect", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMSelect);
    //
	//	}
	//	else {
	//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMSelect").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMSelect, req.param1:%d", ctx->Req.param1[0]);
	//	}
	//}
	//break;
	//case SAMICCommand_SAM_Active:
	//{
	//	l_beginTime = GetTickCountRVC();
	//	eErr = m_hDevHelper->SAMActive(ctx->Req.param1[0]);
	//	l_endTime = GetTickCountRVC();
	//
	//	if (eErr) {
	//		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMActive").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCB")("SAMICCommand::SAMActive, req.param1:%d ,err=%s", ctx->Req.param1[0], SpStrError(eErr));
	//		SetErrPackage("SAMICCommand::SAMActive", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMActive);
	//
	//	}
	//	else {
	//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMActive").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMActive, req.param1:%d", ctx->Req.param1[0]);
	//	}
	//}
	//break;
	//case SAMICCommand_SAM_Deactivate:
	//{
	//	l_beginTime = GetTickCountRVC();
	//	eErr = m_hDevHelper->SAMDeactivate();
	//	l_endTime = GetTickCountRVC();
	//
	//	if (eErr) {
	//		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMDeactivate").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCC")("SAMICCommand::SAMDeactivate err=%s", SpStrError(eErr));
	//		SetErrPackage("SAMICCommand::SAMDeactivate", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMDeactivate);
	//
	//	}
	//	else {
	//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMDeactivate").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMDeactivate");
	//	}
	//}
	//break;
	//case SAMICCommand_SAM_WarmReset:
	//{
	//	l_beginTime = GetTickCountRVC();
	//	eErr = m_hDevHelper->SAMWarmReset();
	//	l_endTime = GetTickCountRVC();
	//
	//	if (eErr) {
	//		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMWarmReset").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCD")("SAMICCommand::SAMWarmReset err=%s", SpStrError(eErr));
	//		SetErrPackage("SAMICCommand::SAMWarmReset", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMWarmReset);
	//
	//	}
	//	else {
	//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMWarmReset").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMWarmReset");
	//	}
	//}
	//break;
	//case SAMICCommand_SAM_QueryStatus:
	//{
	//	SAMStatus samStatus;
	//	l_beginTime = GetTickCountRVC();
	//	eErr = m_hDevHelper->SAMQueryStatus(samStatus);
	//	l_endTime = GetTickCountRVC();
	//
	//	if (eErr == Error_Succeed)
	//	{
	//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMQueryStatus").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMQueryStatus");
	//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SAMWarmReset isActive:%d, chosenOfSAM:%d", samStatus.isActive, samStatus.chosenOfSAM);
	//		ctx->Ans.ret1.Init(2);
	//		ctx->Ans.ret1[0] = samStatus.isActive;
	//		ctx->Ans.ret1[1] = samStatus.chosenOfSAM;
	//	}
	//	else
	//	{
	//		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMQueryStatus").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCE")("SAMICCommand::SAMQueryStatus err=%s", SpStrError(eErr));
	//		SetErrPackage("SAMICCommand::SAMQueryStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMQueryStatus);
	//
	//	}
	//}
	//break;
	//case SAMICCommand_SAM_Command:
	//{
	//	CmdInfo sendBuf, recvBuf;
	//	BYTE* pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
	//	ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
	//	int size = StrBuf2HexBuf(ctx->Req.param2[0], &pTmp);
	//	memcpy(sendBuf.data, pTmp, size);
	//	sendBuf.dwSize = size;
	//
	//	l_beginTime = GetTickCountRVC();
	//	eErr = m_hDevHelper->SAMCommand(sendBuf, recvBuf);
	//	l_endTime = GetTickCountRVC();
	//
	//	if (eErr == Error_Succeed)
	//	{
	//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMCommand").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMCommand");
	//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SAMCommand req.param2:%s, recvBuf.dwSize:%d", ctx->Req.param2[0].GetData(), recvBuf.dwSize);
	//		char* pRet = new char[MAX_IC_BUFFER_SIZE];
	//		ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
	//		//Dbg("%d",recvBuf.dwSize);
	//		HexBuf2StrBuf(recvBuf.data, (char**)&pRet, recvBuf.dwSize);
	//		ctx->Ans.ret1.Init(1);
	//		ctx->Ans.ret2.Init(1);
	//		ctx->Ans.ret1[0] = recvBuf.dwSize * 2;
	//		ctx->Ans.ret2[0] = pRet;
	//		delete[]pRet;
	//	}
	//	else
	//	{
	//		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMCommand").setCostTime(l_endTime - l_beginTime).setResultCode("RTA2WCF")("SAMICCommand::SAMCommand err=%s", SpStrError(eErr));
	//		SetErrPackage("SAMICCommand::SAMCommand", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMCommand);
	//
	//	}
	//	delete[]pTmp;
	//}
	//break;
	case SAMICCommand_IC_Active:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ContactIC();
		l_endTime = GetTickCountRVC();


		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ContactIC").setCostTime(l_endTime - l_beginTime)("SAMICCommandJS::ContactIC");
			CmdInfo atrBuf;
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->ActiveICCardATR(atrBuf);
			l_endTime = GetTickCountRVC();

			if (eErr == Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ActiveICCardATR").setCostTime(l_endTime - l_beginTime)("SAMICCommandJS::ActiveICCardATR");
				BYTE* pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
				if (pTmp == NULL)
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("new MAX_IC_BUFFER_SIZE failed");
					eErr = Error_Unexpect;
					break;
				}
				ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
				HexBuf2StrBuf(atrBuf.data, (char**)&pTmp, atrBuf.dwSize);
				ctx->Ans.ret1.Init(1);
				ctx->Ans.ret2.Init(1);
				ctx->Ans.ret1[0] = atrBuf.dwSize * 2;
				ctx->Ans.ret2[0] = CSimpleStringA((const char*)pTmp);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AtrCtx: size=%d, content=%s, pTmp=%s", ctx->Ans.ret1[0], (LPCTSTR)ctx->Ans.ret2[0], (LPCTSTR)pTmp);
				delete[] pTmp;
				pTmp = NULL;

			}
			else
			{
				SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ActiveICCardATR, "DevAdapter::ActiveICCardATR", __FUNCTION__, false, l_endTime - l_beginTime, "", "SAMICCommandJS::ActiveICCardATR err");
			}
		}
		else
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ContactIC, "DevAdapter::ContactIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "SAMICCommandJS::ContactIC err");
		}
	}
	break;
	case SAMICCommand_IC_Deactivate:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->DeactivateICCard();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->DeactivateICCard();
			l_endTime = GetTickCountRVC();

			if (eErr != Error_Stoped)
			{
				SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard, "DevAdapter::DeactivateICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "SAMICCommandJS::DeactivateICCard err");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommandJS::DeactivateICCard");
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommandJS::DeactivateICCard");
		}
	}
	break;
	case SAMICCommand_IC_WarmReset:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->WarmReset();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_WarmReset, "DevAdapter::WarmReset", __FUNCTION__, false, l_endTime - l_beginTime, "", "SAMICCommandJS::WarmReset err");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::WarmReset").setCostTime(l_endTime - l_beginTime)("SAMICCommandJS::WarmReset");
		}
	}
	break;
	case SAMICCommand_IC_Command:
	{
		CmdInfo sendBuf, recvBuf;
		BYTE* pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
		ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
		int size = StrBuf2HexBuf(ctx->Req.param2[0], &pTmp);
		memcpy(sendBuf.data, pTmp, size);
		sendBuf.dwSize = size;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ICCommand(sendBuf, recvBuf);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime)("SAMICCommandJS::ICCommand");
			if (recvBuf.dwSize > 0 && recvBuf.dwSize < 1024)
			{
				char* pRet = new char[MAX_IC_BUFFER_SIZE];
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ICCommand, recvBuf.dwSize:%d", recvBuf.dwSize);
				HexBuf2StrBuf(recvBuf.data, (char**)&pRet, recvBuf.dwSize);
				ctx->Ans.ret1.Init(1);
				ctx->Ans.ret2.Init(1);
				ctx->Ans.ret1[0] = recvBuf.dwSize * 2;
				ctx->Ans.ret2[0] = pRet;
				delete[]pRet;
			}
		}
		else
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime, "", "SAMICCommandJS::ICCommand err");
		}
		delete[]pTmp;
	}
	break;
	case SAMICCommand_RFIC_Active:
	{
		char chType = 0;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ActiveContactlessICCard('A', 'B', 'M', chType);
		l_endTime = GetTickCountRVC();

		ctx->Ans.ret1.Init(1);
		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ActiveContactlessICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommandJS::ActiveContactlessICCard, chType:%d", chType);
			ctx->Ans.ret1[0] = chType;
		}
		else
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ActiveContactlessICCard, "DevAdapter::ActiveContactlessICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "SAMICCommandJS::ActiveContactlessICCard err");
		}
	}
	break;
	case SAMICCommand_RFIC_Deactivate:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->DeactContactlessICCard();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {

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

			if (eErr != Error_Succeed) {
				SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactContactlessICCard, "DevAdapter::DeactContactlessICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "SAMICCommandJS::DeactContactlessICCard err");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommandJS::DeactContactlessICCard");
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommandJS::DeactContactlessICCard");
		}
	}
	break;
	case SAMICCommand_RFIC_Command:
	{
		CmdInfo sendBuf, recvBuf;
		BYTE* pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
		ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
		int size = StrBuf2HexBuf(ctx->Req.param2[0], &pTmp);
		memcpy(sendBuf.data, pTmp, size);
		sendBuf.dwSize = size;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->RFTypeABCommand(sendBuf, recvBuf);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::RFTypeABCommand").setCostTime(l_endTime - l_beginTime)("SAMICCommandJS::RFTypeABCommand");
			if (recvBuf.dwSize > 0 && recvBuf.dwSize < 1024)
			{
				char* pRet = new char[MAX_IC_BUFFER_SIZE];
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RFTypeABCommand, recvBuf.dwSize:%d", recvBuf.dwSize);
				HexBuf2StrBuf(recvBuf.data, (char**)&pRet, recvBuf.dwSize);
				ctx->Ans.ret1.Init(1);
				ctx->Ans.ret2.Init(1);
				ctx->Ans.ret1[0] = recvBuf.dwSize * 2;
				ctx->Ans.ret2[0] = pRet;
				delete[]pRet;
			}
		}
		else {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_RFTypeABCommand, "DevAdapter::RFTypeABCommand", __FUNCTION__, false, l_endTime - l_beginTime, "", "SAMICCommandJS::RFTypeABCommand err");
		}
		delete[]pTmp;
	}
	break;
	default:
		break;
	}
	if (eErr != Error_Succeed)
		ctx->Answer(eErr, GetAlarmDEC());
	else
		ctx->Answer(Error_Succeed);
	return 0;
}

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

int CCardIssuerFSM::IssueFromBoxJS(SpReqAnsContext<CardIssuerStoreService_IssueFromBoxJS_Req, CardIssuerStoreService_IssueFromBoxJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;

	//Req.hopper
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IssueCard, issue type:%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, CardIssuerStore_UserErrorCode_Invalid_Hopper, errMsg.GetData());
		return 1;
	}
	m_currentHopper = ctx->Req.hopper;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IssueCard, current hopper:%d", m_currentHopper);
	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, "", "IssueFromBoxJS::GetDevStatus err");
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("IssueFromBoxJS::GetDevStatus");
		if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_EMPTY || cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_NOTSUPP) {
			bEmpty = true;
		}
	}
	if (bEmpty)
	{
		//卡箱无卡时返回错误信息
		CSimpleStringA warnInfo = CSimpleStringA::Format("IssuerCard, hopper%d no more cards to issue. Vendor return:NoCard(%d), CardCount(%d)",
			 cis.eIssuerBin[m_currentHopper - 1], cis.dwIssuerCount[m_currentHopper - 1]);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_No_More_Card_Issue, warnInfo.GetData());

		DWORD dwUsrErrCode = 0;
		if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_NOTSUPP)
		{
			if (m_currentHopper == 1)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222045").setResultCode("RTA2W0B")("未检测到卡箱1，请检测卡箱1是否放好");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222045").setResultCode("RTA2W0C")("未检测到卡箱2，请检测卡箱2是否放好");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222045").setResultCode("RTA2W0D")("未检测到卡箱3，请检测卡箱3是否放好");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper3;
			}
			else if (m_currentHopper == 4)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper4;
			else if (m_currentHopper == 5)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper5;
			else if (m_currentHopper == 6)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NotHas_Hopper6;
		}
		else if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_EMPTY)
		{
			if (m_currentHopper == 1)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222045").setResultCode("RTA2W0E")("卡箱1未检测到卡片，请检测卡箱1中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040222045").setResultCode("RTA2W0F")("卡箱2未检测到卡片，请检测卡箱2中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode("QLR040222045").setResultCode("RTA2W0G")("卡箱3未检测到卡片，请检测卡箱3中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper3;
			}
			else if (m_currentHopper == 4)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper4;
			else if (m_currentHopper == 5)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper5;
			else if (m_currentHopper == 6)
				dwUsrErrCode = CardIssuerStore_UserErrorCode_NoCardInHopper6;
		}
		ctx->Answer(Error_DevNotAvailable, dwUsrErrCode);
		return 1;
	}
	//forbid front enter

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
	l_endTime = GetTickCountRVC();

	if (errCode != Error_Succeed)
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "IssueFromBoxJS::SetCardInType err");
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("IssueFromBoxJS::SetCardInType");
	}

	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)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IssueCard::MoveCard error, m_currentHopper:%d", m_currentHopper);
		FSMSetIssueFlag(2);
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FROM_HOPPER, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040222045", CSimpleStringA::Format("IssueFromBoxJS::MoveCard err, m_currentHopper:%d", m_currentHopper));
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
		return 2;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040222045")("IssueCard::MoveCard succ, m_currentHopper:%d", m_currentHopper);
	}
	LogWarn(Severity_Low, Error_Succeed, CardIssuerStore_UserErrorCode_MoveCard_FromHopper, "MoveCard from hopper succ.");

	m_bUseRFTillNext = false;
	Sleep(1000);
	ctx->Ans.reserved1[0] = ctx->Ans.reserved1[1] = 0;
	//兼容旧的退出模式
	if (m_bIssuingExit)
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuerStore_UserErrorCode_CaptureCard_IssueExit, "Issuing exit, to capture card.");
		CaptureJS(NULL);
	}
	ctx->Answer(Error_Succeed);
	return 0;
}

DWORD CCardIssuerFSM::GetFsmStateErrCode()
{
	int state = GetFSMState();
	switch (state)
	{
	case 2:
		return CardIssuerStore_UserErrorCode_PROCESS_IDLE;
	case 4:
		return CardIssuerStore_UserErrorCode_PROCESS_HOLD;
	case 5:
		return CardIssuerStore_UserErrorCode_PROCESS_READ;
	case 6:
		return CardIssuerStore_UserErrorCode_PROCESS_EJECT;
	case 7:
		return CardIssuerStore_UserErrorCode_PROCESS_WAIT_FETCH;
	case 8:
		return CardIssuerStore_UserErrorCode_PROCESS_CAPTURE;
	case 9:
		return CardIssuerStore_UserErrorCode_PROCESS_FAULT;
	case 10:
		return CardIssuerStore_UserErrorCode_PROCESS_ISSUE;
	case 11:
		return CardIssuerStore_UserErrorCode_PROCESS_WRITE_CARD;
	case 14:
		return CardIssuerStore_UserErrorCode_PROCESS_SAMIC;
	case 17:
		return CardIssuerStore_UserErrorCode_PROCESS_OPERATE_CARDSTORE;
	case 18:
		return CardIssuerStore_UserErrorCode_PROCESS_PRINT_CARD;
	default:
		return CardIssuerStore_UserErrorCode_EntityInStateCannotProcess;
	}
}

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;
}

int CCardIssuerFSM::PostOnlineJS_Contact(SpReqAnsContext<CardIssuerStoreService_PostOnlineJS_Req, CardIssuerStoreService_PostOnlineJS_Ans>::Pointer ctx, bool& bICOK)
{
	LOG_FUNCTION();
	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_STORE, m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER_STORE, 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).setLogCode("QLR040222041")("<PostOnlineJS_Contact>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());
	ctx->Answer(Error_Succeed);
	return 0;
}

int CCardIssuerFSM::PostOnlineJS_RF(SpReqAnsContext<CardIssuerStoreService_PostOnlineJS_Req, CardIssuerStoreService_PostOnlineJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	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_STORE_RF, m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER_STORE_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).setLogCode("QLR040222041")("<PostOnlineJS_RF>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());
	ctx->Answer(Error_Succeed);
	return 0;
}