wnmj/Servers/服务器组件/游戏服务器/DataBaseEngineSink.cpp

#include "StdAfx.h"
#include "ServiceUnits.h"
#include "DataBaseEngineSink.h"

//构造函数
CDataBaseEngineSink::CDataBaseEngineSink()
{
	//配置变量
	m_pGameParameter=NULL;
	m_pInitParameter=NULL;
	m_pDataBaseParameter=NULL;
	m_pGameServiceAttrib=NULL;
	m_pGameServiceOption=NULL;

	//组件变量
	m_pIDataBaseEngine=NULL;
	m_pIGameServiceManager=NULL;
	m_pIDataBaseEngineEvent=NULL;
	m_pIGameDataBaseEngineSink=NULL;
	m_pIDBCorrespondManager=NULL;

	//辅助变量
	ZeroMemory(&m_LogonFailure,sizeof(m_LogonFailure));
	ZeroMemory(&m_LogonSuccess,sizeof(m_LogonSuccess));

	return;
}

//析构函数
CDataBaseEngineSink::~CDataBaseEngineSink()
{
	//释放对象
	SafeRelease(m_pIGameDataBaseEngineSink);

	return;
}

//接口查询
VOID * CDataBaseEngineSink::QueryInterface(REFGUID Guid, DWORD dwQueryVer)
{
	QUERYINTERFACE(IDataBaseEngineSink,Guid,dwQueryVer);
	QUERYINTERFACE(IGameDataBaseEngine,Guid,dwQueryVer);
	QUERYINTERFACE_IUNKNOWNEX(IDataBaseEngineSink,Guid,dwQueryVer);
	return NULL;
}

//获取对象
VOID * CDataBaseEngineSink::GetDataBase(REFGUID Guid, DWORD dwQueryVer)
{
	//效验状态
	ASSERT(m_GameDBModule.GetInterface()!=NULL);
	if (m_GameDBModule.GetInterface()==NULL) return NULL;

	//查询对象
	IDataBase * pIDataBase=m_GameDBModule.GetInterface();
	VOID * pIQueryObject=pIDataBase->QueryInterface(Guid,dwQueryVer);

	return pIQueryObject;
}

//获取对象
VOID * CDataBaseEngineSink::GetDataBaseEngine(REFGUID Guid, DWORD dwQueryVer)
{
	//效验状态
	ASSERT(m_pIDataBaseEngine!=NULL);
	if (m_pIDataBaseEngine==NULL) return NULL;

	//查询对象
	VOID * pIQueryObject=m_pIDataBaseEngine->QueryInterface(Guid,dwQueryVer);

	return pIQueryObject;
}

//投递结果
bool CDataBaseEngineSink::PostGameDataBaseResult(WORD wRequestID, VOID * pData, WORD wDataSize)
{
	return true;
}

//启动事件
bool CDataBaseEngineSink::OnDataBaseEngineStart(IUnknownEx * pIUnknownEx)
{
	//查询对象
	ASSERT(QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,IDataBaseEngine)!=NULL);
	m_pIDataBaseEngine=QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,IDataBaseEngine);

	//创建对象
	if ((m_GameDBModule.GetInterface()==NULL)&&(m_GameDBModule.CreateInstance()==false))
	{
		ASSERT(FALSE);
		return false;
	}

	//创建对象
	if ((m_TreasureDBModule.GetInterface()==NULL)&&(m_TreasureDBModule.CreateInstance()==false))
	{
		ASSERT(FALSE);
		return false;
	}

	//创建对象
	if ((m_PlatformDBModule.GetInterface()==NULL)&&(m_PlatformDBModule.CreateInstance()==false))
	{
		ASSERT(FALSE);
		return false;
	}

	//连接游戏
	try
	{
		//连接信息
		tagDataBaseParameter * pTreasureDBParameter=&m_pInitParameter->m_TreasureDBParameter;
		tagDataBaseParameter * pPlatformDBParameter=&m_pInitParameter->m_PlatformDBParameter;

		//设置连接
		m_GameDBModule->SetConnectionInfo(m_pDataBaseParameter->szDataBaseAddr,m_pDataBaseParameter->wDataBasePort,
			m_pDataBaseParameter->szDataBaseName,m_pDataBaseParameter->szDataBaseUser,m_pDataBaseParameter->szDataBasePass);

		//设置连接
		m_TreasureDBModule->SetConnectionInfo(pTreasureDBParameter->szDataBaseAddr,pTreasureDBParameter->wDataBasePort,
			pTreasureDBParameter->szDataBaseName,pTreasureDBParameter->szDataBaseUser,pTreasureDBParameter->szDataBasePass);

		//设置连接
		m_PlatformDBModule->SetConnectionInfo(pPlatformDBParameter->szDataBaseAddr,pPlatformDBParameter->wDataBasePort,
			pPlatformDBParameter->szDataBaseName,pPlatformDBParameter->szDataBaseUser,pPlatformDBParameter->szDataBasePass);

		//发起连接
		m_GameDBModule->OpenConnection();
		m_GameDBAide.SetDataBase(m_GameDBModule.GetInterface());

		//发起连接
		m_TreasureDBModule->OpenConnection();
		m_TreasureDBAide.SetDataBase(m_TreasureDBModule.GetInterface());

		//发起连接
		m_PlatformDBModule->OpenConnection();
		m_PlatformDBAide.SetDataBase(m_PlatformDBModule.GetInterface());

		//数据钩子
		ASSERT(m_pIGameServiceManager!=NULL);
		m_pIGameDataBaseEngineSink=(IGameDataBaseEngineSink *)m_pIGameServiceManager->CreateGameDataBaseEngineSink(IID_IGameDataBaseEngineSink,VER_IGameDataBaseEngineSink);

		//配置对象
		if ((m_pIGameDataBaseEngineSink!=NULL)&&(m_pIGameDataBaseEngineSink->InitializeSink(QUERY_ME_INTERFACE(IUnknownEx))==false))
		{
			//错误断言
			ASSERT(FALSE);

			//输出信息
			CTraceService::TraceString(TEXT("游戏数据库扩展钩子引擎对象配置失败"),TraceLevel_Exception);

			return false;
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}

	return true;
}

//停止事件
bool CDataBaseEngineSink::OnDataBaseEngineConclude(IUnknownEx * pIUnknownEx)
{
	//配置变量
	m_pInitParameter=NULL;
	m_pGameServiceAttrib=NULL;
	m_pGameServiceOption=NULL;

	//组件变量
	m_pIGameServiceManager=NULL;
	m_pIDataBaseEngineEvent=NULL;

	//设置对象
	m_GameDBAide.SetDataBase(NULL);

	//释放对象
	SafeRelease(m_pIGameDataBaseEngineSink);

	//关闭连接
	if (m_GameDBModule.GetInterface()!=NULL)
	{
		m_GameDBModule->CloseConnection();
		m_GameDBModule.CloseInstance();
	}

	//关闭连接
	if (m_TreasureDBModule.GetInterface()!=NULL)
	{
		m_TreasureDBModule->CloseConnection();
		m_TreasureDBModule.CloseInstance();
	}

	//关闭连接
	if (m_PlatformDBModule.GetInterface()!=NULL)
	{
		m_PlatformDBModule->CloseConnection();
		m_PlatformDBModule.CloseInstance();
	}

	return true;
}

//时间事件
bool CDataBaseEngineSink::OnDataBaseEngineTimer(DWORD dwTimerID, WPARAM dwBindParameter)
{
	return false;
}

//控制事件
bool CDataBaseEngineSink::OnDataBaseEngineControl(WORD wControlID, VOID * pData, WORD wDataSize)
{
	return false;
}

