#include "stdafx2.h"
#include "MaterialMgrCnn.h"
#include "md5.h"

#if defined(RVC_OS_LINUX)

#define strncpy_s(d, l, s, n) strcpy(d, s)

#endif //RVC_OS_LINUX

CMaterialMgrCnn::CMaterialMgrCnn(CEntityBase *pEntity)
:SpSecureClient(pEntity)
{
}


CMaterialMgrCnn::~CMaterialMgrCnn()
{
}

ErrorCodeEnum CMaterialMgrCnn::GetMD5(char *pStr, BYTE md5v[16])
{
#if defined(_MSC_VER)
    HCRYPTPROV hCryptProv;
    ErrorCodeEnum rc = Error_Unexpect;

    if (CryptAcquireContextA(&hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET)) {
        HCRYPTHASH hHash;
        if (CryptCreateHash(hCryptProv, CALG_MD5, 0, 0, &hHash)) {
            CryptHashData(hHash, (LPBYTE)pStr, strlen(pStr), 0);

            DWORD dwLen = 16;
            CryptGetHashParam(hHash, HP_HASHVAL, (LPBYTE)&md5v[0], &dwLen, 0);
            rc = Error_Succeed;
        }

        CryptDestroyHash(hHash);
    }

    CryptReleaseContext(hCryptProv, 0);
    return rc;
#else
    unsigned char x[MD5_DIGESTSIZE];
    md5_ctx_t ctx;
    md5_init(&ctx);
	md5(x, pStr, strlen(pStr));
	memcpy(md5v, x, MD5_DIGESTSIZE);
	return Error_Succeed;

#endif //_MSC_VER
}

ErrorCodeEnum CMaterialMgrCnn::ModifyEnrolInfo(const char *pszUserID, const char *pszPwd, const char *pszAddr, const char *pszGPS)
{
	CSmartPointer<IPackage> pReqPkg = CreateNewPackage("ModInfo");
	
	ModifyEnrollInfoReq info = {};

	if (pszAddr != NULL)
		strncpy_s(info.EnrolAddr, sizeof(info.EnrolAddr), pszAddr, _TRUNCATE);

	if (pszGPS != NULL)
	{
		sscanf(pszGPS, "%f,%f", &info.EnrolGPS[0], &info.EnrolGPS[4]);
	}

	CSystemStaticInfo staticInfo;
	m_pEntity->GetFunction()->GetSystemStaticInfo(staticInfo);
	strncpy_s(info.TerminalNo, sizeof(info.TerminalNo), staticInfo.strTerminalID, _TRUNCATE);

	pReqPkg->AddStruct("ModInfoR", false, false, (BYTE*)&info, sizeof(info));

	if (SendPackage(pReqPkg) == "")
		return  Error_Unexpect;

	auto pRetPkg = ReceivePackage(5);
	if (pRetPkg == NULL)
		return Error_TimeOut;

	return HandleModifyEnrollInfoRet(pRetPkg);
}

ErrorCodeEnum CMaterialMgrCnn::AddTradeManage(const char *pszTerminalNo, const char *pszAgentID, const char *pszTime)
{
	auto pReqPkg = CreateNewPackage("TradeManage");

	AddTradeManageReq req = {};
	strncpy_s(req.TerminalNo, sizeof(req.TerminalNo), pszTerminalNo, _TRUNCATE);
	strncpy_s(req.AgentID, sizeof(req.AgentID), pszAgentID, _TRUNCATE);
	strncpy_s(req.Time, sizeof(req.Time), pszTime, _TRUNCATE);

	pReqPkg->AddStruct("AddTMR", false, false, (BYTE*)&req, sizeof(req));

	if (SendPackage(pReqPkg) == "")
		return Error_Unexpect;

	auto pRetPkg = ReceivePackage(5);
	if (pRetPkg == NULL)
		return Error_TimeOut;
	return HandleAddTradeManageRet(pRetPkg);
}

