myvtm/DevAdapter/simulator/cardissuerstore.1.1/cardissuer_impl.cpp

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "cardissuer_impl.h"
#include "cardissuer_httpans.h"
#include <cstring>
#include <cstdio>
#include "log4vendor.h"
#include <path.h>"

#ifdef _MSC_VER
BOOL APIENTRY DllMain(HMODULE hModule,
	DWORD  ul_reason_for_call,
	LPVOID lpReserved
)
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
	case DLL_PROCESS_DETACH:
		break;
	}
	return TRUE;
}
#endif

DEVICEBASE_API ErrorCodeEnum CreateDevComponent(DeviceBaseClass*& pBaseObj)
{
	pBaseObj = new CardIssuerImpl();
	if (pBaseObj == NULL) {
		return Error_Resource;
	}
	cmb::log_init_config config;
	config.dev_name = "vendor_CardIssuerStore";
#ifdef _MSC_VER
	config.log_dir = ("C:\\rvc\\dbg\\");
#else
	config.log_dir = ("/opt/rvc/dbg/");
#endif 
	std::string str;
	cmb::log4vendor::init(config, str);

	std::string tmpStr = GetSimulatorUrl();
	LOG4VTM(INFO, "URL = " << tmpStr.c_str());

	return Error_Succeed;
}
DEVICEBASE_API ErrorCodeEnum ReleaseDevComponent(DeviceBaseClass*& pBaseObj)
{
	if (pBaseObj == NULL) {
		return Error_Param;
	}
	if (CardIssuerImpl* pTmp = dynamic_cast<CardIssuerImpl*>(pBaseObj))
	{
		delete pTmp;
		pTmp = NULL;
		return Error_Succeed;
	}
	return Error_Param;
}


CardIssuerImpl::CardIssuerImpl()
{

}

CardIssuerImpl::~CardIssuerImpl()
{

}

ErrorCodeEnum CardIssuerImpl::GetDevCategory(DevCategoryInfo& devCategory)
{
	ErrorCodeEnum err = Error_Succeed;
	SimulatorDevCategoryAns ans;

	err = SimulatorHttpFunction(EntityName, "GetDevCategory", ans);
	LOG4VTM(INFO, "GetDevCategory err = " << err);

	strcpy(devCategory.szType, ans.szType.c_str());
	strcpy(devCategory.szModel, ans.szModel.c_str());
	strcpy(devCategory.szVendor, ans.szVendor.c_str());
	devCategory.eState = (DevStateEnum)ans.eState;
	devCategory.version.wMajor = ans.version.wMajor;
	devCategory.version.wMinor = ans.version.wMinor;
	devCategory.version.wRevision = ans.version.wRevision;
	devCategory.version.wBuild = ans.version.wBuild;

	return err;
}

