liuye / etradeclient · Files

#include "stdafx.h"

#include "etradeclient/hardware/hardware_cmd.h"

#include <sstream>

#include <boost/algorithm/string.hpp>
#include <boost/property_tree/json_parser.hpp>

//#include "etradeclient/boost_patch/property_tree/json_parser.hpp" // WARNIING! Make sure to include our patched version.
#include "etradeclient/utility/logging.h"
#include "etradeclient/utility/string_converter.h"
#include "etradeclient/utility/application_config.h"

#include "etradeclient/hardware/pin_pad.h"
#include "etradeclient/hardware/id_card_reader.h"
#include "etradeclient/hardware/dili_card_device.h"
#include "etradeclient/hardware/bank_card_reader.h"
#include "etradeclient/hardware/password_machine.h"
#include "ETradeClient/utility/openssl_aes_cbc.h"
#include "../hardware/AES.h"
#include "etradeclient/utility/win_http.h"
#include "etradeclient/utility/logging.h"
#include "etradeclient/utility/url_regex.h"
#include "etradeclient/utility/url_config.h"

namespace StatusCode
{
	static const std::string OK = ""; // 操作成功.

	static const std::string PINPAD_CONNECT_FAILED = "100"; // 连接密码键盘失败. 
	static const std::string PINPAD_TIMEOUT = "101"; // 用户密码输入超时. 
	static const std::string PINPAD_CANCELLED = "102"; // 用户取消密码输入. 
	static const std::string PINPAD_READ_FAILED = "103"; // 读取密码失败. 

	static const std::string ID_CARD_READER_CONNECT_FAILED = "200"; // 连接身份证读卡器失败. 
	static const std::string ID_CARD_READER_VERIFY_FAILED = "201"; // 身份证验证失败.
	static const std::string ID_CARD_READER_READ_FAILED = "202"; // 读取身份证信息失败.

	static const std::string CPU_CARD_DEVICE_CONNECT_FAILED = "300"; // 打开CPU卡读卡器失败. 
	static const std::string CPU_CARD_DEVICE_CANNOT_FIND_CARD = "301"; // 无法找到卡片，请放卡到读卡器上(或重新放置卡片).
	
	static const std::string DILI_CARD_DEVICE_ACTIVATE_CARD_FAILED = "302"; // 卡片激活失败, 请检查该卡是否已处于激活状态.
	static const std::string DILI_CARD_DEVICE_RESET_CARD_FAILED = "303"; // 卡片撤销激活失败, 请检查该卡是否已处于未激活状态.
	static const std::string DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED = "304"; // 读取卡片基本信息失败.
	static const std::string DILI_CARD_DEVICE_READ_SERVICE_INFO_FAILED = "305"; // 读取卡片业务信息失败.
	static const std::string DILI_CARD_DEVICE_WRITE_SERVICE_INFO_FAILED = "306"; // 写入卡片业务信息失败.
	static const std::string DILI_CARD_DEVICE_WRITE_UNMATCHED_CARD = "307"; // 写卡卡片的序列号不匹配.

	static const std::string PWD_MACHINE_CONNECT_FAILED = "401"; // 连接加密机失败.
	static const std::string PWD_MACHINE_GET_KEY_FAILED = "402"; // 从加密机读取密钥失败.

	static const std::string BANK_CARD_READ_CARD_NUM_FAILED = "501"; // 读取银行卡卡号失败.

	static const std::string SCANNER_READ_DATA_FAILED = "601"; //扫码枪扫描数据失败。
}

namespace 
{
	const PINPad& PINPad_()
	{
		static PINPad pin_pad;
		return pin_pad;
	}

	const IDCardReader& IDCardReader_()
	{
		static IDCardReader id_card_reader;
		return id_card_reader;
	}

	const DILICard::RWDevice& DILICardRWDevice()
	{
		static DILICard::RWDevice dili_card_device;
		return dili_card_device;
	}

	const PWDMachine& PWDMachine_()
	{
		static PWDMachine pwd_machine;
		return pwd_machine;
	}

	const BankCardReader& BankCardReader_()
	{
		static BankCardReader bank_card_reader;
		return bank_card_reader;
	}