//请求事件
bool CDataBaseEngineSink::OnDataBaseEngineRequest(WORD wRequestID, DWORD dwContextID, VOID * pData, WORD wDataSize)
{
	//变量定义
	bool bSucceed = false;
	DWORD dwUserID = 0L;

	//请求处理
	switch (wRequestID)
	{
	case DBR_GR_LOGON_USERID:			//I D 登录
	{
		bSucceed = OnRequestLogonUserID(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOGON_MOBILE:			//手机登录
	{
		bSucceed = OnRequestLogonMobile(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOGON_ACCOUNTS:			//帐号登录
	{
		bSucceed = OnRequestLogonAccounts(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_WRITE_GAME_SCORE:		//游戏写分
	{
		bSucceed = OnRequestWriteGameScore(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_BEGINNER_GAME_TIME:		//游戏新手活动记录
	{
		bSucceed = OnRequestBeginnerGameTime(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LEAVE_GAME_SERVER:		//离开房间
	{
		bSucceed = OnRequestLeaveGameServer(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_GAME_SCORE_RECORD:		//游戏记录
	{
		bSucceed = OnRequestGameScoreRecord(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_PRIVATE_GAME_RECORD:		//游戏记录
	{
		bSucceed = OnRequestPrivateGameRecord(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_SINGLE_PRIVATE_RECORD:
	{
		bSucceed = OnRequestSinglePrivateGameRecord(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_UNLOCK_ANDROID_USER://解锁机器人
	{
		bSucceed = OnRequestUnlockAndroidUser(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOAD_CARD_LIBRARY:	//加载牌库
	{
		bSucceed = OnRequestLoadCardLibrary(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_RESET_DATEBASE_INF:
	{
		bSucceed = OnRequestResetDateBaseInfo(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_PRIVATE_GAME_END:
	{
		bSucceed = OnRequestPrivateGameEnd(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOAD_CARD_LIB_CFG:
	{
		bSucceed = OnRequestLoadCardLibCfg(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_UNLOCK_ALL_USER:
	{
		bSucceed = OnRequestUnlockAllUser(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOAD_PARAMETER:			//加载参数
	{
		bSucceed = OnRequestLoadParameter(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOAD_GAME_COLUMN:		//加载列表
	{
		bSucceed = OnRequestLoadGameColumn(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOAD_ANDROID_PARAMETER:	//加载配置
	{
		bSucceed = OnRequestLoadAndroidParameter(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOAD_ANDROID_USER:		//加载机器
	{
		bSucceed = OnRequestLoadAndroidUser(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOAD_GAME_PROPERTY:		//加载道具
	{
		bSucceed = OnRequestLoadGameProperty(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_USER_SAVE_SCORE:		//存入游戏币
	{
		bSucceed = OnRequestUserSaveScore(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_USER_TAKE_SCORE:		//提取游戏币
	{
		bSucceed = OnRequestUserTakeScore(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_USER_TRANSFER_SCORE:	//转账游戏币
	{
		bSucceed = OnRequestUserTransferScore(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_QUERY_INSURE_INFO:		//查询银行
	{
		bSucceed = OnRequestQueryInsureInfo(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_QUERY_TRANSFER_USER_INFO:		//查询用户
	{
		bSucceed = OnRequestQueryTransferUserInfo(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_PROPERTY_REQUEST:		//道具请求
	{
		bSucceed = OnRequestPropertyRequest(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_MANAGE_USER_RIGHT:		//用户权限
	{
		bSucceed = OnRequestManageUserRight(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOAD_SYSTEM_MESSAGE:   //系统消息
	{
		bSucceed = OnRequestLoadSystemMessage(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_LOAD_SENSITIVE_WORDS://加载敏感词
	{
		bSucceed = OnRequestLoadSensitiveWords(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_MATCH_SIGNUP:			//比赛费用
	{
		bSucceed = OnRequestMatchSignup(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_MATCH_UNSIGNUP:			//退出比赛
	{
		bSucceed = OnRequestMatchUnSignup(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_MATCH_START:			//比赛开始
	{
		bSucceed = OnRequestMatchStart(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_MATCH_ELIMINATE:		//比赛淘汰
	{
		bSucceed = OnRequestMatchEliminate(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_MATCH_RECORD_GRADES:  //记录成绩
	{
		bSucceed = OnRequestMatchRecordGrades(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_MATCH_OVER:				//比赛结束
	{
		bSucceed = OnRequestMatchOver(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_MATCH_REWARD:			//比赛奖励
	{
		bSucceed = OnRequestMatchReward(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_MATCH_LOADRANKDATA:
	{
		bSucceed = OnRequestMatchLoadRankData(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_PRIVATE_INFO:			//比赛奖励
	{
		bSucceed = OnRequestPrivateInfo(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_CREATE_PRIVAT:			//检查是否可以创建房间
	{
		bSucceed = OnRequestCreatePrivate(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_CREATE_PRIVAT_COST:			//扣除房费
	{
		bSucceed = OnRequestCreatePrivateCost(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_CREATE_UNION_ROOM:			//工会开房;
	{
		bSucceed = OnRequestCreateUnionRoom(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_UNION_ROOM_USER:
	{
		bSucceed = OnRequestUnionRoomUser(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_DISMISS_UNION_ROOM:
	{
		bSucceed = onRequestDismissUnionRoom(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_JOIN_UNION_ROOM:
	{
		bSucceed = onRequestJoinUnionRoom(dwContextID, pData, wDataSize, dwUserID);
	}break;
	case DBR_GR_UNION_ROOM_END:
	{
		bSucceed = OnRequestUnionRoomEnd(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_WRITE_UNION_SCORE:
	{
		bSucceed = OnRequestWriteUnionScore(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_UNION_ROOM_INFO:
	{
		bSucceed = OnRequestUnionRoomInfo(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_AUTO_UNION_ROOM:
	{
		bSucceed = OnRequestAutoCreateUnionRoom(dwContextID, pData, wDataSize, dwUserID);
	}
	break;
	case DBR_GR_ADD_AUTO_ROOM_INFO:
	{
		bSucceed = OnRequestAddAutoRoomInfo(dwContextID, pData, wDataSize, dwUserID);
		break;
	}
	case DBR_GR_DEL_AUTO_ROOM_INFO:
	{
		bSucceed = OnRequestDelAutoRoomInfo(dwContextID, pData, wDataSize, dwUserID);
		break;
	}
	case DBR_GR_WRITE_UNION_CHAIRID:
	{
		bSucceed = OnRequestWriteUnionChairID(dwContextID, pData, wDataSize, dwUserID);
		break;
	}
	}

	//协调通知
	if (m_pIDBCorrespondManager) m_pIDBCorrespondManager->OnPostRequestComplete(dwUserID, bSucceed);

	return bSucceed;
}

//I D 登录
bool CDataBaseEngineSink::OnRequestLogonUserID(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//执行查询
	DBR_GR_LogonUserID * pLogonUserID=(DBR_GR_LogonUserID *)pData;
	dwUserID = pLogonUserID->dwUserID;

	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_LogonUserID));
	if (wDataSize!=sizeof(DBR_GR_LogonUserID)) return false;

	try
	{
		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pLogonUserID->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@dwUserID"),pLogonUserID->dwUserID);
		m_GameDBAide.AddParameter(TEXT("@strPassword"),pLogonUserID->szPassword);
		m_GameDBAide.AddParameter(TEXT("@strClientIP"),szClientAddr);
		m_GameDBAide.AddParameter(TEXT("@strMachineID"),pLogonUserID->szMachineID);
		m_GameDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);

		////比赛参数;
		//if((m_pGameServiceOption->wServerType&GAME_GENRE_MATCH)!=0)
		{
			m_GameDBAide.AddParameter(TEXT("@dwMatchID"),pLogonUserID->dwMatchID);
			m_GameDBAide.AddParameter(TEXT("@dwMatchNO"),pLogonUserID->dwMatchNO);	
		}

		m_GameDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),m_LogonFailure.szDescribeString,sizeof(m_LogonFailure.szDescribeString),adParamOutput);


		//执行查询
		LONG lResultCode=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_EfficacyUserID"),true);

		//用户信息
		lstrcpyn(m_LogonSuccess.szPassword,pLogonUserID->szPassword,CountArray(m_LogonSuccess.szPassword));
		lstrcpyn(m_LogonSuccess.szMachineID,pLogonUserID->szMachineID,CountArray(m_LogonSuccess.szMachineID));
	
		//结果处理
		CDBVarValue DBVarValue;
		m_GameDBModule->GetParameter(TEXT("@strErrorDescribe"),DBVarValue);
		OnLogonDisposeResult(dwContextID,lResultCode,CW2CT(DBVarValue.bstrVal),false);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//错误处理
		OnLogonDisposeResult(dwContextID,DB_ERROR,TEXT("由于数据库操作异常，请您稍后重试或选择另一服务器登录！"),false);

		return false;
	}

	return true;
}

//I D 登录
bool CDataBaseEngineSink::OnRequestLogonMobile(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//执行查询
	DBR_GR_LogonMobile * pLogonMobile=(DBR_GR_LogonMobile *)pData;
	dwUserID = pLogonMobile->dwUserID;

	try
	{
		//效验参数
		ASSERT(wDataSize==sizeof(DBR_GR_LogonMobile));
		if (wDataSize!=sizeof(DBR_GR_LogonMobile)) return false;

		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pLogonMobile->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@dwUserID"),pLogonMobile->dwUserID);
		m_GameDBAide.AddParameter(TEXT("@strPassword"),pLogonMobile->szPassword);
		m_GameDBAide.AddParameter(TEXT("@strClientIP"),szClientAddr);
		m_GameDBAide.AddParameter(TEXT("@strMachineID"),pLogonMobile->szMachineID);
		m_GameDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);
		m_GameDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),m_LogonFailure.szDescribeString,sizeof(m_LogonFailure.szDescribeString),adParamOutput);

		//执行查询
		LONG lResultCode=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_EfficacyMobile"),true);

		//用户信息
		lstrcpyn(m_LogonSuccess.szPassword,pLogonMobile->szPassword,CountArray(m_LogonSuccess.szPassword));
		lstrcpyn(m_LogonSuccess.szMachineID,pLogonMobile->szMachineID,CountArray(m_LogonSuccess.szMachineID));
		m_LogonSuccess.cbDeviceType=pLogonMobile->cbDeviceType;
		m_LogonSuccess.wBehaviorFlags=pLogonMobile->wBehaviorFlags;
		m_LogonSuccess.wPageTableCount=pLogonMobile->wPageTableCount;
	
		//结果处理
		CDBVarValue DBVarValue;
		m_GameDBModule->GetParameter(TEXT("@strErrorDescribe"),DBVarValue);
		OnLogonDisposeResult(dwContextID,lResultCode,CW2CT(DBVarValue.bstrVal),true,pLogonMobile->cbDeviceType,pLogonMobile->wBehaviorFlags,pLogonMobile->wPageTableCount);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//错误处理
		OnLogonDisposeResult(dwContextID,DB_ERROR,TEXT("由于数据库操作异常，请您稍后重试或选择另一服务器登录！"),true);

		return false;
	}

	return true;
}

//帐号登录
bool CDataBaseEngineSink::OnRequestLogonAccounts(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//效验参数
		ASSERT(wDataSize==sizeof(DBR_GR_LogonAccounts));
		if (wDataSize!=sizeof(DBR_GR_LogonAccounts)) return false;

		//请求处理
		DBR_GR_LogonAccounts * pLogonAccounts=(DBR_GR_LogonAccounts *)pData;

		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pLogonAccounts->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@strAccounts"),pLogonAccounts->szAccounts);
		m_GameDBAide.AddParameter(TEXT("@strPassword"),pLogonAccounts->szPassword);
		m_GameDBAide.AddParameter(TEXT("@strClientIP"),szClientAddr);
		m_GameDBAide.AddParameter(TEXT("@strMachineID"),pLogonAccounts->szMachineID);
		m_GameDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);
		m_GameDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),m_LogonFailure.szDescribeString,sizeof(m_LogonFailure.szDescribeString),adParamOutput);

		//执行查询
		LONG lResultCode=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_EfficacyAccounts"),true);

		//用户信息
		lstrcpyn(m_LogonSuccess.szPassword,pLogonAccounts->szPassword,CountArray(m_LogonSuccess.szPassword));
		lstrcpyn(m_LogonSuccess.szMachineID,pLogonAccounts->szMachineID,CountArray(m_LogonSuccess.szMachineID));

		//结果处理
		CDBVarValue DBVarValue;
		m_GameDBModule->GetParameter(TEXT("@strErrorDescribe"),DBVarValue);
		OnLogonDisposeResult(dwContextID,lResultCode,CW2CT(DBVarValue.bstrVal),false);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//错误处理
		OnLogonDisposeResult(dwContextID,DB_ERROR,TEXT("由于数据库操作异常，请您稍后重试或选择另一服务器登录！"),false);

		return false;
	}

	return true;
}

//游戏写分
bool CDataBaseEngineSink::OnRequestWriteGameScore(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//请求处理
	DBR_GR_WriteGameScore * pWriteGameScore=(DBR_GR_WriteGameScore *)pData;
	dwUserID=pWriteGameScore->dwUserID;

	try
	{
		//效验参数
		ASSERT(wDataSize==sizeof(DBR_GR_WriteGameScore));
		if (wDataSize!=sizeof(DBR_GR_WriteGameScore)) return false;

		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pWriteGameScore->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_PlatformDBAide.ResetParameter();

		//用户信息
		m_PlatformDBAide.AddParameter(TEXT("@dwUserID"), pWriteGameScore->dwUserID);
		m_PlatformDBAide.AddParameter(TEXT("@dwDBQuestID"), pWriteGameScore->dwDBQuestID);
		m_PlatformDBAide.AddParameter(TEXT("@dwInoutIndex"), pWriteGameScore->dwInoutIndex);

		//变更成绩
		m_PlatformDBAide.AddParameter(TEXT("@lVariationScore"), pWriteGameScore->VariationInfo.lScore);
		m_PlatformDBAide.AddParameter(TEXT("@lVariationGrade"), pWriteGameScore->VariationInfo.lGrade);
		m_PlatformDBAide.AddParameter(TEXT("@lVariationInsure"), pWriteGameScore->VariationInfo.lInsure);
		m_PlatformDBAide.AddParameter(TEXT("@lVariationRevenue"), pWriteGameScore->VariationInfo.lRevenue);
		m_PlatformDBAide.AddParameter(TEXT("@lVariationWinCount"), pWriteGameScore->VariationInfo.dwWinCount);
		m_PlatformDBAide.AddParameter(TEXT("@lVariationLostCount"), pWriteGameScore->VariationInfo.dwLostCount);
		m_PlatformDBAide.AddParameter(TEXT("@lVariationDrawCount"), pWriteGameScore->VariationInfo.dwDrawCount);
		m_PlatformDBAide.AddParameter(TEXT("@lVariationFleeCount"), pWriteGameScore->VariationInfo.dwFleeCount);
		m_PlatformDBAide.AddParameter(TEXT("@lVariationUserMedal"), pWriteGameScore->VariationInfo.dwUserMedal);
		m_PlatformDBAide.AddParameter(TEXT("@lVariationExperience"), pWriteGameScore->VariationInfo.dwExperience);
		m_PlatformDBAide.AddParameter(TEXT("@lVariationLoveLiness"), pWriteGameScore->VariationInfo.lLoveLiness);
		m_PlatformDBAide.AddParameter(TEXT("@cbScoreMultiple"), pWriteGameScore->VariationInfo.cbNextScoreMultiple);
		m_PlatformDBAide.AddParameter(TEXT("@dwPlayTimeCount"), pWriteGameScore->VariationInfo.dwPlayTimeCount);

		//任务参数
		//m_GameDBAide.AddParameter(TEXT("@cbTaskForward"),pWriteGameScore->bTaskForward);

		//比赛参数
		if((m_pGameServiceOption->wServerType&GAME_GENRE_MATCH)!=0)
		{
			//比赛信息
			m_PlatformDBAide.AddParameter(TEXT("@dwMatchID"), pWriteGameScore->dwMatchID);
			m_PlatformDBAide.AddParameter(TEXT("@dwMatchNo"), pWriteGameScore->dwMatchNO);
		}

		//属性信息
		m_PlatformDBAide.AddParameter(TEXT("@wKindID"), m_pGameServiceOption->wKindID);
		m_PlatformDBAide.AddParameter(TEXT("@wServerID"), m_pGameServiceOption->wServerID);
		m_PlatformDBAide.AddParameter(TEXT("@strClientIP"), szClientAddr);

		//执行查询
		LONG lResultCode = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_WriteGameScore"), false);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}

	return true;
}
bool CDataBaseEngineSink::OnRequestBeginnerGameTime(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	DBR_GR_Beginner_InGame * pNetInfo=(DBR_GR_Beginner_InGame *)pData;
	dwUserID=pNetInfo->dwUserID;
	
	//try
	//{
	//	//用户信息
	//	m_GameDBAide.ResetParameter();
	//	m_GameDBAide.AddParameter(TEXT("@dwUserID"),dwUserID);
	//	//执行查询
	//	LONG lResultCode=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_BeginnerPlayGame"),false);

	//	return true;
	//}
	//catch (IDataBaseException * pIException)
	//{
	//	//输出错误
	//	CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

	//	return false;
	//}

	return true;
}

//离开房间
bool CDataBaseEngineSink::OnRequestLeaveGameServer(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//请求处理
	DBR_GR_LeaveGameServer * pLeaveGameServer=(DBR_GR_LeaveGameServer *)pData;
	dwUserID=pLeaveGameServer->dwUserID;

	try
	{
		//效验参数
		ASSERT(wDataSize==sizeof(DBR_GR_LeaveGameServer));
		if (wDataSize!=sizeof(DBR_GR_LeaveGameServer)) return false;

		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pLeaveGameServer->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_GameDBAide.ResetParameter();

		//用户信息
		m_GameDBAide.AddParameter(TEXT("@dwUserID"),pLeaveGameServer->dwUserID);
		m_GameDBAide.AddParameter(TEXT("@dwOnLineTimeCount"),pLeaveGameServer->dwOnLineTimeCount);

		//系统信息
		m_GameDBAide.AddParameter(TEXT("@dwInoutIndex"),pLeaveGameServer->dwInoutIndex);
		m_GameDBAide.AddParameter(TEXT("@dwLeaveReason"),pLeaveGameServer->dwLeaveReason);

		//记录成绩
		m_GameDBAide.AddParameter(TEXT("@lRecordScore"),pLeaveGameServer->RecordInfo.lScore);
		m_GameDBAide.AddParameter(TEXT("@lRecordGrade"),pLeaveGameServer->RecordInfo.lGrade);
		m_GameDBAide.AddParameter(TEXT("@lRecordInsure"),pLeaveGameServer->RecordInfo.lInsure);
		m_GameDBAide.AddParameter(TEXT("@lRecordRevenue"),pLeaveGameServer->RecordInfo.lRevenue);
		m_GameDBAide.AddParameter(TEXT("@lRecordWinCount"),pLeaveGameServer->RecordInfo.dwWinCount);
		m_GameDBAide.AddParameter(TEXT("@lRecordLostCount"),pLeaveGameServer->RecordInfo.dwLostCount);
		m_GameDBAide.AddParameter(TEXT("@lRecordDrawCount"),pLeaveGameServer->RecordInfo.dwDrawCount);
		m_GameDBAide.AddParameter(TEXT("@lRecordFleeCount"),pLeaveGameServer->RecordInfo.dwFleeCount);
		m_GameDBAide.AddParameter(TEXT("@lRecordUserMedal"),pLeaveGameServer->RecordInfo.dwUserMedal);
		m_GameDBAide.AddParameter(TEXT("@lRecordExperience"),pLeaveGameServer->RecordInfo.dwExperience);
		m_GameDBAide.AddParameter(TEXT("@lRecordLoveLiness"),pLeaveGameServer->RecordInfo.lLoveLiness);
		m_GameDBAide.AddParameter(TEXT("@dwRecordPlayTimeCount"),pLeaveGameServer->RecordInfo.dwPlayTimeCount);

		//变更成绩
		m_GameDBAide.AddParameter(TEXT("@lVariationScore"),pLeaveGameServer->VariationInfo.lScore);
		m_GameDBAide.AddParameter(TEXT("@lVariationGrade"),pLeaveGameServer->VariationInfo.lGrade);
		m_GameDBAide.AddParameter(TEXT("@lVariationInsure"),pLeaveGameServer->VariationInfo.lInsure);
		m_GameDBAide.AddParameter(TEXT("@lVariationRevenue"),pLeaveGameServer->VariationInfo.lRevenue);
		m_GameDBAide.AddParameter(TEXT("@lVariationWinCount"),pLeaveGameServer->VariationInfo.dwWinCount);
		m_GameDBAide.AddParameter(TEXT("@lVariationLostCount"),pLeaveGameServer->VariationInfo.dwLostCount);
		m_GameDBAide.AddParameter(TEXT("@lVariationDrawCount"),pLeaveGameServer->VariationInfo.dwDrawCount);
		m_GameDBAide.AddParameter(TEXT("@lVariationFleeCount"),pLeaveGameServer->VariationInfo.dwFleeCount);
		m_GameDBAide.AddParameter(TEXT("@lVariationUserMedal"),pLeaveGameServer->VariationInfo.dwUserMedal);
		m_GameDBAide.AddParameter(TEXT("@lVariationExperience"),pLeaveGameServer->VariationInfo.dwExperience);
		m_GameDBAide.AddParameter(TEXT("@lVariationLoveLiness"),pLeaveGameServer->VariationInfo.lLoveLiness);
		//m_GameDBAide.AddParameter(TEXT("@cbScoreMultiple"), pLeaveGameServer->VariationInfo.cbNextScoreMultiple);
		m_GameDBAide.AddParameter(TEXT("@dwVariationPlayTimeCount"),pLeaveGameServer->VariationInfo.dwPlayTimeCount);

		//其他参数
		m_GameDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);
		m_GameDBAide.AddParameter(TEXT("@strClientIP"),szClientAddr);
		m_GameDBAide.AddParameter(TEXT("@strMachineID"),pLeaveGameServer->szMachineID);

		//执行查询
		LONG lResultCode=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_LeaveGameServer"),false);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}

	return true;
}

//游戏记录
bool CDataBaseEngineSink::OnRequestGameScoreRecord(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		DataStream kDataStream(pData,wDataSize);

		DBR_GR_GameScoreRecord kNetInfo;
		kNetInfo.StreamValue(kDataStream,false);
		//变量定义
		DBR_GR_GameScoreRecord * pGameScoreRecord=&kNetInfo;
		dwUserID=INVALID_DWORD;

		//房间信息
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);

		//桌子信息
		m_GameDBAide.AddParameter(TEXT("@wTableID"),pGameScoreRecord->wTableID);
		m_GameDBAide.AddParameter(TEXT("@wUserCount"),pGameScoreRecord->wUserCount);
		m_GameDBAide.AddParameter(TEXT("@wAndroidCount"),pGameScoreRecord->wAndroidCount);

		//税收损耗
		m_GameDBAide.AddParameter(TEXT("@lWasteCount"),pGameScoreRecord->lWasteCount);
		m_GameDBAide.AddParameter(TEXT("@lRevenueCount"),pGameScoreRecord->lRevenueCount);

		//统计信息
		m_GameDBAide.AddParameter(TEXT("@dwUserMemal"),pGameScoreRecord->dwUserMemal);
		m_GameDBAide.AddParameter(TEXT("@dwPlayTimeCount"),pGameScoreRecord->dwPlayTimeCount);

		//时间信息
		m_GameDBAide.AddParameter(TEXT("@SystemTimeStart"),pGameScoreRecord->SystemTimeStart);
		m_GameDBAide.AddParameter(TEXT("@SystemTimeConclude"),pGameScoreRecord->SystemTimeConclude);

		if (pGameScoreRecord->dataGameDefine.size() == 0)
		{
			pGameScoreRecord->dataGameDefine.pushValue((BYTE)0);
		}

		m_GameDBAide.AddParameter(TEXT("@dataUserDefine"),(BYTE*)&pGameScoreRecord->dataGameDefine[0],
			(ULONG)pGameScoreRecord->dataGameDefine.size());

		//执行查询
		LONG lResultCode=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_RecordDrawInfo"),true);

		//写入记录
		if (lResultCode==DB_SUCCESS)
		{
			//获取标识
			DWORD dwDrawID=m_GameDBAide.GetValue_DWORD(TEXT("DrawID"));

			//写入记录
			for (WORD i=0;i<(WORD)pGameScoreRecord->GameScoreRecord.size();i++)
			{
				//重置参数
				m_GameDBAide.ResetParameter();
				
				//房间信息
				m_GameDBAide.AddParameter(TEXT("@dwDrawID"),dwDrawID);
				m_GameDBAide.AddParameter(TEXT("@dwUserID"),pGameScoreRecord->GameScoreRecord[i].dwUserID);
				m_GameDBAide.AddParameter(TEXT("@wChairID"),pGameScoreRecord->GameScoreRecord[i].wChairID);

				//用户信息
				m_GameDBAide.AddParameter(TEXT("@dwDBQuestID"),pGameScoreRecord->GameScoreRecord[i].dwDBQuestID);
				m_GameDBAide.AddParameter(TEXT("@dwInoutIndex"),pGameScoreRecord->GameScoreRecord[i].dwInoutIndex);

				//成绩信息
				m_GameDBAide.AddParameter(TEXT("@lScore"),pGameScoreRecord->GameScoreRecord[i].lScore);
				m_GameDBAide.AddParameter(TEXT("@lGrade"),pGameScoreRecord->GameScoreRecord[i].lGrade);
				m_GameDBAide.AddParameter(TEXT("@lRevenue"),pGameScoreRecord->GameScoreRecord[i].lRevenue);
				m_GameDBAide.AddParameter(TEXT("@dwUserMedal"),pGameScoreRecord->GameScoreRecord[i].dwUserMemal);
				m_GameDBAide.AddParameter(TEXT("@dwPlayTimeCount"),pGameScoreRecord->GameScoreRecord[i].dwPlayTimeCount);

				//执行查询
				m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_RecordDrawScore"),false);
			}
		}
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}

	return true;
}

bool CDataBaseEngineSink::OnRequestPrivateGameRecord(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		DataStream kDataStream(pData,wDataSize);

		if (kDataStream.size() == 0)
		{
			return true;
		}
		std::vector<tagPrivateRandRecordChild>	kRecordChild;
		tagPrivateRandTotalRecord kTotalRecord;
		kTotalRecord.StreamValue(kDataStream,false);

		for (int i = 0;i<(int)kTotalRecord.kRecordChild.size();i++)
		{
			kRecordChild.push_back(kTotalRecord.kRecordChild[i]);
		}
		kTotalRecord.kRecordChild.clear();

		DataStream kTempData;
		kTotalRecord.StreamValue(kTempData,true);

		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@recordID"), kTotalRecord.iRecordID);
		m_GameDBAide.AddParameter(TEXT("@roomNum"), kTotalRecord.iRoomNum);
		m_GameDBAide.AddParameter(TEXT("@kindID"), m_pGameServiceAttrib->wKindID);
		m_GameDBAide.AddParameter(TEXT("@dataUserDefine"),(BYTE*)&kTempData[0],(ULONG)kTempData.size());

		//执行查询;
		LONG lResultCode=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_PrivateGameRecord"),true);

		//写入记录;
		if (lResultCode==DB_SUCCESS)
		{
			//写入记录;
			for (WORD i=0;i<(WORD)kTotalRecord.kUserID.size();i++)
			{
				//重置参数;
				m_GameDBAide.ResetParameter();

				//房间信息
				m_GameDBAide.AddParameter(TEXT("@dwRecordID"), kTotalRecord.iRecordID);
				m_GameDBAide.AddParameter(TEXT("@dwUserID"),(DWORD)kTotalRecord.kUserID[i]);
				m_GameDBAide.AddParameter(TEXT("@wkindID"), m_pGameServiceAttrib->wKindID);

				//执行查询;
				m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_PrivateGameRecordUserRecordID"),true);
			}
		}
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}

	return true;
}

//加载参数
bool CDataBaseEngineSink::OnRequestLoadParameter(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//变量定义
		DBO_GR_GameParameter GameParameter;
		ZeroMemory(&GameParameter,sizeof(GameParameter));

		//执行查询
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);

		//执行查询
		LONG lResultCode=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_LoadParameter"),true);

		//读取信息
		if (lResultCode==DB_SUCCESS)
		{
			//汇率信息
			GameParameter.wMedalRate=m_GameDBAide.GetValue_WORD(TEXT("MedalRate"));
			GameParameter.wRevenueRate=m_GameDBAide.GetValue_WORD(TEXT("RevenueRate"));

			//版本信息
			GameParameter.dwClientVersion=m_GameDBAide.GetValue_DWORD(TEXT("ClientVersion"));
			GameParameter.dwServerVersion=m_GameDBAide.GetValue_DWORD(TEXT("ServerVersion"));
		
			//发送信息
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_PARAMETER,dwContextID,&GameParameter,sizeof(GameParameter));
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}

	return true;
}

//加载列表
bool CDataBaseEngineSink::OnRequestLoadGameColumn(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//变量定义
		DBO_GR_GameColumnInfo GameColumnInfo;
		ZeroMemory(&GameColumnInfo,sizeof(GameColumnInfo));

		//执行查询
		m_GameDBAide.ResetParameter();
		GameColumnInfo.lResultCode=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_GameColumnItem"),true);

		//读取信息
		for (WORD i=0;i<CountArray(GameColumnInfo.ColumnItemInfo);i++)
		{
			//结束判断
			if (m_GameDBModule->IsRecordsetEnd()==true) break;

			//溢出效验
			ASSERT(GameColumnInfo.cbColumnCount<CountArray(GameColumnInfo.ColumnItemInfo));
			if (GameColumnInfo.cbColumnCount>=CountArray(GameColumnInfo.ColumnItemInfo)) break;

			//读取数据
			GameColumnInfo.cbColumnCount++;
			GameColumnInfo.ColumnItemInfo[i].cbColumnWidth=m_GameDBAide.GetValue_BYTE(TEXT("ColumnWidth"));
			GameColumnInfo.ColumnItemInfo[i].cbDataDescribe=m_GameDBAide.GetValue_BYTE(TEXT("DataDescribe"));
			m_GameDBAide.GetValue_String(TEXT("ColumnName"),GameColumnInfo.ColumnItemInfo[i].szColumnName,CountArray(GameColumnInfo.ColumnItemInfo[i].szColumnName));

			//移动记录
			m_GameDBModule->MoveToNext();
		}

		//发送信息
		WORD wHeadSize=sizeof(GameColumnInfo)-sizeof(GameColumnInfo.ColumnItemInfo);
		WORD wPacketSize=wHeadSize+GameColumnInfo.cbColumnCount*sizeof(GameColumnInfo.ColumnItemInfo[0]);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_COLUMN_INFO,dwContextID,&GameColumnInfo,wPacketSize);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//变量定义
		DBO_GR_GameColumnInfo GameColumnInfo;
		ZeroMemory(&GameColumnInfo,sizeof(GameColumnInfo));

		//构造变量
		GameColumnInfo.cbColumnCount=0L;
		GameColumnInfo.lResultCode=pIException->GetExceptionResult();

		//发送信息
		WORD wPacketSize=sizeof(GameColumnInfo)-sizeof(GameColumnInfo.ColumnItemInfo);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_COLUMN_INFO,dwContextID,&GameColumnInfo,wPacketSize);

		return false;
	}

	return true;
}

//加载机器
bool CDataBaseEngineSink::OnRequestLoadAndroidParameter(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//变量定义
		DBO_GR_GameAndroidParameter GameAndroidParameter;
		ZeroMemory(&GameAndroidParameter, sizeof(GameAndroidParameter));

		//用户帐户
		m_TreasureDBAide.ResetParameter();
		m_TreasureDBAide.AddParameter(TEXT("@wKindID"), m_pGameServiceAttrib->wKindID);
		m_TreasureDBAide.AddParameter(TEXT("@wServerID"), m_pGameServiceOption->wServerID);

		//执行查询
		GameAndroidParameter.lResultCode = m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_LoadAndroidConfigure"), true);

		//读取信息
		for (WORD i = 0; i < CountArray(GameAndroidParameter.AndroidParameter); i++)
		{
			//结束判断
			if (m_TreasureDBModule->IsRecordsetEnd() == true) break;

			//溢出效验
			ASSERT(GameAndroidParameter.wParameterCount < CountArray(GameAndroidParameter.AndroidParameter));
			if (GameAndroidParameter.wParameterCount >= CountArray(GameAndroidParameter.AndroidParameter)) break;

			//读取数据
			GameAndroidParameter.wParameterCount++;
			GameAndroidParameter.AndroidParameter[i].dwBatchID = m_TreasureDBAide.GetValue_DWORD(TEXT("BatchID"));
			GameAndroidParameter.AndroidParameter[i].dwServiceMode = m_TreasureDBAide.GetValue_DWORD(TEXT("ServiceMode"));
			GameAndroidParameter.AndroidParameter[i].dwAndroidCount = m_TreasureDBAide.GetValue_DWORD(TEXT("AndroidCount"));
			GameAndroidParameter.AndroidParameter[i].dwEnterTime = m_TreasureDBAide.GetValue_DWORD(TEXT("EnterTime"));
			GameAndroidParameter.AndroidParameter[i].dwLeaveTime = m_TreasureDBAide.GetValue_DWORD(TEXT("LeaveTime"));
			GameAndroidParameter.AndroidParameter[i].lTakeMinScore = m_TreasureDBAide.GetValue_LONGLONG(TEXT("TakeMinScore"));
			GameAndroidParameter.AndroidParameter[i].lTakeMaxScore = m_TreasureDBAide.GetValue_LONGLONG(TEXT("TakeMaxScore"));
			GameAndroidParameter.AndroidParameter[i].dwEnterMinInterval = m_TreasureDBAide.GetValue_DWORD(TEXT("EnterMinInterval"));
			GameAndroidParameter.AndroidParameter[i].dwEnterMaxInterval = m_TreasureDBAide.GetValue_DWORD(TEXT("EnterMaxInterval"));
			GameAndroidParameter.AndroidParameter[i].dwLeaveMinInterval = m_TreasureDBAide.GetValue_DWORD(TEXT("LeaveMinInterval"));
			GameAndroidParameter.AndroidParameter[i].dwLeaveMaxInterval = m_TreasureDBAide.GetValue_DWORD(TEXT("LeaveMaxInterval"));
			GameAndroidParameter.AndroidParameter[i].dwSwitchMinInnings = m_TreasureDBAide.GetValue_DWORD(TEXT("SwitchMinInnings"));
			GameAndroidParameter.AndroidParameter[i].dwSwitchMaxInnings = m_TreasureDBAide.GetValue_DWORD(TEXT("SwitchMaxInnings"));

			//移动记录
			m_TreasureDBModule->MoveToNext();
		}

		//发送信息
		WORD wHeadSize = sizeof(GameAndroidParameter) - sizeof(GameAndroidParameter.AndroidParameter);
		WORD wDataSize = GameAndroidParameter.wParameterCount*sizeof(GameAndroidParameter.AndroidParameter[0]);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_ANDROID_PARAMETER, dwContextID, &GameAndroidParameter, wHeadSize + wDataSize);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		//变量定义
		DBO_GR_GameAndroidParameter GameAndroidParameter;
		ZeroMemory(&GameAndroidParameter, sizeof(GameAndroidParameter));

		//构造变量
		GameAndroidParameter.wParameterCount = 0L;
		GameAndroidParameter.lResultCode = DB_ERROR;

		//发送信息
		WORD wHeadSize = sizeof(GameAndroidParameter) - sizeof(GameAndroidParameter.AndroidParameter);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_ANDROID_PARAMETER, dwContextID, &GameAndroidParameter, wHeadSize);
	}

	return false;
}

//加载机器
bool CDataBaseEngineSink::OnRequestLoadAndroidUser(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//参数校验
	ASSERT(sizeof(DBR_GR_LoadAndroidUser) == wDataSize);
	if (sizeof(DBR_GR_LoadAndroidUser) != wDataSize) return false;

	try
	{
		//提取变量
		DBR_GR_LoadAndroidUser * pLoadAndroidUser = (DBR_GR_LoadAndroidUser *)pData;
		if (pLoadAndroidUser == NULL) return false;

		//变量定义
		DBO_GR_GameAndroidInfo GameAndroidInfo;
		ZeroMemory(&GameAndroidInfo, sizeof(GameAndroidInfo));

		//设置批次
		GameAndroidInfo.dwBatchID = pLoadAndroidUser->dwBatchID;

		//用户帐户
		m_TreasureDBAide.ResetParameter();
		m_TreasureDBAide.AddParameter(TEXT("@wServerID"), m_pGameServiceOption->wServerID);
		m_TreasureDBAide.AddParameter(TEXT("@dwBatchID"), pLoadAndroidUser->dwBatchID);
		m_TreasureDBAide.AddParameter(TEXT("@dwAndroidCount"), pLoadAndroidUser->dwAndroidCount);

		//执行查询
		GameAndroidInfo.lResultCode = m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_LoadAndroidUser"), true);

		//读取信息
		for (WORD i = 0; i < CountArray(GameAndroidInfo.AndroidAccountsInfo); i++)
		{
			//结束判断
			if (m_TreasureDBModule->IsRecordsetEnd() == true) break;

			//溢出效验
			ASSERT(GameAndroidInfo.wAndroidCount < CountArray(GameAndroidInfo.AndroidAccountsInfo));
			if (GameAndroidInfo.wAndroidCount >= CountArray(GameAndroidInfo.AndroidAccountsInfo)) break;

			//读取数据
			GameAndroidInfo.wAndroidCount++;
			GameAndroidInfo.AndroidAccountsInfo[i].dwUserID = m_TreasureDBAide.GetValue_DWORD(TEXT("UserID"));
			m_TreasureDBAide.GetValue_String(TEXT("LogonPass"), GameAndroidInfo.AndroidAccountsInfo[i].szPassword, CountArray(GameAndroidInfo.AndroidAccountsInfo[i].szPassword));

			//移动记录
			m_TreasureDBModule->MoveToNext();
		}

		//发送信息
		WORD wHeadSize = sizeof(GameAndroidInfo) - sizeof(GameAndroidInfo.AndroidAccountsInfo);
		WORD wDataSize = GameAndroidInfo.wAndroidCount*sizeof(GameAndroidInfo.AndroidAccountsInfo[0]);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_ANDROID_INFO, dwContextID, &GameAndroidInfo, wHeadSize + wDataSize);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		//变量定义
		DBO_GR_GameAndroidInfo GameAndroidInfo;
		ZeroMemory(&GameAndroidInfo, sizeof(GameAndroidInfo));

		//构造变量
		GameAndroidInfo.wAndroidCount = 0L;
		GameAndroidInfo.lResultCode = DB_ERROR;

		//发送信息
		WORD wHeadSize = sizeof(GameAndroidInfo) - sizeof(GameAndroidInfo.AndroidAccountsInfo);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_ANDROID_INFO, dwContextID, &GameAndroidInfo, wHeadSize);
	}

	return false;
}

//加载道具
bool CDataBaseEngineSink::OnRequestLoadGameProperty(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//变量定义
		DBO_GR_GamePropertyInfo GamePropertyInfo;
		ZeroMemory(&GamePropertyInfo,sizeof(GamePropertyInfo));

		//构造参数
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);

		//执行查询
		GamePropertyInfo.lResultCode=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_LoadGameProperty"),true);

		//读取信息
		for (WORD i=0;i<CountArray(GamePropertyInfo.PropertyInfo);i++)
		{
			//结束判断
			if (m_GameDBModule->IsRecordsetEnd()==true) break;

			//溢出效验
			ASSERT(GamePropertyInfo.cbPropertyCount<CountArray(GamePropertyInfo.PropertyInfo));
			if (GamePropertyInfo.cbPropertyCount>=CountArray(GamePropertyInfo.PropertyInfo)) break;

			//读取数据
			GamePropertyInfo.cbPropertyCount++;
			GamePropertyInfo.PropertyInfo[i].wIndex=m_GameDBAide.GetValue_WORD(TEXT("ID"));
			GamePropertyInfo.PropertyInfo[i].wDiscount=m_GameDBAide.GetValue_WORD(TEXT("Discount"));
			GamePropertyInfo.PropertyInfo[i].wIssueArea=m_GameDBAide.GetValue_WORD(TEXT("IssueArea"));
			GamePropertyInfo.PropertyInfo[i].dPropertyCash=m_GameDBAide.GetValue_DOUBLE(TEXT("Cash"));
			GamePropertyInfo.PropertyInfo[i].lPropertyGold=m_GameDBAide.GetValue_LONGLONG(TEXT("Gold"));
			GamePropertyInfo.PropertyInfo[i].lSendLoveLiness=m_GameDBAide.GetValue_LONGLONG(TEXT("SendLoveLiness"));
			GamePropertyInfo.PropertyInfo[i].lRecvLoveLiness=m_GameDBAide.GetValue_LONGLONG(TEXT("RecvLoveLiness"));

			//移动记录
			m_GameDBModule->MoveToNext();
		}

		//发送信息
		WORD wHeadSize=sizeof(GamePropertyInfo)-sizeof(GamePropertyInfo.PropertyInfo);
		WORD wDataSize=GamePropertyInfo.cbPropertyCount*sizeof(GamePropertyInfo.PropertyInfo[0]);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_PROPERTY_INFO,dwContextID,&GamePropertyInfo,wHeadSize+wDataSize);
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//变量定义
		DBO_GR_GamePropertyInfo GamePropertyInfo;
		ZeroMemory(&GamePropertyInfo,sizeof(GamePropertyInfo));

		//构造变量
		GamePropertyInfo.cbPropertyCount=0L;
		GamePropertyInfo.lResultCode=DB_ERROR;

		//发送信息
		WORD wHeadSize=sizeof(GamePropertyInfo)-sizeof(GamePropertyInfo.PropertyInfo);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_PROPERTY_INFO,dwContextID,&GamePropertyInfo,wHeadSize);

		return false;
	}

	return true;
}

//存入游戏币
bool CDataBaseEngineSink::OnRequestUserSaveScore(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_UserSaveScore));
	if (wDataSize!=sizeof(DBR_GR_UserSaveScore)) return false;

	//变量定义
	DBR_GR_UserSaveScore * pUserSaveScore=(DBR_GR_UserSaveScore *)pData;
	dwUserID=pUserSaveScore->dwUserID;

	//请求处理
	try
	{
		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pUserSaveScore->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_TreasureDBAide.ResetParameter();
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID"),pUserSaveScore->dwUserID);
		m_TreasureDBAide.AddParameter(TEXT("@lSaveScore"),pUserSaveScore->lSaveScore);
		m_TreasureDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_TreasureDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);
		m_TreasureDBAide.AddParameter(TEXT("@strClientIP"),szClientAddr);
		m_TreasureDBAide.AddParameter(TEXT("@strMachineID"),pUserSaveScore->szMachineID);

		//输出参数
		TCHAR szDescribeString[128]=TEXT("");
		m_TreasureDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),szDescribeString,sizeof(szDescribeString),adParamOutput);

		//执行查询
		LONG lResultCode=m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_UserSaveScore"),true);

		//结果处理
		CDBVarValue DBVarValue;
		m_TreasureDBModule->GetParameter(TEXT("@strErrorDescribe"),DBVarValue);
		OnInsureDisposeResult(dwContextID,lResultCode,pUserSaveScore->lSaveScore,CW2CT(DBVarValue.bstrVal),false,pUserSaveScore->cbActivityGame);
	
		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//错误处理
		OnInsureDisposeResult(dwContextID,DB_ERROR,pUserSaveScore->lSaveScore,TEXT("由于数据库操作异常，请您稍后重试！"),false,pUserSaveScore->cbActivityGame);

		return false;
	}

	return true;
}

//提取游戏币
bool CDataBaseEngineSink::OnRequestUserTakeScore(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_UserTakeScore));
	if (wDataSize!=sizeof(DBR_GR_UserTakeScore)) return false;

	//变量定义
	DBR_GR_UserTakeScore * pUserTakeScore=(DBR_GR_UserTakeScore *)pData;
	dwUserID=pUserTakeScore->dwUserID;

	//请求处理
	try
	{
		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pUserTakeScore->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_TreasureDBAide.ResetParameter();
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID"),pUserTakeScore->dwUserID);
		m_TreasureDBAide.AddParameter(TEXT("@lTakeScore"),pUserTakeScore->lTakeScore);
		m_TreasureDBAide.AddParameter(TEXT("@strPassword"),pUserTakeScore->szPassword);
		m_TreasureDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_TreasureDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);
		m_TreasureDBAide.AddParameter(TEXT("@strClientIP"),szClientAddr);
		m_TreasureDBAide.AddParameter(TEXT("@strMachineID"),pUserTakeScore->szMachineID);

		//输出参数
		TCHAR szDescribeString[128]=TEXT("");
		m_TreasureDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),szDescribeString,sizeof(szDescribeString),adParamOutput);

		//执行查询
		LONG lResultCode=m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_UserTakeScore"),true);

		//结果处理
		CDBVarValue DBVarValue;
		m_TreasureDBModule->GetParameter(TEXT("@strErrorDescribe"),DBVarValue);
		OnInsureDisposeResult(dwContextID,lResultCode,0L,CW2CT(DBVarValue.bstrVal),false,pUserTakeScore->cbActivityGame);
	
		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//错误处理
		OnInsureDisposeResult(dwContextID,DB_ERROR,0L,TEXT("由于数据库操作异常，请您稍后重试！"),false,pUserTakeScore->cbActivityGame);

		return false;
	}

	return true;
}

//转账游戏币
bool CDataBaseEngineSink::OnRequestUserTransferScore(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_UserTransferScore));
	if (wDataSize!=sizeof(DBR_GR_UserTransferScore)) return false;

	//变量定义
	DBR_GR_UserTransferScore * pUserTransferScore=(DBR_GR_UserTransferScore *)pData;
	dwUserID=pUserTransferScore->dwUserID;

	//请求处理
	try
	{
		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pUserTransferScore->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_TreasureDBAide.ResetParameter();
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID"),pUserTransferScore->dwUserID);
		m_TreasureDBAide.AddParameter(TEXT("@cbByNickName"),pUserTransferScore->cbByNickName);
		m_TreasureDBAide.AddParameter(TEXT("@lTransferScore"),pUserTransferScore->lTransferScore);
		m_TreasureDBAide.AddParameter(TEXT("@strPassword"),pUserTransferScore->szPassword);
		m_TreasureDBAide.AddParameter(TEXT("@strNickName"),pUserTransferScore->szNickName);
		m_TreasureDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_TreasureDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);
		m_TreasureDBAide.AddParameter(TEXT("@strClientIP"),szClientAddr);
		m_TreasureDBAide.AddParameter(TEXT("@strMachineID"),pUserTransferScore->szMachineID);

		//输出参数
		TCHAR szDescribeString[128]=TEXT("");
		m_TreasureDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),szDescribeString,sizeof(szDescribeString),adParamOutput);

		//执行查询
		LONG lResultCode=m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_UserTransferScore"),true);

		//结果处理
		CDBVarValue DBVarValue;
		m_TreasureDBModule->GetParameter(TEXT("@strErrorDescribe"),DBVarValue);
		OnInsureDisposeResult(dwContextID,lResultCode,0L,CW2CT(DBVarValue.bstrVal),false,pUserTransferScore->cbActivityGame);
	
		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//错误处理
		OnInsureDisposeResult(dwContextID,DB_ERROR,0L,TEXT("由于数据库操作异常，请您稍后重试！"),false,pUserTransferScore->cbActivityGame);

		return false;
	}

	return true;
}

//查询银行
bool CDataBaseEngineSink::OnRequestQueryInsureInfo(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_QueryInsureInfo));
	if (wDataSize!=sizeof(DBR_GR_QueryInsureInfo)) return false;

	//请求处理
	DBR_GR_QueryInsureInfo * pQueryInsureInfo=(DBR_GR_QueryInsureInfo *)pData;
	dwUserID=pQueryInsureInfo->dwUserID;

	try
	{
		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pQueryInsureInfo->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_TreasureDBAide.ResetParameter();
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID"),pQueryInsureInfo->dwUserID);
		m_TreasureDBAide.AddParameter(TEXT("@strClientIP"),szClientAddr);

		//输出参数
		TCHAR szDescribeString[128]=TEXT("");
		m_TreasureDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),szDescribeString,sizeof(szDescribeString),adParamOutput);

		//结果处理
		if (m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_QueryUserInsureInfo"),true)==DB_SUCCESS)
		{
			//变量定义
			DBO_GR_UserInsureInfo UserInsureInfo;
			ZeroMemory(&UserInsureInfo,sizeof(UserInsureInfo));

			//银行信息
			UserInsureInfo.cbActivityGame=pQueryInsureInfo->cbActivityGame;
			UserInsureInfo.wRevenueTake=m_TreasureDBAide.GetValue_WORD(TEXT("RevenueTake"));
			UserInsureInfo.wRevenueTransfer=m_TreasureDBAide.GetValue_WORD(TEXT("RevenueTransfer"));
			UserInsureInfo.wServerID=m_TreasureDBAide.GetValue_WORD(TEXT("ServerID"));
			UserInsureInfo.lUserScore = (LONG)m_TreasureDBAide.GetValue_DOUBLE(TEXT("Score"));
			UserInsureInfo.lUserInsure = (LONG)m_TreasureDBAide.GetValue_DOUBLE(TEXT("Insure"));
			UserInsureInfo.lTransferPrerequisite=m_TreasureDBAide.GetValue_LONGLONG(TEXT("TransferPrerequisite"));

			//发送结果
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_USER_INSURE_INFO,dwContextID,&UserInsureInfo,sizeof(UserInsureInfo));
		}
		else
		{
			//获取参数
			CDBVarValue DBVarValue;
			m_TreasureDBModule->GetParameter(TEXT("@strErrorDescribe"),DBVarValue);

			//错误处理
			OnInsureDisposeResult(dwContextID,m_TreasureDBAide.GetReturnValue(),0L,CW2CT(DBVarValue.bstrVal),false,pQueryInsureInfo->cbActivityGame);
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//结果处理
		OnInsureDisposeResult(dwContextID,DB_ERROR,0L,TEXT("由于数据库操作异常，请您稍后重试！"),false,pQueryInsureInfo->cbActivityGame);

		return false;
	}

	return true;
}

//查询用户
bool CDataBaseEngineSink::OnRequestQueryTransferUserInfo(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_QueryTransferUserInfo));
	if (wDataSize!=sizeof(DBR_GR_QueryTransferUserInfo)) return false;

	//请求处理
	DBR_GR_QueryTransferUserInfo * pQueryTransferUserInfo=(DBR_GR_QueryTransferUserInfo *)pData;
	dwUserID=pQueryTransferUserInfo->dwUserID;

	try
	{
		//构造参数
		m_TreasureDBAide.ResetParameter();
		m_TreasureDBAide.AddParameter(TEXT("@cbByNickName"),pQueryTransferUserInfo->cbByNickName);
		m_TreasureDBAide.AddParameter(TEXT("@strNickName"),pQueryTransferUserInfo->szNickName);

		//输出参数
		TCHAR szDescribeString[128]=TEXT("");
		m_TreasureDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),szDescribeString,sizeof(szDescribeString),adParamOutput);

		//结果处理
		if (m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_QueryTransferUserInfo"),true)==DB_SUCCESS)
		{
			//变量定义
			DBO_GR_UserTransferUserInfo TransferUserInfo;
			ZeroMemory(&TransferUserInfo,sizeof(TransferUserInfo));

			//银行信息
			TransferUserInfo.cbActivityGame=pQueryTransferUserInfo->cbActivityGame;
			TransferUserInfo.dwGameID=m_TreasureDBAide.GetValue_DWORD(TEXT("GameID"));
			m_TreasureDBAide.GetValue_String(TEXT("NickName"), TransferUserInfo.szNickName, CountArray(TransferUserInfo.szNickName));

			//发送结果
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_USER_INSURE_USER_INFO,dwContextID,&TransferUserInfo,sizeof(TransferUserInfo));
		}
		else
		{
			//获取参数
			CDBVarValue DBVarValue;
			m_TreasureDBModule->GetParameter(TEXT("@strErrorDescribe"),DBVarValue);

			//错误处理
			OnInsureDisposeResult(dwContextID,m_TreasureDBAide.GetReturnValue(),0L,CW2CT(DBVarValue.bstrVal),false,pQueryTransferUserInfo->cbActivityGame);
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//结果处理
		OnInsureDisposeResult(dwContextID,DB_ERROR,0L,TEXT("由于数据库操作异常，请您稍后重试！"),false,pQueryTransferUserInfo->cbActivityGame);

		return false;
	}

	return true;
}

//道具请求
bool CDataBaseEngineSink::OnRequestPropertyRequest(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//效验参数
		ASSERT(wDataSize==sizeof(DBR_GR_PropertyRequest));
		if (wDataSize!=sizeof(DBR_GR_PropertyRequest)) return false;

		//请求处理
		DBR_GR_PropertyRequest * pPropertyRequest=(DBR_GR_PropertyRequest *)pData;
		dwUserID=pPropertyRequest->dwSourceUserID;

		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pPropertyRequest->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_GameDBAide.ResetParameter();

		//消费信息
		m_GameDBAide.AddParameter(TEXT("@dwSourceUserID"),pPropertyRequest->dwSourceUserID);
		m_GameDBAide.AddParameter(TEXT("@dwTargetUserID"),pPropertyRequest->dwTargetUserID);
		m_GameDBAide.AddParameter(TEXT("@wPropertyID"),pPropertyRequest->wPropertyIndex);
		m_GameDBAide.AddParameter(TEXT("@wPropertyCount"),pPropertyRequest->wItemCount);

		//消费区域
		m_GameDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);
		m_GameDBAide.AddParameter(TEXT("@wTableID"),pPropertyRequest->wTableID);

		//购买方式
		m_GameDBAide.AddParameter(TEXT("@cbConsumeScore"),pPropertyRequest->cbConsumeScore);
		m_GameDBAide.AddParameter(TEXT("@lFrozenedScore"),pPropertyRequest->lFrozenedScore);

		//系统信息
		m_GameDBAide.AddParameter(TEXT("@dwEnterID"),pPropertyRequest->dwInoutIndex);
		m_GameDBAide.AddParameter(TEXT("@strClientIP"),szClientAddr);
		m_GameDBAide.AddParameter(TEXT("@strMachineID"),pPropertyRequest->szMachineID);

		//输出参数
		TCHAR szDescribeString[128]=TEXT("");
		m_GameDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),szDescribeString,sizeof(szDescribeString),adParamOutput);

		//结果处理
		if (m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_ConsumeProperty"),true)==DB_SUCCESS)
		{
			//变量定义
			DBO_GR_S_PropertySuccess PresentSuccess;
			ZeroMemory(&PresentSuccess,sizeof(PresentSuccess));

			//道具信息
			PresentSuccess.cbRequestArea=pPropertyRequest->cbRequestArea;
			PresentSuccess.wItemCount=pPropertyRequest->wItemCount;
			PresentSuccess.wPropertyIndex=pPropertyRequest->wPropertyIndex;
			PresentSuccess.dwSourceUserID=pPropertyRequest->dwSourceUserID;
			PresentSuccess.dwTargetUserID=pPropertyRequest->dwTargetUserID;

			//消费模式
			PresentSuccess.cbConsumeScore=pPropertyRequest->cbConsumeScore;
			PresentSuccess.lFrozenedScore=pPropertyRequest->lFrozenedScore;

			//用户权限
			PresentSuccess.dwUserRight=pPropertyRequest->dwUserRight;

			//结果信息
			PresentSuccess.lConsumeGold=m_GameDBAide.GetValue_LONGLONG(TEXT("ConsumeGold"));
			PresentSuccess.lSendLoveLiness=m_GameDBAide.GetValue_LONG(TEXT("SendLoveLiness"));
			PresentSuccess.lRecvLoveLiness=m_GameDBAide.GetValue_LONG(TEXT("RecvLoveLiness"));
			PresentSuccess.cbMemberOrder=m_GameDBAide.GetValue_BYTE(TEXT("MemberOrder"));

			//发送结果
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_PROPERTY_SUCCESS,dwContextID,&PresentSuccess,sizeof(PresentSuccess));
		}
		else
		{
			//获取参数
			CDBVarValue DBVarValue;
			m_GameDBAide.GetParameter(TEXT("@strErrorDescribe"),DBVarValue);

			//变量定义
			DBO_GR_PropertyFailure PropertyFailure;
			ZeroMemory(&PropertyFailure,sizeof(PropertyFailure));

			//设置变量
			PropertyFailure.lResultCode=m_GameDBAide.GetReturnValue();
			PropertyFailure.lFrozenedScore=pPropertyRequest->lFrozenedScore;
			PropertyFailure.cbRequestArea=pPropertyRequest->cbRequestArea;
			lstrcpyn(PropertyFailure.szDescribeString,CW2CT(DBVarValue.bstrVal),CountArray(PropertyFailure.szDescribeString));

			//发送结果
			WORD wDataSize=CountStringBuffer(PropertyFailure.szDescribeString);
			WORD wHeadSize=sizeof(PropertyFailure)-sizeof(PropertyFailure.szDescribeString);
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_PROPERTY_FAILURE,dwContextID,&PropertyFailure,wHeadSize+wDataSize);
		}
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//变量定义
		DBO_GR_PropertyFailure PropertyFailure;
		ZeroMemory(&PropertyFailure,sizeof(PropertyFailure));

		//变量定义
		DBR_GR_PropertyRequest * pPropertyRequest=(DBR_GR_PropertyRequest *)pData;

		//设置变量
		PropertyFailure.lResultCode=DB_ERROR;
		PropertyFailure.lFrozenedScore=pPropertyRequest->lFrozenedScore;
		PropertyFailure.cbRequestArea=pPropertyRequest->cbRequestArea;
		lstrcpyn(PropertyFailure.szDescribeString,TEXT("由于数据库操作异常，请您稍后重试！"),CountArray(PropertyFailure.szDescribeString));

		//发送结果
		WORD wDataSize=CountStringBuffer(PropertyFailure.szDescribeString);
		WORD wHeadSize=sizeof(PropertyFailure)-sizeof(PropertyFailure.szDescribeString);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_PROPERTY_FAILURE,dwContextID,&PropertyFailure,wHeadSize+wDataSize);

		return false;
	}

	return true;
}

//用户权限;
bool CDataBaseEngineSink::OnRequestManageUserRight(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//效验参数
		ASSERT(wDataSize==sizeof(DBR_GR_ManageUserRight));
		if (wDataSize!=sizeof(DBR_GR_ManageUserRight)) return false;

		//请求处理
		DBR_GR_ManageUserRight * pManageUserRight=(DBR_GR_ManageUserRight *)pData;
		dwUserID=pManageUserRight->dwUserID;

		//构造参数
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@dwUserID"),pManageUserRight->dwUserID);
		m_GameDBAide.AddParameter(TEXT("@dwAddRight"),pManageUserRight->dwAddRight);
		m_GameDBAide.AddParameter(TEXT("@dwRemoveRight"),pManageUserRight->dwRemoveRight);

		//执行查询
		LONG lReturnValue=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_ManageUserRight"),false);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//错误处理
		OnInsureDisposeResult(dwContextID,DB_ERROR,0L,TEXT("由于数据库操作异常，请您稍后重试！"),false);

		return false;
	}

	return true;
}

//系统消息;
bool CDataBaseEngineSink::OnRequestLoadSystemMessage(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//构造参数
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);

		//执行查询
		LONG lReturnValue=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_LoadSystemMessage"),true);

		//结果处理
		if(lReturnValue==0)
		{
			TCHAR szServerID[32]={0};
			_sntprintf_s(szServerID, CountArray(szServerID), TEXT("%d"), m_pGameServiceOption->wServerID);

			while(true)
			{
				//结束判断
				if (m_GameDBModule->IsRecordsetEnd()==true) break;

				//定义变量
				TCHAR szServerRange[1024]={0};
				CString strServerRange;
				bool bSendMessage=false;
				bool bAllRoom=false;

				//读取范围
				m_GameDBAide.GetValue_String(TEXT("ServerRange"), szServerRange, CountArray(szServerRange));
				szServerRange[1023]=0;
				strServerRange.Format(TEXT("%s"), szServerRange);

				//范围判断
				while(true)
				{
					int nfind=strServerRange.Find(TEXT(','));
					if(nfind!=-1 && nfind>0)
					{
						CString strID=strServerRange.Left(nfind);
						WORD wServerID=StrToInt(strID);
						bSendMessage=(wServerID==0 || wServerID==m_pGameServiceOption->wServerID);
						if(wServerID==0)bAllRoom=true;

						if(bSendMessage) break;

						strServerRange=strServerRange.Right(strServerRange.GetLength()-nfind-1);
					}
					else
					{
						WORD wServerID=StrToInt(szServerRange);
						bSendMessage=(wServerID==0 || wServerID==m_pGameServiceOption->wServerID);
						if(wServerID==0)bAllRoom=true;

						break;
					}
				}

				//发送消息
				if(bSendMessage)
				{
					//定义变量
					DBR_GR_SystemMessage SystemMessage;
					ZeroMemory(&SystemMessage, sizeof(SystemMessage));

					//读取消息
					SystemMessage.cbMessageID=m_GameDBAide.GetValue_BYTE(TEXT("ID"));
					SystemMessage.cbMessageType=m_GameDBAide.GetValue_BYTE(TEXT("MessageType"));
					SystemMessage.dwTimeRate=m_GameDBAide.GetValue_DWORD(TEXT("TimeRate"));
					SystemMessage.cbAllRoom=bAllRoom?TRUE:FALSE;
					m_GameDBAide.GetValue_String(TEXT("MessageString"),SystemMessage.szSystemMessage,CountArray(SystemMessage.szSystemMessage));

					//发送结果
					m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_SYSTEM_MESSAGE_RESULT,dwContextID,&SystemMessage,sizeof(SystemMessage));
				}

				//下一条
				m_GameDBModule->MoveToNext();
			}
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//错误处理
		OnInsureDisposeResult(dwContextID,DB_ERROR,0L,TEXT("由于数据库操作异常，请您稍后重试！"),false);

		return false;
	}

	return true;
}

//加载敏感词;
bool CDataBaseEngineSink::OnRequestLoadSensitiveWords(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//构造参数
		m_PlatformDBAide.ResetParameter();

		//执行查询
		LONG lReturnValue=m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_LoadSensitiveWords"),true);

		//读取信息
		if (lReturnValue==DB_SUCCESS)
		{
			//起始消息
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_SENSITIVE_WORDS,0xfffe,NULL,0);

			//读取消息
			while (m_PlatformDBModule->IsRecordsetEnd()==false)
			{
				//变量定义
				TCHAR szSensitiveWords[32]=TEXT("");

				//读取消息
				m_PlatformDBAide.GetValue_String(TEXT("SensitiveWords"),szSensitiveWords,CountArray(szSensitiveWords));				

				//发送消息
				m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_SENSITIVE_WORDS,0,szSensitiveWords,sizeof(szSensitiveWords));

				//移动记录
				m_PlatformDBModule->MoveToNext();
			};

			//结束消息
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_SENSITIVE_WORDS,0xffff,NULL,0);
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}

	return true;
}

//解锁机器人;
bool CDataBaseEngineSink::OnRequestUnlockAndroidUser(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//效验参数
		ASSERT(wDataSize == sizeof(DBR_GR_UnlockAndroidUser));
		if (wDataSize != sizeof(DBR_GR_UnlockAndroidUser)) return false;

		//请求处理
		DBR_GR_UnlockAndroidUser * pUnlockAndroidUser = (DBR_GR_UnlockAndroidUser *)pData;

		//构造参数
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@wServerID"), pUnlockAndroidUser->wServerID);
		m_GameDBAide.AddParameter(TEXT("@wBatchID"), pUnlockAndroidUser->wBatchID);

		//执行查询
		LONG lResultCode = m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_UnlockAndroidUser"), false);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
		return false;
	}

	return true;
}

//加载牌库;
bool CDataBaseEngineSink::OnRequestLoadCardLibrary(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@wKindID"), m_pGameServiceOption->wKindID);
		m_PlatformDBAide.AddParameter(TEXT("@wServerID"), m_pGameServiceOption->wServerID);

		//执行查询
		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GP_LoadCardLibrary"), true);

		//读取信息
		if (lReturnValue == DB_SUCCESS)
		{
			//起始消息
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_CARD_LIBRARY, 0xfffe, NULL, 0);

			//读取消息
			while (m_PlatformDBModule->IsRecordsetEnd() == false)
			{
				//变量定义
				DBO_GR_GameCardLibrary mCard;
				ZeroMemory(&mCard, sizeof(DBO_GR_GameCardLibrary));

				//读取消息
				mCard.dwLibID = m_PlatformDBAide.GetValue_DWORD(TEXT("ID"));
				mCard.dwCustomID = m_PlatformDBAide.GetValue_DWORD(TEXT("CustomID"));
				m_PlatformDBAide.GetValue_String(TEXT("Data"), mCard.szCardData, CountArray(mCard.szCardData));
				mCard.cbCardCount = (BYTE)m_PlatformDBAide.GetValue_WORD(TEXT("CardCount"));

				//发送消息
				m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_CARD_LIBRARY, 0, &mCard, sizeof(DBO_GR_GameCardLibrary));

				//移动记录
				m_PlatformDBModule->MoveToNext();
			};

			//结束消息
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_CARD_LIBRARY, 0xffff, NULL, 0);
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
		return false;
	}
	return true;
}

//比赛报名;
bool CDataBaseEngineSink::OnRequestMatchSignup(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_MatchSignup));
	if (wDataSize!=sizeof(DBR_GR_MatchSignup)) return false;

	//变量定义
	DBR_GR_MatchSignup * pMatchSignup=(DBR_GR_MatchSignup *)pData;
	dwUserID=pMatchSignup->dwUserID;

	//请求处理
	try
	{
		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pMatchSignup->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@dwUserID"), pMatchSignup->dwUserID);
		m_PlatformDBAide.AddParameter(TEXT("@lMatchFee"), pMatchSignup->lMatchFee);
		m_PlatformDBAide.AddParameter(TEXT("@wKindID"), m_pGameServiceOption->wKindID);
		m_PlatformDBAide.AddParameter(TEXT("@wServerID"), m_pGameServiceOption->wServerID);
		m_PlatformDBAide.AddParameter(TEXT("@dwMatchID"), pMatchSignup->dwMatchID);
		m_PlatformDBAide.AddParameter(TEXT("@dwMatchNo"), pMatchSignup->dwMatchNO);
		m_PlatformDBAide.AddParameter(TEXT("@cbMatchType"), pMatchSignup->cbMatchType);
		m_PlatformDBAide.AddParameter(TEXT("@strClientIP"), szClientAddr);
		m_PlatformDBAide.AddParameter(TEXT("@strMachineID"), pMatchSignup->szMachineID);

		//输出参数
		TCHAR szDescribeString[128]=TEXT("");
		m_PlatformDBAide.AddParameterOutput(TEXT("@strErrorDescribe"), szDescribeString, sizeof(szDescribeString), adParamOutput);

		//结果处理
		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_UserMatchFee"), true);

		//构造结构
		DBO_GR_MatchSingupResult MatchSignupResult;
		ZeroMemory(&MatchSignupResult,sizeof(MatchSignupResult));

		//设置变量
		MatchSignupResult.bResultCode=lReturnValue==DB_SUCCESS;

		//读取财富
		if(MatchSignupResult.bResultCode==true)
		{
			MatchSignupResult.lCurrGold = m_PlatformDBAide.GetValue_LONGLONG(TEXT("Score"));
			MatchSignupResult.lCurrIngot = m_PlatformDBAide.GetValue_LONGLONG(TEXT("Ingot"));
		}
		else
		{
			//错误描述
			CDBVarValue DBVarValue;
			m_PlatformDBModule->GetParameter(TEXT("@strErrorDescribe"), DBVarValue);
			lstrcpyn(MatchSignupResult.szDescribeString,CW2CT(DBVarValue.bstrVal),CountArray(MatchSignupResult.szDescribeString));
		}

		//发送结果
		WORD wSendDataSize=sizeof(MatchSignupResult)-sizeof(MatchSignupResult.szDescribeString);
		wSendDataSize+=CountStringBuffer(MatchSignupResult.szDescribeString);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_MATCH_SIGNUP_RESULT,dwContextID,&MatchSignupResult,wSendDataSize);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//构造结构
		DBO_GR_MatchSingupResult MatchSignupResult;
		ZeroMemory(&MatchSignupResult,sizeof(MatchSignupResult));

		//设置变量		
		MatchSignupResult.bResultCode=false;
		lstrcpyn(MatchSignupResult.szDescribeString,TEXT("由于数据库操作异常，请您稍后重试！"),CountArray(MatchSignupResult.szDescribeString));

		//发送结果
		WORD wSendDataSize=sizeof(MatchSignupResult)-sizeof(MatchSignupResult.szDescribeString);
		wSendDataSize+=CountStringBuffer(MatchSignupResult.szDescribeString);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_MATCH_SIGNUP_RESULT,dwContextID,&MatchSignupResult,wSendDataSize);

		return false;
	}

	return true;
}

//退出比赛;
bool CDataBaseEngineSink::OnRequestMatchUnSignup(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_MatchSignup));
	if (wDataSize!=sizeof(DBR_GR_MatchSignup)) return false;

	//变量定义
	DBR_GR_MatchSignup * pMatchSignup=(DBR_GR_MatchSignup *)pData;
	dwUserID=pMatchSignup->dwUserID;

	//请求处理
	try
	{
		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pMatchSignup->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@dwUserID"),pMatchSignup->dwUserID);
		m_GameDBAide.AddParameter(TEXT("@lMatchFee"),pMatchSignup->lMatchFee);
		m_GameDBAide.AddParameter(TEXT("@wKindID"),m_pGameServiceOption->wKindID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"),m_pGameServiceOption->wServerID);
		m_GameDBAide.AddParameter(TEXT("@strClientIP"),szClientAddr);
		m_GameDBAide.AddParameter(TEXT("@dwMatchID"),pMatchSignup->dwMatchID);
		m_GameDBAide.AddParameter(TEXT("@dwMatchNo"),pMatchSignup->dwMatchNO);
		m_GameDBAide.AddParameter(TEXT("@strMachineID"),pMatchSignup->szMachineID);

		//输出参数
		TCHAR szDescribeString[128]=TEXT("");
		m_GameDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),szDescribeString,sizeof(szDescribeString),adParamOutput);

		//结果处理
		LONG lReturnValue=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_UserMatchQuit"),true);

		//构造结构
		DBO_GR_MatchSingupResult MatchSignupResult;
		ZeroMemory(&MatchSignupResult,sizeof(MatchSignupResult));

		//设置变量
		MatchSignupResult.bResultCode=lReturnValue==DB_SUCCESS;

		//读取财富
		if(MatchSignupResult.bResultCode==true)
		{
			MatchSignupResult.lCurrGold=m_GameDBAide.GetValue_LONGLONG(TEXT("Score"));
			MatchSignupResult.lCurrIngot=m_GameDBAide.GetValue_LONGLONG(TEXT("Ingot"));
		}
		else
		{
			//错误描述
			CDBVarValue DBVarValue;
			m_GameDBModule->GetParameter(TEXT("@strErrorDescribe"),DBVarValue);
			lstrcpyn(MatchSignupResult.szDescribeString,CW2CT(DBVarValue.bstrVal),CountArray(MatchSignupResult.szDescribeString));
		}

		//发送结果
		WORD wSendDataSize=sizeof(MatchSignupResult)-sizeof(MatchSignupResult.szDescribeString);
		wSendDataSize+=CountStringBuffer(MatchSignupResult.szDescribeString);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_MATCH_UNSIGNUP_RESULT,dwContextID,&MatchSignupResult,wSendDataSize);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//构造结构
		DBO_GR_MatchSingupResult MatchSignupResult;
		ZeroMemory(&MatchSignupResult,sizeof(MatchSignupResult));

		//设置变量
		MatchSignupResult.bResultCode=false;
		lstrcpyn(MatchSignupResult.szDescribeString,TEXT("由于数据库操作异常，请您稍后重试！"),CountArray(MatchSignupResult.szDescribeString));

		//发送结果
		WORD wSendDataSize=sizeof(MatchSignupResult)-sizeof(MatchSignupResult.szDescribeString);
		wSendDataSize+=CountStringBuffer(MatchSignupResult.szDescribeString);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_MATCH_SIGNUP_RESULT,dwContextID,&MatchSignupResult,wSendDataSize);

		return false;
	}
}

//比赛开始;
bool CDataBaseEngineSink::OnRequestMatchStart(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_MatchStart));
	if (wDataSize!=sizeof(DBR_GR_MatchStart)) return false;

	//变量定义
	DBR_GR_MatchStart * pMatchStart=(DBR_GR_MatchStart *)pData;

	//请求处理
	try
	{
		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@wServerID"), pMatchStart->dwMatchID);
		m_PlatformDBAide.AddParameter(TEXT("@wMatchID"), pMatchStart->dwMatchID);
		m_PlatformDBAide.AddParameter(TEXT("@wMatchNo"), pMatchStart->dwMatchNO);
		m_PlatformDBAide.AddParameter(TEXT("@cbMatchType"), pMatchStart->cbMatchType);

		//结果处理
		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_MatchStart"), true);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//错误处理
		OnInsureDisposeResult(dwContextID,DB_ERROR,0L,TEXT("由于数据库操作异常，请您稍后重试！"),false);

		return false;
	}

	return true;
}

//比赛结束;
bool CDataBaseEngineSink::OnRequestMatchOver(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_MatchOver));
	if (wDataSize!=sizeof(DBR_GR_MatchOver)) return false;

	//变量定义
	DBR_GR_MatchOver * pMatchOver=(DBR_GR_MatchOver *)pData;

	//请求处理
	try
	{
		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@wServerID"), pMatchOver->wServerID);
		m_PlatformDBAide.AddParameter(TEXT("@dwMatchID"), pMatchOver->dwMatchID);
		m_PlatformDBAide.AddParameter(TEXT("@dwMatchNo"), pMatchOver->dwMatchNO);
		m_PlatformDBAide.AddParameter(TEXT("@cbMatchType"), pMatchOver->cbMatchType);
		m_PlatformDBAide.AddParameter(TEXT("@cbPlayCount"), pMatchOver->wPlayCount);
		m_PlatformDBAide.AddParameter(TEXT("@bMatchFinish"), pMatchOver->bMatchFinish);
		m_PlatformDBAide.AddParameter(TEXT("@MatchStartTime"), pMatchOver->MatchStartTime);
		m_PlatformDBAide.AddParameter(TEXT("@MatchEndTime"), pMatchOver->MatchEndTime);

		//结果处理
		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_MatchOver"), true);

		//执行成功
		if(lReturnValue==DB_SUCCESS)
		{
			//构造结构
			DBO_GR_MatchRankList MatchRankList;
			ZeroMemory(&MatchRankList,sizeof(MatchRankList));

			//变量定义
			tagMatchRankInfo * pMatchRankInfo=NULL;

			//设置变量
			MatchRankList.dwMatchID=pMatchOver->dwMatchID;
			MatchRankList.dwMatchNO=pMatchOver->dwMatchNO;

			//读取记录
			while (m_PlatformDBModule->IsRecordsetEnd() == false)
			{
				pMatchRankInfo = &MatchRankList.MatchRankInfo[MatchRankList.wUserCount++];
				pMatchRankInfo->wRankID = m_PlatformDBAide.GetValue_WORD(TEXT("RankID"));
				pMatchRankInfo->dwUserID = m_PlatformDBAide.GetValue_DWORD(TEXT("UserID"));
				pMatchRankInfo->lMatchScore = m_PlatformDBAide.GetValue_LONGLONG(TEXT("Score"));
				pMatchRankInfo->lRewardGold = m_PlatformDBAide.GetValue_LONGLONG(TEXT("RewardGold"));
				pMatchRankInfo->dwRewardIngot = m_PlatformDBAide.GetValue_DWORD(TEXT("RewardMedal"));
				pMatchRankInfo->dwRewardExperience = m_PlatformDBAide.GetValue_DWORD(TEXT("RewardExperience"));
				pMatchRankInfo->lInsureSocre = m_PlatformDBAide.GetValue_DWORD(TEXT("RewardInsureScore"));
				pMatchRankInfo->dwGoodsID	= m_PlatformDBAide.GetValue_DWORD(TEXT("GoodsID"));
				pMatchRankInfo->dwGoodsNum	= m_PlatformDBAide.GetValue_DWORD(TEXT("GoodsNum"));

				//移动游标 
				m_PlatformDBModule->MoveToNext();
			}

			//发送数据
			WORD wSendDataSize = sizeof(MatchRankList)-sizeof(MatchRankList.MatchRankInfo);
			wSendDataSize += MatchRankList.wUserCount*sizeof(MatchRankList.MatchRankInfo[0]);
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_MATCH_RANK_LIST,dwContextID,&MatchRankList,wSendDataSize);
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}

	return true;
}

//比赛奖励;
bool CDataBaseEngineSink::OnRequestMatchReward(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_MatchReward));
	if (wDataSize!=sizeof(DBR_GR_MatchReward)) return false;

	//变量定义
	DBR_GR_MatchReward * pMatchReward=(DBR_GR_MatchReward *)pData;
	dwUserID=pMatchReward->dwUserID;

	//请求处理
	try
	{
		//转化地址
		TCHAR szClientAddr[16]=TEXT("");
		BYTE * pClientAddr=(BYTE *)&pMatchReward->dwClientAddr;
		_sntprintf_s(szClientAddr,CountArray(szClientAddr),TEXT("%d.%d.%d.%d"),pClientAddr[0],pClientAddr[1],pClientAddr[2],pClientAddr[3]);

		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@dwUserID"), pMatchReward->dwUserID);
		m_PlatformDBAide.AddParameter(TEXT("@dwRewardGold"), pMatchReward->lRewardGold);
		m_PlatformDBAide.AddParameter(TEXT("@dwRewardIngot"), pMatchReward->dwRewardIngot);
		m_PlatformDBAide.AddParameter(TEXT("@dwRewardExperience"), pMatchReward->dwRewardExperience);
		m_PlatformDBAide.AddParameter(TEXT("@dwInsureSocre"), pMatchReward->lInsureSocre);
		m_PlatformDBAide.AddParameter(TEXT("@dwGoodsID"), pMatchReward->dwGoodsID);
		m_PlatformDBAide.AddParameter(TEXT("@dwGoodsNum"), pMatchReward->dwGoodsNum);
		m_PlatformDBAide.AddParameter(TEXT("@wKindID"), m_pGameServiceOption->wKindID);
		m_PlatformDBAide.AddParameter(TEXT("@wServerID"), m_pGameServiceOption->wServerID);
		m_PlatformDBAide.AddParameter(TEXT("@strClientIP"), szClientAddr);

		//结果处理
		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_MatchReward"), true);

		//构造结构
		DBR_GR_MatchRewardResult MatchRewardResult;
		ZeroMemory(&MatchRewardResult,sizeof(MatchRewardResult));

		//设置变量
		MatchRewardResult.bResultCode=lReturnValue==DB_SUCCESS;

		//读取财富
		if(MatchRewardResult.bResultCode==true)
		{
			MatchRewardResult.lCurrGold = m_PlatformDBAide.GetValue_LONGLONG(TEXT("Score"));
			MatchRewardResult.lCurrIngot = m_PlatformDBAide.GetValue_LONGLONG(TEXT("Ingot"));
			MatchRewardResult.dwCurrExperience = m_PlatformDBAide.GetValue_DWORD(TEXT("Experience"));
			MatchRewardResult.lInsureSocre = m_PlatformDBAide.GetValue_LONGLONG(TEXT("InsureScore"));
		}

		//发送结果
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_MATCH_REWARD_RESULT,dwContextID,&MatchRewardResult,sizeof(MatchRewardResult));

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		//构造结构
		DBR_GR_MatchRewardResult MatchRewardResult;
		ZeroMemory(&MatchRewardResult,sizeof(MatchRewardResult));

		//设置变量
		MatchRewardResult.bResultCode=false;

		//发送结果
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_MATCH_REWARD_RESULT,dwContextID,&MatchRewardResult,sizeof(MatchRewardResult));

		return false;
	}

	return true;
}

//请求私人场信息;
bool CDataBaseEngineSink::OnRequestPrivateInfo(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_Private_Info));
	if (wDataSize!=sizeof(DBR_GR_Private_Info)) return false;

	//变量定义
	DBR_GR_Private_Info * pPrivateInfo=(DBR_GR_Private_Info *)pData;


	//请求处理
	try
	{
		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@wKindID"),pPrivateInfo->wKindID);

		//执行查询
		LONG lReturnValue=m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_LoadPrivateInfo"),true);

		if (!lReturnValue)
		{
			DBO_GR_Private_Info kPrivateInfo;
			ZeroMemory(&kPrivateInfo,sizeof(kPrivateInfo));

			kPrivateInfo.wKindID = m_PlatformDBAide.GetValue_WORD(TEXT("KindID"));
			kPrivateInfo.lCostGold = m_PlatformDBAide.GetValue_LONG(TEXT("CostGold"));
			kPrivateInfo.bPlayCout[0] = m_PlatformDBAide.GetValue_BYTE(TEXT("PlayCout1"));
			kPrivateInfo.bPlayCout[1] = m_PlatformDBAide.GetValue_BYTE(TEXT("PlayCout2"));
			kPrivateInfo.bPlayCout[2] = m_PlatformDBAide.GetValue_BYTE(TEXT("PlayCout3"));
			kPrivateInfo.bPlayCout[3] = m_PlatformDBAide.GetValue_BYTE(TEXT("PlayCout4"));

			kPrivateInfo.lPlayCost[0] = m_PlatformDBAide.GetValue_LONG(TEXT("PlayCost1"));
			kPrivateInfo.lPlayCost[1] = m_PlatformDBAide.GetValue_LONG(TEXT("PlayCost2"));
			kPrivateInfo.lPlayCost[2] = m_PlatformDBAide.GetValue_LONG(TEXT("PlayCost3"));
			kPrivateInfo.lPlayCost[3] = m_PlatformDBAide.GetValue_LONG(TEXT("PlayCost4"));

			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_PRIVATE_INFO,dwContextID,&kPrivateInfo,sizeof(kPrivateInfo));
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}


}

//创建私人场;
bool CDataBaseEngineSink::OnRequestCreatePrivate(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_Create_Private));
	if (wDataSize!=sizeof(DBR_GR_Create_Private)) return false;

	//变量定义
	DBR_GR_Create_Private * pPrivateInfo=(DBR_GR_Create_Private *)pData;
	dwUserID = pPrivateInfo->dwUserID;
	
	//请求处理
	try
	{
		DBO_GR_CreatePrivateResoult kCreatePrivate;
		ZeroMemory(&kCreatePrivate,sizeof(kCreatePrivate));

		kCreatePrivate.dwUnionCode = pPrivateInfo->dwUnionCode;
		kCreatePrivate.cbUnionGoldOpen = pPrivateInfo->cbUnionGoldOpen;
		kCreatePrivate.dwAgaginTable = pPrivateInfo->dwAgaginTable;
		kCreatePrivate.bGameRuleIdex = pPrivateInfo->bGameRuleIdex;
		kCreatePrivate.bGameTypeIdex = pPrivateInfo->bGameTypeIdex;
		kCreatePrivate.bPlayCoutIdex = pPrivateInfo->bPlayCoutIdex;
		kCreatePrivate.cbRoomType = pPrivateInfo->cbRoomType;

		kCreatePrivate.cbEnterRoomScoreType = pPrivateInfo->cbEnterRoomScoreType;
		kCreatePrivate.lInitEnterRoomScore	= pPrivateInfo->lInitEnterRoomScore;
		kCreatePrivate.cbBaseScore = pPrivateInfo->cbBaseScore;

		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@dwUserID"),pPrivateInfo->dwUserID);
		m_PlatformDBAide.AddParameter(TEXT("@dwUnionCode"), pPrivateInfo->dwUnionCode);
		m_PlatformDBAide.AddParameter(TEXT("@cbUnionGoldOpen"), pPrivateInfo->cbUnionGoldOpen);
		m_PlatformDBAide.AddParameter(TEXT("@wKindID"),pPrivateInfo->wKindID);
		m_PlatformDBAide.AddParameter(TEXT("@wCostScore"),pPrivateInfo->dwCost);
		m_PlatformDBAide.AddParameter(TEXT("@wCostType"),pPrivateInfo->dwCostType);

		m_PlatformDBAide.AddParameterOutput(TEXT("@strErrorDescribe"),kCreatePrivate.szDescribeString,sizeof(kCreatePrivate.szDescribeString),adParamOutput);

		LONG lReturnValue=m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_CreatePrivate"),true);

		kCreatePrivate.bSucess = (lReturnValue == DB_SUCCESS);
		if (lReturnValue == DB_SUCCESS)
		{
			kCreatePrivate.lCurSocre=m_PlatformDBAide.GetValue_LONGLONG(TEXT("CurSocre"));

			// 欢乐场
			if (pPrivateInfo->cbUnionGoldOpen == 1)
			{
				/*kCreatePrivate.lScoreMultiple = m_PlatformDBAide.GetValue_LONGLONG(TEXT("ScoreMultiple"));
				if (kCreatePrivate.lScoreMultiple == 0)*/
				{
					kCreatePrivate.lScoreMultiple = 1;
				}

				kCreatePrivate.lGameGold = m_PlatformDBAide.GetValue_LONGLONG(TEXT("GameGold"));
				kCreatePrivate.lUnionScore = m_PlatformDBAide.GetValue_LONGLONG(TEXT("UnionMemberGold"));
			}
		}

		CDBVarValue DBVarValue;
		m_PlatformDBModule->GetParameter(TEXT("@strErrorDescribe"),DBVarValue);

		lstrcpyn(kCreatePrivate.szDescribeString,CW2CT(DBVarValue.bstrVal),CountArray(kCreatePrivate.szDescribeString));

		if (kCreatePrivate.bSucess && (pPrivateInfo->dwAgaginTable == INVALID_DWORD))
		{	
			//创建成功并且是新创建房间时,向数据库中插入空的录像记录主表记录;
			BYTE szTotalData[1] = { 0 };

			m_GameDBAide.ResetParameter();
			m_GameDBAide.AddParameter(TEXT("@recordID"), 0);
			m_GameDBAide.AddParameter(TEXT("@roomNum"), 0);
			m_GameDBAide.AddParameter(TEXT("@kindID"), m_pGameServiceAttrib->wKindID);
			m_GameDBAide.AddParameter(TEXT("@dataUserDefine"), (BYTE*)&szTotalData[0], (ULONG)1);

			//执行查询;
			LONG lResultCode = m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_PrivateGameRecord"), true);

			//写入记录;
			if (lResultCode != DB_SUCCESS)
			{
				return true;
			}

			//获取标识;
			kCreatePrivate.dwRecordID = m_GameDBAide.GetValue_DWORD(TEXT("RecordID"));
		}

		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_CREATE_PRIVATE,dwContextID,&kCreatePrivate,sizeof(kCreatePrivate));

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}
}

//私人房花费返还;
bool CDataBaseEngineSink::OnRequestCreatePrivateCost(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{

	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_Create_Private_Cost));
	if (wDataSize!=sizeof(DBR_GR_Create_Private_Cost)) return false;

	//变量定义
	DBR_GR_Create_Private_Cost * pPrivateInfo=(DBR_GR_Create_Private_Cost *)pData;
	
	dwUserID = 0;

	//请求处理
	try
	{
		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@dwUserID"), pPrivateInfo->dwUserID);
		m_PlatformDBAide.AddParameter(TEXT("@wKindID"), pPrivateInfo->wKindID);
		m_PlatformDBAide.AddParameter(TEXT("@dwRoomID"), pPrivateInfo->dwRoomID);
		m_PlatformDBAide.AddParameter(TEXT("@wCostScore"), pPrivateInfo->dwCost);
		m_PlatformDBAide.AddParameter(TEXT("@wCostType"), pPrivateInfo->dwCostType);
		m_PlatformDBAide.AddParameter(TEXT("@dwGameRule"), pPrivateInfo->dwGameRuleIdex);

		LONG lReturnValue=m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_BackCreatePrivateCostEx"),true);

		CString strDebugInfo;
		strDebugInfo.Format(_T("dwUserID[%d], wCostScore[%d], lReturnValue[%ld]"), pPrivateInfo->dwUserID, pPrivateInfo->dwCost, lReturnValue);
		::OutputDebugString(strDebugInfo.GetBuffer());

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		CTraceService::TraceString("GSP_GR_BackCreatePrivateCostEx", TraceLevel_Exception);

		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}
}

//比赛淘汰;
bool CDataBaseEngineSink::OnRequestMatchEliminate(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize==sizeof(DBR_GR_MatchEliminate));
	if (wDataSize!=sizeof(DBR_GR_MatchEliminate)) return false;

	//变量定义
	DBR_GR_MatchEliminate * pMatchEliminate=(DBR_GR_MatchEliminate *)pData;

	//请求处理
	try
	{
		//构造参数
		m_GameDBAide.ResetParameter();		
		m_GameDBAide.AddParameter(TEXT("@dwUserID"),pMatchEliminate->dwUserID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"),pMatchEliminate->wServerID);
		m_GameDBAide.AddParameter(TEXT("@wMatchID"),pMatchEliminate->dwMatchID);
		m_GameDBAide.AddParameter(TEXT("@wMatchNo"),pMatchEliminate->dwMatchNO);	
		m_GameDBAide.AddParameter(TEXT("@cbMatchType"),pMatchEliminate->cbMatchType);

		//结果处理
		LONG lReturnValue=m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_MatchEliminate"),false);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(),TraceLevel_Exception);

		return false;
	}

	return true;
}

//工会开房;
bool CDataBaseEngineSink::OnRequestCreateUnionRoom(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_Create_UnionRoom));
	if (wDataSize != sizeof(DBR_GR_Create_UnionRoom)) return false;

	//变量定义
	DBR_GR_Create_UnionRoom * pUnionRoomInfo = (DBR_GR_Create_UnionRoom *)pData;
	dwUserID = 0;

	//请求处理
	try
	{
		//构造参数
		m_TreasureDBAide.ResetParameter();

		m_TreasureDBAide.AddParameter(TEXT("@wServerID"), pUnionRoomInfo->wServerID);
		m_TreasureDBAide.AddParameter(TEXT("@dwUnionCode"), pUnionRoomInfo->dwUnionCode);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID"), pUnionRoomInfo->dwCreaterUserID);
		m_TreasureDBAide.AddParameter(TEXT("@wKindID"), pUnionRoomInfo->wKindID);
		m_TreasureDBAide.AddParameter(TEXT("@dwRoomID"), pUnionRoomInfo->dwRoomID);
		m_TreasureDBAide.AddParameter(TEXT("@bPlayCoutIdex"), pUnionRoomInfo->bPlayCoutIdex);
		m_TreasureDBAide.AddParameter(TEXT("@wCostScore"), pUnionRoomInfo->dwCost);
		m_TreasureDBAide.AddParameter(TEXT("@wCostType"), pUnionRoomInfo->dwCostType);
		m_TreasureDBAide.AddParameter(TEXT("@dwGameRule"), pUnionRoomInfo->dwGameRuleIdex);
		m_TreasureDBAide.AddParameter(TEXT("@dwRecordID"), pUnionRoomInfo->dwRecordID);
		m_TreasureDBAide.AddParameter(TEXT("@cbBaseScore"), pUnionRoomInfo->cbBaseScore);

		LONG lReturnValue = m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_CreateUnionRoom_Score"), true);

		//写入记录;
		if (lReturnValue == DB_SUCCESS)
		{
			DBO_GR_CreateUnionRoomResult UnionRoomResult;
			ZeroMemory(&UnionRoomResult, sizeof(UnionRoomResult));

			UnionRoomResult.dwRoomID = pUnionRoomInfo->dwRoomID;
			UnionRoomResult.dwCreaterUserID = pUnionRoomInfo->dwCreaterUserID;

			//获取标识;
			UnionRoomResult.dwUnionConsumerID = m_TreasureDBAide.GetValue_DWORD(TEXT("UnionConsumerID"));

			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_CREATE_UNION_ROOM, 0L, &UnionRoomResult, sizeof(UnionRoomResult));
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		CTraceService::TraceString("GSP_GR_CreateUnionRoom", TraceLevel_Exception);

		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		return false;
	}
}

//记录工会开房玩家;
bool CDataBaseEngineSink::OnRequestUnionRoomUser(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_UnionRoomUser));
	if (wDataSize != sizeof(DBR_GR_UnionRoomUser)) return false;

	//变量定义
	DBR_GR_UnionRoomUser * pUnionRoomInfo = (DBR_GR_UnionRoomUser *)pData;

	//请求处理
	try
	{
		//构造参数
		m_TreasureDBAide.ResetParameter();

		m_TreasureDBAide.AddParameter(TEXT("@dwUnionConsumerID"), pUnionRoomInfo->dwUnionConsumerID);
		m_TreasureDBAide.AddParameter(TEXT("@dwUnionCode"), pUnionRoomInfo->CreateUnionRoom.dwUnionCode);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID"), pUnionRoomInfo->CreateUnionRoom.dwCreaterUserID);
		m_TreasureDBAide.AddParameter(TEXT("@wKindID"), pUnionRoomInfo->CreateUnionRoom.wKindID);
		m_TreasureDBAide.AddParameter(TEXT("@dwRoomID"), pUnionRoomInfo->CreateUnionRoom.dwRoomID);
		m_TreasureDBAide.AddParameter(TEXT("@wCostScore"), pUnionRoomInfo->CreateUnionRoom.dwCost);
		m_TreasureDBAide.AddParameter(TEXT("@wCostType"), pUnionRoomInfo->CreateUnionRoom.dwCostType);
		m_TreasureDBAide.AddParameter(TEXT("@dwGameRule"), pUnionRoomInfo->CreateUnionRoom.dwGameRuleIdex);
		m_TreasureDBAide.AddParameter(TEXT("@cbUserCount"), pUnionRoomInfo->cbUserCount);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID0"), pUnionRoomInfo->dwUserID[0]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID1"), pUnionRoomInfo->dwUserID[1]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID2"), pUnionRoomInfo->dwUserID[2]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID3"), pUnionRoomInfo->dwUserID[3]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID4"), pUnionRoomInfo->dwUserID[4]);
		
		LONG lReturnValue = m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_UnionRoomInfo"), true);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		CTraceService::TraceString("GSP_GR_UnionRoomInfo", TraceLevel_Exception);

		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		return false;
	}
}