ErrorCodeEnum CardIssuerImpl::Reset()
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "Reset");
	LOG4VTM(INFO, "Reset err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::DevClose()
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "DevClose");
	LOG4VTM(INFO, "DevClose err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::GetLastErr(DevErrorInfo& devErrInfo)
{
	ErrorCodeEnum err = Error_Succeed;
	SimulatorDevErrInfoAns ans;

	err = SimulatorHttpFunction(EntityName, "GetLastErr", ans);
	LOG4VTM(INFO, "GetLastErr err = " << err);

	devErrInfo.dwErrMsgLen = ans.dwErrMsgLen;
	strcpy(devErrInfo.szErrMsg, ans.szErrMsg.c_str());

	return err;
}

ErrorCodeEnum CardIssuerImpl::GetDevStatus(CardIssuerStatus& devStatus)
{
	ErrorCodeEnum err = Error_Succeed;
	CardIssuerStatusAns ans;

	err = SimulatorHttpFunction(EntityName, "GetDevStatus", ans);
	LOG4VTM(INFO, "GetDevStatus err = " << err);

	if (err == Error_Succeed) {
		devStatus.eMedia = (CardStatusEnum)ans.eMedia;
		devStatus.eRetainBin = (RtBinStatusEnum)ans.eRetainBin;
		devStatus.dwRetainCount = ans.dwRetainCount;

		for (int i = 0; i < 12; i++)
		{
			if (i >= ans.eIssuerBin.size())
			{
				break;
			}
			devStatus.eIssuerBin[i] = (IssHopperStatusEnum)ans.eIssuerBin[i];
		}

		for (int i = 0; i < 12; i++)
		{
			if (i >= ans.dwIssuerCount.size())
			{
				break;
			}
			devStatus.dwIssuerCount[i] = ans.dwIssuerCount[i];
		}

		for (int i = 0; i < 8; i++)
		{
			if (i >= ans.eKakuTape.size())
			{
				break;
			}
			devStatus.eKakuTape[i] = (KakuPrintStatusEnum)ans.eKakuTape[i];
		}
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::GetDeviceSN(char*& pDevSN)
{
	ErrorCodeEnum err = Error_Succeed;
	GetDeviceSNAns ans;

	err = SimulatorHttpFunction(EntityName, "GetDeviceSN", ans);
	LOG4VTM(INFO, "GetDeviceSN err = " << err);

	if (err == Error_Succeed) {
		strncpy(pDevSN, ans.pDevSN.c_str(), (128 > ans.pDevSN.length()) ? ans.pDevSN.length() : 128);
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::MoveCard(CardPosEnum eCardPos, int hopperNo)
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "MoveCard");
	LOG4VTM(INFO, "MoveCard err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::SetCardInType(CardInEnum eCardIn)
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "SetCardInType");
	LOG4VTM(INFO, "SetCardInType err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::MagRead(MagTracks& magTracks)
{
	ErrorCodeEnum err = Error_Succeed;
	MagTracksAns ans;

	err = SimulatorHttpFunction(EntityName, "MagRead", ans);
	LOG4VTM(INFO, "MagRead err = " << err);

	if (err == Error_Succeed) {
		magTracks.eRange = (TrackRange)ans.eRange;
		for (int i = 0; i < MAX_MAG_TRACK_NUM; ++i) {
			magTracks.track[i].eSource = (TrackSrcEnum)ans.track[i].eSource;
			magTracks.track[i].eStatus = (TrackDataStateEnum)ans.track[i].eStatus;
			magTracks.track[i].dwSize = ans.track[i].dwSize;
			memset(magTracks.track[i].data, 0, sizeof(BYTE) * MAX_MAG_TRACK_SIZE);
			memcpy(magTracks.track[i].data, ans.track[i].data.c_str(), ans.track[i].data.length() + 1);
		}
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::MagWrite(MagTracks magTracks, MagWriteModeEnum eWriteMode)
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "MagWrite");
	LOG4VTM(INFO, "MagWrite err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::ActiveICCard()
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "ActiveICCard");
	LOG4VTM(INFO, "ActiveICCard err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::ContactIC()
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "ContactIC");
	LOG4VTM(INFO, "ContactIC err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::ReleaseIC()
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "ReleaseIC");
	LOG4VTM(INFO, "ReleaseIC err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::WarmReset()
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "WarmReset");
	LOG4VTM(INFO, "WarmReset err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::ICCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
{
	ErrorCodeEnum err = Error_Succeed;
	CmdInfoAns ans;

	err = SimulatorHttpFunction(EntityName, "ICCommand", ans);
	LOG4VTM(INFO, "ICCommand err = " << err);

	if (err == Error_Succeed) {
		recvBuf.dwSize = ans.dwSize;
		memcpy(recvBuf.data, ans.data.bData, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::SAMActive(BYTE vcc)
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "SAMActive");
	LOG4VTM(INFO, "SAMActive err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::SAMDeactivate()
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "SAMDeactivate");
	LOG4VTM(INFO, "SAMDeactivate err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::SAMWarmReset()
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "SAMWarmReset");
	LOG4VTM(INFO, "SAMWarmReset err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::SAMCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
{
	ErrorCodeEnum err = Error_Succeed;
	CmdInfoAns ans;

	err = SimulatorHttpFunction(EntityName, "SAMCommand", ans);
	LOG4VTM(INFO, "SAMCommand err = " << err);

	if (err == Error_Succeed) {
		recvBuf.dwSize = ans.dwSize;
		memcpy(recvBuf.data, ans.data.bData, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::SAMQueryStatus(SAMStatus& samStatus)
{
	ErrorCodeEnum err = Error_Succeed;
	SAMStatusAns ans;

	err = SimulatorHttpFunction(EntityName, "SAMQueryStatus", ans);
	LOG4VTM(INFO, "SAMQueryStatus err = " << err);

	if (err == Error_Succeed) {
		samStatus.isActive = ans.isActive;
		samStatus.chosenOfSAM = ans.chosenOfSAM;
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::SAMSelect(const int sn)
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "SAMSelect");
	LOG4VTM(INFO, "SAMSelect err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::ActiveICCardATR(CmdInfo& atrBuf)
{
	ErrorCodeEnum err = Error_Succeed;
	CmdInfoAns ans;

	err = SimulatorHttpFunction(EntityName, "ActiveICCardATR", ans);
	LOG4VTM(INFO, "ActiveICCardATR err = " << err);

	if (err == Error_Succeed) {
		atrBuf.dwSize = ans.dwSize;
		memcpy(atrBuf.data, ans.data.bData, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::ActiveContactlessICCard(char fstType, char scdType, char thdType, char& outType)
{
	ErrorCodeEnum err = Error_Succeed;
	ActiveContactlessICCardAns ans;

	err = SimulatorHttpFunction(EntityName, "ActiveContactlessICCard", ans);
	LOG4VTM(INFO, "ActiveContactlessICCard err = " << err);

	if (err == Error_Succeed) {
		outType = (char)ans.outType;
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::DeactivateICCard()
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "DeactivateICCard");
	LOG4VTM(INFO, "DeactivateICCard err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::DeactContactlessICCard()
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "DeactContactlessICCard");
	LOG4VTM(INFO, "DeactContactlessICCard err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::RFTypeABCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
{
	ErrorCodeEnum err = Error_Succeed;
	CmdInfoAns ans;

	err = SimulatorHttpFunction(EntityName, "RFTypeABCommand", ans);
	LOG4VTM(INFO, "RFTypeABCommand err = " << err);

	if (err == Error_Succeed) {
		recvBuf.dwSize = ans.dwSize;
		memcpy(recvBuf.data, ans.data.bData, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::DevOpenEx(DWORD dwPort, DWORD dwBaudRate, BYTE btOpenType, const char* pDevSN, BYTE& btType)
{
	ErrorCodeEnum err = Error_Succeed;
	DevOpenExAns ans;

	err = SimulatorHttpFunction(EntityName, "DevOpenEx", ans);
	LOG4VTM(INFO, "DevOpenEx err = " << err);

	if (err == Error_Succeed) {
		btType = (BYTE)ans.btType;
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::TransferEnInit(int& iStatus, BYTE*& Cr1, int& lenR1, BYTE*& Cr3, int& lenR3, BYTE*& dKey, int& lenKey)
{
	ErrorCodeEnum err = Error_Succeed;
	TransferEnInitAns ans;

	err = SimulatorHttpFunction(EntityName, "TransferEnInit", ans);
	LOG4VTM(INFO, "TransferEnInit err = " << err);

	if (err == Error_Succeed) {
		iStatus = ans.iStatus;
		lenR1 = ans.lenR1;
		lenR3 = ans.lenR3;
		lenKey = ans.lenKey;

		memcpy(Cr1, ans.Cr1.c_str(), 256);
		memcpy(Cr3, ans.Cr3.c_str(), 256);
		memcpy(dKey, ans.dKey.c_str(), 256);
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::SetR2(int& iStatus, BYTE* pCr2, int lenR2)
{
	ErrorCodeEnum err = Error_Succeed;
	SetR2Ans ans;

	err = SimulatorHttpFunction(EntityName, "SetR2", ans);
	LOG4VTM(INFO, "SetR2 err = " << err);

	if (err == Error_Succeed) {
		iStatus = ans.iStatus;
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::SendWorkingKey(const char* pWorkingKey)
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "SendWorkingKey");
	LOG4VTM(INFO, "SendWorkingKey err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::MoveCardToSlot(int slot)
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "MoveCardToSlot");
	LOG4VTM(INFO, "MoveCardToSlot err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::MoveCardFromSlot(int slot)
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "MoveCardFromSlot");
	LOG4VTM(INFO, "MoveCardFromSlot err = " << err);

	return err;
}

ErrorCodeEnum CardIssuerImpl::ReadAccount(CardNo& cardNo)
{
	ErrorCodeEnum err = Error_Succeed;
	CardNoAns ans;

	err = SimulatorHttpFunction(EntityName, "ReadAccount", ans);
	LOG4VTM(INFO, "ReadAccount err = " << err);

	if (err == Error_Succeed) {
		cardNo.dwSize = ans.dwSize;
		cardNo.dwTrack2Size = ans.dwTrack2Size;
		cardNo.dwTrack3Size = ans.dwTrack3Size;
		memcpy(cardNo.account, ans.account.c_str(), ans.account.length() + 1);
		memcpy(cardNo.track2, ans.track2.c_str(), ans.track2.length() + 1);
		memcpy(cardNo.track3, ans.track3.c_str(), ans.track3.length() + 1);
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::GetSlotSum(int& sum)
{
	ErrorCodeEnum err = Error_Succeed;
	GetSlotSumAns ans;

	err = SimulatorHttpFunction(EntityName, "GetSlotSum", ans);
	LOG4VTM(INFO, "GetSlotSum err = " << err);

	if (err == Error_Succeed) {
		sum = ans.sum;
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::QuerySlotsStatus(SlotStatus& slots, const int slot, bool bFull /*= false*/)
{
	ErrorCodeEnum err = Error_Succeed;
	SlotStatusAns ans;

	err = SimulatorHttpFunction(EntityName, "QuerySlotsStatus", ans);
	LOG4VTM(INFO, "QuerySlotsStatus err = " << err);

	if (err == Error_Succeed) {
		slots.dwSize = ans.dwSize;

		for (int i = 0; i < ans.status.size(); i++)
		{
			slots.status[i] = (BYTE)ans.status[i];
		}
	}

	return err;
}

ErrorCodeEnum CardIssuerImpl::PrintCardFaceRightNow(const KakuPrintInfo printInfo)
{
	ErrorCodeEnum err = Error_Succeed;

	err = SimulatorHttpFunction(EntityName, "PrintCardFaceRightNow");
	LOG4VTM(INFO, "PrintCardFaceRightNow err = " << err);

	return err;
}