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

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "stdafx.h"
#include "cardissuer_impl.h"

#include "log4vendor.h"
#include "path.h"

#ifdef RVC_OS_WIN
#include <direct.h>
#define GetCurrentDir _getcwd

#else
#include <unistd.h>
#include<cstring>
#include <cstdio>

#include <netdb.h>  //gethostbyname
#include <arpa/inet.h>  //ntohl
#include <unistd.h> // Linux系统中
#include <netdb.h>  
#include <net/if.h>  
#include <arpa/inet.h> 
#include <sys/ioctl.h>  
#include <sys/types.h>  
#include <sys/socket.h>
#include <netinet/in.h>
#define GetCurrentDir getcwd

#endif

#define MAX_SHOW 1024
#define MAX_TRACK_SIZE 512
#define ENTITY_NAME "CardIssuer"


#ifdef RVC_OS_WIN
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


string get_current_directory() {
	char buff[256];
	GetCurrentDir(buff, 256);
	string  current_working_directory(buff);
	return current_working_directory;
}


DEVICEBASE_API ErrorCodeEnum CreateDevComponent(DeviceBaseClass*& pBaseObj)
{
	pBaseObj = new CardIssuerImpl();
	if (pBaseObj == NULL) {
		return Error_Resource;
	}
	cmb::log_init_config config;
	config.dev_name = ENTITY_NAME;
#ifdef RVC_OS_WIN
	config.log_dir = ("C:\\rvc\\dbg\\");
#else
	config.log_dir = ("/opt/rvc/dbg/");
#endif 
	std::string str;
	cmb::log4vendor::init(config, str);
	printf("init after: %s\n", str.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)
{
	strcpy(devCategory.szModel, "szModel");
	strcpy(devCategory.szType, "szType");
	strcpy(devCategory.szVendor, "szVendor=cmbszSimulator");
	return Error_Succeed;
}

ErrorCodeEnum CardIssuerImpl::Reset()
{
	return Error_Succeed;
}

ErrorCodeEnum CardIssuerImpl::DevClose()
{
	return Error_Succeed;
}

ErrorCodeEnum CardIssuerImpl::GetLastErr(DevErrorInfo& devErrInfo)
{
	static int times = 0;
	char szMessage[1024];
	sprintf(szMessage, "这是第 %d 条错误信息", ++times);
	strcpy(devErrInfo.szErrMsg, szMessage);
	devErrInfo.dwErrMsgLen = strlen(szMessage);
	return Error_Succeed;
}

ErrorCodeEnum CardIssuerImpl::GetDevStatus(CardIssuerStatus& devStatus)
{
	if (GetDevStatusHttp(devStatus)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::GetDeviceSN(char*& pDevSN)
{
	if (GetDeviceSNHttp(pDevSN)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::MoveCard(CardPosEnum eCardPos, int hopperNo)
{
	if (MoveCardHttp(eCardPos, hopperNo)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::SetCardInType(CardInEnum eCardIn)
{
	if (SetCardInTypeHttp(eCardIn)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::MagRead(MagTracks& magTracks)
{
	if (MagReadHttp(magTracks)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::MagWrite(MagTracks magTracks, MagWriteModeEnum eWriteMode)
{
	if (MagWriteHttp(magTracks, eWriteMode)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::ActiveICCard()
{
	if (ActiveICCardHttp()) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::ContactIC()
{
	if (ContactICHttp()) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::ReleaseIC()
{
	if (ReleaseICHttp()) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::WarmReset()
{
	if (WarmResetHttp()) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::ICCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
{
	if (ICCommandHttp(sendBuf, recvBuf)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::SAMCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
{
	if (SAMCommandHttp(sendBuf, recvBuf)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::ActiveICCardATR(CmdInfo& atrBuf)
{
	if (ActiveICCardATRHttp(atrBuf)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::ActiveContactlessICCard(char fstType, char scdType, char thdType, char& outType)
{
	if (ActiveContactlessICCardHttp(fstType, scdType, thdType, outType)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::DeactivateICCard()
{
	if (DeactivateICCardHttp()) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::DeactContactlessICCard()
{
	if (DeactContactlessICCardHttp()) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::RFTypeABCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
{
	if (RFTypeABCommandHttp(sendBuf, recvBuf)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::DevOpenEx(DWORD dwPort, DWORD dwBaudRate, BYTE btOpenType, const char* pDevSN, BYTE& btType)
{
	LOG4VTM(INFO, "当前目录:" << get_current_directory());
	depCfgPath = get_current_directory() + SPLIT_SLASH_STR + "dep" + SPLIT_SLASH_STR + "cmbsz.ini";
	bool ret = iniRead.ReadConfig(depCfgPath);
	if (ret == false)
	{
		LOG4VTM(INFO, "dep ReadConfig is Error,cfg=" << depCfgPath);
	}
	if (DevOpenExHttp(dwPort, dwBaudRate, btOpenType, pDevSN, btType)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::TransferEnInit(int& iStatus, BYTE*& Cr1, int& lenR1, BYTE*& Cr3, int& lenR3, BYTE*& dKey, int& lenKey)
{
	if (TransferEnInitHttp(iStatus, Cr1, lenR1, Cr3, lenR3, dKey, lenKey)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::SetR2(int& iStatus, BYTE* pCr2, int lenR2)
{
	if (SetR2Http(iStatus, pCr2, lenR2)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::SendWorkingKey(const char* pWorkingKey)
{
	if (SendWorkingKeyHttp(pWorkingKey)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::MoveCardToSlot(int slot)
{
	if (MoveCardToSlotHttp(slot)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::MoveCardFromSlot(int slot)
{
	if (MoveCardFromSlotHttp(slot)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::ReadAccount(CardNo& cardNo)
{
	if (ReadAccountHttp(cardNo)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::GetSlotSum(int& sum)
{
	if (GetSlotSumHttp(sum)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::QuerySlotsStatus(SlotStatus& slots, const int slot, bool bFull /*= false*/)
{
	if (QuerySlotsStatusHttp(slots, slot, bFull)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

ErrorCodeEnum CardIssuerImpl::PrintCardFaceRightNow(const KakuPrintInfo printInfo)
{
	if (PrintCardFaceRightNowHttp(printInfo)) {
		return Error_Succeed;
	}
	else {
		return Error_Exception;
	}
}

/////////////////////////////////////////

bool CardIssuerImpl::GetDevStatusHttp(CardIssuerStatus& devStatus)
{
	LOG4VTM(INFO, "GetDevStatusHttp");
	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "GetDevStatus";//适配器接口名
	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "GetDevStatusHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					int eMediaRet = rootRet["data"]["eMedia"].asInt();
					devStatus.eMedia = (CardStatusEnum)eMediaRet;

					int eRetainBinRet = rootRet["data"]["eRetainBin"].asInt();
					devStatus.eRetainBin = (RtBinStatusEnum)eRetainBinRet;

					int dwRetainCountRet = rootRet["data"]["dwRetainCount"].asInt();
					devStatus.dwRetainCount = dwRetainCountRet;

					for (int i = 0; i < 12; i++) {
						int eIssuerBinRet = rootRet["data"]["eIssuerBin"][i].asInt();
						devStatus.eIssuerBin[i] = (IssHopperStatusEnum)eIssuerBinRet;
					}
					for (int i = 0; i < 12; i++) {
						int dwIssuerCountRet = rootRet["data"]["dwIssuerCount"][i].asInt();
						devStatus.dwIssuerCount[i] = dwIssuerCountRet;
					}
					for (int i = 0; i < 8; i++) {
						int eKakuTapeRet = rootRet["data"]["eKakuTape"][i].asInt();
						devStatus.eKakuTape[i] = (KakuPrintStatusEnum)eKakuTapeRet;
					}

					LOG4VTM(INFO, "GetDevStatusHttp devStatus.eMedia=" << devStatus.eMedia);
					LOG4VTM(INFO, "GetDevStatusHttp devStatus.eRetainBin=" << devStatus.eRetainBin);
					LOG4VTM(INFO, "GetDevStatusHttp devStatus.dwRetainCount=" << devStatus.dwRetainCount);

					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "GetDevStatusHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "GetDevStatusHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "GetDevStatusHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::GetDeviceSNHttp(char*& pDevSN)
{
	LOG4VTM(INFO, "GetDeviceSNHttp");
	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "GetDeviceSN";//适配器接口名
	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "GetDeviceSNHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					string devSNStr = rootRet["data"]["devSN"].asString();;
					strncpy(pDevSN, devSNStr.c_str(), (128 > devSNStr.length()) ? devSNStr.length() : 128);
					LOG4VTM(INFO, "GetDeviceSNHttp devSN=" << devSNStr);
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "GetDeviceSNHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "GetDeviceSNHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "GetDeviceSNHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::MoveCardHttp(CardPosEnum eCardPos, int hopperNo)
{

	LOG4VTM(INFO, "MoveCardHttp eCardPos=" << eCardPos << " hopperNo=" << hopperNo);
	return commonSimpleHttp("MoveCard");
}

bool CardIssuerImpl::SetCardInTypeHttp(CardInEnum eCardIn)
{
	LOG4VTM(INFO, "SetCardInTypeHttp eCardIn=" << eCardIn);
	return commonSimpleHttp("SetCardInType");
}

bool CardIssuerImpl::MagReadHttp(MagTracks& magTracks)
{
	LOG4VTM(INFO, "MagReadHttp");
	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "MagRead";//适配器接口名
	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "MagReadHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					int eRangeRet = rootRet["data"]["eRange"].asInt();
					magTracks.eRange = (TrackRange)eRangeRet;
					LOG4VTM(INFO, "MagReadHttp magTracks.eRange=" << magTracks.eRange);
					for (int i = 0; i < 3; i++) {
						int  eSourceRet = rootRet["data"]["track"][i]["eSource"].asInt();
						magTracks.track[i].eSource = (TrackSrcEnum)eSourceRet;

						int  eStatusRet = rootRet["data"]["track"][i]["eStatus"].asInt();
						magTracks.track[i].eStatus = (TrackDataStateEnum)eStatusRet;

						int  dwSizeRet = rootRet["data"]["track"][i]["dwSize"].asInt();
						magTracks.track[i].dwSize = dwSizeRet;

						string  dataRet = rootRet["data"]["track"][i]["data"].asString();
						//PBYTE pData = new BYTE[MAX_SHOW];
						//ZeroMemory(pData, MAX_SHOW);
						//int dataLen = StrBuf2HexBuf(dataRet.c_str(), &pData);
						//memcpy(magTracks.track[i].data, pData, dataLen);//赋值
						//delete[] pData;
						memcpy(magTracks.track[i].data, dataRet.c_str(), dwSizeRet);//赋值
						LOG4VTM(INFO, "MagReadHttp magTracks.track.eSource=" << magTracks.track[i].eSource);
						LOG4VTM(INFO, "MagReadHttp magTracks.track.eStatus=" << magTracks.track[i].eStatus);
						LOG4VTM(INFO, "MagReadHttp magTracks.track.dwSize=" << magTracks.track[i].dwSize);
						LOG4VTM(INFO, "MagReadHttp magTracks.track.data.len=" << strlen((const char*)magTracks.track[i].data));
					}
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "MagReadHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "MagReadHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "MagReadHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::MagWriteHttp(MagTracks magTracks, MagWriteModeEnum eWriteMode)
{
	LOG4VTM(INFO, "MagWriteHttp eWriteMode=" << eWriteMode);
	return commonSimpleHttp("MagWrite");
}

bool CardIssuerImpl::ActiveICCardHttp()
{
	LOG4VTM(INFO, "ActiveICCardHttp");
	return commonSimpleHttp("ActiveICCard");
}

bool CardIssuerImpl::ContactICHttp()
{
	LOG4VTM(INFO, "ContactICHttp");
	return commonSimpleHttp("ContactIC");
}

bool CardIssuerImpl::ReleaseICHttp()
{
	LOG4VTM(INFO, "ReleaseICHttp");
	return commonSimpleHttp("ReleaseIC");
}

bool CardIssuerImpl::WarmResetHttp()
{
	LOG4VTM(INFO, "WarmResetHttp");
	return commonSimpleHttp("WarmReset");
}

bool CardIssuerImpl::ICCommandHttp(CmdInfo sendBuf, CmdInfo& recvBuf)
{
	char* show = new char[MAX_SHOW];
	ZeroMemory(show, MAX_SHOW);
	HexBuf2StrBuf(sendBuf.data, &show, sendBuf.dwSize);

	LOG4VTM(INFO, "ICCommandHttp sendBuf=" << show);

	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "ICCommand";//适配器接口名
	//rootReq["dwSize"] = CSimpleStringA::Format("%d",sendBuf.dwSize).GetData();
	//rootReq["dwData"] = CSimpleStringA::Format("%s",show).GetData();


	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	delete[] show;
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "ICCommandHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					int dwSizeRet = rootRet["data"]["dwSize"].asInt();
					string  dataRet = rootRet["data"]["data"].asString();

					LOG4VTM(INFO, "ICCommandHttp recvBuf.dwSize=" << dwSizeRet << ", recvBuf.dwData=" << dataRet);
					//反解析
					PBYTE pData = new BYTE[MAX_SHOW];
					ZeroMemory(pData, MAX_SHOW);
					int dataLen = StrBuf2HexBuf(dataRet.c_str(), &pData);
					ZeroMemory(recvBuf.data, MAX_SHOW);

					memcpy(recvBuf.data, pData, dataLen);//赋值
					recvBuf.dwSize = dataLen;//赋值
					LOG4VTM(INFO, "ICCommandHttp recvBuf.dwSize=" << recvBuf.dwSize << ", recvBuf.dwData=" << dataRet);
					delete[] pData;
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "ICCommandHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "ICCommandHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "ICCommandHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::SAMCommandHttp(CmdInfo sendBuf, CmdInfo& recvBuf)
{
	char* show = new char[MAX_SHOW];
	ZeroMemory(show, MAX_SHOW);
	HexBuf2StrBuf(sendBuf.data, &show, sendBuf.dwSize);

	LOG4VTM(INFO, "SAMCommandHttp sendBuf=" << show);

	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "SAMCommand";//适配器接口名
	//rootReq["CmdInfo"]["dwSize"] = CSimpleStringA::Format("%d", sendBuf.dwSize).GetData();
	//rootReq["CmdInfo"]["dwData"] = CSimpleStringA::Format("%s", show).GetData();


	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	delete[] show;
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "SAMCommandHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					int dwSizeRet = rootRet["data"]["dwSize"].asInt();
					string  dataRet = rootRet["data"]["data"].asString();

					LOG4VTM(INFO, "SAMCommandHttp recvBuf.dwSize=" << dwSizeRet << ", recvBuf.dwData=" << dataRet);
					//反解析
					PBYTE pData = new BYTE[MAX_SHOW];
					ZeroMemory(pData, MAX_SHOW);
					int dataLen = StrBuf2HexBuf(dataRet.c_str(), &pData);
					ZeroMemory(recvBuf.data, MAX_SHOW);

					memcpy(recvBuf.data, pData, dataLen);//赋值
					recvBuf.dwSize = dataLen;//赋值
					LOG4VTM(INFO, "SAMCommandHttp recvBuf.dwSize=" << recvBuf.dwSize << ", recvBuf.dwData=" << dataRet);
					delete[] pData;
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "SAMCommandHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "SAMCommandHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "SAMCommandHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::ActiveICCardATRHttp(CmdInfo& atrBuf)
{
	LOG4VTM(INFO, "ActiveICCardATRHttp");
	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "ActiveICCardATR";//适配器接口名
	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "ActiveICCardATRHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					int dwSizeRet = rootRet["data"]["dwSize"].asInt();
					string  dataRet = rootRet["data"]["data"].asString();

					LOG4VTM(INFO, "ActiveICCardATRHttp recvBuf.dwSize=" << dwSizeRet << ", recvBuf.dwData=" << dataRet);
					//反解析
					PBYTE pData = new BYTE[MAX_SHOW];
					ZeroMemory(pData, MAX_SHOW);
					int dataLen = StrBuf2HexBuf(dataRet.c_str(), &pData);
					ZeroMemory(atrBuf.data, MAX_SHOW);

					memcpy(atrBuf.data, pData, dataLen);//赋值
					atrBuf.dwSize = dataLen;//赋值
					LOG4VTM(INFO, "ActiveICCardATRHttp recvBuf.dwSize=" << atrBuf.dwSize << ", recvBuf.dwData=" << dataRet);
					delete[] pData;
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "ActiveICCardATRHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "ActiveICCardATRHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "ActiveICCardATRHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::ActiveContactlessICCardHttp(char fstType, char scdType, char thdType, char& outType)
{
	LOG4VTM(INFO, "ActiveContactlessICCardHttp fstType=" << fstType << ", scdType=" << scdType << ", thdType=" << thdType);
	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "ActiveContactlessICCard";//适配器接口名
	//rootReq["fstType"] = fstType;
	//rootReq["scdType"] = scdType;
	//rootReq["thdType"] = thdType;

	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "ActiveContactlessICCardHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					string outTypeRet = rootRet["data"]["outType"].asString();
					outType = outTypeRet.c_str()[0];
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "ActiveContactlessICCardHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "ActiveContactlessICCardHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "ActiveContactlessICCardHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::DeactivateICCardHttp()
{
	LOG4VTM(INFO, "DeactivateICCardHttp");
	return commonSimpleHttp("DeactivateICCard");
}

bool CardIssuerImpl::DeactContactlessICCardHttp()
{
	LOG4VTM(INFO, "DeactContactlessICCardHttp");
	return commonSimpleHttp("DeactContactlessICCard");
}

bool CardIssuerImpl::RFTypeABCommandHttp(CmdInfo sendBuf, CmdInfo& recvBuf)
{
	char* show = new char[MAX_SHOW];
	ZeroMemory(show, MAX_SHOW);
	HexBuf2StrBuf(sendBuf.data, &show, sendBuf.dwSize);

	LOG4VTM(INFO, "RFTypeABCommandHttp sendBuf=" << show);

	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "RFTypeABCommand";//适配器接口名
	//rootReq["CmdInfo"]["dwSize"] = (int)sendBuf.dwSize;
	//rootReq["CmdInfo"]["dwData"] = show;


	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	delete[] show;
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "RFTypeABCommandHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					int dwSizeRet = rootRet["data"]["dwSize"].asInt();
					string  dataRet = rootRet["data"]["data"].asString();

					LOG4VTM(INFO, "RFTypeABCommandHttp recvBuf.dwSize=" << dwSizeRet << ", recvBuf.dwData=" << dataRet);
					//反解析
					PBYTE pData = new BYTE[MAX_SHOW];
					ZeroMemory(pData, MAX_SHOW);
					int dataLen = StrBuf2HexBuf(dataRet.c_str(), &pData);
					ZeroMemory(recvBuf.data, MAX_SHOW);

					memcpy(recvBuf.data, pData, dataLen);//赋值
					recvBuf.dwSize = dataLen;//赋值
					LOG4VTM(INFO, "RFTypeABCommandHttp recvBuf.dwSize=" << recvBuf.dwSize << ", recvBuf.dwData=" << dataRet);
					delete[] pData;
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "RFTypeABCommandHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "RFTypeABCommandHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "RFTypeABCommandHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::DevOpenExHttp(DWORD dwPort, DWORD dwBaudRate, BYTE btOpenType, const char* pDevSN, BYTE& btType)
{
	LOG4VTM(INFO, "DevOpenExHttp dwPort=" << dwPort << " dwBaudRate=" << dwBaudRate << " btOpenType=" << btOpenType << " pDevSN=" << pDevSN);
	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "DevOpenEx";//适配器接口名
	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "DevOpenExHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					int btTypeRet = rootRet["data"]["btType"].asInt();
					btType = btTypeRet;
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "DevOpenExHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "DevOpenExHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "DevOpenExHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::TransferEnInitHttp(int& iStatus, BYTE*& Cr1, int& lenR1, BYTE*& Cr3, int& lenR3, BYTE*& dKey, int& lenKey)
{
	LOG4VTM(INFO, "TransferEnInitHttp");

	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "TransferEnInit";//适配器接口名


	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "TransferEnInitHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					iStatus = rootRet["data"]["iStatus"].asInt();
					if (iStatus == 0) {
						int lenR1Ret = rootRet["data"]["lenR1"].asInt();
						lenR1 = lenR1Ret;
						int lenR3Ret = rootRet["data"]["lenR3"].asInt();
						lenR3 = lenR3Ret;
						int lenKeyRet = rootRet["data"]["lenKey"].asInt();
						lenKey = lenKeyRet;

						string  Cr1Ret = rootRet["data"]["Cr1"].asString();
						string  Cr3Ret = rootRet["data"]["Cr3"].asString();
						string  dKeyRet = rootRet["data"]["dKey"].asString();

						//PBYTE pData = new BYTE[2048];
						//ZeroMemory(pData, 2048);
						//int dataLen = StrBuf2HexBuf(Cr1Ret.c_str(), &pData);
						//memcpy(Cr1, pData, dataLen);//赋值

						//ZeroMemory(pData, MAX_TRACK_SIZE);
						//dataLen = StrBuf2HexBuf(Cr3Ret.c_str(), &pData);
						//memcpy(Cr3, pData, dataLen);//赋值

						//ZeroMemory(pData, MAX_TRACK_SIZE);
						//dataLen = StrBuf2HexBuf(dKeyRet.c_str(), &pData);
						//memcpy(dKey, pData, dataLen);//赋值
						//delete[] pData;
						memcpy(Cr1, Cr1Ret.c_str(), lenR1Ret);//赋值
						memcpy(Cr3, Cr3Ret.c_str(), lenR3Ret);//赋值
						memcpy(dKey, dKeyRet.c_str(), lenKeyRet);//赋值

						LOG4VTM(INFO, "TransferEnInitHttp lenR1" << lenR1);
						LOG4VTM(INFO, "TransferEnInitHttp lenR3" << lenR3);
						LOG4VTM(INFO, "TransferEnInitHttp lenKey" << lenKey);
						LOG4VTM(INFO, "TransferEnInitHttp Cr1=" << sizeof(Cr1));
						LOG4VTM(INFO, "TransferEnInitHttp Cr3=" << sizeof(Cr3));
						LOG4VTM(INFO, "TransferEnInitHttp dKey=" << sizeof(dKey));
						return true;
					}
					else {
						return false;
					}
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "TransferEnInitHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "TransferEnInitHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "TransferEnInitHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::SetR2Http(int& iStatus, BYTE* pCr2, int lenR2)
{
	LOG4VTM(INFO, "SetR2Http pCr2Len=" << sizeof(pCr2) << ", lenR2=" << lenR2);
	if (commonSimpleHttp("SetR2")) {
		iStatus = 0;
		return true;
	}
	else {
		iStatus = 1;
		return false;
	}
}

bool CardIssuerImpl::SendWorkingKeyHttp(const char* pWorkingKey)
{
	LOG4VTM(INFO, "SendWorkingKeyHttp pWorkingKey=" << pWorkingKey);
	return commonSimpleHttp("SendWorkingKey");
}



bool CardIssuerImpl::MoveCardToSlotHttp(int slot)
{
	LOG4VTM(INFO, "MoveCardToSlotHttp slot=" << slot);
	return commonSimpleHttp("MoveCardToSlot");
}

bool CardIssuerImpl::MoveCardFromSlotHttp(int slot)
{
	LOG4VTM(INFO, "MoveCardFromSlotHttp slot=" << slot);
	return commonSimpleHttp("MoveCardFromSlot");
}

bool CardIssuerImpl::ReadAccountHttp(CardNo& cardNo)
{
	LOG4VTM(INFO, "ReadAccountHttp");
	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "ReadAccount";//适配器接口名
	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "ReadAccountHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					int dwSizeRet = rootRet["data"]["dwSize"].asInt();
					cardNo.dwSize = dwSizeRet;
					int dwTrack2SizeRet = rootRet["data"]["dwTrack2Size"].asInt();
					cardNo.dwTrack2Size = dwTrack2SizeRet;
					int dwTrack3SizeRet = rootRet["data"]["dwTrack3Size"].asInt();
					cardNo.dwTrack3Size = dwTrack3SizeRet;

					string  accountRet = rootRet["data"]["account"].asString();
					string  track2Ret = rootRet["data"]["track2"].asString();
					string  track3Ret = rootRet["data"]["track3"].asString();
					//LOG4VTM(INFO, "ReadAccountHttp cardNo.dwSize=" << cardNo.dwSize);
					//LOG4VTM(INFO, "ReadAccountHttp cardNo.dwTrack2Size=" << cardNo.dwTrack2Size);
					//LOG4VTM(INFO, "ReadAccountHttp cardNo.dwTrack3Size=" << cardNo.dwTrack3Size);
					//LOG4VTM(INFO, "ReadAccountHttp cardNo.account=" << accountRet.c_str());
					//LOG4VTM(INFO, "ReadAccountHttp cardNo.track2=" << track2Ret.c_str());
					//LOG4VTM(INFO, "ReadAccountHttp cardNo.track3=" << track3Ret.c_str());

					//PBYTE pData = new BYTE[MAX_MAG_TRACK_SIZE];
					//ZeroMemory(pData, MAX_MAG_TRACK_SIZE);
					//int dataLen = StrBuf2HexBuf(accountRet.c_str(), &pData);
					//LOG4VTM(INFO, "ReadAccountHttp cardNo.account=" << pData);
					//memcpy(cardNo.account, pData, dataLen);//赋值
					//delete[] pData;

					//pData = new BYTE[MAX_MAG_TRACK_SIZE];
					//ZeroMemory(pData, MAX_MAG_TRACK_SIZE);
					//dataLen = StrBuf2HexBuf(track2Ret.c_str(), &pData);
					//LOG4VTM(INFO, "ReadAccountHttp cardNo.track2=" << pData);
					//memcpy(cardNo.track2, pData, dataLen);//赋值
					//delete[] pData;

					//pData = new BYTE[MAX_MAG_TRACK_SIZE];
					//ZeroMemory(pData, MAX_MAG_TRACK_SIZE);
					//dataLen = StrBuf2HexBuf(track3Ret.c_str(), &pData);
					//LOG4VTM(INFO, "ReadAccountHttp cardNo.track3=" << pData);
					//memcpy(cardNo.track3, pData, dataLen);//赋值
					//delete[] pData;
					memcpy(cardNo.account, accountRet.c_str(), cardNo.dwSize);//赋值
					memcpy(cardNo.track2, track2Ret.c_str(), cardNo.dwTrack2Size);//赋值
					memcpy(cardNo.track3, track3Ret.c_str(), cardNo.dwTrack3Size);//赋值

					LOG4VTM(INFO, "ReadAccountHttp cardNo.dwSize=" << cardNo.dwSize);
					LOG4VTM(INFO, "ReadAccountHttp cardNo.dwTrack2Size=" << cardNo.dwTrack2Size);
					LOG4VTM(INFO, "ReadAccountHttp cardNo.dwTrack3Size=" << cardNo.dwTrack3Size);
					LOG4VTM(INFO, "ReadAccountHttp cardNo.account=" << strlen(cardNo.account));
					LOG4VTM(INFO, "ReadAccountHttp cardNo.track2=" << strlen(cardNo.track2));
					LOG4VTM(INFO, "ReadAccountHttp cardNo.track3=" << strlen(cardNo.track3));
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "ReadAccountHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "ReadAccountHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "ReadAccountHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::GetSlotSumHttp(int& sum)
{
	LOG4VTM(INFO, "GetSlotSumHttp");
	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "GetSlotSum";//适配器接口名
	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "GetSlotSumHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					int sumRet = rootRet["data"]["sum"].asInt();
					sum = sumRet;
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "GetSlotSumHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "GetSlotSumHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "GetSlotSumHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::QuerySlotsStatusHttp(SlotStatus& slots, const int slot, bool bFull /*= false*/)
{
	LOG4VTM(INFO, "QuerySlotsStatusHttp slot=" << slot << " bFull=" << bFull);
	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = "QuerySlotsStatus";//适配器接口名
	//rootReq["slot"] = slot;
	//rootReq["bFull"] = bFull ? 1 : 0;//转换成0和1表示

	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, "QuerySlotsStatusHttp parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					int sumRet = rootRet["data"]["dwSize"].asInt();
					slots.dwSize = sumRet;
					for (int i = 0; i < sumRet; i++) {
						slots.status[i] = rootRet["data"]["status"][i].asInt();
					}
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, "QuerySlotsStatusHttp return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, "QuerySlotsStatusHttp [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, "QuerySlotsStatusHttp req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}

bool CardIssuerImpl::PrintCardFaceRightNowHttp(const KakuPrintInfo printInfo)
{
	LOG4VTM(INFO, "PrintCardFaceRightNowHttp printInfo.formPath=" << printInfo.formPath << " printInfo.fields=" << printInfo.fields);
	return commonSimpleHttp("PrintCardFaceRightNow");
}

string CardIssuerImpl::getUrl()
{
	string urlStr = iniRead.ReadString("server", "url", "");
	if (urlStr.empty()) {
		LOG4VTM(INFO, "url is empty, use default url");
		return "http://localhost:8080/avs/imitate/simulateDataN";
	}
	else {
		return urlStr;
	}
}

bool CardIssuerImpl::commonSimpleHttp(string adapterInterName)
{
	CommonReq cReq;
	CommonRet cRet;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);

	Json::Value rootReq;
	Json::FastWriter writer;

	rootReq["ip"] = GetLocalIP();
	rootReq["entityName"] = ENTITY_NAME;
	rootReq["adapterInterName"] = adapterInterName;//适配器接口名
	string strErrPrefix = adapterInterName + "http";
	cReq.m_url = getUrl();
	cReq.m_timeOut = 30;
	string jsonReq = writer.write(rootReq);
	cReq.m_reqStr = jsonReq;//请求参数

	bool ret = client->Post(cReq, cRet);
	if (ret) {
		Json::Reader reader;
		Json::Value rootRet;
		if (!reader.parse(cRet.m_retStr, rootRet, false))
		{
			LOG4VTM(INFO, strErrPrefix << " parse resp is fail,url=" << cReq.m_url.c_str());
			return false;//失败
		}
		bool isSucc = rootRet["success"].asBool();
		if (isSucc) {
			//解析数据
			if (rootRet.isMember("data")) {
				bool isResult = rootRet["data"]["result"].asBool();
				if (isResult) {
					return true;
				}
				else {
					return false;
				}
			}
			else {
				LOG4VTM(INFO, strErrPrefix << " return [data] is null");
				return false;
			}
		}
		else {
			LOG4VTM(INFO, strErrPrefix << " [success] is false,");
			return false;
		}
	}
	else {
		LOG4VTM(INFO, strErrPrefix << " req fail,err=%s" << cRet.m_errMsg.c_str());
		return false;
	}
}