//工会房解散;
bool CDataBaseEngineSink::onRequestDismissUnionRoom(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_DismissUnionRoom));
	if (wDataSize != sizeof(DBR_GR_DismissUnionRoom)) return false;

	//变量定义
	DBR_GR_DismissUnionRoom * pDismissUnionRoom = (DBR_GR_DismissUnionRoom *)pData;

	//请求处理
	try
	{
		//构造参数
		m_TreasureDBAide.ResetParameter();

		m_TreasureDBAide.AddParameter(TEXT("@dwUnionCode"), pDismissUnionRoom->dwUnionCode);
		m_TreasureDBAide.AddParameter(TEXT("@dwUnionConsumerID"), pDismissUnionRoom->dwUnionConsumerID);
		m_TreasureDBAide.AddParameter(TEXT("@dwCost"), pDismissUnionRoom->dwCost);

		LONG lReturnValue = m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_DismissUnionRoom"), true);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		CTraceService::TraceString("GSP_GR_DismissUnionRoom", TraceLevel_Exception);
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		return false;
	}
}

//加入工会房;
bool CDataBaseEngineSink::onRequestJoinUnionRoom(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_JoinUnionRoom));
	if (wDataSize != sizeof(DBR_GR_JoinUnionRoom)) return false;

	//变量定义
	DBR_GR_JoinUnionRoom * pJoinUnionRoom = (DBR_GR_JoinUnionRoom *)pData;
	dwUserID = pJoinUnionRoom->dwUserID;

	//请求处理
	try
	{
		DBO_GR_JoinUnionRoomResult JoinUnionRoomResult;
		ZeroMemory(&JoinUnionRoomResult, sizeof(JoinUnionRoomResult));
		JoinUnionRoomResult.dwRoomID = pJoinUnionRoom->dwRoomID;

		//构造参数
		m_TreasureDBAide.ResetParameter();
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID"), pJoinUnionRoom->dwUserID);
		m_TreasureDBAide.AddParameter(TEXT("@dwUnionCode"), pJoinUnionRoom->dwUnionCode);
		m_TreasureDBAide.AddParameter(TEXT("@wKindID"), pJoinUnionRoom->wKindID);
		
		m_TreasureDBAide.AddParameterOutput(TEXT("@strErrorDescribe"), JoinUnionRoomResult.szDescribeString, sizeof(JoinUnionRoomResult.szDescribeString), adParamOutput);

		LONG lReturnValue = m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_JoinUnionRoom"), true);

		JoinUnionRoomResult.bSucess = (lReturnValue == DB_SUCCESS);

		if (lReturnValue == DB_SUCCESS)
		{
			// 欢乐场
			if (pJoinUnionRoom->cbUnionGoldOpen == 1)
			{
				JoinUnionRoomResult.lUnionScore = m_TreasureDBAide.GetValue_LONGLONG(TEXT("UnionMemberGold"));
			}
		}
		
		CDBVarValue DBVarValue;
		m_TreasureDBAide.GetParameter(TEXT("@strErrorDescribe"), DBVarValue);
		lstrcpyn(JoinUnionRoomResult.szDescribeString, CW2CT(DBVarValue.bstrVal), CountArray(JoinUnionRoomResult.szDescribeString));

		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_JOIN_UNION_ROOM, dwContextID, &JoinUnionRoomResult, sizeof(JoinUnionRoomResult));

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		return false;
	}
}