ErrorCodeEnum CMaterialMgrCnn::AddMaterialCounter(const char *pszTerminalNo, const char *pszMaterial)
{
	auto pReqPkg = CreateNewPackage("AddCount");
	
	AddMaterialCounterReq req = {};
	strncpy_s(req.Material, sizeof(req.Material), pszMaterial, _TRUNCATE);
	strncpy_s(req.TerminalNo, sizeof(req.TerminalNo), pszTerminalNo, _TRUNCATE);

	pReqPkg->AddStruct("AddMCR", false, false, (BYTE*)&req, sizeof(req));

	if (SendPackage(pReqPkg) == "")
		return  Error_Unexpect;

	auto pRetPkg = ReceivePackage(5);
	if (pRetPkg == NULL)
		return Error_TimeOut;

	return HandleAddMaterialCounterRet(pRetPkg);
}

ErrorCodeEnum CMaterialMgrCnn::QueryMaterialInfo(const char *pszDeviceNo, unsigned int &count, CAutoArray<CSimpleStringA> &arrDeviceNo, CAutoArray<CSimpleStringA> &arrMateriel,
	CAutoArray<CSimpleStringA> &CardGroove, CAutoArray<CSimpleStringA> &CardBoxNo, CAutoArray<CSimpleStringA> &PsbCode, CAutoArray<CSimpleStringA> &PsbName,
	CAutoArray<unsigned int> &CardInit, CAutoArray<unsigned int> &CardRemains, CAutoArray<unsigned int> &CardIssued, CAutoArray<unsigned int> &CardMixed,
	CAutoArray<unsigned int> &CardPercent, CAutoArray<CSimpleStringA> &TerminalNo, CAutoArray<CSimpleStringA> &Maintainer, CAutoArray<CSimpleStringA> &MaintainTime,
	CAutoArray<CSimpleStringA> &UpdateTime)
{
	auto pReqPkg = CreateNewPackage("QueryMC");

	QueryMaterialInfoReq req = {};
	strncpy_s(req.DeviceNo, sizeof(req.DeviceNo), pszDeviceNo, _TRUNCATE);

	pReqPkg->AddStruct("QryMCR", false, false, (BYTE*)&req, sizeof(req));

	if (SendPackage(pReqPkg) == "")
		return  Error_Unexpect;

	auto pRetPkg = ReceivePackage(5);
	if (pRetPkg == NULL)
		return Error_TimeOut;

	return HandleQueryMaterialInfoRet(pRetPkg, count, arrDeviceNo, arrMateriel, CardGroove, CardBoxNo, PsbCode, PsbName, CardInit,
		CardRemains, CardIssued, CardMixed, CardPercent, TerminalNo, Maintainer, MaintainTime, UpdateTime);
}

ErrorCodeEnum CMaterialMgrCnn::GetMaterialCounter(const char *pszMaterial, const char *pszTerminalNo, const char *pszUserID, unsigned int &nLastCapacity, unsigned int &nUsedCount)
{
	auto pReqPkg = CreateNewPackage("GetCount");
	
	GetMaterialCounterReq req = {};
	strncpy_s(req.Material, sizeof(req.Material), pszMaterial, _TRUNCATE);
	strncpy_s(req.TerminalNo, sizeof(req.TerminalNo), pszTerminalNo, _TRUNCATE);
	strncpy_s(req.Maintainer, sizeof(req.Maintainer), pszUserID, _TRUNCATE);

	pReqPkg->AddStruct("GetMCR", false, false, (BYTE*)&req, sizeof(req));

	if (SendPackage(pReqPkg) == "")
		return  Error_Unexpect;

	auto pRetPkg = ReceivePackage(5);
	if (pRetPkg == NULL)
		return Error_TimeOut;

	return HandleGetMaterialCounterRet(pRetPkg, nLastCapacity, nUsedCount);
}