	std::string g_sCardNum;//用于办卡时，保证操作的卡片是同一张
}

ReadPINPadCmd::Reply ReadPINPadCmd::Execute(const std::string& input)
{
	LOG_TRACE(L"读取用户输入密码。");
	const uint8_t PWD_MAX_LEN = ApplicationConfig::Instance().PINPadPWDLen();
	const uint8_t TIMEOUT = ApplicationConfig::Instance().PINPadTimeout();
	auto& pin_pad = PINPad_();
	std::string pwd("");
	Reply reply;
	do
	{
		try
		{
			if (!pin_pad.Connect())
			{
				LOG_ERROR(L"连接密码键盘失败。");
				reply.error_code = StatusCode::PINPAD_CONNECT_FAILED;
				break;
			}
			pin_pad.DisplayBuiltInText(PINPad::BuiltInText::kEnterPWD);
			pin_pad.PlayVoice(PINPad::BuiltInVoice::kEnterPWD);
			pin_pad.SetPWDMaxLen(PWD_MAX_LEN);
			PINPad::StatusCode res = pin_pad.ReadUserInputPWD(PINPad::DispMode::kEncrypted, PINPad::DispLine::kL2, TIMEOUT, pwd);
			if (PINPad::StatusCode::kCancelled == res)
			{
				reply.error_code = StatusCode::PINPAD_CANCELLED;
				LOG_ERROR(L"用户取消密码输入。");
			}
			else if (PINPad::StatusCode::kTimeout == res)
			{
				reply.error_code = StatusCode::PINPAD_TIMEOUT;
				LOG_ERROR(L"用户输入密码超时。");
			}
			else if (PINPad::StatusCode::kUnknown == res)
			{
				reply.error_code = StatusCode::PINPAD_READ_FAILED;
				LOG_ERROR(L"读取用户输入密码失败，请确认密码键盘连接正常！");
			}
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取用户输入密码发生异常，异常信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::PINPAD_READ_FAILED;
			break;
		}
	} while (0);
	pin_pad.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"读取用户输入密码成功。");

	reply.data.put("password", pwd);
	return reply;
}

ReadPINPadCmd::Reply ReadIDCardCmd::Execute(const std::string& input)
{
	LOG_TRACE(L"读取身份证信息。");
	auto& id_card_reader = IDCardReader_();
	Reply reply;
	IDCardInfo id_card_info;
	do
	{
		try
		{
			if (!id_card_reader.Connect())
			{
				LOG_ERROR(L"建立身份证读卡器连接失败！");
				reply.error_code = StatusCode::ID_CARD_READER_CONNECT_FAILED;
				break;
			}
			if (!id_card_reader.VerifyCard())
			{
				LOG_ERROR(L"未找到身份证或身份证验证失败！");
				reply.error_code = StatusCode::ID_CARD_READER_VERIFY_FAILED;
				break;
			}
			id_card_info = id_card_reader.ReadCard();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取身份证信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::ID_CARD_READER_READ_FAILED;
			break;
		}
	} while (0);
	id_card_reader.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"读取身份证信息成功。");

	reply.data.put("id", wstr_2_str(id_card_info.id_code));
	reply.data.put("name", wstr_2_str(id_card_info.name)); // Use 'wstr_2_str' to convert to UTF-8 string.
	reply.data.put("gender", wstr_2_str(id_card_info.gender));
	reply.data.put("nation", wstr_2_str(id_card_info.nation));
	reply.data.put("birthday", wstr_2_str(id_card_info.birth_date));
	reply.data.put("address", wstr_2_str(id_card_info.address));
	reply.data.put("portrait_img_path", wstr_2_str(id_card_info.portrait_img_path));
	reply.data.put("depart", wstr_2_str(id_card_info.depart));
	reply.data.put("start_date", wstr_2_str(id_card_info.start_date));
	reply.data.put("end_date", wstr_2_str(id_card_info.end_date));
	return reply;
}