//记录工会开房结束;
bool CDataBaseEngineSink::OnRequestUnionRoomEnd(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_UnionRoomEnd));
	if (wDataSize != sizeof(DBR_GR_UnionRoomEnd)) return false;

	//变量定义
	DBR_GR_UnionRoomEnd * pUnionRoomEnd = (DBR_GR_UnionRoomEnd *)pData;

	//请求处理
	try
	{
		//构造参数
		m_TreasureDBAide.ResetParameter();

		m_TreasureDBAide.AddParameter(TEXT("@dwUnionConsumerID"), pUnionRoomEnd->dwUnionConsumerID);
		m_TreasureDBAide.AddParameter(TEXT("@lRevenue"), pUnionRoomEnd->lRevenue);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID0"), pUnionRoomEnd->dwUserID[0]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID1"), pUnionRoomEnd->dwUserID[1]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID2"), pUnionRoomEnd->dwUserID[2]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID3"), pUnionRoomEnd->dwUserID[3]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID4"), pUnionRoomEnd->dwUserID[4]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserScore0"), pUnionRoomEnd->lUserScore[0]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserScore1"), pUnionRoomEnd->lUserScore[1]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserScore2"), pUnionRoomEnd->lUserScore[2]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserScore3"), pUnionRoomEnd->lUserScore[3]);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserScore4"), pUnionRoomEnd->lUserScore[4]);

		LONG lReturnValue = m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_UnionRoomEnd"), true);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		CTraceService::TraceString("GSP_GR_UnionRoomInfo", TraceLevel_Exception);
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
		return false;
	}
}