ErrorCodeEnum CMaterialMgrCnn::ResetMaterialCounter(const char *pszMaterial, const char *pszTerminalNo, 
		const char *pszUserID, int nResetCapacity, int nTerminalCount,  int nRemainCount, const char *pszComment)
{
	auto pReqPkg = CreateNewPackage("ResetMC");
	
	ResetMaterialCounterReq req = {};
	strncpy_s(req.Material, sizeof(req.Material), pszMaterial, _TRUNCATE);
	strncpy_s(req.TerminalNo, sizeof(req.TerminalNo), pszTerminalNo, _TRUNCATE);
	strncpy_s(req.Maintainer, sizeof(req.Maintainer), pszUserID, _TRUNCATE);
	req.ResetCapacity = nResetCapacity;
	req.TerminalCounter = nTerminalCount;
	req.RemainCounter = nRemainCount;
	strncpy_s(req.Comment, sizeof(req.Comment), pszComment, _TRUNCATE);

	pReqPkg->AddStruct("ResetMCR", false, false, (BYTE*)&req, sizeof(req));

	if (SendPackage(pReqPkg) == "")
		return  Error_Unexpect;

	auto pRetPkg = ReceivePackage(5);
	if (pRetPkg == NULL)
		return Error_TimeOut;

	return HandleResetMaterialCounterRet(pRetPkg);
}

ErrorCodeEnum CMaterialMgrCnn::MaintainerLogin(const char* pszMaintainerID, const char *pszPassword)
{
	auto pReqPkg = CreateNewPackage("UsrLogin");
	
	UserLoginReq req = {};
	strncpy_s(req.User, sizeof(req.User), pszMaintainerID, _TRUNCATE);
	strncpy_s(req.Password, sizeof(req.Password), pszPassword, _TRUNCATE);

	pReqPkg->AddStruct("LOGINREQ", false, false, (BYTE*)&req, sizeof(req));

	if (SendPackage(pReqPkg) == "")
		return  Error_Unexpect;

	auto pRetPkg = ReceivePackage(5);
	if (pRetPkg == NULL)
		return Error_TimeOut;

	return HandleMaintainerLoginRet(pRetPkg);
}

ErrorCodeEnum CMaterialMgrCnn::RegistSwallowedCard(const char *pszTerminalType, const char *pszTerminalNo, const char *pszCardNo,
	const char *pszReasonCode, const char *pszSwallowDate, const char *pszSwallowTime, const char *pszDeviceSciNo)
{
	RegistSwallowedCardReqV2 req = {};
	strncpy_s(req.TerminalType, sizeof(req.TerminalType), pszTerminalType, _TRUNCATE);
	strncpy_s(req.TerminalNo, sizeof(req.TerminalNo), pszTerminalNo, _TRUNCATE);
	strncpy_s(req.CardNo, sizeof(req.CardNo), pszCardNo, _TRUNCATE);
	
	strncpy(req.ReasonCode, pszReasonCode, sizeof(req.ReasonCode));
	strncpy(req.SwallowDate, pszSwallowDate, sizeof(req.SwallowDate));
	strncpy(req.SwallowTime, pszSwallowTime, sizeof(req.SwallowTime));
	
	strncpy_s(req.DeviceSciNo, sizeof(req.DeviceSciNo), pszDeviceSciNo, _TRUNCATE);

	auto pReqPkg = CreateNewPackage("RegCard");
	pReqPkg->AddStruct("RegCard2", false, false, (BYTE*)&req, sizeof(req));

	if (SendPackage(pReqPkg) == "")
		return  Error_Unexpect;

	auto pRetPkg = ReceivePackage(5);
	if (pRetPkg == NULL)
		return Error_TimeOut;

	return HandleRegistSwallowedCardRet(pRetPkg);
}

