#include "StdAfx.h"
#include "ServerPtr.h"
#include "OnlineUser.h"
#include <time.h>
#include "CritSection.h"
#include "../hp-src/SendPackage.h"
#include "../ODBCPOOL/UserInfo.h"
#include "../ODBCPOOL/UserDetail.h"
#include "../ODBCPOOL/StaffInfo.h"
#include "../ODBCPOOL/ProductType.h"
#include "../ODBCPOOL/ProductInfo.h"
#include "../ODBCPOOL/SceneryInfo.h"
#include "../ODBCPOOL/PackageType.h"
#include "../ODBCPOOL/PackageInfo.h"
#include "../ODBCPOOL/PackageItems.h"
#include "../ODBCPOOL/CustomerFrom.h"
#include "../ODBCPOOL/CustomerInfo.h"
#include "../ODBCPOOL/OrderType.h"
#include "../ODBCPOOL/OrderInfo.h"
#include "../ODBCPOOL/OrderScenery.h"
#include "../ODBCPOOL/OrderPackageItems.h"
#include "../ODBCPOOL/SysConfig.h"
#include "../ODBCPOOL/StudioLog.h"
#include "../ODBCPOOL/StudioInfo.h"
#include "../ODBCPOOL/DepartmentInfo.h"
#include "../ODBCPOOL/PackageItemDetail.h"
#include "../ODBCPOOL/PackageItemView.h"

time_t g_systm;
// 服务通信对象;
CServerPtr* CServerPtr::m_spThis = NULL;

CServerPtr::CServerPtr(void)
{
	// 创建监听器对象
	m_pListener = ::Create_HP_TcpServerListener();
	// 创建 Socket 对象
	m_pServer = ::Create_HP_TcpPackServer(m_pListener);
	// 设置 Socket 监听器回调函数
	::HP_Set_FN_Server_OnPrepareListen(m_pListener, OnPrepareListen);
	::HP_Set_FN_Server_OnAccept(m_pListener, OnAccept);
	::HP_Set_FN_Server_OnSend(m_pListener, OnSend);
	::HP_Set_FN_Server_OnReceive(m_pListener, OnReceive);
	::HP_Set_FN_Server_OnClose(m_pListener, OnClose);
	::HP_Set_FN_Server_OnShutdown(m_pListener, OnShutdown);
	// 获取机器时间;
	time(&g_systm); // g_systm = time(NULL);
}

CServerPtr::~CServerPtr(void)
{
	// 销毁 Socket 对象
	::Destroy_HP_TcpPackServer(m_spThis->m_pServer);
	// 销毁监听器对象
	::Destroy_HP_TcpServerListener(m_pListener);
}

void CServerPtr::Release()
{
	if (m_spThis)
		delete m_spThis;
	m_spThis = NULL;
}

BOOL CServerPtr::Start()
{
	if (m_spThis == NULL)
		return FALSE;

	::HP_TcpPackServer_SetMaxPackSize(m_spThis->m_pServer, 0x3FFFFF);
	::HP_TcpPackServer_SetPackHeaderFlag(m_spThis->m_pServer, 0x3FE);

	if (::HP_Server_Start(m_spThis->m_pServer, _T("0.0.0.0"), Global::g_dwSvrPort))
	{
		//::LogServerStart(ADDRESS, PORT);
		OutputDebugString(_T("服务器启动成功！\n"));
		//SetAppState(ST_STARTED);
	}
	else
	{
		//::LogServerStartFail(::HP_Server_GetLastError(m_spThis->m_pServer), ::HP_Server_GetLastErrorDesc(m_spThis->m_pServer));
		OutputDebugString(_T("服务器启动失败！\n"));
		//SetAppState(ST_STOPPED);
	}

	return TRUE;
}

BOOL CServerPtr::Stop()
{
	if (::HP_Server_Stop(m_spThis->m_pServer))
	{
		OutputDebugString(_T("停止服务器成功！\n"));
		::LogServerStop();
		//SetAppState(ST_STOPPED);
	}
	else
	{
		ASSERT(FALSE);
	}

	return TRUE;
}

BOOL CServerPtr::Disconnect(IN const DWORD& dwConnId)
{
	if (::HP_Server_Disconnect(m_spThis->m_pServer, dwConnId, TRUE))
	{
		// 移除登录的用户信息;
		COnlineUser::GetInstance()->EraseOnlineUser(dwConnId);
		::LogDisconnect(dwConnId);
	}
	else
	{
		::LogDisconnectFail(dwConnId);
	}

	return TRUE;
}

En_HP_HandleResult CServerPtr::OnPrepareListen(SOCKET soListen)
{
	TCHAR szAddress[40];
	int iAddressLen = sizeof(szAddress) / sizeof(TCHAR);
	USHORT usPort;

	::HP_Server_GetListenAddress(m_spThis->m_pServer, szAddress, &iAddressLen, &usPort);
	::PostOnPrepareListen(szAddress, usPort);
	return HR_OK;
}

En_HP_HandleResult CServerPtr::OnAccept(HP_CONNID dwConnID, SOCKET soClient)
{
	BOOL bPass = TRUE;
	TCHAR szAddress[40];
	int iAddressLen = sizeof(szAddress) / sizeof(TCHAR);
	USHORT usPort;

	::HP_Server_GetRemoteAddress(m_spThis->m_pServer, dwConnID, szAddress, &iAddressLen, &usPort);

	if (!m_spThis->m_strAddress.IsEmpty())
	{
		if (m_spThis->m_strAddress.CompareNoCase(szAddress) == 0)
			bPass = FALSE;
	}

	//::PostOnAccept(dwConnID, szAddress, usPort, bPass);

	TRACE(_T("新客户端连接：%d, %s, %d！\n"), dwConnID, szAddress, usPort);

	return bPass ? HR_OK : HR_ERROR;
}

En_HP_HandleResult CServerPtr::OnSend(HP_CONNID dwConnID, const BYTE* pData, int iLength)
{
	TRACE(_T("发送数据给客户端：%d, %s, %d！\n"), dwConnID, pData, iLength);
	//::PostOnSend(dwConnID, pData, iLength);
	return HR_OK;
}