//写玩家工会积分;
bool CDataBaseEngineSink::OnRequestWriteUnionScore(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_UnionScore));
	if (wDataSize != sizeof(DBR_GR_UnionScore)) return false;

	//请求处理
	try
	{
		//变量定义
		DBR_GR_UnionScore * pUnionRoomEnd = (DBR_GR_UnionScore *)pData;

		//构造参数
		m_TreasureDBAide.ResetParameter();

		m_TreasureDBAide.AddParameter(TEXT("@dwUserID"), pUnionRoomEnd->dwUserID);
		m_TreasureDBAide.AddParameter(TEXT("@dwUnoinCode"), pUnionRoomEnd->dwUnoinCode);
		m_TreasureDBAide.AddParameter(TEXT("@lUserScore"), pUnionRoomEnd->lUserScore);

		LONG lReturnValue = m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_WriteUnionScore"), true);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		CTraceService::TraceString("GSP_GR_UnionRoomInfo", TraceLevel_Exception);
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
		return false;
	}
}

//获取工会房间信息;
bool CDataBaseEngineSink::OnRequestUnionRoomInfo(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_UnionRoomInfo));
	if (wDataSize != sizeof(DBR_GR_UnionRoomInfo)) return false;

	dwUserID = 0;

	//请求处理
	try
	{
		//变量定义
		DBR_GR_UnionRoomInfo * pUnionRoomInfo = (DBR_GR_UnionRoomInfo *)pData;

		//构造参数
		m_PlatformDBAide.ResetParameter();

		m_PlatformDBAide.AddParameter(TEXT("@wServerID"), pUnionRoomInfo->wServerID);
		m_PlatformDBAide.AddParameter(TEXT("@wKindID"), pUnionRoomInfo->wKindID);

		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_GetUnionRoomInfo"), true);

		if (lReturnValue == DB_SUCCESS)
		{
			CMD_GR_UnionRoomList UnionRoomList;
			UnionRoomList.wServerID = pUnionRoomInfo->wServerID;

			//读取消息
			while (m_PlatformDBModule->IsRecordsetEnd() == false)
			{
				//变量定义
				CMD_GR_AutoCreatePrivate info;
				ZeroMemory(&info, sizeof(CMD_GR_AutoCreatePrivate));

				info.dwIndex = m_PlatformDBAide.GetValue_DWORD(TEXT("id"));
				info.dwUnionCode = m_PlatformDBAide.GetValue_DWORD(TEXT("UnionCode"));
				info.cbUnionGoldOpen = m_PlatformDBAide.GetValue_BYTE(TEXT("UnionGoldOpen"));
				info.cbGameType = m_PlatformDBAide.GetValue_BYTE(TEXT("GameType"));
				info.bPlayCoutIdex = m_PlatformDBAide.GetValue_BYTE(TEXT("PlayCoutIdex"));
				info.bPlayCout = m_PlatformDBAide.GetValue_BYTE(TEXT("PlayCout"));
				info.bGameTypeIdex = m_PlatformDBAide.GetValue_BYTE(TEXT("GameTypeIdex"));
				info.bGameRuleIdex = m_PlatformDBAide.GetValue_DWORD(TEXT("GameRuleIdex"));
				info.cbEnterRoomScoreType = m_PlatformDBAide.GetValue_BYTE(TEXT("EnterRoomScoreType"));
				info.lInitEnterRoomScore = m_PlatformDBAide.GetValue_LONG(TEXT("InitEnterRoomScore"));
				info.cbBaseScore = m_PlatformDBAide.GetValue_LONG(TEXT("BaseScore"));

				UnionRoomList.kList.push_back(info);

				//移动记录
				m_PlatformDBModule->MoveToNext();
			};

			// 获得玩家所在工会列表;
			DataStream kListDataStream;
			UnionRoomList.StreamValue(kListDataStream, true);
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_UnionRoomInfo, dwContextID, &kListDataStream[0], kListDataStream.size());
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		CTraceService::TraceString("GSP_GR_UnionRoomInfo", TraceLevel_Exception);
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
		return false;
	}
}