ErrorCodeEnum CMaterialMgrCnn::SyncMaterialCount(const char *pszDeviceNo, DWORD dwCardBoxNum,
	CAutoArray<bool> &arrMaintainFlag, CAutoArray<CSimpleStringA> &arrMaintainer, CAutoArray<unsigned int> &arrMaintainTime,
	CAutoArray<CSimpleStringA> &arrCardBoxNo, CAutoArray<CSimpleStringA> &arrPsbCode,
	CAutoArray<CSimpleStringA> &arrPsbName, CAutoArray<unsigned int> &arrCardInit,
	CAutoArray<unsigned int> &arrCardRemains, CAutoArray<unsigned int> &arrCardIssued,
	CAutoArray<unsigned int> &arrCardMixed, CAutoArray<unsigned int> &arrCardPercent)
{
	CSystemStaticInfo info;
	m_pEntity->GetFunction()->GetSystemStaticInfo(info);

	SyncMaterialCountReq1 req1 = {};
	strncpy_s(req1.TerminalNo, sizeof(req1.TerminalNo), info.strTerminalID, _TRUNCATE);
	strncpy_s(req1.DeviceNo, sizeof(req1.DeviceNo), pszDeviceNo, _TRUNCATE);
	strncpy_s(req1.Material, sizeof(req1.Material), "DebitCard", _TRUNCATE);
	req1.CardBoxNum = dwCardBoxNum;

	// 最后一个数组列放吞卡计数
	char buf[1024] = {};
	assert(sizeof(SyncMaterialCountReq2) * (dwCardBoxNum +1)< 1024);
	SyncMaterialCountReq2 *pReq2 = (SyncMaterialCountReq2*)buf;
	for (int i = 0; i <= dwCardBoxNum; i++)
	{
		pReq2[i].bMaintain= arrMaintainFlag[i];
		if (arrMaintainFlag[i])
		{
			strncpy_s(pReq2[i].Maintainer, sizeof(pReq2[i].Maintainer), arrMaintainer[i], _TRUNCATE);
			pReq2[i].MaintainTime = arrMaintainTime[i];
		}

		strncpy_s(pReq2[i].CardBoxNo, sizeof(pReq2[i].CardBoxNo), arrCardBoxNo[i], _TRUNCATE);
		strncpy_s(pReq2[i].PsbCode, sizeof(pReq2[i].PsbCode), arrPsbCode[i], _TRUNCATE);
		strncpy_s(pReq2[i].PsbName, sizeof(pReq2[i].PsbName), arrPsbName[i], _TRUNCATE);
		pReq2[i].CardInit = arrCardInit[i];
		pReq2[i].CardRemains = arrCardRemains[i];
		pReq2[i].CardIssued = arrCardIssued[i];
		pReq2[i].CardMixed = arrCardMixed[i];
		pReq2[i].CardPercent = arrCardPercent[i];
	}

	auto pReqPkg = CreateNewPackage("SyncMC");
	pReqPkg->AddStruct("SyncMC1", false, false, (BYTE*)&req1, sizeof(req1));
	pReqPkg->AddStruct("SyncMC2", false, false, (BYTE*)pReq2, sizeof(SyncMaterialCountReq2)*(dwCardBoxNum+1), dwCardBoxNum+1);

	if (SendPackage(pReqPkg) == "")
		return  Error_Unexpect;

	auto pReplyPkg = ReceivePackage(5);
	if (pReplyPkg == NULL || pReplyPkg->GetServiceCode() != "SyncMC")
		return Error_TimeOut;

	return HandleSyncMaterialCount(pReplyPkg);
}

void CMaterialMgrCnn::OnDisconnect()
{
	Dbg("connection disconnected");
}

void CMaterialMgrCnn::OnPkgAnswer(const CSmartPointer<IPackage> &pRecvPkg)
{
	string serviceCode = pRecvPkg->GetServiceCode();
	if (serviceCode == "ModInfo")
	{
		HandleModifyEnrollInfoRet(pRecvPkg);
	}
	else if (serviceCode == "AddCount")
	{
		HandleAddMaterialCounterRet(pRecvPkg);
	}
	else if (serviceCode == "TradeManage")
	{
		HandleAddTradeManageRet(pRecvPkg);
	}
	else if (serviceCode == "QryMC")
	{
		unsigned int count;
		CAutoArray<CSimpleStringA> arrDeviceNo, arrMateriel, CardGroove, CardBoxNo, PsbCode, PsbName, TerminalNo, Maintainer, MaintainTime, UpdateTime;
		CAutoArray<unsigned int> CardInit, CardRemains, CardIssued, CardMixed, CardPercent;
		HandleQueryMaterialInfoRet(pRecvPkg, count, arrDeviceNo, arrMateriel, CardGroove, CardBoxNo, PsbCode, PsbName, CardInit, CardRemains, CardIssued, CardMixed, CardPercent,
			TerminalNo, Maintainer, MaintainTime, UpdateTime);
	}
	else if (serviceCode == "GetCount")
	{
		unsigned int nCapacity(0), nCount(0);
		HandleGetMaterialCounterRet(pRecvPkg, nCapacity, nCount);
	}
	else if (serviceCode == "ResetMC")
	{
		HandleResetMaterialCounterRet(pRecvPkg);
	}
	else if (serviceCode == "UsrLogin")
	{
		HandleMaintainerLoginRet(pRecvPkg);
	}
	else if (serviceCode == "RegCard")
	{
		HandleRegistSwallowedCardRet(pRecvPkg);
	}
	else if (serviceCode == "SyncMC")
	{
		HandleSyncMaterialCount(pRecvPkg);
	}
	else
	{
		Dbg("unknown service code: %s", serviceCode.c_str());
	}
}

