Эх сурвалжийг харах

Z991239-5317 #comment 卡机新增cardissuerStand接口

Signed-Off-By: commit-hook
刘文涛80174520 1 жил өмнө
parent
commit
700b1f4268

+ 17 - 17
Module/mod_CardIssuerStand/CardIssuerFSM.cpp

@@ -8,7 +8,7 @@
 //oilyang@20200522 go on using
 // deprecated!! [4/17/2020 16:15 @Gifur]
 #include "CardIssuer_UserErrorCode.h"	//后续替代EventCode.h,暂时混合使用,时间太紧
-#include "CardIssuer_msg_g.h"
+#include "CardIssuerStand_msg_g.h"
 #include "ModuleMix.h"
 
 #include "publicFunExport.h"
@@ -1825,7 +1825,7 @@ int CCardIssuerFSM::UnAcceptCard()
 	}
 	return 1;
 }
-int CCardIssuerFSM::IssueCard(SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx, SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctxEx)
+int CCardIssuerFSM::IssueCard(SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx, SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctxEx)
 {
 	LOG_FUNCTION();
 
@@ -2162,7 +2162,7 @@ int CCardIssuerFSM::IssueCard(SpReqAnsContext<CardIssuerService_Issue_Req, CardI
 }
 
 /** 0:succeed,1:failed [Gifur@2022516]*/
-int CCardIssuerFSM::CaptureCard(SpReqAnsContext<CardIssuerService_Capture_Req,CardIssuerService_Capture_Ans>::Pointer ctx)
+int CCardIssuerFSM::CaptureCard(SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	if (ctx != NULL)
@@ -2219,7 +2219,7 @@ int CCardIssuerFSM::CaptureCard(SpReqAnsContext<CardIssuerService_Capture_Req,Ca
 }
 
 /** 0:succeed,1:failed [Gifur@2022516]*/
-int CCardIssuerFSM::EjectCard(SpReqAnsContext<CardIssuerService_Eject_Req,CardIssuerService_Eject_Ans>::Pointer ctx)
+int CCardIssuerFSM::EjectCard(SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	Sleep(300);//oilyang@20230106 for keba said "maybe we need stay for machine to prepare..."
@@ -2413,7 +2413,7 @@ Err:
 	}
 	return err;
 }
-int CCardIssuerFSM::AcceptCard(SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx)
+int CCardIssuerFSM::AcceptCard(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	m_pCardProcess->DataInit();
@@ -2523,7 +2523,7 @@ int CCardIssuerFSM::SplitTrack2(CSimpleStringA pTrack2,Track2Data &decodeData)
 	return 0;
 }
 
-int CCardIssuerFSM::ReadCard(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx)
+int CCardIssuerFSM::ReadCard(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx)
 {
 	bool bCtOK = false;
 	memset(m_magTracks.track[0].data, 0, sizeof(m_magTracks.track[0].data));
@@ -2540,7 +2540,7 @@ int CCardIssuerFSM::ReadCard(SpReqAnsContext<CardIssuerService_Read_Req, CardIss
 	else
 		return ret;
 }
-int CCardIssuerFSM::ReadCard_Contact(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx, bool& bICOK)
+int CCardIssuerFSM::ReadCard_Contact(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx, bool& bICOK)
 {
 	bICOK = false;
 	m_currCardNo = "";
@@ -2816,7 +2816,7 @@ int CCardIssuerFSM::ReadCard_Contact(SpReqAnsContext<CardIssuerService_Read_Req,
 	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220303")("ReadCard suc.");
 	return 0;
 }
-int CCardIssuerFSM::ReadCard_RF(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx)
+int CCardIssuerFSM::ReadCard_RF(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	ErrorCodeEnum eErr, eMagReadErr;
@@ -3067,7 +3067,7 @@ int CCardIssuerFSM::ReadCard_RF(SpReqAnsContext<CardIssuerService_Read_Req, Card
 	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220303")("ReadCard suc.");
 	return 0;
 }
-int CCardIssuerFSM::PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req, CardIssuerService_PreOnline_Ans>::Pointer ctx)
+int CCardIssuerFSM::PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx)
 {
 	if (m_bUseRFTillNext)
 		return PreOnline_RF(ctx);
@@ -3079,7 +3079,7 @@ int CCardIssuerFSM::PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req, C
 	else
 		return ret;
 }
-int CCardIssuerFSM::PreOnline_Contact(SpReqAnsContext<CardIssuerService_PreOnline_Req,CardIssuerService_PreOnline_Ans>::Pointer ctx, bool& bICOK)
+int CCardIssuerFSM::PreOnline_Contact(SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>::Pointer ctx, bool& bICOK)
 {
 	LOG_FUNCTION();
 	//oilyang@20220611 only return 0;if unexpected,process and return 0
@@ -3460,7 +3460,7 @@ int CCardIssuerFSM::PreOnline_Contact(SpReqAnsContext<CardIssuerService_PreOnlin
 	ctx->Answer(Error_Succeed);
 	return 0;
 }
-int CCardIssuerFSM::PreOnline_RF(SpReqAnsContext<CardIssuerService_PreOnline_Req, CardIssuerService_PreOnline_Ans>::Pointer ctx)
+int CCardIssuerFSM::PreOnline_RF(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	long l_beginTime, l_endTime;
@@ -3796,7 +3796,7 @@ int CCardIssuerFSM::PreOnline_RF(SpReqAnsContext<CardIssuerService_PreOnline_Req
 	ctx->Answer(Error_Succeed);
 	return 0;
 }
-int CCardIssuerFSM::PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req, CardIssuerService_PostOnline_Ans>::Pointer ctx)
+int CCardIssuerFSM::PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx)
 {
 	if (m_bUseRFTillNext)
 		return PostOnline_RF(ctx);
@@ -3808,7 +3808,7 @@ int CCardIssuerFSM::PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req,
 	else
 		return ret;
 }
-int CCardIssuerFSM::PostOnline_Contact(SpReqAnsContext<CardIssuerService_PostOnline_Req,CardIssuerService_PostOnline_Ans>::Pointer ctx, bool& bICOK)
+int CCardIssuerFSM::PostOnline_Contact(SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>::Pointer ctx, bool& bICOK)
 {
 	LOG_FUNCTION();
 	m_pCardProcess->DataInit();
@@ -3842,7 +3842,7 @@ int CCardIssuerFSM::PostOnline_Contact(SpReqAnsContext<CardIssuerService_PostOnl
 	ctx->Answer(Error_Succeed);
 	return 0;
 }
-int CCardIssuerFSM::PostOnline_RF(SpReqAnsContext<CardIssuerService_PostOnline_Req, CardIssuerService_PostOnline_Ans>::Pointer ctx)
+int CCardIssuerFSM::PostOnline_RF(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	m_pCardProcess->DataInit();
@@ -3867,7 +3867,7 @@ int CCardIssuerFSM::PostOnline_RF(SpReqAnsContext<CardIssuerService_PostOnline_R
 	ctx->Answer(Error_Succeed);
 	return 0;
 }
-int CCardIssuerFSM::WriteCard(SpReqAnsContext<CardIssuerService_WriteTrack_Req, CardIssuerService_WriteTrack_Ans>::Pointer ctx)
+int CCardIssuerFSM::WriteCard(SpReqAnsContext<CardIssuerStandService_WriteTrack_Req, CardIssuerStandService_WriteTrack_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	ErrorCodeEnum eErr;
@@ -4818,7 +4818,7 @@ bool CCardIssuerFSM::IsValidCardNo(const char *pCardNo,int len)
 	}
 	return true;
 }
-int CCardIssuerFSM::SAMICCommand(SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx)
+int CCardIssuerFSM::SAMICCommand(SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx)
 {
 	ErrorCodeEnum eErr = Error_Unexpect;
 	long l_beginTime, l_endTime;
@@ -5453,7 +5453,7 @@ int CCardIssuerFSM::JudgeCardType(CSimpleStringA cardno, bool& bMismatch)
 void CCardIssuerFSM::HttpsLogCallBack(const char* logtxt) {
 	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s", logtxt);
 }
-void CCardIssuerFSM::QueryCIStatus(SpReqAnsContext<CardIssuerService_QueryCIStatus_Req, CardIssuerService_QueryCIStatus_Ans>::Pointer ctx)
+void CCardIssuerFSM::QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx)
 {
 	if (m_hDevHelper == nullptr)
 		ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);

+ 43 - 43
Module/mod_CardIssuerStand/CardIssuerFSM.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #include "SpFSM.h"
-#include "CardIssuer_server_g.h"
+#include "CardIssuerStand_server_g.h"
 //#include "GUIConsole_client_g.h"
 #include "HeartBeat_client_g.h"
 #include "AccessAuthorization_client_g.h"
@@ -15,7 +15,7 @@
 #include "IHttpFunc.h"
 #include "json/json.h"
 #define REFLECTION(var) #var
-using namespace CardIssuer;
+using namespace CardIssuerStand;
 //using namespace GUIConsole;
 using namespace HeartBeat;
 using namespace AccessAuthorization;
@@ -112,7 +112,7 @@ class CardInitFinishedEvent : public FSMEvent
 public:
 	CardInitFinishedEvent() : FSMEvent(USER_EVT_INITFINISHED){}
 	~CardInitFinishedEvent(){}
-	SpReqAnsContext<CardIssuerService_Insert_Req,CardIssuerService_Insert_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Insert_Req,CardIssuerStandService_Insert_Ans>::Pointer ctx;
 
 protected:
 private:
@@ -123,7 +123,7 @@ class CardAcceptEvent : public FSMEvent
 public:
 	CardAcceptEvent() : FSMEvent(USER_EVT_ACCEPT) {}
 	~CardAcceptEvent() {}
-	SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx;
 	virtual void OnUnhandled()
 	{
 		if (ctx != NULL)
@@ -138,7 +138,7 @@ class CardIssueEvent : public FSMEvent
 public:
 	CardIssueEvent() : FSMEvent(USER_EVT_ISSUE) {}
 	~CardIssueEvent() {}
-	SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx;
 	virtual void OnUnhandled()
 	{
 		if (ctx != NULL)
@@ -165,7 +165,7 @@ class CardReadEvent : public FSMEvent
 public:
 	CardReadEvent() : FSMEvent(USER_EVT_READ) {}
 	~CardReadEvent() {}
-	SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx;
 	virtual void OnUnhandled()
 	{
 		if (ctx != NULL)
@@ -182,7 +182,7 @@ class CardReadFinishedEvent : public FSMEvent
 public:
 	CardReadFinishedEvent() : FSMEvent(USER_EVT_READ_FINISHED) {}
 	~CardReadFinishedEvent() {}
-	SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx;
 	virtual void OnUnhandled()
 	{
 		if (ctx != NULL)
@@ -214,7 +214,7 @@ class PreOnlineEvent : public FSMEvent
 public:
 	PreOnlineEvent() : FSMEvent(USER_EVT_PREONLINE){}
 	~PreOnlineEvent(){}
-	SpReqAnsContext<CardIssuerService_PreOnline_Req,CardIssuerService_PreOnline_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>::Pointer ctx;
 	virtual void OnUnhandled() 
 	{
 		if (ctx != NULL)
@@ -228,7 +228,7 @@ class PostOnlineEvent : public FSMEvent
 public:
 	PostOnlineEvent() : FSMEvent(USER_EVT_POSTONLINE){}
 	~PostOnlineEvent(){}
-	SpReqAnsContext<CardIssuerService_PostOnline_Req,CardIssuerService_PostOnline_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>::Pointer ctx;
 	virtual void OnUnhandled() 
 	{
 		if (ctx != NULL)
@@ -242,7 +242,7 @@ class CardCaptureEvent : public FSMEvent
 public:
 	CardCaptureEvent() : FSMEvent(USER_EVT_CAPTURE){}
 	~CardCaptureEvent(){}
-	SpReqAnsContext<CardIssuerService_Capture_Req,CardIssuerService_Capture_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>::Pointer ctx;
 	virtual void OnUnhandled() 
 	{
 		if (ctx != NULL)
@@ -257,7 +257,7 @@ class CardEjectEvent : public FSMEvent
 public:
 	CardEjectEvent() : FSMEvent(USER_EVT_EJECT){}
 	~CardEjectEvent(){}
-	SpReqAnsContext<CardIssuerService_Eject_Req,CardIssuerService_Eject_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>::Pointer ctx;
 	virtual void OnUnhandled() 
 	{
 		if (ctx != NULL)
@@ -271,7 +271,7 @@ class CardWriteEvent : public FSMEvent
 public:
 	CardWriteEvent() : FSMEvent(USER_EVT_WRITE){}
 	~CardWriteEvent(){}
-	SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_WriteTrack_Req,CardIssuerStandService_WriteTrack_Ans>::Pointer ctx;
 	virtual void OnUnhandled() 
 	{
 		if (ctx != NULL)
@@ -288,7 +288,7 @@ class CardWriteFinishedEvent : public FSMEvent
 public:
 	CardWriteFinishedEvent() : FSMEvent(USER_EVT_WRITE_FINISHED){}
 	~CardWriteFinishedEvent(){}
-	SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_WriteTrack_Req,CardIssuerStandService_WriteTrack_Ans>::Pointer ctx;
 	virtual void OnUnhandled() 
 	{
 		if (ctx != NULL)
@@ -304,7 +304,7 @@ class GetMaterialExEvent : public FSMEvent
 public:
 	GetMaterialExEvent() : FSMEvent(USER_EVT_GET_MATERIAL_EX) {}
 	~GetMaterialExEvent() {}
-	SpReqAnsContext<CardIssuerService_GetMaterialCountEx_Req, CardIssuerService_GetMaterialCountEx_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_GetMaterialCountEx_Req, CardIssuerStandService_GetMaterialCountEx_Ans>::Pointer ctx;
 	virtual void OnUnhandled()
 	{
 		if (ctx != NULL)
@@ -318,7 +318,7 @@ class SetMaterialExEvent : public FSMEvent
 public:
 	SetMaterialExEvent() : FSMEvent(USER_EVT_SET_MATERIAL_EX){}
 	~SetMaterialExEvent(){}
-	SpReqAnsContext<CardIssuerService_SetMaterialCountEx_Req, CardIssuerService_SetMaterialCountEx_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_SetMaterialCountEx_Req, CardIssuerStandService_SetMaterialCountEx_Ans>::Pointer ctx;
 	virtual void OnUnhandled()
 	{
 		if (ctx != NULL)
@@ -332,7 +332,7 @@ class CardIssueExEvent : public FSMEvent
 public:
 	CardIssueExEvent() : FSMEvent(USER_EVT_ISSUE_EX){}
 	~CardIssueExEvent(){}
-	SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctx;
 	virtual void OnUnhandled()
 	{
 		if (ctx != NULL)
@@ -347,7 +347,7 @@ class SAMICCommandEvent : public FSMEvent
 public:
 	SAMICCommandEvent() : FSMEvent(USER_EVT_SAM_IC){}
 	~SAMICCommandEvent(){}
-	SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx;
 	virtual void OnUnhandled()
 	{
 		if (ctx != NULL)
@@ -841,23 +841,23 @@ public:
 	int Initial();
 	bool GetDevStatus(bool bPrint=true);
 	int UnAcceptCard();
-	int CaptureCard(SpReqAnsContext<CardIssuerService_Capture_Req,CardIssuerService_Capture_Ans>::Pointer ctx);
-	int EjectCard(SpReqAnsContext<CardIssuerService_Eject_Req,CardIssuerService_Eject_Ans>::Pointer ctx);
+	int CaptureCard(SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>::Pointer ctx);
+	int EjectCard(SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>::Pointer ctx);
 	int WaitFetchingCard();
-	int ReadCard(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx);
-	int PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req, CardIssuerService_PreOnline_Ans>::Pointer ctx);
-	int PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req, CardIssuerService_PostOnline_Ans>::Pointer ctx);
-	int ReadCard_Contact(SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx, bool& bICOK);
-	int PreOnline_Contact(SpReqAnsContext<CardIssuerService_PreOnline_Req,CardIssuerService_PreOnline_Ans>::Pointer ctx, bool& bICOK);
-	int PostOnline_Contact(SpReqAnsContext<CardIssuerService_PostOnline_Req,CardIssuerService_PostOnline_Ans>::Pointer ctx, bool& bICOK);
-	int ReadCard_RF(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx);
-	int PreOnline_RF(SpReqAnsContext<CardIssuerService_PreOnline_Req, CardIssuerService_PreOnline_Ans>::Pointer ctx);
-	int PostOnline_RF(SpReqAnsContext<CardIssuerService_PostOnline_Req, CardIssuerService_PostOnline_Ans>::Pointer ctx);
+	int ReadCard(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx);
+	int PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx);
+	int PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx);
+	int ReadCard_Contact(SpReqAnsContext<CardIssuerStandService_Read_Req,CardIssuerStandService_Read_Ans>::Pointer ctx, bool& bICOK);
+	int PreOnline_Contact(SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>::Pointer ctx, bool& bICOK);
+	int PostOnline_Contact(SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>::Pointer ctx, bool& bICOK);
+	int ReadCard_RF(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx);
+	int PreOnline_RF(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx);
+	int PostOnline_RF(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx);
 	int Reset();
 	int InternalAcceptCard();
-	int AcceptCard(SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx);
-	int IssueCard(SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx, SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctxEx);
-	int WriteCard(SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>::Pointer ctx);
+	int AcceptCard(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx);
+	int IssueCard(SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx, SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctxEx);
+	int WriteCard(SpReqAnsContext<CardIssuerStandService_WriteTrack_Req,CardIssuerStandService_WriteTrack_Ans>::Pointer ctx);
 
 	bool GetWaitFlag(){return m_bWaitingAccept;}
 	void SetWaitMore(){m_bWaitAccepteMore = true;}
@@ -890,7 +890,7 @@ public:
 	int SyncDataToDB(bool bMaintain[12],bool bSetCaptured=true);//同步物料计数
 	void SetHopperNum(int hopperNum);
 	void DoExitWhenIdle();
-	int SAMICCommand(SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx);
+	int SAMICCommand(SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx);
 
 	bool WriteCardInfo(CSmartPointer<IConfigInfo> &cfgRun, const char *acc, const char* serial, int slot, bool bClear = false, bool bHasCard = false);
 	bool ReadCardInfo(CSmartPointer<IConfigInfo> &cfgRun, CSimpleStringA &acc, CSimpleStringA &serial, int slot);
@@ -917,7 +917,7 @@ public:
 	void WaitCardActive();
 	static void HttpsLogCallBack(const char* logtxt);
 	int JudgeCardType(CSimpleStringA cardno, bool &bMismatch);
-	void QueryCIStatus(SpReqAnsContext<CardIssuerService_QueryCIStatus_Req, CardIssuerService_QueryCIStatus_Ans>::Pointer ctx);
+	void QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx);
 	bool RegistCardWhileCaptureCard(CSimpleStringA cardno);
 	bool SyncMaterialCount(IHttpFunc* client,SyncMaterialCountInfo syncInfo);
 protected:
@@ -994,7 +994,7 @@ struct InitTask : public ITaskSp
 struct AcceptTask : public ITaskSp
 {
 	CCardIssuerFSM* fsm;
-	SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx;
 	AcceptTask(CCardIssuerFSM* f) : fsm(f) {}
 	void Process()
 	{
@@ -1007,8 +1007,8 @@ struct AcceptTask : public ITaskSp
 struct IssueTask : public ITaskSp
 {
 	CCardIssuerFSM* fsm;
-	SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx;
-	SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctxEx;
+	SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctxEx;
 	IssueTask(CCardIssuerFSM* f) : fsm(f) {}
 	void Process()
 	{
@@ -1030,7 +1030,7 @@ struct IssueTask : public ITaskSp
 
 struct ReadTask : public ITaskSp
 {
-	SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Read_Req,CardIssuerStandService_Read_Ans>::Pointer ctx;
 	CCardIssuerFSM* fsm;
 	ReadTask(CCardIssuerFSM* f) : fsm(f) {}
 	void Process()
@@ -1043,7 +1043,7 @@ struct ReadTask : public ITaskSp
 };
 struct PreOnlineTask : public ITaskSp
 {
-	SpReqAnsContext<CardIssuerService_PreOnline_Req,CardIssuerService_PreOnline_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>::Pointer ctx;
 	CCardIssuerFSM* fsm;
 	PreOnlineTask(CCardIssuerFSM* f) : fsm(f) {}
 	void Process()
@@ -1055,7 +1055,7 @@ struct PreOnlineTask : public ITaskSp
 };
 struct PostOnlineTask : public ITaskSp
 {
-	SpReqAnsContext<CardIssuerService_PostOnline_Req,CardIssuerService_PostOnline_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>::Pointer ctx;
 	CCardIssuerFSM* fsm;
 	PostOnlineTask(CCardIssuerFSM* f) : fsm(f) {}
 	void Process()
@@ -1068,7 +1068,7 @@ struct PostOnlineTask : public ITaskSp
 struct CaptureTask : public ITaskSp
 {
 	CCardIssuerFSM* fsm;
-	SpReqAnsContext<CardIssuerService_Capture_Req,CardIssuerService_Capture_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>::Pointer ctx;
 	CaptureTask(CCardIssuerFSM* f) : fsm(f) {}
 	void Process()
 	{
@@ -1079,7 +1079,7 @@ struct CaptureTask : public ITaskSp
 };
 struct EjectTask : public ITaskSp
 {
-	SpReqAnsContext<CardIssuerService_Eject_Req,CardIssuerService_Eject_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>::Pointer ctx;
 	CCardIssuerFSM* fsm;
 	EjectTask(CCardIssuerFSM* f) : fsm(f) {}
 	void Process()
@@ -1113,7 +1113,7 @@ struct ResetTask : public ITaskSp
 };
 struct WriteTask : public ITaskSp
 {
-	SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_WriteTrack_Req,CardIssuerStandService_WriteTrack_Ans>::Pointer ctx;
 	CCardIssuerFSM* fsm;
 	WriteTask(CCardIssuerFSM* f) : fsm(f) {}
 	void Process()
@@ -1137,7 +1137,7 @@ struct DoExitWhenIdleTask : public ITaskSp
 struct SAMICCommandTask : public ITaskSp
 {
 	CCardIssuerFSM* fsm;
-	SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx;
+	SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx;
 	SAMICCommandTask(CCardIssuerFSM* f) : fsm(f) {}
 	void Process()
 	{

+ 1607 - 0
Module/mod_CardIssuerStand/CardIssuerStand_client_g.h

@@ -0,0 +1,1607 @@
+
+#ifndef __CARDISSUERSTAND_CLIENT_G_H
+#define __CARDISSUERSTAND_CLIENT_G_H
+
+#pragma once
+
+// This code is generated by spgen tool!
+
+#include "CardIssuerStand_def_g.h"
+
+namespace CardIssuerStand {
+class CardIssuerStandService_ClientBase : public CClientSessionBase {
+public:
+	explicit CardIssuerStandService_ClientBase(CEntityBase *pEntity) : m_pEntityBase(pEntity), m_bSysManaged(false) {}
+
+	CardIssuerStandService_ClientBase* operator () (const linkContext &curLink) 
+	{
+		m_context = curLink;
+		return this;
+	}
+
+protected:
+	virtual ~CardIssuerStandService_ClientBase()
+	{
+		/// override by user
+	}
+public:
+
+	void OnConnectSucceed()
+	{
+		bSessionClosed = false;
+	}
+	void OnClose(ErrorCodeEnum)
+	{
+		Dbg("session closed.");
+		bSessionClosed = true;
+	}
+	bool QuerySessionClosed()
+	{
+		return bSessionClosed;
+	}
+	ErrorCodeEnum Connect(CSmartPointer<IAsynWaitSp> &spAsyncWait)
+	{
+		CSmartPointer<IEntityFunction> pFunc = m_pEntityBase->GetFunction();
+		ErrorCodeEnum Error = pFunc->ConnectRemoteEntity(this, "CardIssuerStand", "CardIssuerStandService", spAsyncWait);
+		if (Error == Error_Succeed) {
+			m_bSysManaged = true;
+			bSessionClosed = false;
+		}
+		return Error;
+	}
+	ErrorCodeEnum Connect()
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Connect(spAsyncWait);
+		if (Error == Error_Succeed) {
+			Error = spAsyncWait->WaitAnswer();
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum Insert(CardIssuerStandService_Insert_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_Insert, CardIssuerStandService_MethodSignature_Insert, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum Insert(CardIssuerStandService_Insert_Req &Req, CardIssuerStandService_Insert_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Insert(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Insert(CardIssuerStandService_Insert_Req &Req, CardIssuerStandService_Insert_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Insert(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Insert(CardIssuerStandService_Insert_Req &Req, CardIssuerStandService_Insert_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Insert(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum CancelInsert()
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->OnewayCall(CardIssuerStandService_Method_CancelInsert, CardIssuerStandService_MethodSignature_CancelInsert, m_context);
+		m_context.clear();
+		return ret;
+	}
+
+	ErrorCodeEnum InsertWaitMore()
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->OnewayCall(CardIssuerStandService_Method_InsertWaitMore, CardIssuerStandService_MethodSignature_InsertWaitMore, m_context);
+		m_context.clear();
+		return ret;
+	}
+
+	ErrorCodeEnum Read(CardIssuerStandService_Read_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_Read, CardIssuerStandService_MethodSignature_Read, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum Read(CardIssuerStandService_Read_Req &Req, CardIssuerStandService_Read_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Read(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Read(CardIssuerStandService_Read_Req &Req, CardIssuerStandService_Read_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Read(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Read(CardIssuerStandService_Read_Req &Req, CardIssuerStandService_Read_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Read(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum Capture(CardIssuerStandService_Capture_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_Capture, CardIssuerStandService_MethodSignature_Capture, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum Capture(CardIssuerStandService_Capture_Req &Req, CardIssuerStandService_Capture_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Capture(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Capture(CardIssuerStandService_Capture_Req &Req, CardIssuerStandService_Capture_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Capture(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Capture(CardIssuerStandService_Capture_Req &Req, CardIssuerStandService_Capture_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Capture(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum Eject(CardIssuerStandService_Eject_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_Eject, CardIssuerStandService_MethodSignature_Eject, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum Eject(CardIssuerStandService_Eject_Req &Req, CardIssuerStandService_Eject_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Eject(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Eject(CardIssuerStandService_Eject_Req &Req, CardIssuerStandService_Eject_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Eject(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Eject(CardIssuerStandService_Eject_Req &Req, CardIssuerStandService_Eject_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Eject(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum PreOnline(CardIssuerStandService_PreOnline_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_PreOnline, CardIssuerStandService_MethodSignature_PreOnline, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum PreOnline(CardIssuerStandService_PreOnline_Req &Req, CardIssuerStandService_PreOnline_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PreOnline(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum PreOnline(CardIssuerStandService_PreOnline_Req &Req, CardIssuerStandService_PreOnline_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PreOnline(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum PreOnline(CardIssuerStandService_PreOnline_Req &Req, CardIssuerStandService_PreOnline_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PreOnline(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum PostOnline(CardIssuerStandService_PostOnline_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_PostOnline, CardIssuerStandService_MethodSignature_PostOnline, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum PostOnline(CardIssuerStandService_PostOnline_Req &Req, CardIssuerStandService_PostOnline_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PostOnline(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum PostOnline(CardIssuerStandService_PostOnline_Req &Req, CardIssuerStandService_PostOnline_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PostOnline(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum PostOnline(CardIssuerStandService_PostOnline_Req &Req, CardIssuerStandService_PostOnline_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PostOnline(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum Exit()
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->OnewayCall(CardIssuerStandService_Method_Exit, CardIssuerStandService_MethodSignature_Exit, m_context);
+		m_context.clear();
+		return ret;
+	}
+
+	ErrorCodeEnum Issue(CardIssuerStandService_Issue_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_Issue, CardIssuerStandService_MethodSignature_Issue, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum Issue(CardIssuerStandService_Issue_Req &Req, CardIssuerStandService_Issue_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Issue(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Issue(CardIssuerStandService_Issue_Req &Req, CardIssuerStandService_Issue_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Issue(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Issue(CardIssuerStandService_Issue_Req &Req, CardIssuerStandService_Issue_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Issue(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum GetMaterialCount(CardIssuerStandService_GetMaterialCount_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_GetMaterialCount, CardIssuerStandService_MethodSignature_GetMaterialCount, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetMaterialCount(CardIssuerStandService_GetMaterialCount_Req &Req, CardIssuerStandService_GetMaterialCount_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetMaterialCount(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetMaterialCount(CardIssuerStandService_GetMaterialCount_Req &Req, CardIssuerStandService_GetMaterialCount_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetMaterialCount(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetMaterialCount(CardIssuerStandService_GetMaterialCount_Req &Req, CardIssuerStandService_GetMaterialCount_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetMaterialCount(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum SetMaterialCount(CardIssuerStandService_SetMaterialCount_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_SetMaterialCount, CardIssuerStandService_MethodSignature_SetMaterialCount, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum SetMaterialCount(CardIssuerStandService_SetMaterialCount_Req &Req, CardIssuerStandService_SetMaterialCount_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetMaterialCount(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetMaterialCount(CardIssuerStandService_SetMaterialCount_Req &Req, CardIssuerStandService_SetMaterialCount_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetMaterialCount(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetMaterialCount(CardIssuerStandService_SetMaterialCount_Req &Req, CardIssuerStandService_SetMaterialCount_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetMaterialCount(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum SetIssueFlag()
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->OnewayCall(CardIssuerStandService_Method_SetIssueFlag, CardIssuerStandService_MethodSignature_SetIssueFlag, m_context);
+		m_context.clear();
+		return ret;
+	}
+
+	ErrorCodeEnum ReadEx(CardIssuerStandService_ReadEx_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_ReadEx, CardIssuerStandService_MethodSignature_ReadEx, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum ReadEx(CardIssuerStandService_ReadEx_Req &Req, CardIssuerStandService_ReadEx_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = ReadEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum ReadEx(CardIssuerStandService_ReadEx_Req &Req, CardIssuerStandService_ReadEx_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = ReadEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum ReadEx(CardIssuerStandService_ReadEx_Req &Req, CardIssuerStandService_ReadEx_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = ReadEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum QueryCardInfo(CardIssuerStandService_QueryCardInfo_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_QueryCardInfo, CardIssuerStandService_MethodSignature_QueryCardInfo, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum QueryCardInfo(CardIssuerStandService_QueryCardInfo_Req &Req, CardIssuerStandService_QueryCardInfo_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryCardInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum QueryCardInfo(CardIssuerStandService_QueryCardInfo_Req &Req, CardIssuerStandService_QueryCardInfo_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryCardInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum QueryCardInfo(CardIssuerStandService_QueryCardInfo_Req &Req, CardIssuerStandService_QueryCardInfo_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryCardInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum WriteTrack(CardIssuerStandService_WriteTrack_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_WriteTrack, CardIssuerStandService_MethodSignature_WriteTrack, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum WriteTrack(CardIssuerStandService_WriteTrack_Req &Req, CardIssuerStandService_WriteTrack_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = WriteTrack(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum WriteTrack(CardIssuerStandService_WriteTrack_Req &Req, CardIssuerStandService_WriteTrack_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = WriteTrack(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum WriteTrack(CardIssuerStandService_WriteTrack_Req &Req, CardIssuerStandService_WriteTrack_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = WriteTrack(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum GetMaterialCountEx(CardIssuerStandService_GetMaterialCountEx_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_GetMaterialCountEx, CardIssuerStandService_MethodSignature_GetMaterialCountEx, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetMaterialCountEx(CardIssuerStandService_GetMaterialCountEx_Req &Req, CardIssuerStandService_GetMaterialCountEx_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetMaterialCountEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetMaterialCountEx(CardIssuerStandService_GetMaterialCountEx_Req &Req, CardIssuerStandService_GetMaterialCountEx_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetMaterialCountEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetMaterialCountEx(CardIssuerStandService_GetMaterialCountEx_Req &Req, CardIssuerStandService_GetMaterialCountEx_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetMaterialCountEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum SetMaterialCountEx(CardIssuerStandService_SetMaterialCountEx_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_SetMaterialCountEx, CardIssuerStandService_MethodSignature_SetMaterialCountEx, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum SetMaterialCountEx(CardIssuerStandService_SetMaterialCountEx_Req &Req, CardIssuerStandService_SetMaterialCountEx_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetMaterialCountEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetMaterialCountEx(CardIssuerStandService_SetMaterialCountEx_Req &Req, CardIssuerStandService_SetMaterialCountEx_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetMaterialCountEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetMaterialCountEx(CardIssuerStandService_SetMaterialCountEx_Req &Req, CardIssuerStandService_SetMaterialCountEx_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetMaterialCountEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum SetSomeFlag(CardIssuerStandService_SetSomeFlag_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_SetSomeFlag, CardIssuerStandService_MethodSignature_SetSomeFlag, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum SetSomeFlag(CardIssuerStandService_SetSomeFlag_Req &Req, CardIssuerStandService_SetSomeFlag_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetSomeFlag(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetSomeFlag(CardIssuerStandService_SetSomeFlag_Req &Req, CardIssuerStandService_SetSomeFlag_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetSomeFlag(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetSomeFlag(CardIssuerStandService_SetSomeFlag_Req &Req, CardIssuerStandService_SetSomeFlag_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetSomeFlag(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum GetSCIInfo(CardIssuerStandService_GetSCIInfo_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_GetSCIInfo, CardIssuerStandService_MethodSignature_GetSCIInfo, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetSCIInfo(CardIssuerStandService_GetSCIInfo_Req &Req, CardIssuerStandService_GetSCIInfo_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetSCIInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetSCIInfo(CardIssuerStandService_GetSCIInfo_Req &Req, CardIssuerStandService_GetSCIInfo_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetSCIInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetSCIInfo(CardIssuerStandService_GetSCIInfo_Req &Req, CardIssuerStandService_GetSCIInfo_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetSCIInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum IssueEx(CardIssuerStandService_IssueEx_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_IssueEx, CardIssuerStandService_MethodSignature_IssueEx, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum IssueEx(CardIssuerStandService_IssueEx_Req &Req, CardIssuerStandService_IssueEx_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = IssueEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum IssueEx(CardIssuerStandService_IssueEx_Req &Req, CardIssuerStandService_IssueEx_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = IssueEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum IssueEx(CardIssuerStandService_IssueEx_Req &Req, CardIssuerStandService_IssueEx_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = IssueEx(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum OpenSafeLock(CardIssuerStandService_OpenSafeLock_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_OpenSafeLock, CardIssuerStandService_MethodSignature_OpenSafeLock, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum OpenSafeLock(CardIssuerStandService_OpenSafeLock_Req &Req, CardIssuerStandService_OpenSafeLock_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = OpenSafeLock(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum OpenSafeLock(CardIssuerStandService_OpenSafeLock_Req &Req, CardIssuerStandService_OpenSafeLock_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = OpenSafeLock(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum OpenSafeLock(CardIssuerStandService_OpenSafeLock_Req &Req, CardIssuerStandService_OpenSafeLock_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = OpenSafeLock(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum SAMICCommand(CardIssuerStandService_SAMICCommand_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_SAMICCommand, CardIssuerStandService_MethodSignature_SAMICCommand, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum SAMICCommand(CardIssuerStandService_SAMICCommand_Req &Req, CardIssuerStandService_SAMICCommand_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SAMICCommand(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SAMICCommand(CardIssuerStandService_SAMICCommand_Req &Req, CardIssuerStandService_SAMICCommand_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SAMICCommand(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SAMICCommand(CardIssuerStandService_SAMICCommand_Req &Req, CardIssuerStandService_SAMICCommand_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SAMICCommand(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum QueryPrinterStatus(CardIssuerStandService_QueryPrinterStatus_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_QueryPrinterStatus, CardIssuerStandService_MethodSignature_QueryPrinterStatus, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum QueryPrinterStatus(CardIssuerStandService_QueryPrinterStatus_Req &Req, CardIssuerStandService_QueryPrinterStatus_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryPrinterStatus(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum QueryPrinterStatus(CardIssuerStandService_QueryPrinterStatus_Req &Req, CardIssuerStandService_QueryPrinterStatus_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryPrinterStatus(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum QueryPrinterStatus(CardIssuerStandService_QueryPrinterStatus_Req &Req, CardIssuerStandService_QueryPrinterStatus_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryPrinterStatus(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum Print(CardIssuerStandService_Print_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_Print, CardIssuerStandService_MethodSignature_Print, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum Print(CardIssuerStandService_Print_Req &Req, CardIssuerStandService_Print_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Print(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Print(CardIssuerStandService_Print_Req &Req, CardIssuerStandService_Print_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Print(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum Print(CardIssuerStandService_Print_Req &Req, CardIssuerStandService_Print_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = Print(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum QuerySCIList(CardIssuerStandService_QuerySCIList_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_QuerySCIList, CardIssuerStandService_MethodSignature_QuerySCIList, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum QuerySCIList(CardIssuerStandService_QuerySCIList_Req &Req, CardIssuerStandService_QuerySCIList_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QuerySCIList(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum QuerySCIList(CardIssuerStandService_QuerySCIList_Req &Req, CardIssuerStandService_QuerySCIList_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QuerySCIList(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum QuerySCIList(CardIssuerStandService_QuerySCIList_Req &Req, CardIssuerStandService_QuerySCIList_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QuerySCIList(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum BindSCI(CardIssuerStandService_BindSCI_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_BindSCI, CardIssuerStandService_MethodSignature_BindSCI, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum BindSCI(CardIssuerStandService_BindSCI_Req &Req, CardIssuerStandService_BindSCI_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = BindSCI(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum BindSCI(CardIssuerStandService_BindSCI_Req &Req, CardIssuerStandService_BindSCI_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = BindSCI(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum BindSCI(CardIssuerStandService_BindSCI_Req &Req, CardIssuerStandService_BindSCI_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = BindSCI(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum PreOnlineOnStore(CardIssuerStandService_PreOnlineOnStore_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_PreOnlineOnStore, CardIssuerStandService_MethodSignature_PreOnlineOnStore, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum PreOnlineOnStore(CardIssuerStandService_PreOnlineOnStore_Req &Req, CardIssuerStandService_PreOnlineOnStore_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PreOnlineOnStore(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum PreOnlineOnStore(CardIssuerStandService_PreOnlineOnStore_Req &Req, CardIssuerStandService_PreOnlineOnStore_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PreOnlineOnStore(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum PreOnlineOnStore(CardIssuerStandService_PreOnlineOnStore_Req &Req, CardIssuerStandService_PreOnlineOnStore_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PreOnlineOnStore(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum NotifyPreonline(CardIssuerStandService_NotifyPreonline_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_NotifyPreonline, CardIssuerStandService_MethodSignature_NotifyPreonline, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum NotifyPreonline(CardIssuerStandService_NotifyPreonline_Req &Req, CardIssuerStandService_NotifyPreonline_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = NotifyPreonline(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum NotifyPreonline(CardIssuerStandService_NotifyPreonline_Req &Req, CardIssuerStandService_NotifyPreonline_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = NotifyPreonline(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum NotifyPreonline(CardIssuerStandService_NotifyPreonline_Req &Req, CardIssuerStandService_NotifyPreonline_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = NotifyPreonline(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum QueryCardInfoOnStore(CardIssuerStandService_QueryCardInfoOnStore_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_QueryCardInfoOnStore, CardIssuerStandService_MethodSignature_QueryCardInfoOnStore, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum QueryCardInfoOnStore(CardIssuerStandService_QueryCardInfoOnStore_Req &Req, CardIssuerStandService_QueryCardInfoOnStore_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryCardInfoOnStore(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum QueryCardInfoOnStore(CardIssuerStandService_QueryCardInfoOnStore_Req &Req, CardIssuerStandService_QueryCardInfoOnStore_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryCardInfoOnStore(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum QueryCardInfoOnStore(CardIssuerStandService_QueryCardInfoOnStore_Req &Req, CardIssuerStandService_QueryCardInfoOnStore_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryCardInfoOnStore(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum GetAddCardInfo(CardIssuerStandService_GetAddCardInfo_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_GetAddCardInfo, CardIssuerStandService_MethodSignature_GetAddCardInfo, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetAddCardInfo(CardIssuerStandService_GetAddCardInfo_Req &Req, CardIssuerStandService_GetAddCardInfo_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetAddCardInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetAddCardInfo(CardIssuerStandService_GetAddCardInfo_Req &Req, CardIssuerStandService_GetAddCardInfo_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetAddCardInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetAddCardInfo(CardIssuerStandService_GetAddCardInfo_Req &Req, CardIssuerStandService_GetAddCardInfo_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetAddCardInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum PrintCardImmediately(CardIssuerStandService_PrintCardImmediately_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_PrintCardImmediately, CardIssuerStandService_MethodSignature_PrintCardImmediately, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum PrintCardImmediately(CardIssuerStandService_PrintCardImmediately_Req &Req, CardIssuerStandService_PrintCardImmediately_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PrintCardImmediately(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum PrintCardImmediately(CardIssuerStandService_PrintCardImmediately_Req &Req, CardIssuerStandService_PrintCardImmediately_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PrintCardImmediately(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum PrintCardImmediately(CardIssuerStandService_PrintCardImmediately_Req &Req, CardIssuerStandService_PrintCardImmediately_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = PrintCardImmediately(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum QueryCIStatus(CardIssuerStandService_QueryCIStatus_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_QueryCIStatus, CardIssuerStandService_MethodSignature_QueryCIStatus, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum QueryCIStatus(CardIssuerStandService_QueryCIStatus_Req &Req, CardIssuerStandService_QueryCIStatus_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryCIStatus(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum QueryCIStatus(CardIssuerStandService_QueryCIStatus_Req &Req, CardIssuerStandService_QueryCIStatus_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryCIStatus(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum QueryCIStatus(CardIssuerStandService_QueryCIStatus_Req &Req, CardIssuerStandService_QueryCIStatus_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = QueryCIStatus(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum GetDevInfo(CardIssuerStandService_GetDevInfo_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(CardIssuerStandService_Method_GetDevInfo, CardIssuerStandService_MethodSignature_GetDevInfo, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetDevInfo(CardIssuerStandService_GetDevInfo_Req &Req, CardIssuerStandService_GetDevInfo_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetDevInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetDevInfo(CardIssuerStandService_GetDevInfo_Req &Req, CardIssuerStandService_GetDevInfo_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetDevInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetDevInfo(CardIssuerStandService_GetDevInfo_Req &Req, CardIssuerStandService_GetDevInfo_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetDevInfo(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+
+	bool SafeDelete()
+	{
+		if (!m_bSysManaged) {
+			delete this;
+		}
+		return m_bSysManaged;
+	}
+
+protected:
+	bool m_bSysManaged;
+	CEntityBase *m_pEntityBase;
+	linkContext m_context;
+	bool bSessionClosed;
+};
+
+///////////////////////////
+
+} // namespace CardIssuerStand
+#endif // __CARDISSUERSTAND_CLIENT_G_H

+ 999 - 0
Module/mod_CardIssuerStand/CardIssuerStand_def_g.h

@@ -0,0 +1,999 @@
+#ifndef __CARDISSUERSTAND_DEF_G_H
+#define __CARDISSUERSTAND_DEF_G_H
+
+#pragma once
+
+// This code is generated by spgen tool!
+
+#include "SpHelper.h"
+
+namespace CardIssuerStand {
+//
+// const goes here
+//
+
+#define CardIssuerStandService_Method_Insert 0
+#define CardIssuerStandService_Method_CancelInsert 1
+#define CardIssuerStandService_Method_InsertWaitMore 2
+#define CardIssuerStandService_Method_Read 3
+#define CardIssuerStandService_Method_Capture 4
+#define CardIssuerStandService_Method_Eject 5
+#define CardIssuerStandService_Method_PreOnline 6
+#define CardIssuerStandService_Method_PostOnline 7
+#define CardIssuerStandService_Method_Exit 8
+#define CardIssuerStandService_Method_Issue 9
+#define CardIssuerStandService_Method_GetMaterialCount 10
+#define CardIssuerStandService_Method_SetMaterialCount 11
+#define CardIssuerStandService_Method_SetIssueFlag 12
+#define CardIssuerStandService_Method_ReadEx 13
+#define CardIssuerStandService_Method_QueryCardInfo 14
+#define CardIssuerStandService_Method_WriteTrack 15
+#define CardIssuerStandService_Method_GetMaterialCountEx 16
+#define CardIssuerStandService_Method_SetMaterialCountEx 17
+#define CardIssuerStandService_Method_SetSomeFlag 18
+#define CardIssuerStandService_Method_GetSCIInfo 19
+#define CardIssuerStandService_Method_IssueEx 20
+#define CardIssuerStandService_Method_OpenSafeLock 21
+#define CardIssuerStandService_Method_SAMICCommand 22
+#define CardIssuerStandService_Method_QueryPrinterStatus 23
+#define CardIssuerStandService_Method_Print 24
+#define CardIssuerStandService_Method_QuerySCIList 25
+#define CardIssuerStandService_Method_BindSCI 26
+#define CardIssuerStandService_Method_PreOnlineOnStore 27
+#define CardIssuerStandService_Method_NotifyPreonline 28
+#define CardIssuerStandService_Method_QueryCardInfoOnStore 29
+#define CardIssuerStandService_Method_GetAddCardInfo 30
+#define CardIssuerStandService_Method_PrintCardImmediately 31
+#define CardIssuerStandService_Method_QueryCIStatus 32
+#define CardIssuerStandService_Method_GetDevInfo 65535
+
+#define CardIssuerStandService_MethodSignature_Insert 1091033773
+#define CardIssuerStandService_MethodSignature_CancelInsert -1202478828
+#define CardIssuerStandService_MethodSignature_InsertWaitMore 493791658
+#define CardIssuerStandService_MethodSignature_Read 591445479
+#define CardIssuerStandService_MethodSignature_Capture -1807054569
+#define CardIssuerStandService_MethodSignature_Eject -377455114
+#define CardIssuerStandService_MethodSignature_PreOnline 640958030
+#define CardIssuerStandService_MethodSignature_PostOnline 923284555
+#define CardIssuerStandService_MethodSignature_Exit -1158854104
+#define CardIssuerStandService_MethodSignature_Issue 438783077
+#define CardIssuerStandService_MethodSignature_GetMaterialCount -605917749
+#define CardIssuerStandService_MethodSignature_SetMaterialCount 870103115
+#define CardIssuerStandService_MethodSignature_SetIssueFlag 187641303
+#define CardIssuerStandService_MethodSignature_ReadEx -842531343
+#define CardIssuerStandService_MethodSignature_QueryCardInfo 154962579
+#define CardIssuerStandService_MethodSignature_WriteTrack -1424799012
+#define CardIssuerStandService_MethodSignature_GetMaterialCountEx 1356148904
+#define CardIssuerStandService_MethodSignature_SetMaterialCountEx -1512312761
+#define CardIssuerStandService_MethodSignature_SetSomeFlag -2033418025
+#define CardIssuerStandService_MethodSignature_GetSCIInfo 1097494981
+#define CardIssuerStandService_MethodSignature_IssueEx 1390328640
+#define CardIssuerStandService_MethodSignature_OpenSafeLock 177980614
+#define CardIssuerStandService_MethodSignature_SAMICCommand 406988293
+#define CardIssuerStandService_MethodSignature_QueryPrinterStatus -890728447
+#define CardIssuerStandService_MethodSignature_Print 2096006675
+#define CardIssuerStandService_MethodSignature_QuerySCIList -1772231453
+#define CardIssuerStandService_MethodSignature_BindSCI -1242011672
+#define CardIssuerStandService_MethodSignature_PreOnlineOnStore 158325869
+#define CardIssuerStandService_MethodSignature_NotifyPreonline -808637659
+#define CardIssuerStandService_MethodSignature_QueryCardInfoOnStore 1217447214
+#define CardIssuerStandService_MethodSignature_GetAddCardInfo 684031940
+#define CardIssuerStandService_MethodSignature_PrintCardImmediately -1976184201
+#define CardIssuerStandService_MethodSignature_QueryCIStatus -1907000703
+#define CardIssuerStandService_MethodSignature_GetDevInfo 296205965
+
+#define CardIssuerStandService_LogCode_Insert "QLR040220300"
+#define CardIssuerStandService_LogCode_CancelInsert "QLR040220301"
+#define CardIssuerStandService_LogCode_InsertWaitMore "QLR040220302"
+#define CardIssuerStandService_LogCode_Read "QLR040220303"
+#define CardIssuerStandService_LogCode_Capture "QLR040220304"
+#define CardIssuerStandService_LogCode_Eject "QLR040220305"
+#define CardIssuerStandService_LogCode_PreOnline "QLR040220306"
+#define CardIssuerStandService_LogCode_PostOnline "QLR040220307"
+#define CardIssuerStandService_LogCode_Exit "QLR040220308"
+#define CardIssuerStandService_LogCode_Issue "QLR040220309"
+#define CardIssuerStandService_LogCode_GetMaterialCount "QLR040220310"
+#define CardIssuerStandService_LogCode_SetMaterialCount "QLR040220311"
+#define CardIssuerStandService_LogCode_SetIssueFlag "QLR040220312"
+#define CardIssuerStandService_LogCode_ReadEx "QLR040220313"
+#define CardIssuerStandService_LogCode_QueryCardInfo "QLR040220314"
+#define CardIssuerStandService_LogCode_WriteTrack "QLR040220315"
+#define CardIssuerStandService_LogCode_GetMaterialCountEx "QLR040220316"
+#define CardIssuerStandService_LogCode_SetMaterialCountEx "QLR040220317"
+#define CardIssuerStandService_LogCode_SetSomeFlag "QLR040220318"
+#define CardIssuerStandService_LogCode_GetSCIInfo "QLR040220319"
+#define CardIssuerStandService_LogCode_IssueEx "QLR040220320"
+#define CardIssuerStandService_LogCode_OpenSafeLock "QLR040220321"
+#define CardIssuerStandService_LogCode_SAMICCommand "QLR040220322"
+#define CardIssuerStandService_LogCode_QueryPrinterStatus "QLR040220323"
+#define CardIssuerStandService_LogCode_Print "QLR040220324"
+#define CardIssuerStandService_LogCode_QuerySCIList "QLR040220325"
+#define CardIssuerStandService_LogCode_BindSCI "QLR040220326"
+#define CardIssuerStandService_LogCode_PreOnlineOnStore "QLR040220327"
+#define CardIssuerStandService_LogCode_NotifyPreonline "QLR040220328"
+#define CardIssuerStandService_LogCode_QueryCardInfoOnStore "QLR040220329"
+#define CardIssuerStandService_LogCode_GetAddCardInfo "QLR040220330"
+#define CardIssuerStandService_LogCode_PrintCardImmediately "QLR040220331"
+#define CardIssuerStandService_LogCode_QueryCIStatus "QLR040220332"
+#define CardIssuerStandService_LogCode_GetDevInfo "QLR040220399"
+
+struct CardIssuerStandService_Insert_Req
+{
+	CSimpleStringA aid;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & aid;
+	}
+
+};
+
+struct CardIssuerStandService_Insert_Ans
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_CancelInsert_Info
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_InsertWaitMore_Info
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_Read_Req
+{
+	CSimpleStringA aid;
+	int reserved1;
+	int reserved2;
+	CSimpleStringA reserved3;
+	CSimpleStringA reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & aid & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_Read_Ans
+{
+	CSimpleStringA track1;
+	CSimpleStringA track2;
+	CSimpleStringA track3;
+	int ICType;
+	CSimpleStringA ICData;
+	int status;
+	CSimpleStringA t2Account;
+	CSimpleStringA t2Region;
+	CSimpleStringA t2CardSerial;
+	CSimpleStringA t2CVC;
+	CSimpleStringA t2ExpireDate;
+	int reserved1;
+	int reserved2;
+	CSimpleStringA reserved3;
+	CSimpleStringA reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & track1 & track2 & track3 & ICType & ICData & status & t2Account & t2Region & t2CardSerial & t2CVC & t2ExpireDate & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_Capture_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_Capture_Ans
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_Eject_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_Eject_Ans
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_PreOnline_Req
+{
+	CSimpleStringA businessData;
+	CSimpleStringA reserved1;
+	CSimpleStringA reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & businessData & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_PreOnline_Ans
+{
+	CSimpleStringA result;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & result;
+	}
+
+};
+
+struct CardIssuerStandService_PostOnline_Req
+{
+	CSimpleStringA data;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & data;
+	}
+
+};
+
+struct CardIssuerStandService_PostOnline_Ans
+{
+	CSimpleStringA result;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & result;
+	}
+
+};
+
+struct CardIssuerStandService_Exit_Info
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_Issue_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_Issue_Ans
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_GetMaterialCount_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_GetMaterialCount_Ans
+{
+	int remains;
+	int captured;
+	int issued;
+	int mixed;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & remains & captured & issued & mixed;
+	}
+
+};
+
+struct CardIssuerStandService_SetMaterialCount_Req
+{
+	int remains;
+	int captured;
+	int issued;
+	bool bRemains;
+	bool bCaptured;
+	bool bIssued;
+	int mixed;
+	bool bMixed;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & remains & captured & issued & bRemains & bCaptured & bIssued & mixed & bMixed;
+	}
+
+};
+
+struct CardIssuerStandService_SetMaterialCount_Ans
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_SetIssueFlag_Info
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_ReadEx_Req
+{
+	CSimpleStringA aid;
+	CSimpleStringA reserved1;
+	CSimpleStringA reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & aid & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_ReadEx_Ans
+{
+	CSimpleStringA track1;
+	CSimpleStringA track2;
+	CSimpleStringA track3;
+	int CDType;
+	int ICType;
+	int CMBType;
+	CSimpleStringA ICData;
+	int status;
+	CSimpleStringA t2Account;
+	CSimpleStringA t2Region;
+	CSimpleStringA t2CardSerial;
+	CSimpleStringA t2CVC;
+	CSimpleStringA t2ExpireDate;
+	CSimpleStringA reserved1;
+	CSimpleStringA reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & track1 & track2 & track3 & CDType & ICType & CMBType & ICData & status & t2Account & t2Region & t2CardSerial & t2CVC & t2ExpireDate & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_QueryCardInfo_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_QueryCardInfo_Ans
+{
+	int position;
+	int reserved1;
+	CSimpleStringA reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & position & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_WriteTrack_Req
+{
+	int mode;
+	int co;
+	CSimpleStringW track1;
+	CSimpleStringW track2;
+	CSimpleStringW track3;
+	CSimpleStringW reserved;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & mode & co & track1 & track2 & track3 & reserved;
+	}
+
+};
+
+struct CardIssuerStandService_WriteTrack_Ans
+{
+	int result;
+	int reserved1;
+	CSimpleStringA reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & result & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_GetMaterialCountEx_Req
+{
+	CAutoArray<int> GetHopper;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & GetHopper & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_GetMaterialCountEx_Ans
+{
+	int captured;
+	CAutoArray<int> hasHopper;
+	CAutoArray<CSimpleStringA> CardBoxNo;
+	CAutoArray<CSimpleStringA> PsbCode;
+	CAutoArray<CSimpleStringA> PsbName;
+	CAutoArray<CSimpleStringA> Maintainer;
+	CAutoArray<CSimpleStringA> MaintainTime;
+	CAutoArray<int> CardInit;
+	CAutoArray<int> CardPercent;
+	CAutoArray<int> remains;
+	CAutoArray<int> issued;
+	CAutoArray<int> mixed;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & captured & hasHopper & CardBoxNo & PsbCode & PsbName & Maintainer & MaintainTime & CardInit & CardPercent & remains & issued & mixed & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_SetMaterialCountEx_Req
+{
+	CAutoArray<int> SetHopper;
+	int SetCaptured;
+	int captured;
+	CAutoArray<CSimpleStringA> CardBoxNo;
+	CAutoArray<CSimpleStringA> PsbCode;
+	CAutoArray<CSimpleStringA> PsbName;
+	CAutoArray<CSimpleStringA> Maintainer;
+	CAutoArray<CSimpleStringA> MaintainTime;
+	CAutoArray<int> CardInit;
+	CAutoArray<int> CardPercent;
+	CAutoArray<int> remains;
+	CAutoArray<int> issued;
+	CAutoArray<int> mixed;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & SetHopper & SetCaptured & captured & CardBoxNo & PsbCode & PsbName & Maintainer & MaintainTime & CardInit & CardPercent & remains & issued & mixed & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_SetMaterialCountEx_Ans
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_SetSomeFlag_Req
+{
+	int IssueBusiness;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & IssueBusiness & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_SetSomeFlag_Ans
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_GetSCIInfo_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_GetSCIInfo_Ans
+{
+	int connected;
+	CSimpleStringA DevSN;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & connected & DevSN & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_IssueEx_Req
+{
+	int hopper;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & hopper & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_IssueEx_Ans
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_OpenSafeLock_Req
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_OpenSafeLock_Ans
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_SAMICCommand_Req
+{
+	int cmdType;
+	CAutoArray<int> param1;
+	CAutoArray<CSimpleStringA> param2;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & cmdType & param1 & param2 & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_SAMICCommand_Ans
+{
+	CAutoArray<int> ret1;
+	CAutoArray<CSimpleStringA> ret2;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & ret1 & ret2 & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_QueryPrinterStatus_Req
+{
+	CAutoArray<int> param1;
+	CAutoArray<CSimpleStringA> param2;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & param1 & param2 & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_QueryPrinterStatus_Ans
+{
+	CAutoArray<int> ret1;
+	CAutoArray<CSimpleStringA> ret2;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & ret1 & ret2 & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_Print_Req
+{
+	CBlob data1;
+	CBlob data2;
+	CBlob data3;
+	CBlob data4;
+	CBlob data5;
+	CBlob data6;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & data1 & data2 & data3 & data4 & data5 & data6 & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_Print_Ans
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_QuerySCIList_Req
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_QuerySCIList_Ans
+{
+	CAutoArray<CSimpleStringA> sciNo;
+	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> Maintainer;
+	CAutoArray<CSimpleStringA> MaintainTime;
+	CAutoArray<CSimpleStringA> UpdateTime;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & sciNo & arrMateriel & CardGroove & CardBoxNo & PsbCode & PsbName & CardInit & CardRemains & CardIssued & CardMixed & CardPercent & Maintainer & MaintainTime & UpdateTime & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_BindSCI_Req
+{
+	int type;
+	CSimpleStringA sciNo;
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & type & sciNo & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_BindSCI_Ans
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<CSimpleStringA> reserved2;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2;
+	}
+
+};
+
+struct CardIssuerStandService_PreOnlineOnStore_Req
+{
+	CSimpleStringA account;
+	CSimpleStringA termNo;
+	CSimpleStringA businessData;
+	int slot;
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & account & termNo & businessData & slot & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_PreOnlineOnStore_Ans
+{
+	int findCard;
+	int cardPos;
+	CSimpleStringA result;
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & findCard & cardPos & result & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_NotifyPreonline_Req
+{
+	int findCard;
+	int cardPos;
+	int errCode;
+	CSimpleStringA account;
+	CSimpleStringA termNo;
+	CSimpleStringA data;
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & findCard & cardPos & errCode & account & termNo & data & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_NotifyPreonline_Ans
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_QueryCardInfoOnStore_Req
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_QueryCardInfoOnStore_Ans
+{
+	int findCard;
+	int cardPos;
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & findCard & cardPos & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_GetAddCardInfo_Req
+{
+	int isSync;
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & isSync & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_GetAddCardInfo_Ans
+{
+	int count;
+	CAutoArray<int> slot;
+	CAutoArray<CSimpleStringA> account;
+	CAutoArray<CSimpleStringA> cardSerial;
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & count & slot & account & cardSerial & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_PrintCardImmediately_Req
+{
+	CSimpleStringA formFile;
+	CSimpleStringA printData;
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & formFile & printData & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_PrintCardImmediately_Ans
+{
+	int ret;
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & ret & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_QueryCIStatus_Req
+{
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_QueryCIStatus_Ans
+{
+	int retainBin;
+	CAutoArray<int> hopperNo;
+	CAutoArray<int> hopperStatus;
+	CAutoArray<int> reserved1;
+	CAutoArray<int> reserved2;
+	CAutoArray<CSimpleStringA> reserved3;
+	CAutoArray<CSimpleStringA> reserved4;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & retainBin & hopperNo & hopperStatus & reserved1 & reserved2 & reserved3 & reserved4;
+	}
+
+};
+
+struct CardIssuerStandService_GetDevInfo_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct CardIssuerStandService_GetDevInfo_Ans
+{
+	CSimpleStringA type;
+	CSimpleStringA model;
+	CSimpleStringA version;
+	int state;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & type & model & version & state;
+	}
+
+};
+
+
+///////////////////////////
+
+} // namespace CardIssuerStand
+
+#endif // __CARDISSUERSTAND_DEF_G_H

+ 45 - 0
Module/mod_CardIssuerStand/CardIssuerStand_msg_g.h

@@ -0,0 +1,45 @@
+
+#ifndef __CARDISSUERSTAND_MSG_G_H
+#define __CARDISSUERSTAND_MSG_G_H
+
+#pragma once
+
+// This code is generated by spgen tool!
+
+#include "SpHelper.h"
+
+namespace CardIssuerStand {
+#define eMsg_FetchCard 0
+#define eMsg_SCIConnect 1
+
+#define eMsgSig_FetchCard 1110804794
+#define eMsgSig_SCIConnect 721962700
+
+struct FetchCard
+{
+	int status;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & status;
+	}
+
+};
+
+///////////////////////////
+
+struct SCIConnect
+{
+	int status;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & status;
+	}
+
+};
+
+///////////////////////////
+
+} // namespace CardIssuerStand
+#endif // __CARDISSUERSTAND_MSG_G_H

+ 1001 - 0
Module/mod_CardIssuerStand/CardIssuerStand_server_g.h

@@ -0,0 +1,1001 @@
+
+#ifndef __CARDISSUERSTAND_SERVER_G_H
+#define __CARDISSUERSTAND_SERVER_G_H
+
+#pragma once
+
+// This code is generated by spgen tool!
+
+#include "CardIssuerStand_def_g.h"
+
+namespace CardIssuerStand {
+class CardIssuerStandService_ServerSessionBase : public CServerSessionBase
+{
+public:
+	CardIssuerStandService_ServerSessionBase()
+	{
+		/// override by user
+	}
+
+	virtual ~CardIssuerStandService_ServerSessionBase()
+	{
+		/// override by user
+	}
+
+	virtual bool IsExclusive() { return false; }
+
+	virtual bool IsSessionOverlap() { return true; }
+
+	virtual ErrorCodeEnum GetMessageAttr(DWORD dwMessageID, DWORD dwSignature, bool &bOverlap)
+	{
+		ErrorCodeEnum Error = Error_Succeed;
+		switch (dwMessageID) {
+		case CardIssuerStandService_Method_Insert:
+			if (dwSignature == CardIssuerStandService_MethodSignature_Insert) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_CancelInsert:
+			if (dwSignature == CardIssuerStandService_MethodSignature_CancelInsert) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_InsertWaitMore:
+			if (dwSignature == CardIssuerStandService_MethodSignature_InsertWaitMore) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Read:
+			if (dwSignature == CardIssuerStandService_MethodSignature_Read) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Capture:
+			if (dwSignature == CardIssuerStandService_MethodSignature_Capture) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Eject:
+			if (dwSignature == CardIssuerStandService_MethodSignature_Eject) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_PreOnline:
+			if (dwSignature == CardIssuerStandService_MethodSignature_PreOnline) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_PostOnline:
+			if (dwSignature == CardIssuerStandService_MethodSignature_PostOnline) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Exit:
+			if (dwSignature == CardIssuerStandService_MethodSignature_Exit) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Issue:
+			if (dwSignature == CardIssuerStandService_MethodSignature_Issue) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_GetMaterialCount:
+			if (dwSignature == CardIssuerStandService_MethodSignature_GetMaterialCount) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_SetMaterialCount:
+			if (dwSignature == CardIssuerStandService_MethodSignature_SetMaterialCount) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_SetIssueFlag:
+			if (dwSignature == CardIssuerStandService_MethodSignature_SetIssueFlag) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_ReadEx:
+			if (dwSignature == CardIssuerStandService_MethodSignature_ReadEx) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_QueryCardInfo:
+			if (dwSignature == CardIssuerStandService_MethodSignature_QueryCardInfo) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_WriteTrack:
+			if (dwSignature == CardIssuerStandService_MethodSignature_WriteTrack) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_GetMaterialCountEx:
+			if (dwSignature == CardIssuerStandService_MethodSignature_GetMaterialCountEx) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_SetMaterialCountEx:
+			if (dwSignature == CardIssuerStandService_MethodSignature_SetMaterialCountEx) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_SetSomeFlag:
+			if (dwSignature == CardIssuerStandService_MethodSignature_SetSomeFlag) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_GetSCIInfo:
+			if (dwSignature == CardIssuerStandService_MethodSignature_GetSCIInfo) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_IssueEx:
+			if (dwSignature == CardIssuerStandService_MethodSignature_IssueEx) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_OpenSafeLock:
+			if (dwSignature == CardIssuerStandService_MethodSignature_OpenSafeLock) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_SAMICCommand:
+			if (dwSignature == CardIssuerStandService_MethodSignature_SAMICCommand) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_QueryPrinterStatus:
+			if (dwSignature == CardIssuerStandService_MethodSignature_QueryPrinterStatus) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Print:
+			if (dwSignature == CardIssuerStandService_MethodSignature_Print) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_QuerySCIList:
+			if (dwSignature == CardIssuerStandService_MethodSignature_QuerySCIList) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_BindSCI:
+			if (dwSignature == CardIssuerStandService_MethodSignature_BindSCI) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_PreOnlineOnStore:
+			if (dwSignature == CardIssuerStandService_MethodSignature_PreOnlineOnStore) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_NotifyPreonline:
+			if (dwSignature == CardIssuerStandService_MethodSignature_NotifyPreonline) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_QueryCardInfoOnStore:
+			if (dwSignature == CardIssuerStandService_MethodSignature_QueryCardInfoOnStore) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_GetAddCardInfo:
+			if (dwSignature == CardIssuerStandService_MethodSignature_GetAddCardInfo) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_PrintCardImmediately:
+			if (dwSignature == CardIssuerStandService_MethodSignature_PrintCardImmediately) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_QueryCIStatus:
+			if (dwSignature == CardIssuerStandService_MethodSignature_QueryCIStatus) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_GetDevInfo:
+			if (dwSignature == CardIssuerStandService_MethodSignature_GetDevInfo) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		default:
+			Error = Error_MethodNotFound;
+			break;
+		}
+		return Error;
+	}
+
+	int CheckMessageSignature(DWORD dwMessageID, DWORD dwSignature)
+	{
+		ErrorCodeEnum Error = Error_Succeed;
+		switch (dwMessageID) {
+		case CardIssuerStandService_Method_Insert:
+			if (dwSignature != CardIssuerStandService_MethodSignature_Insert) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_CancelInsert:
+			if (dwSignature != CardIssuerStandService_MethodSignature_CancelInsert) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_InsertWaitMore:
+			if (dwSignature != CardIssuerStandService_MethodSignature_InsertWaitMore) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Read:
+			if (dwSignature != CardIssuerStandService_MethodSignature_Read) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Capture:
+			if (dwSignature != CardIssuerStandService_MethodSignature_Capture) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Eject:
+			if (dwSignature != CardIssuerStandService_MethodSignature_Eject) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_PreOnline:
+			if (dwSignature != CardIssuerStandService_MethodSignature_PreOnline) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_PostOnline:
+			if (dwSignature != CardIssuerStandService_MethodSignature_PostOnline) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Exit:
+			if (dwSignature != CardIssuerStandService_MethodSignature_Exit) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Issue:
+			if (dwSignature != CardIssuerStandService_MethodSignature_Issue) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_GetMaterialCount:
+			if (dwSignature != CardIssuerStandService_MethodSignature_GetMaterialCount) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_SetMaterialCount:
+			if (dwSignature != CardIssuerStandService_MethodSignature_SetMaterialCount) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_SetIssueFlag:
+			if (dwSignature != CardIssuerStandService_MethodSignature_SetIssueFlag) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_ReadEx:
+			if (dwSignature != CardIssuerStandService_MethodSignature_ReadEx) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_QueryCardInfo:
+			if (dwSignature != CardIssuerStandService_MethodSignature_QueryCardInfo) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_WriteTrack:
+			if (dwSignature != CardIssuerStandService_MethodSignature_WriteTrack) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_GetMaterialCountEx:
+			if (dwSignature != CardIssuerStandService_MethodSignature_GetMaterialCountEx) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_SetMaterialCountEx:
+			if (dwSignature != CardIssuerStandService_MethodSignature_SetMaterialCountEx) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_SetSomeFlag:
+			if (dwSignature != CardIssuerStandService_MethodSignature_SetSomeFlag) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_GetSCIInfo:
+			if (dwSignature != CardIssuerStandService_MethodSignature_GetSCIInfo) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_IssueEx:
+			if (dwSignature != CardIssuerStandService_MethodSignature_IssueEx) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_OpenSafeLock:
+			if (dwSignature != CardIssuerStandService_MethodSignature_OpenSafeLock) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_SAMICCommand:
+			if (dwSignature != CardIssuerStandService_MethodSignature_SAMICCommand) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_QueryPrinterStatus:
+			if (dwSignature != CardIssuerStandService_MethodSignature_QueryPrinterStatus) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_Print:
+			if (dwSignature != CardIssuerStandService_MethodSignature_Print) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_QuerySCIList:
+			if (dwSignature != CardIssuerStandService_MethodSignature_QuerySCIList) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_BindSCI:
+			if (dwSignature != CardIssuerStandService_MethodSignature_BindSCI) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_PreOnlineOnStore:
+			if (dwSignature != CardIssuerStandService_MethodSignature_PreOnlineOnStore) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_NotifyPreonline:
+			if (dwSignature != CardIssuerStandService_MethodSignature_NotifyPreonline) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_QueryCardInfoOnStore:
+			if (dwSignature != CardIssuerStandService_MethodSignature_QueryCardInfoOnStore) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_GetAddCardInfo:
+			if (dwSignature != CardIssuerStandService_MethodSignature_GetAddCardInfo) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_PrintCardImmediately:
+			if (dwSignature != CardIssuerStandService_MethodSignature_PrintCardImmediately) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_QueryCIStatus:
+			if (dwSignature != CardIssuerStandService_MethodSignature_QueryCIStatus) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case CardIssuerStandService_Method_GetDevInfo:
+			if (dwSignature != CardIssuerStandService_MethodSignature_GetDevInfo) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		default:
+			Error = Error_MethodNotFound;
+			break;
+		}
+		return Error;
+	}
+
+	virtual void Handle_Insert(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_CancelInsert(SpOnewayCallContext<CardIssuerStandService_CancelInsert_Info>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_InsertWaitMore(SpOnewayCallContext<CardIssuerStandService_InsertWaitMore_Info>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_Read(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_Capture(SpReqAnsContext<CardIssuerStandService_Capture_Req, CardIssuerStandService_Capture_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_Eject(SpReqAnsContext<CardIssuerStandService_Eject_Req, CardIssuerStandService_Eject_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_Exit(SpOnewayCallContext<CardIssuerStandService_Exit_Info>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_Issue(SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_GetMaterialCount(SpReqAnsContext<CardIssuerStandService_GetMaterialCount_Req, CardIssuerStandService_GetMaterialCount_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_SetMaterialCount(SpReqAnsContext<CardIssuerStandService_SetMaterialCount_Req, CardIssuerStandService_SetMaterialCount_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_SetIssueFlag(SpOnewayCallContext<CardIssuerStandService_SetIssueFlag_Info>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_ReadEx(SpReqAnsContext<CardIssuerStandService_ReadEx_Req, CardIssuerStandService_ReadEx_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_QueryCardInfo(SpReqAnsContext<CardIssuerStandService_QueryCardInfo_Req, CardIssuerStandService_QueryCardInfo_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_WriteTrack(SpReqAnsContext<CardIssuerStandService_WriteTrack_Req, CardIssuerStandService_WriteTrack_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_GetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_GetMaterialCountEx_Req, CardIssuerStandService_GetMaterialCountEx_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_SetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_SetMaterialCountEx_Req, CardIssuerStandService_SetMaterialCountEx_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_SetSomeFlag(SpReqAnsContext<CardIssuerStandService_SetSomeFlag_Req, CardIssuerStandService_SetSomeFlag_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_GetSCIInfo(SpReqAnsContext<CardIssuerStandService_GetSCIInfo_Req, CardIssuerStandService_GetSCIInfo_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_IssueEx(SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_OpenSafeLock(SpReqAnsContext<CardIssuerStandService_OpenSafeLock_Req, CardIssuerStandService_OpenSafeLock_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_SAMICCommand(SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_QueryPrinterStatus(SpReqAnsContext<CardIssuerStandService_QueryPrinterStatus_Req, CardIssuerStandService_QueryPrinterStatus_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_Print(SpReqAnsContext<CardIssuerStandService_Print_Req, CardIssuerStandService_Print_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_QuerySCIList(SpReqAnsContext<CardIssuerStandService_QuerySCIList_Req, CardIssuerStandService_QuerySCIList_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_BindSCI(SpReqAnsContext<CardIssuerStandService_BindSCI_Req, CardIssuerStandService_BindSCI_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_PreOnlineOnStore(SpReqAnsContext<CardIssuerStandService_PreOnlineOnStore_Req, CardIssuerStandService_PreOnlineOnStore_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_NotifyPreonline(SpReqAnsContext<CardIssuerStandService_NotifyPreonline_Req, CardIssuerStandService_NotifyPreonline_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_QueryCardInfoOnStore(SpReqAnsContext<CardIssuerStandService_QueryCardInfoOnStore_Req, CardIssuerStandService_QueryCardInfoOnStore_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_GetAddCardInfo(SpReqAnsContext<CardIssuerStandService_GetAddCardInfo_Req, CardIssuerStandService_GetAddCardInfo_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_PrintCardImmediately(SpReqAnsContext<CardIssuerStandService_PrintCardImmediately_Req, CardIssuerStandService_PrintCardImmediately_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_GetDevInfo(SpReqAnsContext<CardIssuerStandService_GetDevInfo_Req, CardIssuerStandService_GetDevInfo_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void OnRequest(CSmartPointer<ITransactionContext> pTransactionContext)
+	{
+		CAutoBuffer Buf;
+		DWORD dwMessageID;
+		DWORD dwMessageSignature;
+		ErrorCodeEnum Error = pTransactionContext->GetReceiveBuffer(dwMessageID, dwMessageSignature, Buf);
+		if (Error == Error_Succeed) {
+#ifdef DEBUG
+			assert(CheckMessageSignature(dwMessageID, dwMessageSignature) == Error_Succeed);
+#else
+			if (CheckMessageSignature(dwMessageID, dwMessageSignature) != Error_Succeed) {
+				pTransactionContext->SendAnswer(Error_MethodSignatureFailed);
+				return;
+			}
+#endif
+			switch (dwMessageID) {
+				case CardIssuerStandService_Method_Insert:
+					{
+						SpReqAnsContext<CardIssuerStandService_Insert_Req,CardIssuerStandService_Insert_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_Insert_Req,CardIssuerStandService_Insert_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_Insert(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_CancelInsert:
+					{
+						SpOnewayCallContext<CardIssuerStandService_CancelInsert_Info>::Pointer ctx;
+						ctx.Attach(new SpOnewayCallContext<CardIssuerStandService_CancelInsert_Info>());
+						SpBuffer2Object(Buf, ctx->Info);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_CancelInsert(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_InsertWaitMore:
+					{
+						SpOnewayCallContext<CardIssuerStandService_InsertWaitMore_Info>::Pointer ctx;
+						ctx.Attach(new SpOnewayCallContext<CardIssuerStandService_InsertWaitMore_Info>());
+						SpBuffer2Object(Buf, ctx->Info);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_InsertWaitMore(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_Read:
+					{
+						SpReqAnsContext<CardIssuerStandService_Read_Req,CardIssuerStandService_Read_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_Read_Req,CardIssuerStandService_Read_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_Read(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_Capture:
+					{
+						SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_Capture(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_Eject:
+					{
+						SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_Eject(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_PreOnline:
+					{
+						SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_PreOnline(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_PostOnline:
+					{
+						SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_PostOnline(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_Exit:
+					{
+						SpOnewayCallContext<CardIssuerStandService_Exit_Info>::Pointer ctx;
+						ctx.Attach(new SpOnewayCallContext<CardIssuerStandService_Exit_Info>());
+						SpBuffer2Object(Buf, ctx->Info);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_Exit(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_Issue:
+					{
+						SpReqAnsContext<CardIssuerStandService_Issue_Req,CardIssuerStandService_Issue_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_Issue_Req,CardIssuerStandService_Issue_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_Issue(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_GetMaterialCount:
+					{
+						SpReqAnsContext<CardIssuerStandService_GetMaterialCount_Req,CardIssuerStandService_GetMaterialCount_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_GetMaterialCount_Req,CardIssuerStandService_GetMaterialCount_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetMaterialCount(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_SetMaterialCount:
+					{
+						SpReqAnsContext<CardIssuerStandService_SetMaterialCount_Req,CardIssuerStandService_SetMaterialCount_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_SetMaterialCount_Req,CardIssuerStandService_SetMaterialCount_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_SetMaterialCount(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_SetIssueFlag:
+					{
+						SpOnewayCallContext<CardIssuerStandService_SetIssueFlag_Info>::Pointer ctx;
+						ctx.Attach(new SpOnewayCallContext<CardIssuerStandService_SetIssueFlag_Info>());
+						SpBuffer2Object(Buf, ctx->Info);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_SetIssueFlag(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_ReadEx:
+					{
+						SpReqAnsContext<CardIssuerStandService_ReadEx_Req,CardIssuerStandService_ReadEx_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_ReadEx_Req,CardIssuerStandService_ReadEx_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_ReadEx(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_QueryCardInfo:
+					{
+						SpReqAnsContext<CardIssuerStandService_QueryCardInfo_Req,CardIssuerStandService_QueryCardInfo_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_QueryCardInfo_Req,CardIssuerStandService_QueryCardInfo_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_QueryCardInfo(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_WriteTrack:
+					{
+						SpReqAnsContext<CardIssuerStandService_WriteTrack_Req,CardIssuerStandService_WriteTrack_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_WriteTrack_Req,CardIssuerStandService_WriteTrack_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_WriteTrack(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_GetMaterialCountEx:
+					{
+						SpReqAnsContext<CardIssuerStandService_GetMaterialCountEx_Req,CardIssuerStandService_GetMaterialCountEx_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_GetMaterialCountEx_Req,CardIssuerStandService_GetMaterialCountEx_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetMaterialCountEx(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_SetMaterialCountEx:
+					{
+						SpReqAnsContext<CardIssuerStandService_SetMaterialCountEx_Req,CardIssuerStandService_SetMaterialCountEx_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_SetMaterialCountEx_Req,CardIssuerStandService_SetMaterialCountEx_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_SetMaterialCountEx(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_SetSomeFlag:
+					{
+						SpReqAnsContext<CardIssuerStandService_SetSomeFlag_Req,CardIssuerStandService_SetSomeFlag_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_SetSomeFlag_Req,CardIssuerStandService_SetSomeFlag_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_SetSomeFlag(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_GetSCIInfo:
+					{
+						SpReqAnsContext<CardIssuerStandService_GetSCIInfo_Req,CardIssuerStandService_GetSCIInfo_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_GetSCIInfo_Req,CardIssuerStandService_GetSCIInfo_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetSCIInfo(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_IssueEx:
+					{
+						SpReqAnsContext<CardIssuerStandService_IssueEx_Req,CardIssuerStandService_IssueEx_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_IssueEx_Req,CardIssuerStandService_IssueEx_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_IssueEx(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_OpenSafeLock:
+					{
+						SpReqAnsContext<CardIssuerStandService_OpenSafeLock_Req,CardIssuerStandService_OpenSafeLock_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_OpenSafeLock_Req,CardIssuerStandService_OpenSafeLock_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_OpenSafeLock(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_SAMICCommand:
+					{
+						SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req,CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req,CardIssuerStandService_SAMICCommand_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_SAMICCommand(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_QueryPrinterStatus:
+					{
+						SpReqAnsContext<CardIssuerStandService_QueryPrinterStatus_Req,CardIssuerStandService_QueryPrinterStatus_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_QueryPrinterStatus_Req,CardIssuerStandService_QueryPrinterStatus_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_QueryPrinterStatus(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_Print:
+					{
+						SpReqAnsContext<CardIssuerStandService_Print_Req,CardIssuerStandService_Print_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_Print_Req,CardIssuerStandService_Print_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_Print(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_QuerySCIList:
+					{
+						SpReqAnsContext<CardIssuerStandService_QuerySCIList_Req,CardIssuerStandService_QuerySCIList_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_QuerySCIList_Req,CardIssuerStandService_QuerySCIList_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_QuerySCIList(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_BindSCI:
+					{
+						SpReqAnsContext<CardIssuerStandService_BindSCI_Req,CardIssuerStandService_BindSCI_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_BindSCI_Req,CardIssuerStandService_BindSCI_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_BindSCI(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_PreOnlineOnStore:
+					{
+						SpReqAnsContext<CardIssuerStandService_PreOnlineOnStore_Req,CardIssuerStandService_PreOnlineOnStore_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_PreOnlineOnStore_Req,CardIssuerStandService_PreOnlineOnStore_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_PreOnlineOnStore(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_NotifyPreonline:
+					{
+						SpReqAnsContext<CardIssuerStandService_NotifyPreonline_Req,CardIssuerStandService_NotifyPreonline_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_NotifyPreonline_Req,CardIssuerStandService_NotifyPreonline_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_NotifyPreonline(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_QueryCardInfoOnStore:
+					{
+						SpReqAnsContext<CardIssuerStandService_QueryCardInfoOnStore_Req,CardIssuerStandService_QueryCardInfoOnStore_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_QueryCardInfoOnStore_Req,CardIssuerStandService_QueryCardInfoOnStore_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_QueryCardInfoOnStore(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_GetAddCardInfo:
+					{
+						SpReqAnsContext<CardIssuerStandService_GetAddCardInfo_Req,CardIssuerStandService_GetAddCardInfo_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_GetAddCardInfo_Req,CardIssuerStandService_GetAddCardInfo_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetAddCardInfo(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_PrintCardImmediately:
+					{
+						SpReqAnsContext<CardIssuerStandService_PrintCardImmediately_Req,CardIssuerStandService_PrintCardImmediately_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_PrintCardImmediately_Req,CardIssuerStandService_PrintCardImmediately_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_PrintCardImmediately(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_QueryCIStatus:
+					{
+						SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req,CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req,CardIssuerStandService_QueryCIStatus_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_QueryCIStatus(ctx);
+					}
+					break;
+				case CardIssuerStandService_Method_GetDevInfo:
+					{
+						SpReqAnsContext<CardIssuerStandService_GetDevInfo_Req,CardIssuerStandService_GetDevInfo_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<CardIssuerStandService_GetDevInfo_Req,CardIssuerStandService_GetDevInfo_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetDevInfo(ctx);
+					}
+					break;
+				default:
+					assert(0);
+					break;
+			}
+			
+		} else {
+			pTransactionContext->SendAnswer(Error);
+		}
+	}
+
+};
+
+
+///////////////////////////
+
+} // namespace CardIssuerStand
+#endif // __CARDISSUERSTAND_SERVER_G_H

+ 19 - 19
Module/mod_CardIssuerStand/mod_cardissuer.cpp

@@ -10,14 +10,14 @@
 
 #include "CardIssuerClass.h"
 
-void CardIssuerServerSession::Handle_Insert(SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_Insert(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("Insert");
 	m_pEntity->Insert(ctx);
 }
-void CardIssuerServerSession::Handle_Read(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_Read(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
@@ -25,7 +25,7 @@ void CardIssuerServerSession::Handle_Read(SpReqAnsContext<CardIssuerService_Read
 	m_pEntity->Read(ctx);
 }
 
-void CardIssuerServerSession::Handle_Capture(SpReqAnsContext<CardIssuerService_Capture_Req, CardIssuerService_Capture_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_Capture(SpReqAnsContext<CardIssuerStandService_Capture_Req, CardIssuerStandService_Capture_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
@@ -33,7 +33,7 @@ void CardIssuerServerSession::Handle_Capture(SpReqAnsContext<CardIssuerService_C
 	m_pEntity->Capture(ctx);
 }
 
-void CardIssuerServerSession::Handle_Eject(SpReqAnsContext<CardIssuerService_Eject_Req, CardIssuerService_Eject_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_Eject(SpReqAnsContext<CardIssuerStandService_Eject_Req, CardIssuerStandService_Eject_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
@@ -41,104 +41,104 @@ void CardIssuerServerSession::Handle_Eject(SpReqAnsContext<CardIssuerService_Eje
 	m_pEntity->Eject(ctx);
 }
 
-void CardIssuerServerSession::Handle_CancelInsert(SpOnewayCallContext<CardIssuerService_CancelInsert_Info>::Pointer ctx)
+void CardIssuerServerSession::Handle_CancelInsert(SpOnewayCallContext<CardIssuerStandService_CancelInsert_Info>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("CancelInsert");
 	m_pEntity->CancelInsert(ctx);
 }
-void CardIssuerServerSession::Handle_InsertWaitMore(SpOnewayCallContext<CardIssuerService_InsertWaitMore_Info>::Pointer ctx)
+void CardIssuerServerSession::Handle_InsertWaitMore(SpOnewayCallContext<CardIssuerStandService_InsertWaitMore_Info>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("InsertWaitMore");
 	m_pEntity->InsertWaitMore(ctx);
 }
-void CardIssuerServerSession::Handle_PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req, CardIssuerService_PreOnline_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("PreOnline");
 	m_pEntity->PreOnline(ctx);
 }
-void CardIssuerServerSession::Handle_PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req, CardIssuerService_PostOnline_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("PostOnline");
 	m_pEntity->PostOnline(ctx);
 }
-void CardIssuerServerSession::Handle_Exit(SpOnewayCallContext<CardIssuerService_Exit_Info>::Pointer ctx)
+void CardIssuerServerSession::Handle_Exit(SpOnewayCallContext<CardIssuerStandService_Exit_Info>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("Exit");
 	m_pEntity->Exit(ctx);
 }
- void CardIssuerServerSession::Handle_SetIssueFlag(SpOnewayCallContext<CardIssuerService_SetIssueFlag_Info>::Pointer ctx)
+ void CardIssuerServerSession::Handle_SetIssueFlag(SpOnewayCallContext<CardIssuerStandService_SetIssueFlag_Info>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("SetIssueFlag");
 	m_pEntity->SetIssueFlag(ctx);
 }
-void CardIssuerServerSession::Handle_QueryCardInfo(SpReqAnsContext<CardIssuerService_QueryCardInfo_Req, CardIssuerService_QueryCardInfo_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_QueryCardInfo(SpReqAnsContext<CardIssuerStandService_QueryCardInfo_Req, CardIssuerStandService_QueryCardInfo_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("QueryCardInfo");
 	m_pEntity->QueryCardInfo(ctx);
 }
-void CardIssuerServerSession::Handle_WriteTrack(SpReqAnsContext<CardIssuerService_WriteTrack_Req, CardIssuerService_WriteTrack_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_WriteTrack(SpReqAnsContext<CardIssuerStandService_WriteTrack_Req, CardIssuerStandService_WriteTrack_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("WriteTrack");
 	m_pEntity->WriteTrack(ctx);
 }
-void CardIssuerServerSession::Handle_GetMaterialCountEx(SpReqAnsContext<CardIssuerService_GetMaterialCountEx_Req, CardIssuerService_GetMaterialCountEx_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_GetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_GetMaterialCountEx_Req, CardIssuerStandService_GetMaterialCountEx_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("GetMaterialCountEx");
 	m_pEntity->GetMaterialCountEx(ctx);
 }
-void CardIssuerServerSession::Handle_SetMaterialCountEx(SpReqAnsContext<CardIssuerService_SetMaterialCountEx_Req, CardIssuerService_SetMaterialCountEx_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_SetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_SetMaterialCountEx_Req, CardIssuerStandService_SetMaterialCountEx_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("SetMaterialCountEx");
 	m_pEntity->SetMaterialCountEx(ctx);
 }
-void CardIssuerServerSession::Handle_SetSomeFlag(SpReqAnsContext<CardIssuerService_SetSomeFlag_Req, CardIssuerService_SetSomeFlag_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_SetSomeFlag(SpReqAnsContext<CardIssuerStandService_SetSomeFlag_Req, CardIssuerStandService_SetSomeFlag_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("SetSomeFlag");
 	m_pEntity->SetSomeFlag(ctx);
 }
-void CardIssuerServerSession::Handle_IssueEx(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_IssueEx(SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("IssueEx");
 	m_pEntity->IssueEx(ctx);
 }
-void CardIssuerServerSession::Handle_SAMICCommand(SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_SAMICCommand(SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx)
 {
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("SAMICCommand");
 	m_pEntity->SAMICCommand(ctx);
 }
-void CardIssuerServerSession::Handle_QueryCIStatus(SpReqAnsContext<CardIssuerService_QueryCIStatus_Req, CardIssuerService_QueryCIStatus_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();
 	DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setAPI(__FUNCTION__)("QueryCIStatus");
 	m_pEntity->QueryCIStatus(ctx);
 }
-void CardIssuerServerSession::Handle_GetDevInfo(SpReqAnsContext<CardIssuerService_GetDevInfo_Req, CardIssuerService_GetDevInfo_Ans>::Pointer ctx)
+void CardIssuerServerSession::Handle_GetDevInfo(SpReqAnsContext<CardIssuerStandService_GetDevInfo_Req, CardIssuerStandService_GetDevInfo_Ans>::Pointer ctx)
 {
 	LOG_FUNCTION();
 	DbgToBeidou(ctx->link, __FUNCTION__)();

+ 44 - 44
Module/mod_CardIssuerStand/mod_cardissuer.h

@@ -1,35 +1,35 @@
-#include "CardIssuer_server_g.h"
-#include "CardIssuer_def_g.h"
+#include "CardIssuerStand_server_g.h"
+#include "CardIssuerStand_def_g.h"
 #include "CardIssuerFSM.h"
 #include "DevEntityCommBase.hpp"
-using namespace CardIssuer;
+using namespace CardIssuerStand;
 
 class CCardIssuerEntity;
 
-class CardIssuerServerSession : public CardIssuerService_ServerSessionBase
+class CardIssuerServerSession : public CardIssuerStandService_ServerSessionBase
 {
 public:
 	CardIssuerServerSession(CCardIssuerEntity* pEntity):m_pEntity(pEntity){}
 	virtual ~CardIssuerServerSession(){}
-	virtual void Handle_Insert(SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx);
-	virtual void Handle_Read(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx);
-	virtual void Handle_Capture(SpReqAnsContext<CardIssuerService_Capture_Req, CardIssuerService_Capture_Ans>::Pointer ctx);
-	virtual void Handle_Eject(SpReqAnsContext<CardIssuerService_Eject_Req, CardIssuerService_Eject_Ans>::Pointer ctx);
-	virtual void Handle_CancelInsert(SpOnewayCallContext<CardIssuerService_CancelInsert_Info>::Pointer ctx);
-	virtual void Handle_InsertWaitMore(SpOnewayCallContext<CardIssuerService_InsertWaitMore_Info>::Pointer ctx);
-	virtual void Handle_PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req, CardIssuerService_PreOnline_Ans>::Pointer ctx);
-	virtual void Handle_PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req, CardIssuerService_PostOnline_Ans>::Pointer ctx);
-	virtual void Handle_Exit(SpOnewayCallContext<CardIssuerService_Exit_Info>::Pointer ctx);	
-	virtual void Handle_SetIssueFlag(SpOnewayCallContext<CardIssuerService_SetIssueFlag_Info>::Pointer ctx);
-	virtual void Handle_QueryCardInfo(SpReqAnsContext<CardIssuerService_QueryCardInfo_Req, CardIssuerService_QueryCardInfo_Ans>::Pointer ctx);
-	virtual void Handle_WriteTrack(SpReqAnsContext<CardIssuerService_WriteTrack_Req, CardIssuerService_WriteTrack_Ans>::Pointer ctx);
-	virtual void Handle_GetMaterialCountEx(SpReqAnsContext<CardIssuerService_GetMaterialCountEx_Req, CardIssuerService_GetMaterialCountEx_Ans>::Pointer ctx);
-	virtual void Handle_SetMaterialCountEx(SpReqAnsContext<CardIssuerService_SetMaterialCountEx_Req, CardIssuerService_SetMaterialCountEx_Ans>::Pointer ctx);
-	virtual void Handle_SetSomeFlag(SpReqAnsContext<CardIssuerService_SetSomeFlag_Req, CardIssuerService_SetSomeFlag_Ans>::Pointer ctx);
-	virtual void Handle_IssueEx(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx);
-	virtual void Handle_SAMICCommand(SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx);
-	virtual void Handle_QueryCIStatus(SpReqAnsContext<CardIssuerService_QueryCIStatus_Req, CardIssuerService_QueryCIStatus_Ans>::Pointer ctx);
-	virtual void Handle_GetDevInfo(SpReqAnsContext<CardIssuerService_GetDevInfo_Req, CardIssuerService_GetDevInfo_Ans>::Pointer ctx);
+	virtual void Handle_Insert(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx);
+	virtual void Handle_Read(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx);
+	virtual void Handle_Capture(SpReqAnsContext<CardIssuerStandService_Capture_Req, CardIssuerStandService_Capture_Ans>::Pointer ctx);
+	virtual void Handle_Eject(SpReqAnsContext<CardIssuerStandService_Eject_Req, CardIssuerStandService_Eject_Ans>::Pointer ctx);
+	virtual void Handle_CancelInsert(SpOnewayCallContext<CardIssuerStandService_CancelInsert_Info>::Pointer ctx);
+	virtual void Handle_InsertWaitMore(SpOnewayCallContext<CardIssuerStandService_InsertWaitMore_Info>::Pointer ctx);
+	virtual void Handle_PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx);
+	virtual void Handle_PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx);
+	virtual void Handle_Exit(SpOnewayCallContext<CardIssuerStandService_Exit_Info>::Pointer ctx);
+	virtual void Handle_SetIssueFlag(SpOnewayCallContext<CardIssuerStandService_SetIssueFlag_Info>::Pointer ctx);
+	virtual void Handle_QueryCardInfo(SpReqAnsContext<CardIssuerStandService_QueryCardInfo_Req, CardIssuerStandService_QueryCardInfo_Ans>::Pointer ctx);
+	virtual void Handle_WriteTrack(SpReqAnsContext<CardIssuerStandService_WriteTrack_Req, CardIssuerStandService_WriteTrack_Ans>::Pointer ctx);
+	virtual void Handle_GetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_GetMaterialCountEx_Req, CardIssuerStandService_GetMaterialCountEx_Ans>::Pointer ctx);
+	virtual void Handle_SetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_SetMaterialCountEx_Req, CardIssuerStandService_SetMaterialCountEx_Ans>::Pointer ctx);
+	virtual void Handle_SetSomeFlag(SpReqAnsContext<CardIssuerStandService_SetSomeFlag_Req, CardIssuerStandService_SetSomeFlag_Ans>::Pointer ctx);
+	virtual void Handle_IssueEx(SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctx);
+	virtual void Handle_SAMICCommand(SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx);
+	virtual void Handle_QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx);
+	virtual void Handle_GetDevInfo(SpReqAnsContext<CardIssuerStandService_GetDevInfo_Req, CardIssuerStandService_GetDevInfo_Ans>::Pointer ctx);
 private:
 	CCardIssuerEntity* m_pEntity;
 };
@@ -41,7 +41,7 @@ public:
 	{
 	}
 	virtual ~CCardIssuerEntity(){}
-	virtual const char *GetEntityName() const { return "CardIssuer"; }
+	virtual const char *GetEntityName() const { return "CardIssuerStand"; }
 	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
 	{ 
 		LOG_FUNCTION();
@@ -87,7 +87,7 @@ public:
 		return new CardIssuerServerSession(this);
 	}
 
-	void Insert(SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx)
+	void Insert(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_Insert_Ans>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		if(!m_fsm.GetDevInitFlag()){
@@ -102,14 +102,14 @@ public:
 		}
 	}
 
-	void Read(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx)
+	void Read(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		CardReadEvent* e = new CardReadEvent();
 		e->ctx = ctx;
 		m_fsm.PostEventFIFO(e);
 	}
-	void Capture(SpReqAnsContext<CardIssuerService_Capture_Req, CardIssuerService_Capture_Ans>::Pointer ctx)
+	void Capture(SpReqAnsContext<CardIssuerStandService_Capture_Req, CardIssuerStandService_Capture_Ans>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		CardCaptureEvent* e = new CardCaptureEvent();
@@ -117,26 +117,26 @@ public:
 		m_fsm.PostEventFIFO(e);
 	}
 
-	void Eject(SpReqAnsContext<CardIssuerService_Eject_Req, CardIssuerService_Eject_Ans>::Pointer ctx)
+	void Eject(SpReqAnsContext<CardIssuerStandService_Eject_Req, CardIssuerStandService_Eject_Ans>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		CardEjectEvent* e = new CardEjectEvent();
 		e->ctx = ctx;
 		m_fsm.PostEventFIFO(e);
 	}
-	void CancelInsert(SpOnewayCallContext<CardIssuerService_CancelInsert_Info>::Pointer ctx)
+	void CancelInsert(SpOnewayCallContext<CardIssuerStandService_CancelInsert_Info>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		CancelAcceptEvent *e = new CancelAcceptEvent();
 		m_fsm.PostEventFIFO(e);
 	}
-	void InsertWaitMore(SpOnewayCallContext<CardIssuerService_InsertWaitMore_Info>::Pointer ctx)
+	void InsertWaitMore(SpOnewayCallContext<CardIssuerStandService_InsertWaitMore_Info>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		if (m_fsm.GetWaitFlag())
 			m_fsm.SetWaitMore();
 	}
-	void Issue(SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx)
+	void Issue(SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		m_bNewSessionInit = false;
@@ -144,7 +144,7 @@ public:
 		pEvt->ctx = ctx;
 		m_fsm.PostEventFIFO(pEvt);
 	}
-	void PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req, CardIssuerService_PreOnline_Ans>::Pointer ctx)
+	void PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		if (!m_fsm.GetDevInitFlag()) {
@@ -170,21 +170,21 @@ public:
 			m_fsm.PostEventFIFO(e);
 		}
 	}
-	void PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req, CardIssuerService_PostOnline_Ans>::Pointer ctx)
+	void PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		PostOnlineEvent* e = new PostOnlineEvent();
 		e->ctx = ctx;
 		m_fsm.PostEventFIFO(e);
 	}
-	void Exit(SpOnewayCallContext<CardIssuerService_Exit_Info>::Pointer ctx)
+	void Exit(SpOnewayCallContext<CardIssuerStandService_Exit_Info>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		m_bNewSessionInit = false;
 		FSMEvent *evt = new FSMEvent(USER_EVT_EXIT);
 		m_fsm.PostEventFIFO(evt);
 	}
-	void QueryCardInfo(SpReqAnsContext<CardIssuerService_QueryCardInfo_Req, CardIssuerService_QueryCardInfo_Ans>::Pointer ctx)
+	void QueryCardInfo(SpReqAnsContext<CardIssuerStandService_QueryCardInfo_Req, CardIssuerStandService_QueryCardInfo_Ans>::Pointer ctx)
 	{
 		if (m_bNewSessionInit)
 		{
@@ -199,28 +199,28 @@ public:
 			ctx->Answer(Error_Succeed);
 		}
 	}
-	void WriteTrack(SpReqAnsContext<CardIssuerService_WriteTrack_Req, CardIssuerService_WriteTrack_Ans>::Pointer ctx)
+	void WriteTrack(SpReqAnsContext<CardIssuerStandService_WriteTrack_Req, CardIssuerStandService_WriteTrack_Ans>::Pointer ctx)
 	{
 		CardWriteEvent *pEvt = new CardWriteEvent();
 		pEvt->ctx = ctx;
 		m_fsm.PostEventFIFO(pEvt);
 	}
-	void SetIssueFlag(SpOnewayCallContext<CardIssuerService_SetIssueFlag_Info>::Pointer ctx){ m_fsm.FrontSetIssueFlag(true); }
-	void GetMaterialCountEx(SpReqAnsContext<CardIssuerService_GetMaterialCountEx_Req, CardIssuerService_GetMaterialCountEx_Ans>::Pointer ctx)
+	void SetIssueFlag(SpOnewayCallContext<CardIssuerStandService_SetIssueFlag_Info>::Pointer ctx){ m_fsm.FrontSetIssueFlag(true); }
+	void GetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_GetMaterialCountEx_Req, CardIssuerStandService_GetMaterialCountEx_Ans>::Pointer ctx)
 	{
 		m_bNewSessionInit = false;
 		GetMaterialExEvent *pEvt = new GetMaterialExEvent();
 		pEvt->ctx = ctx;
 		m_fsm.PostEventFIFO(pEvt);
 	}
-	void SetMaterialCountEx(SpReqAnsContext<CardIssuerService_SetMaterialCountEx_Req, CardIssuerService_SetMaterialCountEx_Ans>::Pointer ctx)
+	void SetMaterialCountEx(SpReqAnsContext<CardIssuerStandService_SetMaterialCountEx_Req, CardIssuerStandService_SetMaterialCountEx_Ans>::Pointer ctx)
 	{
 		m_bNewSessionInit = false;
 		SetMaterialExEvent *pEvt = new SetMaterialExEvent();
 		pEvt->ctx = ctx;
 		m_fsm.PostEventFIFO(pEvt);
 	}
-	void SetSomeFlag(SpReqAnsContext<CardIssuerService_SetSomeFlag_Req, CardIssuerService_SetSomeFlag_Ans>::Pointer ctx)
+	void SetSomeFlag(SpReqAnsContext<CardIssuerStandService_SetSomeFlag_Req, CardIssuerStandService_SetSomeFlag_Ans>::Pointer ctx)
 	{
 		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("set issue flag to %d", ctx->Req.IssueBusiness);
 		if (ctx->Req.IssueBusiness == 1)
@@ -254,7 +254,7 @@ public:
 		ctx->Answer(Error_Succeed);
 
 	}
-	void IssueEx(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx)
+	void IssueEx(SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		int state = m_fsm.GetFSMState();
@@ -271,14 +271,14 @@ public:
 			m_fsm.PostEventFIFO(pEvt);
 		}
 	}
-	void SAMICCommand(SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx)
+	void SAMICCommand(SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx)
 	{
 		LOG_FUNCTION();
 		SAMICCommandEvent *pEvt = new SAMICCommandEvent();
 		pEvt->ctx = ctx;
 		m_fsm.PostEventFIFO(pEvt);
 	}
-	void GetDevInfo(SpReqAnsContext<CardIssuerService_GetDevInfo_Req, CardIssuerService_GetDevInfo_Ans>::Pointer ctx)
+	void GetDevInfo(SpReqAnsContext<CardIssuerStandService_GetDevInfo_Req, CardIssuerStandService_GetDevInfo_Ans>::Pointer ctx)
 	{
 		ctx->Ans.state = m_fsm.GetDevState();
 
@@ -290,7 +290,7 @@ public:
 		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevInfo state=%d",ctx->Ans.state);
 		ctx->Answer(Error_Succeed);
 	}
-	void QueryCIStatus(SpReqAnsContext<CardIssuerService_QueryCIStatus_Req, CardIssuerService_QueryCIStatus_Ans>::Pointer ctx)
+	void QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx)
 	{
 		m_fsm.QueryCIStatus(ctx);
 	}