//自动创建工会房;
bool CDataBaseEngineSink::OnRequestAutoCreateUnionRoom(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_Create_Private));
	if (wDataSize != sizeof(DBR_GR_Create_Private)) return false;
	
	dwUserID = 0;

	//变量定义
	DBR_GR_Create_Private * pPrivateInfo = (DBR_GR_Create_Private *)pData;

	//请求处理
	try
	{
		DBO_GR_CreatePrivateResoult kCreatePrivate;
		ZeroMemory(&kCreatePrivate, sizeof(kCreatePrivate));

		kCreatePrivate.dwDaikaiIndex = pPrivateInfo->dwDaikaiIndex;
		kCreatePrivate.dwUnionCode = pPrivateInfo->dwUnionCode;
		kCreatePrivate.cbUnionGoldOpen = pPrivateInfo->cbUnionGoldOpen;
		kCreatePrivate.dwAgaginTable = pPrivateInfo->dwAgaginTable;
		kCreatePrivate.bGameRuleIdex = pPrivateInfo->bGameRuleIdex;
		kCreatePrivate.bGameTypeIdex = pPrivateInfo->bGameTypeIdex;
		kCreatePrivate.bPlayCoutIdex = pPrivateInfo->bPlayCoutIdex;
		kCreatePrivate.cbRoomType = pPrivateInfo->cbRoomType;

		kCreatePrivate.cbEnterRoomScoreType = pPrivateInfo->cbEnterRoomScoreType;
		kCreatePrivate.lInitEnterRoomScore = pPrivateInfo->lInitEnterRoomScore;
		kCreatePrivate.cbBaseScore = pPrivateInfo->cbBaseScore;

		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@dwUserID"), pPrivateInfo->dwUserID);
		m_PlatformDBAide.AddParameter(TEXT("@dwUnionCode"), pPrivateInfo->dwUnionCode);
		m_PlatformDBAide.AddParameter(TEXT("@cbUnionGoldOpen"), pPrivateInfo->cbUnionGoldOpen);
		m_PlatformDBAide.AddParameter(TEXT("@wKindID"), pPrivateInfo->wKindID);
		m_PlatformDBAide.AddParameter(TEXT("@wCostScore"), pPrivateInfo->dwCost);
		m_PlatformDBAide.AddParameter(TEXT("@wCostType"), pPrivateInfo->dwCostType);

		m_PlatformDBAide.AddParameterOutput(TEXT("@strErrorDescribe"), kCreatePrivate.szDescribeString, sizeof(kCreatePrivate.szDescribeString), adParamOutput);

		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_AutoCreatePrivate"), true);

		kCreatePrivate.bSucess = (lReturnValue == DB_SUCCESS);
		if (lReturnValue == DB_SUCCESS)
		{
			kCreatePrivate.lCurSocre = m_PlatformDBAide.GetValue_LONGLONG(TEXT("CurSocre"));

			// 欢乐场
			if (pPrivateInfo->cbUnionGoldOpen == 1)
			{
				/*kCreatePrivate.lScoreMultiple = m_PlatformDBAide.GetValue_LONGLONG(TEXT("ScoreMultiple"));
				if (kCreatePrivate.lScoreMultiple == 0)*/
				{
					kCreatePrivate.lScoreMultiple = 1;
				}

				kCreatePrivate.lGameGold = m_PlatformDBAide.GetValue_LONGLONG(TEXT("GameGold"));
			}
		}

		CDBVarValue DBVarValue;
		m_PlatformDBModule->GetParameter(TEXT("@strErrorDescribe"), DBVarValue);

		lstrcpyn(kCreatePrivate.szDescribeString, CW2CT(DBVarValue.bstrVal), CountArray(kCreatePrivate.szDescribeString));

		if (kCreatePrivate.bSucess && (pPrivateInfo->dwAgaginTable == INVALID_DWORD))
		{
			//创建成功并且是新创建房间时,向数据库中插入空的录像记录主表记录;
			BYTE szTotalData[1] = { 0 };

			m_GameDBAide.ResetParameter();
			m_GameDBAide.AddParameter(TEXT("@recordID"), 0);
			m_GameDBAide.AddParameter(TEXT("@roomNum"), 0);
			m_GameDBAide.AddParameter(TEXT("@kindID"), m_pGameServiceAttrib->wKindID);
			m_GameDBAide.AddParameter(TEXT("@dataUserDefine"), (BYTE*)&szTotalData[0], (ULONG)1);

			//执行查询;
			LONG lResultCode = m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_PrivateGameRecord"), true);

			//写入记录;
			if (lResultCode != DB_SUCCESS)
			{
				return true;
			}

			//获取标识;
			kCreatePrivate.dwRecordID = m_GameDBAide.GetValue_DWORD(TEXT("RecordID"));
		}

		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_AUTO_CREATE, dwContextID, &kCreatePrivate, sizeof(kCreatePrivate));

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		return false;
	}
}