ErrorCodeEnum CMaterialMgrCnn::HandleModifyEnrollInfoRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, rc, dwUserCode, 
			CSimpleStringA::Format("modify terminal enroll info fail, %s", strErrMsg.c_str()));
		
		return rc;
	}

	Dbg("modify terminal deployment info succeed");
	return Error_Succeed;
}

ErrorCodeEnum CMaterialMgrCnn::HandleAddTradeManageRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, rc, dwUserCode,
			CSimpleStringA::Format("add terminal trade manage fail, %s", strErrMsg.c_str()));

		return rc;
	}

	Dbg("add terminal trade manage succeed");
	return Error_Succeed;
}


ErrorCodeEnum CMaterialMgrCnn::HandleAddMaterialCounterRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, rc, dwUserCode, 
			CSimpleStringA::Format("add terminal material counter fail, %s", strErrMsg.c_str()));
		
		return rc;
	}

	Dbg("add terminal material counter succeed");
	return Error_Succeed;
}

//查询物料信息
ErrorCodeEnum CMaterialMgrCnn::HandleQueryMaterialInfoRet(const CSmartPointer<IPackage> &pRecvPkg, unsigned int &count,
	CAutoArray<CSimpleStringA> &arrDeviceNo, CAutoArray<CSimpleStringA> &arrMateriel, CAutoArray<CSimpleStringA> &CardGroove,
	CAutoArray<CSimpleStringA> &CardBoxNo, CAutoArray<CSimpleStringA> &PsbCode, CAutoArray<CSimpleStringA> &PsbName, CAutoArray<unsigned int> &CardInit,
	CAutoArray<unsigned int> &CardRemains, CAutoArray<unsigned int> &CardIssued, CAutoArray<unsigned int> &CardMixed, CAutoArray<unsigned int> &CardPercent,
	CAutoArray<CSimpleStringA> &TerminalNo, CAutoArray<CSimpleStringA> &Maintainer, CAutoArray<CSimpleStringA> &MaintainTime, CAutoArray<CSimpleStringA> &UpdateTime)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, rc, dwUserCode, CSimpleStringA::Format("query material info fail, %s", strErrMsg.c_str()));

		return rc;
	}

	//Dbg("get material counter succeed");
	QueryMaterialInfoRet1 ret = {};
	int nRetSize = sizeof(ret);
	int nArrayNum = 0;
	if (!pRecvPkg->GetStructData("QryMCA1", (BYTE*)&ret, &nRetSize, &nArrayNum))
	{
		Dbg("get struct {QryMCA1} fail");
		return Error_Param;
	}
	else
		Dbg("get struct {QryMCA1} success, count:%d", ret.count);

	QueryMaterialInfoRetDate *ret2 = new QueryMaterialInfoRetDate[ret.count];
	ZeroMemory(ret2, sizeof(QueryMaterialInfoRetDate) * ret.count);
	nRetSize = sizeof(QueryMaterialInfoRetDate) * ret.count;
	nArrayNum = 0;

	if (!pRecvPkg->GetStructData("QryMCA2", (BYTE *)ret2, &nRetSize, &nArrayNum))
	{
		Dbg("get struct {QryMCA2} fail");
		delete []ret2;
		return Error_Param;
	}
	else
	{
		Dbg("get struct {QryMCA2} success, retSize:%d, arrayNum:%d", nRetSize, nArrayNum);
	}


	// 返回物料数
	count = ret.count;
	arrDeviceNo.Init(count + 1);arrMateriel.Init(count + 1);CardGroove.Init(count + 1);CardBoxNo.Init(count + 1);PsbCode.Init(count + 1);PsbName.Init(count + 1);CardInit.Init(count + 1);
	CardRemains.Init(count + 1);CardIssued.Init(count + 1);	CardMixed.Init(count + 1);CardPercent.Init(count + 1);TerminalNo.Init(count + 1);Maintainer.Init(count + 1);
	MaintainTime.Init(count + 1);UpdateTime.Init(count + 1);
	for (int i = 0; i < count; i++)
	{
		arrDeviceNo[i] = ret2[i].DeviceNo;
		arrMateriel[i] = ret2[i].Materiel;
		CardGroove[i] = ret2[i].CardGroove;
		CardBoxNo[i] = ret2[i].CardBoxNo;
		char tempStr[200] = "";
#if defined(_MSC_VER)
        strncpy_s(tempStr, ret2[i].PsbCode, sizeof(ret2[i].PsbCode));
#else
		strcpy(tempStr, ret2[i].PsbCode);
#endif //_MSC_VER
		tempStr[4] = '\0';
		PsbCode[i] = tempStr;
		PsbName[i] = ret2[i].PsbName;
		CardInit[i] = ret2[i].CardInit;
		CardRemains[i] = ret2[i].CardRemains;
		CardIssued[i] = ret2[i].CardIssued;
		CardMixed[i] = ret2[i].CardMixed;
		CardPercent[i] = ret2[i].CardPercent;
		TerminalNo[i] = ret2[i].TerminalNo;
		Maintainer[i] = ret2[i].Maintainer;
		MaintainTime[i] = ret2[i].MaintainTime;
		UpdateTime[i] = ret2[i].UpdateTime;
	}
	delete []ret2;
	return Error_Succeed;
	
}