En_HP_HandleResult CServerPtr::OnReceive(HP_CONNID dwConnID, const BYTE* pData, int iLength)
{
	TheProPackage thepackage;
	memcpy(&thepackage, pData, sizeof(TheProPackage));

	EnHandleResult nResult = HR_OK;
	BYTE *pSendData = NULL;
	DWORD dwSendLen = 0;
	switch (thepackage.nCmd)
	{
		// 客户端请求登录;
	case C2CCMD_REQ_LOGIN:
	{
		Req_Login(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求登出;
	case C2CCMD_REQ_LOGOUT:
	{
		Req_LogOut(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求添加部门;
	case C2CCMD_NEW_DEPARTMENT:
	{
		New_Department(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除部门;
	case C2CCMD_DEL_DEPARTMENT:
	{
		Del_Department(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改部门;
	case C2CCMD_MOD_DEPARTMENT:
	{
		// 暂未使用;
		Mod_Department(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询部门;
	case C2CCMD_QRY_DEPARTMENT:
	{
		nResult = Ask_Department(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加员工;
	case C2CCMD_NEW_STAFFINFO:
	{
		New_StaffInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除员工;
	case C2CCMD_DEL_STAFFINFO:
	{
		Del_StaffInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改员工;
	case C2CCMD_MOD_STAFFINFO:
	{
		Mod_StaffInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询员工;
	case C2CCMD_QRY_STAFFINFO:
	{
		nResult = Ask_StaffInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加用户;
	case C2CCMD_NEW_USERINFO:
	{
		New_UerInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除用户;
	case C2CCMD_DEL_USERINFO:
	{
		Del_UerInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改用户;
	case C2CCMD_MOD_USERINFO:
	{
		Mod_UerInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询用户;
	case C2CCMD_QRY_USERINFO:
	{
		nResult = Ask_UerInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加商品类型;
	case C2CCMD_NEW_PRODUCTTYPE:
	{
		New_ProductType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除商品类型;
	case C2CCMD_DEL_PRODUCTTYPE:
	{
		Del_ProductType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改商品类型;
	case C2CCMD_MOD_PRODUCTTYPE:
	{
		Mod_ProductType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询商品类型;
	case C2CCMD_QRY_PRODUCTTYPE:
	{
		nResult = Ask_ProductType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加商品信息;
	case C2CCMD_NEW_PRODUCT:
	{
		New_ProductInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除商品信息;
	case C2CCMD_DEL_PRODUCT:
	{
		Del_ProductInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改商品信息;
	case C2CCMD_MOD_PRODUCT:
	{
		Mod_ProductInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询商品信息;
	case C2CCMD_QRY_PRODUCT:
	{
		nResult = Ask_ProductInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加景点;
	case C2CCMD_NEW_SCENERY:
	{
		New_Scenery(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除景点;
	case C2CCMD_DEL_SCENERY:
	{
		Del_Scenery(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改景点;
	case C2CCMD_MOD_SCENERY:
	{
		Mod_Scenery(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询景点;
	case C2CCMD_QRY_SCENERY:
	{
		nResult = Ask_Scenery(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加套餐类型信息;
	case C2CCMD_NEW_PACKAGETYPE:
	{
		New_PackageType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除套餐类型信息;
	case C2CCMD_DEL_PACKAGETYPE:
	{
		Del_PackageType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改套餐类型信息;
	case C2CCMD_MOD_PACKAGETYPE:
	{
		Mod_PackageType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询套餐类型信息;
	case C2CCMD_QRY_PACKAGETYPE:
	{
		nResult = Ask_PackageType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加套餐信息;
	case C2CCMD_NEW_PACKAGEINFO:
	{
		New_PackageInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除套餐信息;
	case C2CCMD_DEL_PACKAGEINFO:
	{
		Del_PackageInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改套餐信息;
	case C2CCMD_MOD_PACKAGEINFO:
	{
		Mod_PackageInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询套餐信息;
	case C2CCMD_QRY_PACKAGEINFO:
	{
		nResult = Ask_PackageInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加套餐类型信息;
	case C2CCMD_NEW_PACKAGEITEM:
	{
		New_PackageItem(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	case C2CCMD_NEW_PACKAGEITEM2:
	{
		New_PackageItem2(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求添加套餐类型信息;
	case C2CCMD_DEL_PACKAGEITEM:
	{
		Del_PackageItem(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求添加套餐类型信息;
	case C2CCMD_MOD_PACKAGEITEM:
	{
		Mod_PackageItem(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求添加套餐类型信息;
	case C2CCMD_QRY_PACKAGEITEM:
	{
		nResult = Ask_PackageItem(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求查询套系项详情;
	case C2CCMD_QRY_PACKAGEITEM_DETAIL:
	{
		nResult = Ask_PackageItemDetail(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求查询套系项信息;
	case C2CCMD_QRY_PACKAGEITEM_VIEW:
	{
		nResult = Ask_PackageItemView(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加顾客来源信息;
	case C2CCMD_NEW_CUSTOMERFROM:
	{
		New_CustomerFrom(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除顾客来源信息;
	case C2CCMD_DEL_CUSTOMERFROM:
	{
		Del_CustomerFrom(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改顾客来源信息;
	case C2CCMD_MOD_CUSTOMERFROM:
	{
		Mod_CustomerFrom(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询顾客来源信息;
	case C2CCMD_QRY_CUSTOMERFROM:
	{
		nResult = Ask_CustomerFrom(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加顾客信息;
	case C2CCMD_NEW_CUSTOMERINFO:
	{
		New_CustomerInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除顾客信息;
	case C2CCMD_DEL_CUSTOMERINFO:
	{
		Del_CustomerInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改顾客信息;
	case C2CCMD_MOD_CUSTOMERINFO:
	{
		Mod_CustomerInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询顾客信息;
	case C2CCMD_QRY_CUSTOMERINFO:
	{
		nResult = Ask_CustomerInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加订单类型;
	case C2CCMD_NEW_ORDERTYPE:
	{
		New_OrderType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除订单类型;
	case C2CCMD_DEL_ORDERTYPE:
	{
		Del_OrderType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改订单类型;
	case C2CCMD_MOD_ORDERTYPE:
	{
		Mod_OrderType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询订单类型;
	case C2CCMD_QRY_ORDERTYPE:
	{
		nResult = Ask_OrderType(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求开单;
	case C2CCMD_NEW_ORDERINFO:
	{
		New_OrderInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除订单;
	case C2CCMD_DEL_ORDERINFO:
	{
		Del_OrderInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改订单;
	case C2CCMD_MOD_ORDERINFO:
	{
		Mod_OrderInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	case C2CCMD_MOD_ORDERINFO2:
	{
		Mod_OrderInfo2(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询订单;
	case C2CCMD_QRY_ORDERINFO:
	{
		nResult = Ask_OrderInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求添加订单套餐项;
	case C2CCMD_NEW_ORDERPACKAGEITEM:
	{
		New_OrderPackageItem(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	case C2CCMD_NEW_ORDERPACKAGEITEM2:
	{
		New_OrderPackageItem2(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求删除订单套餐项;
	case C2CCMD_DEL_ORDERPACKAGEITEM:
	{
		Del_OrderPackageItem(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改订单套餐项;
	case C2CCMD_MOD_ORDERPACKAGEITEM:
	{
		Mod_OrderPackageItem(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求查询订单套餐项;
	case C2CCMD_QRY_ORDERPACKAGEITEM:
	{
		nResult = Ask_OrderPackageItem(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 客户端请求修改影楼信息;
	case C2CCMD_NEW_STUDIOINFO:
	{
		New_StudioInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改影楼信息;
	case C2CCMD_DEL_STUDIOINFO:
	{
		Del_StudioInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改影楼信息;
	case C2CCMD_MOD_STUDIOINFO:
	{
		Mod_StudioInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 客户端请求修改影楼信息;
	case C2CCMD_QRY_STUDIOINFO:
	{
		nResult = Ask_StudioInfo(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 添加订单景点信息;
	case C2CCMD_NEW_ORDERSCENERY:
	{
		New_OrderScenery(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 删除订单景点信息;
	case C2CCMD_DEL_ORDERSCENERY:
	{
		Del_OrderScenery(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	case C2CCMD_DEL_ORDERSCENERY2:
	{
		Del_OrderScenery2(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 修改订单景点信息;
	case C2CCMD_MOD_ORDERSCENERY:
	{
		Mod_OrderScenery(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 查询订单景点信息;
	case C2CCMD_QRY_ORDERSCENERY:
	{
		nResult = Ask_OrderScenery(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
		if (nResult != HR_IGNORE)
			return nResult;
	}
	break;
	// 获取订单序号;
	case C2CCMD_GET_ORDER_SERIALNUMBER:
	{
		Ask_OrderSerialNum(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	// 获取打印序号;
	case C2CCMD_GET_PRINT_SERIALNUMBER:
	{
		Ask_PrintSerialNum(dwConnID, pData, iLength, thepackage, pSendData, dwSendLen);
	}
	break;
	//////////////////////////////////////////////////////////////////////////
	default:
		break;
	}

	BOOL bSendResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
	if (pSendData)
		delete[]pSendData;

	return bSendResult ? HR_OK : HR_ERROR;
}

En_HP_HandleResult CServerPtr::OnClose(HP_CONNID dwConnID, En_HP_SocketOperation enOperation, int iErrorCode)
{
	// 移除登录的用户信息;
	COnlineUser::GetInstance()->EraseOnlineUser(dwConnID);

	iErrorCode == SE_OK ? ::PostOnClose(dwConnID) : ::PostOnError(dwConnID, enOperation, iErrorCode);

	return HR_OK;
}

En_HP_HandleResult CServerPtr::OnShutdown()
{
	::PostOnShutdown();

	return HR_OK;
}

//////////////////////////////////////////////////////////////////////////
void CServerPtr::Req_Login(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	if (COnlineUser::GetInstance()->IsAccountExist(thepackage.szStudioId, thepackage.szAccount) == -1)
	{// 用户没在线;
		// 查询数据库是否存在用户;
		INT nRet = USER_NULL;
		CUserDetail tagUserDetail;
		nRet = g_pODBCPool->QueryUserDetail(thepackage.szStudioId, thepackage.szAccount, thepackage.szPassword, &tagUserDetail);
		if (nRet == USER_LOGIN)
		{
			CMemFile mf;
			CArchive ar(&mf, CArchive::store);
			tagUserDetail.Serialize(ar);
			ar.Close();

			DWORD dwArchive = mf.GetLength();
			dwSendLen = sizeof(TheProPackage) - 2 + dwArchive;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_ONESELF;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = dwArchive;
			pPackage->dwReserve = USER_LOGIN;

			BYTE *pMf = mf.Detach();
			memcpy(pPackage->byBody, pMf, dwArchive);
			if (pMf)
				delete pMf;
			// 记录在线用户;
			COnlineUser::GetInstance()->InsertOnlineUser(dwConnID, thepackage.szStudioId, thepackage.szAccount);
		}
		else
		{
			dwSendLen = sizeof(TheProPackage);
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_ONESELF;
			pPackage->nCmd = C2CCMD_REQ_LOGIN;
			pPackage->nDataLen = 0;
			pPackage->dwReserve = nRet;
			OutputDebugString(_T("用户密码不对\n"));
		}
	}
	else
	{
		dwSendLen = sizeof(TheProPackage);
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = C2CCMD_REQ_LOGIN;
		pPackage->nDataLen = 0;
		pPackage->dwReserve = USER_HAVE_LOGIN;
		OutputDebugString(_T("用户已登录\n"));
	}
}

void CServerPtr::Req_LogOut(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{

}

void CServerPtr::New_Department(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CAddDepartment tagAddDepartment;
	tagAddDepartment.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL;
	strSQL.Format(_T("INSERT INTO [DepartmentInfo](")
		_T("[StudioID], [DepartmentName], [DepartmentNote]) values ('%s', '%s', '%s')"),
		thepackage.szStudioId, tagAddDepartment.m_strDepartmentName, tagAddDepartment.m_strDepartmentNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_Department(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CAddDepartment tagAddDepartment;
	tagAddDepartment.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL;
	strSQL.Format(_T("DELETE FROM [DepartmentInfo] WHERE [StudioID] = '%s' and [DepartmentName] = '%s' "), thepackage.szStudioId, tagAddDepartment.m_strDepartmentName);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_Department(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{

}

EnHandleResult CServerPtr::Ask_Department(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList tagDpmList;
	INT nRet = g_pODBCPool->QueryDepartmentInfo(thepackage.szStudioId, &tagDpmList);

	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagDpmList.Serialize(ar);
	ar.Close();

	// 删除列表对象;
	POSITION pos = tagDpmList.GetHeadPosition();
	while (pos)
	{
		CDepartmentInfoObj *pdpmObj = (CDepartmentInfoObj*)tagDpmList.GetNext(pos);
		if (pdpmObj)
			delete pdpmObj;
	}
	tagDpmList.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nRet;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nRet;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);

		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 员工;
void CServerPtr::New_StaffInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CStaffInfoObj tagStaffInfo;
	tagStaffInfo.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [StaffInfo](")
		_T("[StudioID],")
		_T("[StaffSN],")
		_T("[StaffName],")
		_T("[StaffGender],")
		_T("[StaffAddress],")
		_T("[StaffOffice],")
		_T("[StaffBirthday],")
		_T("[StaffPhone],")
		_T("[StaffNote]) ")
		_T("VALUES ('%s','%s', '%s', %d, '%s','%s','%s','%s','%s')"),
		thepackage.szStudioId,
		tagStaffInfo.m_StaffSN,
		tagStaffInfo.m_StaffName,
		tagStaffInfo.m_StaffGender,
		tagStaffInfo.m_StaffAddress,
		tagStaffInfo.m_StaffOffice,
		tagStaffInfo.m_StaffBirthday,
		tagStaffInfo.m_StaffPhone,
		tagStaffInfo.m_StaffNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_StaffInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CString strSQL = _T("");
	strSQL.Format(_T("DELETE FROM [StaffInfo] WHERE [StudioID] = '%s' and [AutoID] = %d"), thepackage.szStudioId, thepackage.dwReserve);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_StaffInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CStaffInfoObj tagStaffObj;
	tagStaffObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [StaffInfo] SET ")
		_T("[StaffName] = '%s',")
		_T("[StaffGender] = %d, ")
		_T("[StaffAddress] = '%s',")
		_T("[StaffOffice] = '%s',")
		_T("[StaffBirthday] = '%s',")
		_T("[StaffPhone] = '%s',")
		_T("[StaffStatus] = %d,")
		_T("[StaffNote] = '%s' ")
		_T("WHERE [StudioID] = '%s' AND [AutoID] = %d"),
		tagStaffObj.m_StaffName,
		tagStaffObj.m_StaffGender,
		tagStaffObj.m_StaffAddress,
		tagStaffObj.m_StaffOffice,
		tagStaffObj.m_StaffBirthday,
		tagStaffObj.m_StaffPhone,
		tagStaffObj.m_StaffStatus,
		tagStaffObj.m_StaffNote,
		thepackage.szStudioId, tagStaffObj.m_AutoID);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_StaffInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList tagStaffArray;
	INT nCount = g_pODBCPool->QueryStaffInfo(thepackage.szStudioId, &tagStaffArray);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagStaffArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagStaffArray.GetHeadPosition();
	while (pos)
	{
		CStaffInfoObj *pStaffObj = (CStaffInfoObj*)tagStaffArray.GetNext(pos);
		if (pStaffObj)
			delete pStaffObj;
	}
	tagStaffArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 用户;
void CServerPtr::New_UerInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CUserInfoObj tagUserInfoObj;
	tagUserInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [UserInfo] (")
		_T("[StudioID],[StaffSN],[UserAccount],[UserPassword],[UserNickName],[UserLevel],[UserRights],[UserEnable])")
		_T(" VALUES ('%s','%s','%s','%s','%s',%d,'%s',%d)"),
		thepackage.szStudioId,
		tagUserInfoObj.m_StaffSN,
		tagUserInfoObj.m_UserAccount,
		tagUserInfoObj.m_UserPassword,
		tagUserInfoObj.m_UserNickName,
		tagUserInfoObj.m_UserLevel,
		tagUserInfoObj.m_UserRights, tagUserInfoObj.m_UserEnable);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}
void CServerPtr::Del_UerInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR szUserAccount[17] = { 0 };	// 注：长度16是数据库中设定的长度;
	memcpy(szUserAccount, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CString strSQL;
	strSQL.Format(_T("DELETE FROM [UserInfo] WHERE [StudioID] = '%s' and [UserAccount] = '%s' "), thepackage.szStudioId, szUserAccount);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_UerInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CUserInfoObj tagUserInfoObj;
	tagUserInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [UserInfo] SET ")
		_T("[StaffSN] = '%s',")
		_T("[UserPassword] = '%s',")
		_T("[UserNickName] = '%s',")
		_T("[UserLevel] = %d,")
		_T("[UserRights] = '%s',")
		_T("[UserEnable] = %d ")
		_T("WHERE [StudioID] = '%s' AND [UserAccount] = '%s'"),
		tagUserInfoObj.m_StaffSN,
		tagUserInfoObj.m_UserPassword,
		tagUserInfoObj.m_UserNickName,
		tagUserInfoObj.m_UserLevel,
		tagUserInfoObj.m_UserRights,
		tagUserInfoObj.m_UserEnable,
		thepackage.szStudioId, tagUserInfoObj.m_UserAccount);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_UerInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{

	CObList tagUserInfoArray;
	INT nCount = g_pODBCPool->QueryUserInfo(thepackage.szStudioId, &tagUserInfoArray);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagUserInfoArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagUserInfoArray.GetHeadPosition();
	while (pos)
	{
		CUserInfoObj *pUserObj = (CUserInfoObj*)tagUserInfoArray.GetNext(pos);
		if (pUserObj)
			delete pUserObj;
	}
	tagUserInfoArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 商品类型;
void CServerPtr::New_ProductType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CProductTypeObj tagProductTypeObj;
	tagProductTypeObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [ProductType] ([StudioID],[ProductTypeName],[ProductTypeNote]) VALUES ('%s','%s','%s')"),
		thepackage.szStudioId, tagProductTypeObj.m_ProductTypeName, tagProductTypeObj.m_ProductTypeNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_ProductType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR szProductTypeName[17] = { 0 };	// 注：长度16是数据库中设定的长度;
	memcpy(szProductTypeName, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CString strSQL;
	strSQL.Format(_T("DELETE FROM [ProductType] WHERE [StudioID] = '%s' and [ProductTypeName] = '%s' "), thepackage.szStudioId, szProductTypeName);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_ProductType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CProductTypeObj tagProductTypeObj;
	tagProductTypeObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [ProductType] SET [ProductTypeNote] = '%s' WHERE [StudioID] = '%s' AND [ProductTypeName] = '%s'"),
		tagProductTypeObj.m_ProductTypeNote, thepackage.szStudioId, tagProductTypeObj.m_ProductTypeName);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_ProductType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList tagProductTypeArray;
	INT nCount = g_pODBCPool->QueryProductType(thepackage.szStudioId, &tagProductTypeArray);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagProductTypeArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagProductTypeArray.GetHeadPosition();
	while (pos)
	{
		CProductTypeObj *pProductType = (CProductTypeObj*)tagProductTypeArray.GetNext(pos);
		if (pProductType)
			delete pProductType;
	}
	tagProductTypeArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 商品信息;
void CServerPtr::New_ProductInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CProductInfoObj tagProductInfoObj;
	tagProductInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [ProductInfo] (")
		_T("[StudioID],")
		_T("[ProductSN],")
		_T("[ProductName],")
		_T("[ProductCost],")
		_T("[ProductPrice],")
		_T("[ProductTypes],")
		_T("[ProductUnit],")
		_T("[ProductShelves],")
		_T("[ProductNote]) ")
		_T("VALUES ('%s','%s','%s',%lf,%lf,'%s','%s',%d,'%s')"),
		thepackage.szStudioId,
		tagProductInfoObj.m_ProductSN,
		tagProductInfoObj.m_ProductName,
		tagProductInfoObj.m_ProductCost,
		tagProductInfoObj.m_ProductPrice,
		tagProductInfoObj.m_ProductTypes,
		tagProductInfoObj.m_ProductUnit,
		tagProductInfoObj.m_ProductShelves, tagProductInfoObj.m_ProductNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_ProductInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CString strSQL;
	strSQL.Format(_T("DELETE FROM [ProductInfo] WHERE [StudioID] = '%s' and [AutoID] = %d "), thepackage.szStudioId, thepackage.dwReserve);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_ProductInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CProductInfoObj tagProductInfoObj;
	tagProductInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [ProductInfo] SET ")
		_T("[ProductSN] = '%s',")
		_T("[ProductName] = '%s',")
		_T("[ProductCost] = %lf,")
		_T("[ProductPrice] = %lf,")
		_T("[ProductTypes] = '%s',")
		_T("[ProductUnit] = '%s',")
		_T("[ProductShelves] = %d,")
		_T("[ProductNote] = '%s' ")
		_T("WHERE [StudioID] = '%s' AND [AutoID] = %d"),
		tagProductInfoObj.m_ProductSN,
		tagProductInfoObj.m_ProductName,
		tagProductInfoObj.m_ProductCost,
		tagProductInfoObj.m_ProductPrice,
		tagProductInfoObj.m_ProductTypes,
		tagProductInfoObj.m_ProductUnit,
		tagProductInfoObj.m_ProductShelves,
		tagProductInfoObj.m_ProductNote,
		thepackage.szStudioId, tagProductInfoObj.m_AutoID);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_ProductInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList tagProductInfoArray;
	INT nCount = g_pODBCPool->QueryProductInfo(thepackage.szStudioId, &tagProductInfoArray);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagProductInfoArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagProductInfoArray.GetHeadPosition();
	while (pos)
	{
		CProductInfoObj *pProductInfo = (CProductInfoObj*)tagProductInfoArray.GetNext(pos);
		if (pProductInfo)
			delete pProductInfo;
	}
	tagProductInfoArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 景点;
void CServerPtr::New_Scenery(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CSceneryInfoObj tagSceneryInfoObj;
	tagSceneryInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [SceneryInfo](")
		_T("[StudioID],")
		_T("[ScenerySN],")
		_T("[SceneryName],")
		_T("[SceneryCostPrice],")
		_T("[ScenerySalePrice],")
		_T("[SceneryShelves],")
		_T("[SceneryNote])VALUES('%s','%s','%s',%lf,%lf,%d,'%s')"),
		thepackage.szStudioId,
		tagSceneryInfoObj.m_ScenerySN,
		tagSceneryInfoObj.m_SceneryName,
		tagSceneryInfoObj.m_SceneryCostPrice,
		tagSceneryInfoObj.m_ScenerySalePrice,
		tagSceneryInfoObj.m_SceneryShelves,
		tagSceneryInfoObj.m_SceneryNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_Scenery(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CString strSQL;
	strSQL.Format(_T("DELETE FROM [SceneryInfo] WHERE [StudioID] = '%s' and [AutoID] = %d "), thepackage.szStudioId, thepackage.dwReserve);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_Scenery(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CSceneryInfoObj tagSceneryInfoObj;
	tagSceneryInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [SceneryInfo] SET ")
		_T("[ScenerySN] = '%s',")
		_T("[SceneryName] = '%s',")
		_T("[SceneryCostPrice] = %lf,")
		_T("[ScenerySalePrice] = %lf,")
		_T("[SceneryShelves] = %d,")
		_T("[SceneryNote] = '%s' ")
		_T("WHERE [StudioID] = '%s' AND [AutoID] = %d"),
		tagSceneryInfoObj.m_ScenerySN,
		tagSceneryInfoObj.m_SceneryName,
		tagSceneryInfoObj.m_SceneryCostPrice,
		tagSceneryInfoObj.m_ScenerySalePrice,
		tagSceneryInfoObj.m_SceneryShelves,
		tagSceneryInfoObj.m_SceneryNote,
		thepackage.szStudioId, tagSceneryInfoObj.m_AutoID);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_Scenery(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList tagSceneryInfoArray;
	INT nCount = g_pODBCPool->QuerySceneryInfo(thepackage.szStudioId, &tagSceneryInfoArray);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagSceneryInfoArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagSceneryInfoArray.GetHeadPosition();
	while (pos)
	{
		CSceneryInfoObj *pSceneryInfo = (CSceneryInfoObj*)tagSceneryInfoArray.GetNext(pos);
		if (pSceneryInfo)
			delete pSceneryInfo;
	}
	tagSceneryInfoArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 套餐类型;
void CServerPtr::New_PackageType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CPackageTypeObj tagPackageTypeObj;
	tagPackageTypeObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [PackageType]([StudioID],[PackageTypesName],[PackageTypesNote])VALUES('%s','%s','%s')"),
		thepackage.szStudioId, tagPackageTypeObj.m_PackageTypesName, tagPackageTypeObj.m_PackageTypesNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_PackageType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR szPackageTypeName[17] = { 0 };	// 注：长度16是数据库中设定的长度;
	memcpy(szPackageTypeName, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CString strSQL;
	strSQL.Format(_T("DELETE FROM [PackageType] WHERE [StudioID] = '%s' and [PackageTypesName] = '%s' "), thepackage.szStudioId, szPackageTypeName);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_PackageType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CPackageTypeObj tagPackageTypeObj;
	tagPackageTypeObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [PackageType] SET [PackageTypesNote] = '%s' WHERE [StudioID] = '%s' AND [PackageTypesName] = '%s'"),
		tagPackageTypeObj.m_PackageTypesNote, thepackage.szStudioId, tagPackageTypeObj.m_PackageTypesName);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_PackageType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList tagPackageTypeArray;
	INT nCount = g_pODBCPool->QueryPackageType(thepackage.szStudioId, &tagPackageTypeArray);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagPackageTypeArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagPackageTypeArray.GetHeadPosition();
	while (pos)
	{
		CPackageTypeObj *pPackageType = (CPackageTypeObj*)tagPackageTypeArray.GetNext(pos);
		if (pPackageType)
			delete pPackageType;
	}
	tagPackageTypeArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 套餐信息;
void CServerPtr::New_PackageInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CPackageInfoObj tagPackageInfoObj;
	tagPackageInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [PackageInfo]")
		_T("([StudioID]")
		_T(", [PackageSN]")
		_T(", [PackageTypes]")
		_T(", [PackageName]")
		_T(", [PackageCostPrice]")
		_T(", [PackageSalesPrice]")
		_T(", [PackageAlbum]")
		_T(", [PackageFilm]")
		_T(", [PackageShelves]")
		_T(", [PackageNote])")
		_T("VALUES('%s', '%s', '%s', '%s', '%lf', '%lf', '%d', '%d', '%d', '%s')"),
		thepackage.szStudioId, tagPackageInfoObj.m_PackageSN, tagPackageInfoObj.m_PackageTypes, tagPackageInfoObj.m_PackageName,
		tagPackageInfoObj.m_PackageCostPrice, tagPackageInfoObj.m_PackageSalesPrice, tagPackageInfoObj.m_PackageAlbum, tagPackageInfoObj.m_PackageFilm,
		tagPackageInfoObj.m_PackageShelves, tagPackageInfoObj.m_PackageNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_PackageInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CString strSQL;
	strSQL.Format(_T("DELETE FROM [PackageInfo] WHERE [StudioID] = '%s' and [AutoID] = %d "), thepackage.szStudioId, thepackage.dwReserve);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_PackageInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CPackageInfoObj tagPackageInfoObj;
	tagPackageInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [PackageInfo] SET ")
		_T(" [PackageSN] = '%s',")
		_T(" [PackageTypes] = '%s',")
		_T(" [PackageName] = '%s',")
		_T(" [PackageCostPrice] = '%lf',")
		_T(" [PackageSalesPrice] = '%lf',")
		_T(" [PackageAlbum] = '%d',")
		_T(" [PackageFilm] = '%d',")
		_T(" [PackageShelves] = '%d',")
		_T(" [PackageNote] = '%s' WHERE [StudioID] = '%s' AND [AutoID] = %d"),
		tagPackageInfoObj.m_PackageSN,
		tagPackageInfoObj.m_PackageTypes,
		tagPackageInfoObj.m_PackageName,
		tagPackageInfoObj.m_PackageCostPrice,
		tagPackageInfoObj.m_PackageSalesPrice,
		tagPackageInfoObj.m_PackageAlbum,
		tagPackageInfoObj.m_PackageFilm,
		tagPackageInfoObj.m_PackageShelves,
		tagPackageInfoObj.m_PackageNote,
		thepackage.szStudioId, tagPackageInfoObj.m_AutoID);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_PackageInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList tagPackageInfoArray;
	INT nCount = g_pODBCPool->QueryPackageInfo(thepackage.szStudioId, &tagPackageInfoArray);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagPackageInfoArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagPackageInfoArray.GetHeadPosition();
	while (pos)
	{
		CPackageInfoObj *pPackageInfo = (CPackageInfoObj*)tagPackageInfoArray.GetNext(pos);
		if (pPackageInfo)
			delete pPackageInfo;
	}
	tagPackageInfoArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 套餐项目信息;
void CServerPtr::New_PackageItem(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CPackageItemsObj tagPackageItemsObj;
	tagPackageItemsObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [PackageItems](")
		_T("[StudioID],")
		_T("[PackageSN],")
		_T("[PackageItemSN],")
		_T("[PackageItemName],")
		_T("[PackageItemType],")
		_T("[PackageItemCount],")
		_T("[PackageItemNote]) VALUES ('%s','%s','%s','%s','%s',%d,'%s')"),
		thepackage.szStudioId,
		tagPackageItemsObj.m_PackageSN,
		tagPackageItemsObj.m_PackageItemSN,
		tagPackageItemsObj.m_PackageItemName,
		tagPackageItemsObj.m_PackageItemType,
		tagPackageItemsObj.m_PackageItemCount,
		tagPackageItemsObj.m_PackageItemNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::New_PackageItem2(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CObList Objlist;
	Objlist.Serialize(ar);
	ar.Close();
	mf.Detach();

	// 更新所有操作;
	BOOL bRet = TRUE;
	CString strSQL = _T("");
	POSITION pos = Objlist.GetHeadPosition();
	while (pos)
	{
		CPackageItemsObj *pObj = (CPackageItemsObj*)Objlist.GetNext(pos);
		switch (pObj->m_byOpType)
		{
		case OPT_NEW:	// 新记录;
		{
			strSQL.Format(_T("INSERT INTO [PackageItems](")
				_T("[StudioID],")
				_T("[PackageSN],")
				_T("[PackageItemSN],")
				_T("[PackageItemName],")
				_T("[PackageItemType],")
				_T("[PackageItemCount],")
				_T("[PackageItemNote]) VALUES ('%s','%s','%s','%s','%s',%d,'%s')"),
				thepackage.szStudioId,
				pObj->m_PackageSN,
				pObj->m_PackageItemSN,
				pObj->m_PackageItemName,
				pObj->m_PackageItemType,
				pObj->m_PackageItemCount,
				pObj->m_PackageItemNote);
		}
		break;
		case OPT_ORG | OPT_DEL:	// 原数据删除;
		{
			strSQL.Format(_T("DELETE FROM [PackageItems] WHERE StudioID = '%s' AND PackageSN = '%s' AND PackageItemName = '%s' AND PackageItemType = '%s'"),
				thepackage.szStudioId, pObj->m_PackageSN, pObj->m_PackageItemName, pObj->m_PackageItemType);
		}
		break;
		case OPT_ORG | OPT_UPD:	// 原数据更新;
		{
			strSQL.Format(_T("UPDATE [PackageItems] SET ")
				_T("[PackageItemCount] = %d,")
				_T("[PackageItemNote] = '%s' WHERE [StudioID] = '%s' AND PackageSN = '%s' AND PackageItemSN = '%s' AND PackageItemName = '%s' AND PackageItemType = '%s'"),
				pObj->m_PackageItemCount,
				pObj->m_PackageItemNote,
				thepackage.szStudioId,
				pObj->m_PackageSN,
				pObj->m_PackageItemSN,
				pObj->m_PackageItemName,
				pObj->m_PackageItemType);
		}
		break;
		default:
			strSQL.Empty();
			break;
		}

		if (!strSQL.IsEmpty())
		{
			if (!g_pODBCPool->ExecuteSQL(strSQL))
				bRet = FALSE;
		}
	}

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_PackageItem(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CString strSQL;
	strSQL.Format(_T("DELETE FROM [PackageItems] WHERE [StudioID] = '%s' and [AutoID] = %d "), thepackage.szStudioId, thepackage.dwReserve);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_PackageItem(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CPackageItemsObj tagPackageItemsObj;
	tagPackageItemsObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [PackageItems] SET ")
		_T("[PackageSN] = '%s',")
		_T("[PackageItemSN] = '%s',")
		_T("[PackageItemName] = '%s',")
		_T("[PackageItemType] = '%s',")
		_T("[PackageItemCount] = %d,")
		_T("[PackageItemNote] = '%s' WHERE [StudioID] = '%s' AND [AutoID] = %d"),
		tagPackageItemsObj.m_PackageSN,
		tagPackageItemsObj.m_PackageItemSN,
		tagPackageItemsObj.m_PackageItemName,
		tagPackageItemsObj.m_PackageItemType,
		tagPackageItemsObj.m_PackageItemCount,
		tagPackageItemsObj.m_PackageItemNote,
		thepackage.szStudioId,
		tagPackageItemsObj.m_AutoID);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_PackageItem(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList tagPackageItemsArray;
	INT nCount = g_pODBCPool->QueryPackageItems(thepackage.szStudioId, &tagPackageItemsArray);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagPackageItemsArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagPackageItemsArray.GetHeadPosition();
	while (pos)
	{
		CPackageItemsObj *pPackageItems = (CPackageItemsObj*)tagPackageItemsArray.GetNext(pos);
		if (pPackageItems)
			delete pPackageItems;
	}
	tagPackageItemsArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

EnHandleResult CServerPtr::Ask_PackageItemDetail(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR szPackageSN[17] = { 0 };	// 注：长度16是数据库中设定的长度;
	if (nlen)
		memcpy(szPackageSN, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CObList Objlist;
	INT nCount = g_pODBCPool->QueryPackageItemsDetail(thepackage.szStudioId, szPackageSN, &Objlist);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	Objlist.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = Objlist.GetHeadPosition();
	while (pos)
	{
		CPackageItemDetailObj *pObj = (CPackageItemDetailObj*)Objlist.GetNext(pos);
		if (pObj)
			delete pObj;
	}
	Objlist.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

EnHandleResult CServerPtr::Ask_PackageItemView(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList Objlist;
	INT nCount = g_pODBCPool->QueryPackageItemsView(thepackage.szStudioId, &Objlist);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	Objlist.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = Objlist.GetHeadPosition();
	while (pos)
	{
		CPackageItemViewObj *pObj = (CPackageItemViewObj*)Objlist.GetNext(pos);
		if (pObj)
			delete pObj;
	}
	Objlist.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 顾客信息;
void CServerPtr::New_CustomerInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CCustomerInfoObj tagCustomerInfoObj;
	tagCustomerInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [CustomerInfo](")
		_T("[StudioID],")
		_T("[CustomerID],")
		_T("[CustomerName],")
		_T("[CustomerGender],")
		_T("[CustomerPhone],")
		_T("[CustomerQQ],")
		_T("[CustomerWX],")
		_T("[CustomerEMail],")
		_T("[CustomerFrom],")
		_T("[CustomerAddress],")
		_T("[CustomerBirthday],")
		_T("[CustomerNote])")
		_T("VALUES('%s', '%s', '%s', %d, '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s')"),
		thepackage.szStudioId,
		tagCustomerInfoObj.m_CustomerID,
		tagCustomerInfoObj.m_CustomerName,
		tagCustomerInfoObj.m_CustomerGender,
		tagCustomerInfoObj.m_CustomerPhone,
		tagCustomerInfoObj.m_CustomerQQ,
		tagCustomerInfoObj.m_CustomerWX,
		tagCustomerInfoObj.m_CustomerEMail,
		tagCustomerInfoObj.m_CustomerFrom,
		tagCustomerInfoObj.m_CustomerAddress,
		tagCustomerInfoObj.m_CustomerBirthday,
		tagCustomerInfoObj.m_CustomerNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_CustomerInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR szCustomerID[33] = { 0 };	// 注：长度16是数据库中设定的长度;
	memcpy(szCustomerID, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CString strSQL;
	strSQL.Format(_T("DELETE FROM [CustomerInfo] WHERE [StudioID] = '%s' AND [CustomerID] = '%s' "), thepackage.szStudioId, szCustomerID);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_CustomerInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CCustomerInfoObj tagCustomerInfoObj;
	tagCustomerInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [CustomerInfo] SET ")
		_T("[CustomerName] = '%s', ")
		_T("[CustomerGender] = %d,")
		_T("[CustomerPhone] = '%s',")
		_T("[CustomerQQ] = '%s',")
		_T("[CustomerWX] = '%s',")
		_T("[CustomerEMail] = '%s',")
		_T("[CustomerFrom] = '%s',")
		_T("[CustomerAddress] = '%s',")
		_T("[CustomerBirthday] = '%s',")
		_T("[CustomerNote] = '%s' ")
		_T("WHERE [StudioID] = '%s' AND [CustomerID] = '%s'"),
		tagCustomerInfoObj.m_CustomerName,
		tagCustomerInfoObj.m_CustomerGender,
		tagCustomerInfoObj.m_CustomerPhone,
		tagCustomerInfoObj.m_CustomerQQ,
		tagCustomerInfoObj.m_CustomerWX,
		tagCustomerInfoObj.m_CustomerEMail,
		tagCustomerInfoObj.m_CustomerFrom,
		tagCustomerInfoObj.m_CustomerAddress,
		tagCustomerInfoObj.m_CustomerNote,
		thepackage.szStudioId,
		tagCustomerInfoObj.m_CustomerID);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_CustomerInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR *pFilter = NULL;
	if (nlen != 0)
	{
		pFilter = new TCHAR[nlen];
		memcpy(pFilter, pReceiveData + sizeof(TheProPackage) - 2, nlen);
	}

	CObList tagCustomerInfoArray;
	INT nCount = g_pODBCPool->QueryCustomerInfo(thepackage.szStudioId, &tagCustomerInfoArray, pFilter);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagCustomerInfoArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagCustomerInfoArray.GetHeadPosition();
	while (pos)
	{
		CCustomerInfoObj *pCustomerInfoObj = (CCustomerInfoObj*)tagCustomerInfoArray.GetNext(pos);
		if (pCustomerInfoObj)
			delete pCustomerInfoObj;
	}
	tagCustomerInfoArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 顾客来源;
void CServerPtr::New_CustomerFrom(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CCustomerFromObj tagCustomerFromObj;
	tagCustomerFromObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [dbo].[CustomerFrom]([StudioID],[CustomerFrom],[CustomerFromNote])VALUES('%s','%s','%s')"),
		thepackage.szStudioId, tagCustomerFromObj.m_CustomerFrom, tagCustomerFromObj.m_CustomerFromNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_CustomerFrom(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR szCustomerFrom[17] = { 0 };	// 注：长度16是数据库中设定的长度;
	memcpy(szCustomerFrom, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CString strSQL;
	strSQL.Format(_T("DELETE FROM [dbo].[CustomerFrom] WHERE [StudioID] = '%s' and [CustomerFrom] = '%s' "), thepackage.szStudioId, szCustomerFrom);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_CustomerFrom(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CCustomerFromObj tagCustomerFromObj;
	tagCustomerFromObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [dbo].[CustomerFrom] SET [CustomerFromNote] = '%s' WHERE [StudioID] = '%s' AND [CustomerFrom] = '%s'"),
		tagCustomerFromObj.m_CustomerFromNote, thepackage.szStudioId, tagCustomerFromObj.m_CustomerFrom);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_CustomerFrom(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList tagCustomerFromArray;
	INT nCount = g_pODBCPool->QueryCustomerType(thepackage.szStudioId, &tagCustomerFromArray);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagCustomerFromArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagCustomerFromArray.GetHeadPosition();
	while (pos)
	{
		CCustomerFromObj *pCustomerFromObj = (CCustomerFromObj*)tagCustomerFromArray.GetNext(pos);
		if (pCustomerFromObj)
			delete pCustomerFromObj;
	}
	tagCustomerFromArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 订单类型;
void CServerPtr::New_OrderType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	COrderTypeObj tagOrderTypeObj;
	tagOrderTypeObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [OrderType]([StudioID],[OrderTypesName],[OrderTypesNote]) VALUES ('%s','%s','%s')"),
		thepackage.szStudioId, tagOrderTypeObj.m_OrderTypesName, tagOrderTypeObj.m_OrderTypesNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_OrderType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR szOrderTypeName[9] = { 0 };	// 注：长度16是数据库中设定的长度;
	memcpy(szOrderTypeName, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CString strSQL;
	strSQL.Format(_T("DELETE FROM [OrderType] WHERE [StudioID] = '%s' and [OrderTypesName] = '%s' "), thepackage.szStudioId, szOrderTypeName);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_OrderType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	COrderType tagOrderTypeObj;
	tagOrderTypeObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [OrderType] SET [OrderTypesNote] = '%s' WHERE [StudioID] = '%s' AND [OrderTypesName] = '%s')"),
		tagOrderTypeObj.m_OrderTypesNote, thepackage.szStudioId, tagOrderTypeObj.m_OrderTypesName);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_OrderType(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CObList tagOrderTypeArray;
	INT nCount = g_pODBCPool->QueryOrderType(thepackage.szStudioId, &tagOrderTypeArray);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagOrderTypeArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagOrderTypeArray.GetHeadPosition();
	while (pos)
	{
		COrderTypeObj *pOrderTypeObj = (COrderTypeObj*)tagOrderTypeArray.GetNext(pos);
		if (pOrderTypeObj)
			delete pOrderTypeObj;
	}
	tagOrderTypeArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 订单信息;
void CServerPtr::New_OrderInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	COrderInfoObj tagOrderInfoObj;
	tagOrderInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	INT nMaxId = Ask_OrderSerialNum(thepackage.szStudioId);
	tagOrderInfoObj.m_OrderNum.Format(_T("%s-%03d"), CTime::GetCurrentTime().Format(_T("%Y%m%d")), ++nMaxId);
	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [OrderInfo](")
		_T("[StudioID]")
		_T(",[OrderNum]")
		_T(",[CustomerFrom]")
		_T(",[CustomerName]")
		_T(",[CustomerGender]")
		_T(",[CustomerPhone]")
		_T(",[OrderAmountPaid]")
		_T(",[OrderSignPerson]")
		_T(",[OrderTypes]")
		_T(",[OrderSubsist]")
		_T(",[OrderPackageAlbum]")
		_T(",[OrderPackageFilm]")
		_T(",[OrderFinishStatus]")
		_T(",[OrderFinishTime]")
		_T(",[OrderGenerateDate]")
		_T(",[OrderSelectionStatus]")
		_T(",[OrderExraPhoto]")
		_T(",[OrderAdditionalAmount]")
		_T(",[OrderLateStageAmount]")
		_T(",[OrderPackageName]")
		_T(",[OrderPackageSales]")
		_T(",[OrderPackageType]")
		_T(",[OrderSelectionAppointment]")
		_T(",[OrderSelectionFinishDate]")
		_T(",[OrderNote]")
		_T(",[OrderSelectionNote])")
		_T("VALUES ('%s','%s','%s','%s',%d,'%s',%lf,'%s','%s',%lf,%d, %d, %d, '%s','%s',%d,%d,%lf,%lf,'%s',%lf,'%s','%s','%s','%s','%s')"),
		thepackage.szStudioId,
		tagOrderInfoObj.m_OrderNum,
		tagOrderInfoObj.m_CustomerFrom,
		tagOrderInfoObj.m_CustomerName,
		tagOrderInfoObj.m_CustomerGender,
		tagOrderInfoObj.m_CustomerPhone,
		tagOrderInfoObj.m_OrderAmountPaid,
		tagOrderInfoObj.m_OrderSignPerson,
		tagOrderInfoObj.m_OrderTypes,
		tagOrderInfoObj.m_OrderSubsist,
		tagOrderInfoObj.m_OrderPackageAlbum,
		tagOrderInfoObj.m_OrderPackageFilm,
		tagOrderInfoObj.m_OrderFinishStatus,
		tagOrderInfoObj.m_OrderFinishTime,
		tagOrderInfoObj.m_OrderGenerateDate,
		tagOrderInfoObj.m_OrderSelectionStatus,
		tagOrderInfoObj.m_OrderExtraPhoto,
		tagOrderInfoObj.m_OrderAdditionalAmount,
		tagOrderInfoObj.m_OrderLateStageAmount,
		tagOrderInfoObj.m_OrderPackageName,
		tagOrderInfoObj.m_OrderPackageSales,
		tagOrderInfoObj.m_OrderPackageType,
		tagOrderInfoObj.m_OrderSelectionAppointment,
		tagOrderInfoObj.m_OrderSelectionFinishDate,
		tagOrderInfoObj.m_OrderNote,
		tagOrderInfoObj.m_OrderSelectionNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_OrderInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR szOrderNum[25] = { 0 };	// 注：长度16是数据库中设定的长度;
	memcpy(szOrderNum, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CString strSQL;
	strSQL.Format(_T("DELETE FROM [OrderInfo] WHERE [StudioID] = '%s' and [OrderNum] = '%s' "), thepackage.szStudioId, szOrderNum);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_OrderInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	COrderInfoObj tagOrderInfoObj;
	tagOrderInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [OrderInfo]")
		_T("SET [CustomerFrom] = '%s'")
		_T(",[CustomerName] = '%s'")
		_T(",[CustomerGender] = %d")
		_T(",[CustomerPhone] = '%s'")
		_T(",[OrderAmountPaid] = %lf")
		_T(",[OrderSignPerson] = '%s'")
		_T(",[OrderTypes] = '%s'")
		_T(",[OrderSubsist] = %lf")
		_T(",[OrderFinishStatus] = %d")
		_T(",[OrderFinishTime] = '%s'")
		_T(",[OrderGenerateDate] = '%s'")
		_T(",[OrderSelectionStatus] = %d")
		_T(",[OrderExraPhoto] = %d")
		_T(",[OrderAdditionalAmount] = %lf")
		_T(",[OrderLateStageAmount] = %lf")
		_T(",[OrderPackageName] = '%s'")
		_T(",[OrderPackageSales] = %lf")
		_T(",[OrderPackageType] = '%s'")
		_T(",[OrderSelectionAppointment] = '%s'")
		_T(",[OrderSelectionFinishDate] = '%s'")
		_T(",[OrderNote] = '%s'")
		_T(",[OrderSelectionNote] = '%s'")
		_T(",[CustomerRequirements] = '%s'")
		_T("WHERE [StudioID] = '%s' AND [OrderNum] = '%s'"),
		tagOrderInfoObj.m_CustomerFrom,
		tagOrderInfoObj.m_CustomerName,
		tagOrderInfoObj.m_CustomerGender,
		tagOrderInfoObj.m_CustomerPhone,
		tagOrderInfoObj.m_OrderAmountPaid,
		tagOrderInfoObj.m_OrderSignPerson,
		tagOrderInfoObj.m_OrderTypes,
		tagOrderInfoObj.m_OrderSubsist,
		tagOrderInfoObj.m_OrderFinishStatus,
		tagOrderInfoObj.m_OrderFinishTime,
		tagOrderInfoObj.m_OrderGenerateDate,
		tagOrderInfoObj.m_OrderSelectionStatus,
		tagOrderInfoObj.m_OrderExtraPhoto,
		tagOrderInfoObj.m_OrderAdditionalAmount,
		tagOrderInfoObj.m_OrderLateStageAmount,
		tagOrderInfoObj.m_OrderPackageName,
		tagOrderInfoObj.m_OrderPackageSales,
		tagOrderInfoObj.m_OrderPackageType,
		tagOrderInfoObj.m_OrderSelectionAppointment,
		tagOrderInfoObj.m_OrderSelectionFinishDate,
		tagOrderInfoObj.m_OrderNote,
		tagOrderInfoObj.m_OrderSelectionNote,
		tagOrderInfoObj.m_CustomerRequirements,
		thepackage.szStudioId,
		tagOrderInfoObj.m_OrderNum);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}


void CServerPtr::Mod_OrderInfo2(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	COrderInfoObj tagOrderInfoObj;
	tagOrderInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [OrderInfo] SET ")
		_T("[OrderSelectionStatus] = %d")
		_T(",[OrderExraPhoto] = %d")
		_T(",[OrderAdditionalAmount] = %lf")
		_T(",[OrderLateStageAmount] = %lf")
		_T(",[OrderSelectionAppointment] = '%s'")
		_T(",[OrderSelectionFinishDate] = '%s'")
		_T(",[OrderSelectionNote] = '%s'")
		_T(",[CustomerRequirements] = '%s'")
		_T("WHERE [StudioID] = '%s' AND [OrderNum] = '%s'"),
		tagOrderInfoObj.m_OrderSelectionStatus,
		tagOrderInfoObj.m_OrderExtraPhoto,
		tagOrderInfoObj.m_OrderAdditionalAmount,
		tagOrderInfoObj.m_OrderLateStageAmount,
		tagOrderInfoObj.m_OrderSelectionAppointment,
		tagOrderInfoObj.m_OrderSelectionFinishDate,
		tagOrderInfoObj.m_OrderSelectionNote,
		tagOrderInfoObj.m_CustomerRequirements,
		thepackage.szStudioId,
		tagOrderInfoObj.m_OrderNum);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_OrderInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR *pFilter = new TCHAR[nlen];
	memcpy(pFilter, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CObList tagOrderInfoArray;
	INT nCount = g_pODBCPool->QueryOrderInfo(thepackage.szStudioId, &tagOrderInfoArray, pFilter);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagOrderInfoArray.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagOrderInfoArray.GetHeadPosition();
	while (pos)
	{
		COrderInfoObj *pOrderInfoObj = (COrderInfoObj*)tagOrderInfoArray.GetNext(pos);
		if (pOrderInfoObj)
			delete pOrderInfoObj;
	}
	tagOrderInfoArray.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	BYTE *pMf = mf.Detach();

#if 0		// 使用lzmar压缩数据比不压缩要慢更多;
	byte prop[5] = { 0 };
	size_t nPropSize = 5;

	size_t nDesLen = nArchive;
	BYTE *pDesData = new BYTE[nDesLen];

	int nRet = LzmaCompress(pDesData, &nDesLen, pMf, nArchive, prop, &nPropSize, 9, 1 << 24, 3, 0, 2, 32, 2);
	while (SZ_ERROR_OUTPUT_EOF == nRet)
	{//申请内存不足; 
		delete[]pDesData;
		nDesLen += nArchive;
		pDesData = new BYTE[nDesLen];
		nRet = LzmaCompress(pDesData, &nDesLen, pMf, nArchive, prop, &nPropSize, 9, (1 << 24), 3, 0, 2, 32, 2);
	}
	if (pMf)
		delete[]pMf;

	if ((nDesLen + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nDesLen;

		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nUnCompressLen = nArchive;
			pPackage->nDataLen = nDesLen;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byProp, prop, 5);
			memcpy(pPackage->byBody, pDesData + nDesLen - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pDesData)
					delete pDesData;
				return HR_ERROR;
			}
		}

		if (pDesData)
			delete pDesData;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nDesLen;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nUnCompressLen = nArchive;
		pPackage->nDataLen = nDesLen;
		pPackage->dwReserve = nCount;

		memcpy(pPackage->byProp, prop, 5);
		memcpy(pPackage->byBody, pDesData, nDesLen);
		if (pDesData)
			delete pDesData;
	}

#else
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;

		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}
#endif

	return HR_IGNORE;
}

// 订单套餐信息;
void CServerPtr::New_OrderPackageItem(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	COrderPackageItemsObj tagOrderItemsObj;
	tagOrderItemsObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [OrderPackageItems]")
		_T("([StudioID]")
		_T(",[OrderNum]")
		_T(",[PackageItemSN]")
		_T(",[PackageItemName]")
		_T(",[PackageItemType]")
		_T(",[PackageItemCost]")
		_T(",[PackageItemSales]")
		_T(",[PackageItemUnit]")
		_T(",[PackageItemCount]")
		_T(",[ItemRelatedPhotos]")
		_T(",[ItemNote])")
		_T("VALUES ('%s','%s','%s','%s','%s',%lf,%lf,'%s',%d,'%s','%s')"),
		thepackage.szStudioId,
		tagOrderItemsObj.m_OrderNum,
		tagOrderItemsObj.m_PackageItemSN,
		tagOrderItemsObj.m_PackageItemName,
		tagOrderItemsObj.m_PackageItemType,
		tagOrderItemsObj.m_PackageItemCost,
		tagOrderItemsObj.m_PackageItemSales,
		tagOrderItemsObj.m_PackageItemUnit,
		tagOrderItemsObj.m_PackageItemCount,
		tagOrderItemsObj.m_ItemRelatedPhotos,
		tagOrderItemsObj.m_ItemNote);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::New_OrderPackageItem2(IN HP_CONNID dwConnID, IN const BYTE * pReceiveData, IN INT nReceiveLength, IN TheProPackage & thepackage, OUT BYTE *& pSendData, OUT DWORD & dwSendLen)
{
	CMemFile mf;
	mf.Attach(const_cast<BYTE*>(pReceiveData) + sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CObList Objlist;
	Objlist.Serialize(ar);
	ar.Close();
	mf.Detach();

	// 更新所有操作;
	BOOL bRet = TRUE;
	BOOL bDeleted = FALSE;
	CString strSQL = _T("");
	POSITION pos = Objlist.GetHeadPosition();
	while (pos)
	{
		COrderPackageItemsObj *pObj = (COrderPackageItemsObj*)Objlist.GetNext(pos);
		if (!bDeleted)
		{
			strSQL.Format(_T("delete from [OrderPackageItems] where [StudioID] = '%s' and [OrderNum] = '%s'"), thepackage.szStudioId, pObj->m_OrderNum );
			g_pODBCPool->ExecuteSQL(strSQL);
			bDeleted = TRUE;
		}

		strSQL.Format(_T("INSERT INTO [OrderPackageItems]")
			_T("([StudioID]")
			_T(",[OrderNum]")
			_T(",[PackageItemSN]")
			_T(",[PackageItemName]")
			_T(",[PackageItemType]")
			_T(",[PackageItemCost]")
			_T(",[PackageItemSales]")
			_T(",[PackageItemUnit]")
			_T(",[PackageItemCount]")
			_T(",[ItemRelatedPhotos]")
			_T(",[ItemNote])")
			_T("VALUES ('%s','%s','%s','%s','%s',%lf,%lf,'%s',%d,'%s','%s')"),
			thepackage.szStudioId,
			pObj->m_OrderNum,
			pObj->m_PackageItemSN,
			pObj->m_PackageItemName,
			pObj->m_PackageItemType,
			pObj->m_PackageItemCost,
			pObj->m_PackageItemSales,
			pObj->m_PackageItemUnit,
			pObj->m_PackageItemCount,
			pObj->m_ItemRelatedPhotos,
			pObj->m_ItemNote);

		BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);
	}

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_OrderPackageItem(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CString strSQL;
	strSQL.Format(_T("DELETE FROM [OrderPackageItems] WHERE [StudioID] = '%s' and [AutoID] = '%s' "), thepackage.szStudioId, thepackage.dwReserve);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_OrderPackageItem(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	COrderPackageItemsObj tagOrderItemsObj;
	tagOrderItemsObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [OrderPackageItems]")
		_T("SET [PackageItemName] = '%s'")
		_T(",[PackageItemType] = '%s'")
		_T(",[PackageItemCost] = %lf")
		_T(",[PackageItemSales] = %lf")
		_T(",[PackageItemUnit] = '%s'")
		_T(",[PackageItemCount] = %d")
		_T(",[ItemRelatedPhotos] = '%s'")
		_T(",[ItemNote] = '%s'")
		_T("WHERE [StudioID] = '%s' AND [OrderNum] = '%s' AND [AutoID] = %d"),
		tagOrderItemsObj.m_PackageItemName,
		tagOrderItemsObj.m_PackageItemType,
		tagOrderItemsObj.m_PackageItemCost,
		tagOrderItemsObj.m_PackageItemSales,
		tagOrderItemsObj.m_PackageItemUnit,
		tagOrderItemsObj.m_PackageItemCount,
		tagOrderItemsObj.m_ItemRelatedPhotos,
		tagOrderItemsObj.m_ItemNote,
		thepackage.szStudioId,
		tagOrderItemsObj.m_OrderNum,
		tagOrderItemsObj.m_AutoID);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_OrderPackageItem(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR *pFilter = new TCHAR[nlen];
	memcpy(pFilter, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CObList tagObList;
	INT nCount = g_pODBCPool->QueryOrderPackageItems(thepackage.szStudioId, &tagObList, pFilter);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagObList.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagObList.GetHeadPosition();
	while (pos)
	{
		COrderPackageItemsObj *pOrderPackageItemsObj = (COrderPackageItemsObj*)tagObList.GetNext(pos);
		if (pOrderPackageItemsObj)
			delete pOrderPackageItemsObj;
	}
	tagObList.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 影楼信息;
void CServerPtr::New_StudioInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CStudioInfoObj tagStudioInfoObj;
	tagStudioInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	tagStudioInfoObj.m_StudioQRCode.SetSize(thepackage.nSubDataLen);
	memcpy(tagStudioInfoObj.m_StudioQRCode.GetData(), const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2 + thepackage.nDataLen, thepackage.nSubDataLen);

	BOOL bRet = g_pODBCPool->InsertStudioInfo(&tagStudioInfoObj);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_StudioInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{

}

void CServerPtr::Mod_StudioInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	CStudioInfoObj tagStudioInfoObj;
	tagStudioInfoObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	tagStudioInfoObj.m_StudioQRCode.SetSize(thepackage.nSubDataLen);
	memcpy(tagStudioInfoObj.m_StudioQRCode.GetData(), const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2 + thepackage.nDataLen, thepackage.nSubDataLen);

	BOOL bRet = g_pODBCPool->UpdateStudioInfo(&tagStudioInfoObj);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_StudioInfo(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CStudioInfoObj tagStudioInfoObj;
	INT nCount = g_pODBCPool->QueryStudioInfo(thepackage.szStudioId, &tagStudioInfoObj);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagStudioInfoObj.Serialize(ar);
	ar.Close();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 订单景点信息;
void CServerPtr::New_OrderScenery(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	COrderSceneryObj tagObj;
	tagObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("INSERT INTO [OrderScenery](")
		_T("[StudioID]")
		_T(", [OrderNum]")
		_T(", [ScenerySN]")
		_T(", [SceneryName]")
		_T(", [SceneryPhotog]")
		_T(", [SceneryMakeupArtist]")
		_T(", [SceneryPhotogAssistant]")
		_T(", [SceneryMakeupArtistAssistant]")
		_T(", [SceneryAppointment]")
		_T(", [SceneryFinishDate]")
		_T(", [SceneryPhotoStatus]")
		_T(", [SceneryNote])")
		_T("VALUES('%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', %d, '%s')"),
		thepackage.szStudioId,
		tagObj.m_OrderNum,
		tagObj.m_ScenerySN,
		tagObj.m_SceneryName,
		tagObj.m_SceneryPhotog,
		tagObj.m_SceneryMakeupArtist,
		tagObj.m_SceneryPhotogAssistant,
		tagObj.m_SceneryMakeupArtistAssistant,
		tagObj.m_SceneryAppointment,
		tagObj.m_SceneryFinishDate,
		tagObj.m_SceneryPhotoStatus,
		tagObj.m_SceneryNote
		);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_OrderScenery(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CString strSQL;
	strSQL.Format(_T("DELETE FROM [OrderScenery] WHERE [StudioID] = '%s' and [AutoID] = '%s' "), thepackage.szStudioId, thepackage.dwReserve);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Del_OrderScenery2(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	COrderSceneryObj tagObj;
	tagObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("DELETE FROM [OrderScenery] WHERE [StudioID] = '%s' and [OrderNum] = '%s' and [SceneryName] = '%s'"), thepackage.szStudioId, tagObj.m_OrderNum, tagObj.m_SceneryName);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

void CServerPtr::Mod_OrderScenery(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	CMemFile mf;
	//mf.Attach(thepackage.szBody, thepackage.nDataLen);//错误方式;
	mf.Attach(const_cast<BYTE*>(pReceiveData)+sizeof(TheProPackage) - 2, thepackage.nDataLen);
	CArchive ar(&mf, CArchive::load);
	COrderSceneryObj tagObj;
	tagObj.Serialize(ar);
	ar.Close();
	mf.Detach();

	CString strSQL = _T("");
	strSQL.Format(_T("UPDATE [OrderScenery] SET ")
		_T("[SceneryName] = '%s'")
		_T(", [SceneryPhotog] = '%s'")
		_T(", [SceneryMakeupArtist] = '%s'")
		_T(", [SceneryPhotogAssistant] = '%s'")
		_T(", [SceneryMakeupArtistAssistant] = '%s'")
		_T(", [SceneryAppointment] = '%s'")
		_T(", [SceneryFinishDate] = '%s'")
		_T(", [SceneryPhotoStatus] = %d")
		_T(", [SceneryNote] = '%s'")
		_T(" WHERE [StudioID] = '%s' and [AutoID] = %d"),
		tagObj.m_SceneryName,
		tagObj.m_SceneryPhotog,
		tagObj.m_SceneryMakeupArtist,
		tagObj.m_SceneryPhotogAssistant,
		tagObj.m_SceneryMakeupArtistAssistant,
		tagObj.m_SceneryAppointment,
		tagObj.m_SceneryFinishDate,
		tagObj.m_SceneryPhotoStatus,
		tagObj.m_SceneryNote,
		thepackage.szStudioId,
		tagObj.m_nAutoID
		);
	BOOL bRet = g_pODBCPool->ExecuteSQL(strSQL);

	// 返回信息;
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = bRet;
}

EnHandleResult CServerPtr::Ask_OrderScenery(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	INT nlen = nReceiveLength - sizeof(TheProPackage) + 2;
	TCHAR *pFilter = new TCHAR[nlen];
	memcpy(pFilter, pReceiveData + sizeof(TheProPackage) - 2, nlen);

	CObList tagObList;
	INT nCount = g_pODBCPool->QueryOrderScenery(thepackage.szStudioId, &tagObList, pFilter);
	CMemFile mf;
	CArchive ar(&mf, CArchive::store);
	tagObList.Serialize(ar);
	ar.Close();
	// 删除列表对象;
	POSITION pos = tagObList.GetHeadPosition();
	while (pos)
	{
		COrderSceneryObj *pObj = (COrderSceneryObj*)tagObList.GetNext(pos);
		if (pObj)
			delete pObj;
	}
	tagObList.RemoveAll();

	BOOL bResult = FALSE;
	__int64 nArchive = mf.GetLength();
	if ((nArchive + sizeof(TheProPackage) - 2) > 0x3FFFFF)
	{
		__int64 nSubLen = nArchive;
		BYTE *pMf = mf.Detach();
		while (nSubLen > 0)
		{
			if (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2 > 0)
				dwSendLen = 0x3FFFFF;
			else
				dwSendLen = nSubLen + sizeof(TheProPackage) - 2;
			pSendData = new BYTE[dwSendLen];
			TheProPackage *pPackage = (TheProPackage*)pSendData;
			pPackage->flag = PACKAGE_MULTIPLE;
			pPackage->nCmd = thepackage.nCmd;
			pPackage->nDataLen = nArchive;
			pPackage->nSubDataLen = (nSubLen - 0x3FFFFF + sizeof(TheProPackage) - 2) > 0 ? (0x3FFFFF - sizeof(TheProPackage) + 2) : nSubLen;
			pPackage->dwReserve = nCount;
			memcpy(pPackage->byBody, pMf + nArchive - nSubLen, pPackage->nSubDataLen);
			nSubLen -= (0x3FFFFF - sizeof(TheProPackage) + 2);

			bResult = ::HP_Server_Send(m_spThis->m_pServer, dwConnID, pSendData, dwSendLen);
			if (pSendData)
				delete[]pSendData;
			pSendData = NULL;

			if (!bResult)
			{
				if (pMf)
					delete pMf;
				return HR_ERROR;
			}
		}

		if (pMf)
			delete pMf;

		return HR_OK;
	}
	else
	{// 单包;
		dwSendLen = sizeof(TheProPackage) - 2 + nArchive;
		pSendData = new BYTE[dwSendLen];
		TheProPackage *pPackage = (TheProPackage*)pSendData;
		pPackage->flag = PACKAGE_ONESELF;
		pPackage->nCmd = thepackage.nCmd;
		pPackage->nDataLen = nArchive;
		pPackage->dwReserve = nCount;

		BYTE *pMf = mf.Detach();
		memcpy(pPackage->byBody, pMf, nArchive);
		if (pMf)
			delete pMf;
	}

	return HR_IGNORE;
}

// 订单序号;
INT CServerPtr::Ask_OrderSerialNum(IN LPCTSTR lpStudioId)
{
	static ThreadSection critSection;
	AutoThreadSection aSection(&critSection);
	return g_pODBCPool->QueryMaxOrderId(lpStudioId);
}

void CServerPtr::Ask_OrderSerialNum(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = Ask_OrderSerialNum(thepackage.szStudioId);
}

// 打印序号;
INT CServerPtr::Ask_PrintSerialNum(IN LPCTSTR lpStudioId)
{
	static ThreadSection critSection;
	AutoThreadSection aSection(&critSection);
	return g_pODBCPool->QueryMaxPrintId(lpStudioId);
}

void CServerPtr::Ask_PrintSerialNum(IN HP_CONNID dwConnID, IN const BYTE* pReceiveData, IN INT nReceiveLength, IN TheProPackage &thepackage, OUT BYTE*& pSendData, OUT DWORD &dwSendLen)
{
	dwSendLen = sizeof(TheProPackage);
	pSendData = new BYTE[dwSendLen];
	TheProPackage *pPackage = (TheProPackage*)pSendData;
	pPackage->flag = PACKAGE_ONESELF;
	pPackage->nCmd = thepackage.nCmd;
	pPackage->nDataLen = 0;
	pPackage->dwReserve = Ask_PrintSerialNum(thepackage.szStudioId);
}