//增加自动开房信息;
bool CDataBaseEngineSink::OnRequestAddAutoRoomInfo(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_AutoRoomInfo));
	if (wDataSize != sizeof(DBR_GR_AutoRoomInfo)) return false;

	//变量定义
	DBR_GR_AutoRoomInfo * pPrivateInfo = (DBR_GR_AutoRoomInfo *)pData;
	dwUserID = pPrivateInfo->dwUserID;

	//请求处理
	try
	{
		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@dwUserID"), pPrivateInfo->dwUserID);
		m_PlatformDBAide.AddParameter(TEXT("@wKindID"), pPrivateInfo->wKindID);
		m_PlatformDBAide.AddParameter(TEXT("@wServerID"), pPrivateInfo->wServerID);
		m_PlatformDBAide.AddParameter(TEXT("@cbGameType"), pPrivateInfo->cbGameType);
		m_PlatformDBAide.AddParameter(TEXT("@cbPlayCoutIdex"), pPrivateInfo->bPlayCoutIdex);
		m_PlatformDBAide.AddParameter(TEXT("@cbPlayCout"), pPrivateInfo->bPlayCout);
		m_PlatformDBAide.AddParameter(TEXT("@cbGameTypeIdex"), pPrivateInfo->bGameTypeIdex);
		m_PlatformDBAide.AddParameter(TEXT("@dwGameRuleIdex"), pPrivateInfo->bGameRuleIdex);
		m_PlatformDBAide.AddParameter(TEXT("@cbEnterRoomScoreType"), pPrivateInfo->cbEnterRoomScoreType);
		m_PlatformDBAide.AddParameter(TEXT("@lInitEnterRoomScore"), pPrivateInfo->lInitEnterRoomScore);
		m_PlatformDBAide.AddParameter(TEXT("@cbBaseScore"), pPrivateInfo->cbBaseScore);

		TCHAR szDescribeString[128] = TEXT("");
		m_PlatformDBAide.AddParameterOutput(TEXT("@strErrorDescribe"), szDescribeString, sizeof(szDescribeString), adParamOutput);

		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_AddAutoRoomInfo_Score"), true);

		if (lReturnValue == DB_SUCCESS)
		{
			//变量定义
			CMD_GR_AutoCreatePrivate info;
			ZeroMemory(&info, sizeof(CMD_GR_AutoCreatePrivate));

			info.dwIndex = m_PlatformDBAide.GetValue_DWORD(TEXT("id"));
			info.dwUnionCode = m_PlatformDBAide.GetValue_DWORD(TEXT("UnionCode"));
			info.cbUnionGoldOpen = m_PlatformDBAide.GetValue_BYTE(TEXT("UnionGoldOpen"));
			info.cbGameType = m_PlatformDBAide.GetValue_BYTE(TEXT("GameType"));
			info.bPlayCoutIdex = m_PlatformDBAide.GetValue_BYTE(TEXT("PlayCoutIdex"));
			info.bPlayCout = m_PlatformDBAide.GetValue_BYTE(TEXT("PlayCout"));
			info.bGameTypeIdex = m_PlatformDBAide.GetValue_BYTE(TEXT("GameTypeIdex"));
			info.bGameRuleIdex = m_PlatformDBAide.GetValue_DWORD(TEXT("GameRuleIdex"));
			info.cbEnterRoomScoreType = m_PlatformDBAide.GetValue_BYTE(TEXT("EnterRoomScoreType"));
			info.lInitEnterRoomScore = m_PlatformDBAide.GetValue_LONG(TEXT("InitEnterRoomScore"));
			info.cbBaseScore = m_PlatformDBAide.GetValue_LONG(TEXT("BaseScore"));

			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_ADD_AUTO_SUCC, dwContextID, &info, sizeof(info));
		}
		else
		{
			CDBVarValue DBVarValue;
			m_PlatformDBModule->GetParameter(TEXT("@strErrorDescribe"), DBVarValue);

			//变量定义
			DBO_GR_AutoFailure autoFailure;
			ZeroMemory(&autoFailure, sizeof(autoFailure));

			//构造数据
			autoFailure.lResultCode = lReturnValue;
			lstrcpyn(autoFailure.szDescribeString, CW2CT(DBVarValue.bstrVal), CountArray(autoFailure.szDescribeString));

			//发送结果
			WORD wDataSize = CountStringBuffer(autoFailure.szDescribeString);
			WORD wHeadSize = sizeof(autoFailure) - sizeof(autoFailure.szDescribeString);
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_ADD_AUTO_ERR, dwContextID, &autoFailure, wHeadSize + wDataSize);

		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
	}

	return false;
}

//删除代开信息;
bool CDataBaseEngineSink::OnRequestDelAutoRoomInfo(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBO_GR_DelAutoRoomInfo));
	if (wDataSize != sizeof(DBO_GR_DelAutoRoomInfo)) return false;

	//变量定义
	DBO_GR_DelAutoRoomInfo * pPrivateInfo = (DBO_GR_DelAutoRoomInfo *)pData;
	dwUserID = pPrivateInfo->dwUserID;

	//请求处理
	try
	{
		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@dwIndex"), pPrivateInfo->dwIndex);
		m_PlatformDBAide.AddParameter(TEXT("@wServerID"), pPrivateInfo->wServerID);

		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_DelAutoRoomInfo"), true);

		if (lReturnValue == DB_SUCCESS)
		{
			//变量定义
			DBO_GR_AutoFailure autoFailure;
			ZeroMemory(&autoFailure, sizeof(autoFailure));
			autoFailure.lResultCode = lReturnValue;

			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_DEL_AUTO_RESULTE, dwContextID, &autoFailure, sizeof(autoFailure));
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
	}

	return false;
}

//写公会房间椅子号;
bool CDataBaseEngineSink::OnRequestWriteUnionChairID(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_WriteUnionRoomChairID));
	if (wDataSize != sizeof(DBR_GR_WriteUnionRoomChairID)) return false;

	//变量定义
	DBR_GR_WriteUnionRoomChairID * pPrivateInfo = (DBR_GR_WriteUnionRoomChairID *)pData;
	dwUserID = 0;

	//请求处理
	try
	{
		//构造参数
		m_TreasureDBAide.ResetParameter();
		m_TreasureDBAide.AddParameter(TEXT("@dwUnionConsumerID"), pPrivateInfo->dwUnionConsumerID);
		m_TreasureDBAide.AddParameter(TEXT("@wChairID"), pPrivateInfo->wChairID);
		m_TreasureDBAide.AddParameter(TEXT("@dwUserID"), pPrivateInfo->dwUserID);

		LONG lReturnValue = m_TreasureDBAide.ExecuteProcess(TEXT("GSP_GR_WriteUnionChairID"), true);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
	}

	return false;
}