ErrorCodeEnum CMaterialMgrCnn::HandleGetMaterialCounterRet(const CSmartPointer<IPackage> &pRecvPkg, 
	unsigned int &nLastCapacity, unsigned int &nUsedCount)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, rc, dwUserCode, CSimpleStringA::Format("get material counter fail, %s", strErrMsg.c_str()));

		return rc;
	}

	//Dbg("get material counter succeed");
	GetMaterialCounterRet ret = {};
	int nRetSize = sizeof(ret);
	int nArrayNum = 0;
	if (!pRecvPkg->GetStructData("GetMCA", (BYTE*)&ret, &nRetSize, &nArrayNum))
	{
		LogError(Severity_Middle, Error_Param, 0, "get struct {GetMCA} fail");
		return Error_Param;
	}

	// 返回物料数
	nLastCapacity = ret.Capacity;
	nUsedCount = ret.Counter;
	return Error_Succeed;
}

ErrorCodeEnum CMaterialMgrCnn::HandleResetMaterialCounterRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, rc, dwUserCode, 
			CSimpleStringA::Format("reset material counter fail, %s", strErrMsg.c_str()));
		
		return rc;
	}

	Dbg("reset material counter succeed");
	return Error_Succeed;
}

ErrorCodeEnum CMaterialMgrCnn::HandleMaintainerLoginRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;		
		LogError(Severity_Middle, rc, dwUserCode,  CSimpleStringA::Format("maintainer login fail, %s", strErrMsg.c_str()));
		
		return rc;
	}

	Dbg("maintainer login succeed");
	return rc;
}

ErrorCodeEnum CMaterialMgrCnn::HandleRegistSwallowedCardRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, rc, dwUserCode, CSimpleStringA::Format("regist swallowed card fail, %s", strErrMsg.c_str()));
	}
	else
		Dbg("regist swallowed card succeed");

	return rc;
}

ErrorCodeEnum CMaterialMgrCnn::HandleSyncMaterialCount(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, rc, dwUserCode, CSimpleStringA::Format("sync material count fail, %s", strErrMsg.c_str()));
	}
	else
		Dbg("sync material count succeed");

	return rc;
}