ReadPINPadCmd::Reply ActivateDILICardCmd::Execute(const std::string& input)
{
	Reply reply;
	LOG_TRACE(L"卡片激活。");
	
	std::string card_sn;
	std::string key_DCCK, key_F0015_DACK, key_F0015_DEAK, key_F0015_DAMK1;
	DILICard::BasicInfo card_basic_info;
	bool bIsEncrypt = ApplicationConfig::Instance().IsEncrypt();
	uint8_t u8EncrypType = ApplicationConfig::Instance().EncryptType();
	auto& dili_card_device = DILICardRWDevice();
	do 
	{
		try
		{
			dili_card_device.Connect();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}
		try
		{
			dili_card_device.FindCard();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"寻卡失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
			break;
		}

		DILICard::BasicInfo stuCardBasicInfo;
		try { stuCardBasicInfo = dili_card_device.ReadCardBasicInfo(); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片基本信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
			break;
		}

		card_sn = stuCardBasicInfo.chip_num + std::string("44494c49") + stuCardBasicInfo.chip_num;

		if (bIsEncrypt)
		{
			const std::string PWD_MACHINE_IP = ApplicationConfig::Instance().PWDMachineIP();
			const uint32_t PWD_MACHINE_PORT = ApplicationConfig::Instance().PWDMachinePort();
			const uint8_t TIMEOUT = ApplicationConfig::Instance().PWDMachineTimeout();

			if (u8EncrypType == 0)
			{
				auto& pwd_machine = PWDMachine_();

				if (!pwd_machine.Connect(PWD_MACHINE_IP, PWD_MACHINE_PORT))
				{
					LOG_ERROR(L"连接加密机失败！");
					reply.error_code = StatusCode::PWD_MACHINE_CONNECT_FAILED;
				}

				try
				{
					key_DCCK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kDCCK>(), card_sn, TIMEOUT);
					key_F0015_DACK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DACK>(), card_sn, TIMEOUT);
					key_F0015_DEAK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DEAK>(), card_sn, TIMEOUT);
					key_F0015_DAMK1 = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DAMK1>(), card_sn, TIMEOUT);
				}
				catch (std::exception& ex)
				{
					LOG_FATAL(L"从加密机读取密钥失败，错误信息： " + str_2_wstr(ex.what()));
					reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
					break;
				}

				pwd_machine.Disconnect();
			} 
			else if (u8EncrypType == 1)
			{
				try
				{
					key_DCCK = AES_CBC::Encrypt(card_sn, 1);
					key_F0015_DACK = AES_CBC::Encrypt(card_sn, 2);
					key_F0015_DEAK = AES_CBC::Encrypt(card_sn, 3);
					key_F0015_DAMK1 = AES_CBC::Encrypt(card_sn, 4);
				}
				catch (std::exception& ex)
				{
					LOG_FATAL(L"软加密密钥失败");
					reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
					break;
				}
			}
		}
		else
		{
			key_DCCK = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0";
			key_F0015_DACK = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6";
			key_F0015_DEAK = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7";
			key_F0015_DAMK1 = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8";
		}

		try
		{
			dili_card_device.ActivateCard(card_sn, key_DCCK, key_F0015_DACK, key_F0015_DEAK, key_F0015_DAMK1);
			card_basic_info = dili_card_device.ReadCardBasicInfo();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"卡片激活失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_ACTIVATE_CARD_FAILED;
			break;
		}
		
	} while (0);
	
	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"卡片激活成功。");

	reply.data.put("chipNo", card_basic_info.chip_num);
	reply.data.put("deviceId", card_basic_info.device_id);
	reply.data.put("type", card_basic_info.type_code);
	reply.data.put("issuerCode", card_basic_info.issuer_code);
	reply.data.put("verifyCode", card_basic_info.verify_code);
	return reply;
}