//登录结果
VOID CDataBaseEngineSink::OnLogonDisposeResult(DWORD dwContextID, DWORD dwErrorCode, LPCTSTR pszErrorString, bool bMobileClient,BYTE cbDeviceType,WORD wBehaviorFlags,WORD wPageTableCount)
{
	if (dwErrorCode==DB_SUCCESS)
	{
		//属性资料
		m_LogonSuccess.wFaceID=m_GameDBAide.GetValue_WORD(TEXT("FaceID"));
		m_LogonSuccess.dwUserID=m_GameDBAide.GetValue_DWORD(TEXT("UserID"));
		m_LogonSuccess.dwGameID=m_GameDBAide.GetValue_DWORD(TEXT("GameID"));
		//m_LogonSuccess.dwGroupID=m_GameDBAide.GetValue_DWORD(TEXT("GroupID"));
		m_LogonSuccess.dwCustomID=m_GameDBAide.GetValue_DWORD(TEXT("CustomID"));
		m_GameDBAide.GetValue_String(TEXT("NickName"),m_LogonSuccess.szNickName,CountArray(m_LogonSuccess.szNickName));
		m_GameDBAide.GetValue_String(TEXT("GroupName"),m_LogonSuccess.szGroupName,CountArray(m_LogonSuccess.szGroupName));

		//用户资料
		m_LogonSuccess.cbGender=m_GameDBAide.GetValue_BYTE(TEXT("Gender"));
		m_LogonSuccess.cbMemberOrder=m_GameDBAide.GetValue_BYTE(TEXT("MemberOrder"));
		m_LogonSuccess.cbMasterOrder=m_GameDBAide.GetValue_BYTE(TEXT("MasterOrder"));
		m_GameDBAide.GetValue_String(TEXT("UnderWrite"),m_LogonSuccess.szUnderWrite,CountArray(m_LogonSuccess.szUnderWrite));

		//积分信息
		m_LogonSuccess.lScore = (SCORE)m_GameDBAide.GetValue_DOUBLE(TEXT("Score"));
		m_LogonSuccess.lGrade=m_GameDBAide.GetValue_LONGLONG(TEXT("Grade"));
		m_LogonSuccess.lInsure = (SCORE)m_GameDBAide.GetValue_DOUBLE(TEXT("Insure"));

		//局数信息
		m_LogonSuccess.cbScoreMultiple = m_GameDBAide.GetValue_BYTE(TEXT("ScoreMultiple"));
		m_LogonSuccess.dwWinCount=m_GameDBAide.GetValue_LONG(TEXT("WinCount"));
		m_LogonSuccess.dwLostCount=m_GameDBAide.GetValue_LONG(TEXT("LostCount"));
		m_LogonSuccess.dwDrawCount=m_GameDBAide.GetValue_LONG(TEXT("DrawCount"));
		m_LogonSuccess.dwFleeCount=m_GameDBAide.GetValue_LONG(TEXT("FleeCount"));
		m_LogonSuccess.dwUserMedal=m_GameDBAide.GetValue_LONG(TEXT("UserMedal"));
		m_LogonSuccess.dwExperience=m_GameDBAide.GetValue_LONG(TEXT("Experience"));
		m_LogonSuccess.lLoveLiness=m_GameDBAide.GetValue_LONG(TEXT("LoveLiness"));

		//牌库变量
		m_LogonSuccess.dwCardLibIndex = m_GameDBAide.GetValue_DWORD(TEXT("CardLibIndex"));
		m_LogonSuccess.cbCardLibEnabled = (BYTE)m_GameDBAide.GetValue_DWORD(TEXT("CardLibEnable"));

		TCHAR szStartLibTime[64] = {0};
		TCHAR szStopLibTime[64] = { 0 };
		m_GameDBAide.GetValue_String(TEXT("StartLibTime"), szStartLibTime, CountArray(szStartLibTime));
		m_GameDBAide.GetValue_String(TEXT("StopLibTime"), szStopLibTime, CountArray(szStopLibTime));

		if (szStartLibTime[0] != _T('\0') && szStopLibTime[0] != _T('\0'))
		{
			try
			{
				CTime cTime = CTime::GetCurrentTime();

				CString strDateTime;
				strDateTime.Format(_T("%s %s"), cTime.Format("%Y-%m-%d"), szStartLibTime);
				m_LogonSuccess.dwStartLibTime = (DWORD)CWHService::ConvertDateTimeToDWORD(strDateTime);

				strDateTime.Format(_T("%s %s"), cTime.Format("%Y-%m-%d"), szStopLibTime);
				m_LogonSuccess.dwStopLibTime = (DWORD)CWHService::ConvertDateTimeToDWORD(strDateTime);
			}
			catch (...)
			{
				m_LogonSuccess.dwStartLibTime = 0;
				m_LogonSuccess.dwStopLibTime = 0;
				m_LogonSuccess.cbCardLibEnabled = 0;
			}
		}
		else
		{
			m_LogonSuccess.cbCardLibEnabled = 0;
		}

		//附加信息
		m_LogonSuccess.dwUserRight=m_GameDBAide.GetValue_DWORD(TEXT("UserRight"));
		m_LogonSuccess.dwMasterRight=m_GameDBAide.GetValue_DWORD(TEXT("MasterRight"));
		m_LogonSuccess.cbDeviceType=cbDeviceType;
		m_LogonSuccess.wBehaviorFlags=wBehaviorFlags;
		m_LogonSuccess.wPageTableCount=wPageTableCount;

		//索引变量
		m_LogonSuccess.dwInoutIndex=m_GameDBAide.GetValue_DWORD(TEXT("InoutIndex"));

		//头像HTTP	
		ZeroMemory(m_LogonSuccess.szHeadHttp, CountArray(m_LogonSuccess.szHeadHttp));
		m_GameDBAide.GetValue_String(TEXT("HeadHttp"), m_LogonSuccess.szHeadHttp, CountArray(m_LogonSuccess.szHeadHttp));

		//获取信息
		if(pszErrorString!=NULL)lstrcpyn(m_LogonSuccess.szDescribeString,pszErrorString,CountArray(m_LogonSuccess.szDescribeString));

		//发送结果
		WORD wDataSize=CountStringBuffer(m_LogonSuccess.szDescribeString);
		WORD wHeadSize=sizeof(m_LogonSuccess)-sizeof(m_LogonSuccess.szDescribeString);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_LOGON_SUCCESS,dwContextID,&m_LogonSuccess,wHeadSize+wDataSize);
	}
	else
	{
		//变量定义
		DBO_GR_LogonFailure LogonFailure;
		ZeroMemory(&LogonFailure,sizeof(LogonFailure));

		//构造数据
		LogonFailure.lResultCode=dwErrorCode;
		lstrcpyn(LogonFailure.szDescribeString,pszErrorString,CountArray(LogonFailure.szDescribeString));

		//发送结果
		WORD wDataSize=CountStringBuffer(LogonFailure.szDescribeString);
		WORD wHeadSize=sizeof(LogonFailure)-sizeof(LogonFailure.szDescribeString);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_LOGON_FAILURE,dwContextID,&LogonFailure,wHeadSize+wDataSize);
	}

	return;
}

//银行结果
VOID CDataBaseEngineSink::OnInsureDisposeResult(DWORD dwContextID, DWORD dwErrorCode, SCORE lFrozenedScore, LPCTSTR pszErrorString, bool bMobileClient,BYTE cbActivityGame)
{
	if (dwErrorCode==DB_SUCCESS)
	{
		//变量定义
		DBO_GR_UserInsureSuccess UserInsureSuccess;
		ZeroMemory(&UserInsureSuccess,sizeof(UserInsureSuccess));

		//构造变量
		UserInsureSuccess.cbActivityGame=cbActivityGame;
		UserInsureSuccess.lFrozenedScore=lFrozenedScore;
		UserInsureSuccess.dwUserID=m_TreasureDBAide.GetValue_DWORD(TEXT("UserID"));
		UserInsureSuccess.lSourceScore=m_TreasureDBAide.GetValue_LONGLONG(TEXT("SourceScore"));
		UserInsureSuccess.lSourceInsure=m_TreasureDBAide.GetValue_LONGLONG(TEXT("SourceInsure"));
		UserInsureSuccess.lInsureRevenue=m_TreasureDBAide.GetValue_LONGLONG(TEXT("InsureRevenue"));
		UserInsureSuccess.lVariationScore=m_TreasureDBAide.GetValue_LONGLONG(TEXT("VariationScore"));
		UserInsureSuccess.lVariationInsure=m_TreasureDBAide.GetValue_LONGLONG(TEXT("VariationInsure"));
		lstrcpyn(UserInsureSuccess.szDescribeString,pszErrorString,CountArray(UserInsureSuccess.szDescribeString));

		//发送结果
		WORD wDataSize=CountStringBuffer(UserInsureSuccess.szDescribeString);
		WORD wHeadSize=sizeof(UserInsureSuccess)-sizeof(UserInsureSuccess.szDescribeString);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_USER_INSURE_SUCCESS,dwContextID,&UserInsureSuccess,wHeadSize+wDataSize);
	}
	else
	{
		//变量定义
		DBO_GR_UserInsureFailure UserInsureFailure;
		ZeroMemory(&UserInsureFailure,sizeof(UserInsureFailure));

		//构造变量
		UserInsureFailure.cbActivityGame=cbActivityGame;
		UserInsureFailure.lResultCode=dwErrorCode;
		UserInsureFailure.lFrozenedScore=lFrozenedScore;
		lstrcpyn(UserInsureFailure.szDescribeString,pszErrorString,CountArray(UserInsureFailure.szDescribeString));

		//发送结果
		WORD wDataSize=CountStringBuffer(UserInsureFailure.szDescribeString);
		WORD wHeadSize=sizeof(UserInsureFailure)-sizeof(UserInsureFailure.szDescribeString);
		m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_USER_INSURE_FAILURE,dwContextID,&UserInsureFailure,wHeadSize+wDataSize);
	}

	return;
}

bool CDataBaseEngineSink::OnRequestSinglePrivateGameRecord(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		DataStream kDataStream(pData, wDataSize);
		if (kDataStream.size() == 0)
		{
			return true;
		}

		tagPrivateRandRecordChild singleGameRecord;
		singleGameRecord.StreamValue(kDataStream, false);

		CString strUserScore = "";
		for (int i = 0; i < (int)singleGameRecord.kScore.size(); i++)
		{
			CString strTmp = "";

			if (!strUserScore.IsEmpty())
			{
				if (singleGameRecord.kScore[i] > 0)
				{
					strTmp.Format(",+%d", singleGameRecord.kScore[i]);
				}
				else
				{
					strTmp.Format(",%d", singleGameRecord.kScore[i]);
				}
			}
			else
			{
				if (singleGameRecord.kScore[i] > 0)
				{
					strTmp.Format("+%d", singleGameRecord.kScore[i]);
				}
				else
				{
					strTmp.Format("%d", singleGameRecord.kScore[i]);
				}
			}

			strUserScore += strTmp;
		}

		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@dwRecordID"), singleGameRecord.iRecordID);
		m_GameDBAide.AddParameter(TEXT("@strUserScore"), strUserScore);
		m_GameDBAide.AddParameter(TEXT("@strUserIDs"), singleGameRecord.kUserDefine.c_str());
		m_GameDBAide.AddParameter(TEXT("@dataUserDefine"), (BYTE*)pData, wDataSize);

		//执行查询;
		m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_WriteGameScore_PlayCout"), true);

	}
	catch (IDataBaseException * pIException)
	{
		//输出错误;
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		return false;
	}

	return true;
}

//私人房结束;
bool CDataBaseEngineSink::OnRequestPrivateGameEnd(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	
	//效验参数
	ASSERT(wDataSize == sizeof(DBO_GR_PrivateGameEnd));
	if (wDataSize != sizeof(DBO_GR_PrivateGameEnd)) return false;

	//变量定义
	DBO_GR_PrivateGameEnd * pGameEnd = (DBO_GR_PrivateGameEnd *)pData;

	try
	{
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@dwUserID"), pGameEnd->dwUserID);
		m_GameDBAide.AddParameter(TEXT("@lScore"), pGameEnd->lScore);
		m_GameDBAide.AddParameter(TEXT("@wPlayCount"), pGameEnd->wPlayCount);
		m_GameDBAide.AddParameter(TEXT("@dwCardLibIndex"), pGameEnd->dwCardLibIndex);
		m_GameDBAide.AddParameter(TEXT("@wKindID"), pGameEnd->wKindID);
		m_GameDBAide.AddParameter(TEXT("@wServerID"), pGameEnd->wServerID);

		//执行查询;
		m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_PrivateGameEnd"), true);

	}
	catch (IDataBaseException * pIException)
	{
		//输出错误;
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		return false;
	}

	return true;
}

//牌库全局配置;
bool CDataBaseEngineSink::OnRequestLoadCardLibCfg(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		//构造参数
		m_PlatformDBAide.ResetParameter();

		//执行查询
		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GP_LoadCardLibraryConfig"), true);

		//读取信息
		if (lReturnValue == DB_SUCCESS)
		{
			//读取消息
			if (m_PlatformDBModule->IsRecordsetEnd() == false)
			{
				//变量定义
				DBO_GR_GameCardLibraryCfg mCardLibCfg;
				ZeroMemory(&mCardLibCfg, sizeof(DBO_GR_GameCardLibraryCfg));

				//读取消息
				TCHAR szStatusString[128] = _T("");
				m_PlatformDBAide.GetValue_String(TEXT("StatusString"), szStatusString, CountArray(szStatusString));

				mCardLibCfg.cbEnable = m_PlatformDBAide.GetValue_BYTE(TEXT("StatusValue"));

				CString strSub;
				int nCount = 0;
				CStringArray aryString;

				while (AfxExtractSubString(strSub, szStatusString, nCount++, '|'))
				{
					aryString.Add(strSub);
				}

				if ( aryString.GetCount()>2 )
				{
					mCardLibCfg.dwCount = atoi(aryString[2]);
					mCardLibCfg.dwStartDateTime = (DWORD)CWHService::ConvertDateTimeToDWORD(aryString[0]);

					CString strDateTime;
					strDateTime.Format(_T("%s 23:59:59"), aryString[1]);
					mCardLibCfg.dwEndDateTime = (DWORD)CWHService::ConvertDateTimeToDWORD(strDateTime);
				}
				else
				{
					mCardLibCfg.cbEnable = 0;
				}

				//CTime cTime(mCardLibCfg.dwEndDateTime);
				//CString strTime = cTime.Format("%Y-%m-%d %H:%M:%S");

				//发送消息
				m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_GAME_CARD_LIB_CFG, 0, &mCardLibCfg, sizeof(DBO_GR_GameCardLibraryCfg));
			};
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//输出错误
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
		return false;
	}

	return true;
}

//清空本服务器所有玩家;
bool CDataBaseEngineSink::OnRequestUnlockAllUser(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		dwUserID = INVALID_DWORD;

		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@wServerID"), m_pGameServiceOption->wServerID);

		//执行查询;
		m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_UnlockAllUser"), true);

	}
	catch (IDataBaseException * pIException)
	{
		//输出错误;
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		return false;
	}

	return true;
}

//比赛记录成绩;
bool CDataBaseEngineSink::OnRequestMatchRecordGrades(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_MatchRecordGrades));
	if (wDataSize != sizeof(DBR_GR_MatchRecordGrades))
	{
		return false;
	}

	//变量定义
	DBR_GR_MatchRecordGrades * pMatchRecordGrades = (DBR_GR_MatchRecordGrades *)pData;
	dwUserID = pMatchRecordGrades->dwUserID;

	//请求处理
	try
	{
		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@dwUserID"), pMatchRecordGrades->dwUserID);
		m_PlatformDBAide.AddParameter(TEXT("@wServerID"), pMatchRecordGrades->wServerID);
		m_PlatformDBAide.AddParameter(TEXT("@dwMatchID"), pMatchRecordGrades->dwMatchID);
		m_PlatformDBAide.AddParameter(TEXT("@lMatchNo"), pMatchRecordGrades->lMatchNo);
		m_PlatformDBAide.AddParameter(TEXT("@lInitScore"), pMatchRecordGrades->lInitScore);

		//结果处理
		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_MatchRecordGrades"), false);

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
		CTraceService::TraceString(TEXT("GSP_GR_MatchRecordGrades"), TraceLevel_Exception);
		return false;
	}

	return true;
}

//加载排行数据;
bool CDataBaseEngineSink::OnRequestMatchLoadRankData(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	//效验参数
	ASSERT(wDataSize == sizeof(DBR_GR_MatchLoadRankData));
	if (wDataSize != sizeof(DBR_GR_MatchLoadRankData))
	{
		return false;
	}

	//变量定义
	DBR_GR_MatchLoadRankData * pLoadRankData = (DBR_GR_MatchLoadRankData *)pData;
	//dwUserID = INVALID_DWORD;

	//请求处理
	try
	{
		TCHAR szDescribeString[128] = "";

		//构造参数
		m_PlatformDBAide.ResetParameter();
		m_PlatformDBAide.AddParameter(TEXT("@dwMatchID"), pLoadRankData->dwMatchID);
		m_PlatformDBAide.AddParameter(TEXT("@dwMatchNo"), pLoadRankData->dwMatchNO);
		m_PlatformDBAide.AddParameter(TEXT("@dwAllRank"), 1);
		m_PlatformDBAide.AddParameter(TEXT("@dwRankNum"), 0);
		m_PlatformDBAide.AddParameter(TEXT("@dwUserID"), 0);
		m_PlatformDBAide.AddParameterOutput(TEXT("@@strErrorDesc"), szDescribeString, sizeof(szDescribeString), adParamOutput);

		//结果处理
		LONG lReturnValue = m_PlatformDBAide.ExecuteProcess(TEXT("GSP_GR_GetCurMatchList"), true);


		//执行成功
		if (lReturnValue == DB_SUCCESS)
		{
			//构造结构
			DBO_GR_MatchRankDataList MatchRankDataList;
			ZeroMemory(&MatchRankDataList, sizeof(MatchRankDataList));

			//变量定义
			tagMatchRankDataInfo * pMatchRankInfo = NULL;

			//设置变量
			MatchRankDataList.dwMatchID = pLoadRankData->dwMatchID;
			MatchRankDataList.dwMatchNO = pLoadRankData->dwMatchNO;

			//读取记录;
			while (m_PlatformDBModule->IsRecordsetEnd() == false)
			{
				pMatchRankInfo = &MatchRankDataList.MatchRankInfo[MatchRankDataList.wUserCount++];
				pMatchRankInfo->wRankID = m_PlatformDBAide.GetValue_WORD(TEXT("RankID"));
				pMatchRankInfo->dwUserID = m_PlatformDBAide.GetValue_DWORD(TEXT("UserID"));
				pMatchRankInfo->lScore = m_PlatformDBAide.GetValue_LONGLONG(TEXT("CurScore"));
				pMatchRankInfo->lFinishMaxScore = m_PlatformDBAide.GetValue_LONGLONG(TEXT("Score"));

				m_PlatformDBAide.GetValue_String(TEXT("NickName"),pMatchRankInfo->szNickName, LEN_NICKNAME);

				if (MatchRankDataList.wUserCount >= 64)
				{
					//发送数据;
					WORD wSendDataSize = sizeof(MatchRankDataList) - sizeof(MatchRankDataList.MatchRankInfo);
					wSendDataSize += MatchRankDataList.wUserCount*sizeof(MatchRankDataList.MatchRankInfo[0]);
					m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_MATCH_RANKDATA_LIST, dwContextID, &MatchRankDataList, wSendDataSize);

					MatchRankDataList.wUserCount = 0;
				}

				//移动游标;
				m_PlatformDBModule->MoveToNext();
			}

			//发送数据
			WORD wSendDataSize = sizeof(MatchRankDataList) - sizeof(MatchRankDataList.MatchRankInfo);
			wSendDataSize += MatchRankDataList.wUserCount*sizeof(MatchRankDataList.MatchRankInfo[0]);
			m_pIDataBaseEngineEvent->OnEventDataBaseResult(DBO_GR_MATCH_RANKDATA_LIST, dwContextID, &MatchRankDataList, wSendDataSize);
		}

		return true;
	}
	catch (IDataBaseException * pIException)
	{
		//错误信息
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);
		CTraceService::TraceString(TEXT("GSP_GR_GetCurMatchList"), TraceLevel_Exception);
		return false;
	}

	return true;
}

//重置数据库信息;
bool CDataBaseEngineSink::OnRequestResetDateBaseInfo(DWORD dwContextID, VOID * pData, WORD wDataSize, DWORD &dwUserID)
{
	try
	{
		m_GameDBAide.ResetParameter();
		m_GameDBAide.AddParameter(TEXT("@wServerID"), m_pGameServiceOption->wServerID);

		//执行查询;
		m_GameDBAide.ExecuteProcess(TEXT("GSP_GR_ResetDateBaseInfo"), true);

	}
	catch (IDataBaseException * pIException)
	{
		//输出错误;
		CTraceService::TraceString(pIException->GetExceptionDescribe(), TraceLevel_Exception);

		return false;
	}

	return true;
}

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