ReadPINPadCmd::Reply ResetDILICardCmd::Execute(const std::string& input)
{
	//const uint8_t BEEP_TIME = 20; // 20 * 10ms
	

	LOG_TRACE(L"卡片撤销激活。");
	auto& dili_card_device = DILICardRWDevice();
	
	Reply reply;
	std::string card_sn;
	std::string key_DCCK, key_F0015_DACK;
	DILICard::BasicInfo card_basic_info;

	uint8_t u8EncrypType = ApplicationConfig::Instance().EncryptType();
	bool bIsEncrypt = ApplicationConfig::Instance().IsEncrypt();

	do
	{
		try
		{
			dili_card_device.Connect();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}
		try
		{
			dili_card_device.FindCard();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"寻卡失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
			break;
		}

		DILICard::BasicInfo stuCardBasicInfo;
		try { stuCardBasicInfo = dili_card_device.ReadCardBasicInfo(); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片基本信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
			break;
		}
		card_sn = stuCardBasicInfo.device_id;

		if (bIsEncrypt)
		{
			if (u8EncrypType == 0)
			{
				const std::string PWD_MACHINE_IP = ApplicationConfig::Instance().PWDMachineIP();
				const uint32_t PWD_MACHINE_PORT = ApplicationConfig::Instance().PWDMachinePort();
				const uint8_t TIMEOUT = ApplicationConfig::Instance().PWDMachineTimeout();

				auto& pwd_machine = PWDMachine_();

				if (!pwd_machine.Connect(PWD_MACHINE_IP, PWD_MACHINE_PORT))
				{
					LOG_ERROR(L"连接加密机失败！");
					reply.error_code = StatusCode::PWD_MACHINE_CONNECT_FAILED;
					break;
				}

				try
				{
					key_DCCK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kDCCK>(), card_sn, TIMEOUT);
					key_F0015_DACK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DACK>(), card_sn, TIMEOUT);
				}
				catch (std::exception& ex)
				{
					LOG_FATAL(L"从加密机读取密钥失败，错误信息： " + str_2_wstr(ex.what()));
					reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
					break;
				}

				pwd_machine.Disconnect();
			}
			else if (u8EncrypType == 1)
			{
				key_DCCK = AES_CBC::Encrypt(card_sn, 1);
				key_F0015_DACK = AES_CBC::Encrypt(card_sn, 2);
			}
		}
		else
		{
			key_DCCK = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0";
			key_F0015_DACK = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6";
		}
		
		try
		{
			if (bIsEncrypt)
			{
				dili_card_device.ResetCard(key_DCCK, key_F0015_DACK);
			}
			card_basic_info = dili_card_device.ReadCardBasicInfo();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"卡片撤销激活失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_RESET_CARD_FAILED;
			break;
		}
	} while (0);
	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"卡片撤销激活成功。");

	reply.data.put("chipNo", card_basic_info.chip_num);
	reply.data.put("deviceId", card_basic_info.device_id);
	reply.data.put("type", card_basic_info.type_code);
	reply.data.put("issuerCode", card_basic_info.issuer_code);
	reply.data.put("verifyCode", card_basic_info.verify_code);
	return reply;
}

ReadPINPadCmd::Reply ReadDILICardBasicInfoCmd::Execute(const std::string& input)
{
	LOG_TRACE(L"读取卡片基本信息。");
	auto& dili_card_device = DILICardRWDevice();
	Reply reply;
	DILICard::BasicInfo card_basic_info;
	do
	{
		try 
		{ 
			dili_card_device.Connect(); 
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}
		try
		{
			dili_card_device.FindCard();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"寻卡失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
			break;
		}

		try { card_basic_info = dili_card_device.ReadCardBasicInfo(); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片基本信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
			break;
		}

		
	} while (0);
	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"读取卡片基本信息成功。");

	reply.data.put("chipNo", card_basic_info.chip_num);
	reply.data.put("deviceId", card_basic_info.device_id);
	reply.data.put("type", card_basic_info.type_code);
	reply.data.put("issuerCode", card_basic_info.issuer_code);
	reply.data.put("verifyCode", card_basic_info.verify_code);
	g_sCardNum = card_basic_info.device_id;
	return reply;
}

ReadPINPadCmd::Reply ReadDILICardServiceInfoCmd::Execute(const std::string& input)
{
	bool bIsEncrypt = ApplicationConfig::Instance().IsEncrypt();
	uint8_t u8EncrypType = ApplicationConfig::Instance().EncryptType();
	LOG_TRACE(L"读取卡片业务信息。");
	auto& dili_card_device = DILICardRWDevice();
	
	Reply reply;
	std::string card_sn;
	std::string key_r;
	std::string service_data;
	do
	{
		try
		{
			dili_card_device.Connect();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}
		try
		{
			dili_card_device.FindCard();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"寻卡失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
			break;
		}

		DILICard::BasicInfo stuCardBasicInfo;
		try { stuCardBasicInfo = dili_card_device.ReadCardBasicInfo(); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片基本信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
			break;
		}
		card_sn = stuCardBasicInfo.device_id;

		if (bIsEncrypt)
		{
			if (u8EncrypType == 0)
			{
				auto& pwd_machine = PWDMachine_();
				const std::string PWD_MACHINE_IP = ApplicationConfig::Instance().PWDMachineIP();
				const uint32_t PWD_MACHINE_PORT = ApplicationConfig::Instance().PWDMachinePort();
				const uint8_t TIMEOUT = ApplicationConfig::Instance().PWDMachineTimeout();

				if (!pwd_machine.Connect(PWD_MACHINE_IP, PWD_MACHINE_PORT))
				{
					LOG_ERROR(L"连接加密机失败！");
					reply.error_code = StatusCode::PWD_MACHINE_CONNECT_FAILED;
					break;
				}

				try { key_r = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DEAK>(), card_sn, TIMEOUT); }
				catch (std::exception& ex)
				{
					LOG_FATAL(L"从加密机读取密钥失败，错误信息： " + str_2_wstr(ex.what()));
					reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
					break;
				}

				pwd_machine.Disconnect();
			}
			else if (u8EncrypType == 1)
			{
				key_r = AES_CBC::Encrypt(card_sn, 3);
			}
		}
		else
		{
			key_r = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7";
		}

		try { service_data = dili_card_device.ReadCardServiceInfo(key_r); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片业务信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_SERVICE_INFO_FAILED;
			break;
		}
	} while (0);
	
	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"读取卡片业务信息成功。");

	reply.data.put("", service_data);
	return reply;
}

ReadPINPadCmd::Reply WriteDILICardServiceInfoCmd::Execute(const std::string& input)
{
	const char DATA_SPLITER = ':';
	bool bIsEncrypt = ApplicationConfig::Instance().IsEncrypt();
	uint8_t u8EncrypType = ApplicationConfig::Instance().EncryptType();

	LOG_TRACE(L"写入卡片业务信息。");
	auto& dili_card_device = DILICardRWDevice();
	
	Reply reply;
	std::string card_sn;
	std::string key_w;
	do
	{
		try
		{
			dili_card_device.Connect();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}
		try
		{
			dili_card_device.FindCard();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"寻卡失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
			break;
		}

		DILICard::BasicInfo stuCardBasicInfo;
		try { stuCardBasicInfo = dili_card_device.ReadCardBasicInfo(); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片基本信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
			break;
		}
		card_sn = stuCardBasicInfo.device_id;

		std::size_t index = input.find(DATA_SPLITER);
		if (std::string::npos == index) // NOT found.
		{
			LOG_ERROR(L"写入卡片业务信息失败，错误信息：请求数据错误。");
			reply.error_code = StatusCode::DILI_CARD_DEVICE_WRITE_SERVICE_INFO_FAILED;
			break;
		}
		std::string device_id = g_sCardNum;//用于办卡时，保证操作的卡片是同一张;
		std::string service_data = input.substr(index + 1, input.size() - index - 1);

		// 验证操作的是否是同一张卡，即device_id是否匹配
		if (!boost::iequals(card_sn, device_id))
		{
			LOG_ERROR(L"写卡卡片的序列号不匹配！");
			reply.error_code = StatusCode::DILI_CARD_DEVICE_WRITE_UNMATCHED_CARD;
			break;
		}

		if (bIsEncrypt)
		{
			if (u8EncrypType == 0)
			{
				auto& pwd_machine = PWDMachine_();

				const std::string PWD_MACHINE_IP = ApplicationConfig::Instance().PWDMachineIP();
				const uint32_t PWD_MACHINE_PORT = ApplicationConfig::Instance().PWDMachinePort();
				const uint8_t TIMEOUT = ApplicationConfig::Instance().PWDMachineTimeout();

				if (!pwd_machine.Connect(PWD_MACHINE_IP, PWD_MACHINE_PORT))
				{
					LOG_ERROR(L"连接加密机失败！");
					reply.error_code = StatusCode::PWD_MACHINE_CONNECT_FAILED;
					break;
				}

				try { key_w = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DAMK1>(), card_sn, TIMEOUT); }
				catch (std::exception& ex)
				{
					LOG_FATAL(L"从加密机读取密钥失败，错误信息： " + str_2_wstr(ex.what()));
					reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
					break;
				}
				
				pwd_machine.Disconnect();
			}
			else if (u8EncrypType == 1)
			{
				key_w = AES_CBC::Encrypt(card_sn, 4);
			}
		}
		else
		{
			key_w = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8";
		}
		
		try { dili_card_device.WriteCardServiceInfo(key_w, service_data); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"写入卡片业务信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_WRITE_SERVICE_INFO_FAILED;
			break;
		}

		
	} while (0);
	
	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"写入卡片业务信息成功。");
	reply.data.put("", "");
	return reply;
}

ReadPINPadCmd::Reply ReadBankCardNumCmd::Execute(const std::string& input)
{
	LOG_TRACE(L"读取银行卡号。");
	auto& bank_card_reader = BankCardReader_();
	std::string bank_card_no("");
	Reply reply;
	do
	{
		try
		{
			if (!bank_card_reader.Connect())
			{
				LOG_ERROR(L"连接银行卡读卡器失败。");
				reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
				break;
			}
			bank_card_no = bank_card_reader.ReadBankCardNum();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取银行卡号失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::BANK_CARD_READ_CARD_NUM_FAILED;
			break;
		}
	} while (0);
	bank_card_reader.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"读取银行卡号成功。");

	reply.data.put("chipNo", bank_card_no);
	return reply;
}

ReadPINPadCmd::Reply DecodeScannerCmd::Execute(const std::string& input)
{
	LOG_TRACE(L"读取扫码枪数据。");
	Reply reply;
	/*unsigned char *in_data = new unsigned char[input.size()];
	unsigned char *out_data = new unsigned char[input.size()];
	memset(in_data, 0, input.size());
	memset(out_data, 0, input.size());
	memcpy(in_data, input.c_str(), input.size());

	AESDecode(in_data, input.size(), out_data);

	std::string s_len;
	for (int index = 0; index < 4; ++index)
	{
		s_len += out_data[index];
	}
	int len = std::stoi(s_len);

	std::string real_data;
	for (int index = 4; index < len; ++index)
	{
		real_data += out_data[index];
	}

	delete in_data;
	delete out_data;

	reply.data.put("plaint_data", real_data);*/

	auto& url_cfg = URLConfig::Instance();
	const uint32_t kHTTPOK = 200;
	WinHttp win_http;
	win_http.ConnectHost(url_cfg.DecodeHost(), url_cfg.Port(), url_cfg.IsHttps());
	auto& request = win_http.OpenRequest(WinHttp::Method::POST, url_cfg.DecodePath());
	request.SetPostData("{\"data\":\"" + input + "\"}");
	request.Send();
	uint32_t status_code = request.GetResponseStatus();
	if (kHTTPOK != status_code)
	{
		LOG_ERROR(L"网络请求错误！ 错误码: " + std::to_wstring(status_code));
		reply.error_code = StatusCode::SCANNER_READ_DATA_FAILED;
		return reply;
	}
	std::string response_body = request.ReadResponseBody();
	if (response_body.empty())
	{
		LOG_ERROR(L"获取服务器响应数据失败，请确保网络连接正常！");
		reply.error_code = StatusCode::SCANNER_READ_DATA_FAILED;
		return reply;
	}

	namespace PT = boost::property_tree;
	bool login_res = false;
	try //Parse the configuration file
	{
		PT::ptree ptree, pchildtree;
		std::stringstream ss;
		ss << response_body;
		PT::read_json(ss, ptree);
		pchildtree = ptree.get_child("data");
		std::string res = pchildtree.get<std::string>("data");
		reply.data.put("plaint_data", res);
	}
	catch (...)
	{
		LOG_ERROR(L"解析服务器返回的登录结果信息时出错！请确认返回数据不为空，返回的数据格式为正确的Json格式！");
		reply.error_code = StatusCode::SCANNER_READ_DATA_FAILED;
		return reply;
	}
	return reply;
}