#include "StdAfx.h"
#include "BranchInfo.h"
#include "Implffsco.h"
#include <shlwapi.h>
#include <Dbghelp.h>
#pragma comment(lib,"Dbghelp.lib")
#include <strsafe.h >
#include <Winbase.h>
#include "CharacterConvert.h"

#include "BakPhotoModel\BackupFactory.h"
#include "BakPhotoModel\BackupInterface.h"
#include "mysqldata.h"

#define IS_USE_VER1	1

TblVersion CBranchInfo::m_TblVersion;
vector<TblCatalogInfo*> CBranchInfo::m_TblCatalogInfo;
vector<TblNetShareInfo*> CBranchInfo::m_TblNetShareInfo;


typedef HRESULT (WINAPI *GetClassBackupObject)(REFCLSID, REFIID, LPVOID*);

CBranchInfo::CBranchInfo()
{
	m_bIsOur = FALSE;
	memset(m_szBranchName, 0, sizeof(TCHAR)*MAX_PATH);
	memset(m_szBranchDoMain, 0, sizeof(TCHAR)*MAX_PATH);
	memset(m_szBranchIP, 0, sizeof(TCHAR)*MAX_PATH);
	m_strBranchId.Empty();

	//////////////////////////////////////////////////////////////////////////
	m_hIncrement = NULL;
	m_hIncrementCtrl = NULL;
	m_hIncrementWaitableTm = NULL;

	m_hRemove = NULL;
	m_hRemoveCtrl = NULL;
	m_hRemoveWaitableTm = NULL;
}

CBranchInfo::CBranchInfo(LPCTSTR lpBranchName, LPCTSTR lpBranchDoMain, LPCTSTR lpBranchIP)
{
	m_bIsOur = FALSE;

	if (_tcscmp(lpBranchName, _T("")) != 0 && lpBranchName)
	{
		_tcscpy_s(m_szBranchName, lpBranchName);
	}

	if (_tcscmp(lpBranchDoMain, _T("")) != 0 && lpBranchDoMain)
	{
		_tcscpy_s(m_szBranchDoMain, lpBranchDoMain);
	}

	if (_tcscmp(lpBranchIP, _T("")) != 0 && lpBranchIP)
	{
		_tcscpy_s(m_szBranchIP, lpBranchIP);
	}
}

CBranchInfo::~CBranchInfo(void)
{
	EndOfThread();
}

/************************************************************************/
/* 
	函数:RemoveNetShareInfo
	描述:清除内存资源;
	参数:#
	返回:#
	要求:#
	注意:由外部调用该函数,不放在析造函数处理.
	示例:
*/
/************************************************************************/
void CBranchInfo::RemoveNetShareInfo()
{
	TblNetShareInfo *pNetShareInfo = NULL;
	for ( NETSHAREINFO::iterator it = m_TblNetShareInfo.begin(); it != m_TblNetShareInfo.end();)
	{
		pNetShareInfo = *it;
		delete pNetShareInfo;
		pNetShareInfo = NULL;

		it = m_TblNetShareInfo.erase(it);
	}
}

/************************************************************************/
/* 
	函数:RemoveNetShareInfo
	描述:清除内存资源;
	参数:#
	返回:#
	要求:#
	注意:由外部调用该函数,不放在析造函数处理
	示例:
*/
/************************************************************************/
void CBranchInfo::RemvoeCatalogInfo()
{
	TblCatalogInfo *pCatalogInfo = NULL;
	for ( CATALOGINFO::iterator it = m_TblCatalogInfo.begin(); it != m_TblCatalogInfo.end();)
	{
		pCatalogInfo = *it;
		delete pCatalogInfo;
		pCatalogInfo = NULL;

		it = m_TblCatalogInfo.erase(it);
	}
}

/************************************************************************/
/* 
	函数:IsValidDate
	描述:判断日期有效性;
	参数:
		IN:		lpDate	日期字符串,格式如:"2015-05-06 18:20:30"或"2015/05/12 21:30:22"
	返回:日期有效返回TRUE,否则返回FALSE;
	要求:
	注意:只判断公历日期;
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::IsValidDate(IN LPCTSTR lpDate)
{
	if(lpDate == NULL || _tcscmp(lpDate,_T("")) == 0)
		return FALSE;

	CString strDate = lpDate;
	if (strDate.IsEmpty()) return FALSE;

	// 判断日期合法性;
	static int nYear = 0;
	static int nMonth = 0;
	static int nDay = 0;

	nYear = nMonth = nDay = 0;
	nYear = _ttoi(strDate.Left(4));

	nMonth = _ttoi(strDate.Mid(5, 2));
	nDay = _ttoi(strDate.Mid(8, 2));

	CONST static INT nNormalMonth[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	CONST static INT nLeapMonth[12] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

	if ((nDay <= 0) || (nDay > 31) || (nMonth <= 0) || (nMonth > 12)) return FALSE;

	if ((nYear % 400 == 0) || (nYear % 4 == 0 && nYear % 100 != 0))
	{
		if (nDay > nLeapMonth[nMonth - 1])	return FALSE;
	}
	else
	{
		if (nDay > nNormalMonth[nMonth - 1]) return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:EasyGetFileSize
	描述:获取文件大小;
	参数:
	     IN:lpFolder 文件名;
	返回:成功则返回文件的大小,否则返回-1;
	注意:;
	要求:
	示例:
*/
/************************************************************************/
UINT64 CBranchInfo::EasyGetFileSize(IN LPCTSTR lpFile)
{
	// 判断文件是否存在;
	//if ( !lpFile || !_tcscmp(lpFile,_T("")) || !PathFileExists(lpFile) )
	//	return 0;
	// 传参前已判断,不需要再判断;

	WIN32_FIND_DATA fileinfo;
	UINT64    dwSize = 0;
	HANDLE hFind = FindFirstFile(lpFile,&fileinfo);
	if ( hFind != INVALID_HANDLE_VALUE)
	{
		dwSize = fileinfo.nFileSizeLow;
		FindClose(hFind);
	}

	return dwSize;
}

/************************************************************************/
/* 
	函数:EasyGetFileSzie
	描述:获取指定文件的大小以及文件占用磁盘的空间大小;
	参数:
		IN:	lpFile指定的文件名;
		IN:	uFileSpaceSize 返回文件占用磁盘空间大小(字节数);
	返回:成功获取文件,返回文件大小(字节数),若返回-1则文件不存在或其他错误;
	注意:lpFileName可以是网络路径上的共享文件;
	要求:
		在vc6.0中,必须到微软下载Win32 FileID API Library
		下载地址:http://www.microsoft.com/en-us/download/details.aspx?id=22599
		解压包含fileextd.h和fileextd.lib
		然后才能使用GetFileInformationByHandleEx函数和结构体FILE_STANDARD_INFO;
	示例:
*/
/************************************************************************/
UINT64 CBranchInfo::EasyGetFileSpacesSzie(IN LPCTSTR lpFileName)
{
	// 文件是否存在;
	if ( !PathFileExists(lpFileName) )
	{
		//OutputDebugString(_T("文件不存在\n"));
		return -1;
	}

	// 打开文件句柄;
	HANDLE hFile = ::CreateFile(lpFileName, GENERIC_READ , FILE_SHARE_READ, 
		NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hFile == INVALID_HANDLE_VALUE)
	{
		//OutputDebugString(_T("打开文件句柄失败\n"));
		return -1;
	}

#if 0
	// 获取文件大小;
	UINT64 uFileSize = 0;
	::GetFileSizeEx(hFile, reinterpret_cast<PLARGE_INTEGER>(&uFileSize));
#endif

	FILE_STANDARD_INFO fsi = {0};
	if (!::GetFileInformationByHandleEx(hFile, FileStandardInfo, &fsi, sizeof(FILE_STANDARD_INFO)))
	{
		CloseHandle(hFile);
		//OutputDebugString(_T("获取文件信息失败\n"));
		return -1;
	}

	UINT64 uFileSpacesSize = fsi.AllocationSize.HighPart;

	CloseHandle(hFile);

	return uFileSpacesSize;
}


/************************************************************************/
/* 
	函数:EasyGetSizeOfFiles
	描述:获取指定文件路径数组的全部文件大小;
	参数:
	     IN:	strAryOfFile 文件名数组;
		 OUT:	dwFiles 文件夹下的文件数量;
		 OUT:	dwFolders 文件夹下的子目录数量;
	返回:成功则返回文件夹占用磁盘空间的大小,否则返回-1;
	注意:
	要求:
	示例:
*/
/************************************************************************/
UINT64 CBranchInfo::EasyGetSizeOfFiles(IN CStringArray &strAryOfFile)
{
	UINT64 uSizeOfFiles = 0;

	int nSize = strAryOfFile.GetSize();
	for ( int i = 0; i < nSize; i++)
	{
		CString strFile = strAryOfFile.ElementAt(i);
		if ( PathFileExists(strFile) )
		{
			uSizeOfFiles += EasyGetFileSize(strFile);
		}
	}

	return uSizeOfFiles;
}

/************************************************************************/
/*
	函数：GetDiskSpaceInfo
	描述：获取指定目录或盘符的容量信息;
	参数：
		IN:		lpRootPathName 根目录名称;
		INOUT:	dTotalNum  总容量;
		INOUT:	dFreeNum 可用容量;
	返回：
	注意：
		GetDiskFreeSpace函数不能满足当前超过2T的硬盘容量,因为里面的数据类型是UINT,最大支持32位(4G);
		GetDiskFreeSpaceEx支持64位(16384P=1024*16384T)
	只能获取本机硬盘信息,且路径必须包含":"冒号;
	调用约定：
*/
/************************************************************************/
BOOL CBranchInfo::GetDiskSpaceInfo(IN LPCTSTR lpRootPathName,IN OUT double &dTotalNum, IN OUT double &dFreeNum)
{
	// 校验参数有效性;
	if(lpRootPathName == NULL || _tcscmp(lpRootPathName,_T("")) == 0)
	{
		//OutputDebugString(_T("目录为空\n"));
		return FALSE;
	}

	// 如果长度==1;
	int nlen = _tcslen(lpRootPathName);
	if((1 == nlen) || ( 2 == nlen && lpRootPathName[nlen-1] != _T(':')))
	{
		//OutputDebugString(_T("根目录无效\n"));
		return FALSE;
	}

	if ( !PathFileExists(lpRootPathName))
	{
		//OutputDebugString(_T("根目录不存在\n"));
		return FALSE;
	}

 	BOOL fResult = FALSE;
	DWORD dwSectPerClust;	// 每簇的扇区数;
	DWORD dwBytesPerSect;	// 每个扇区的字节数;
	DWORD dwFreeClusters;	// 可用簇数;
	DWORD dwTotalClusters;	// 总簇数;

	typedef BOOL (WINAPI *P_GDFSE)(LPCTSTR, PULARGE_INTEGER,PULARGE_INTEGER, PULARGE_INTEGER);
	P_GDFSE pGetDiskFreeSpaceEx = NULL;

	/*unsigned*/ __int64 i64FreeBytesToCaller;
	/*unsigned*/ __int64 i64TotalBytes;
	/*unsigned*/ __int64 i64FreeBytes;

	// 调用GetDiskFreeSpaceEx失败则调用GetDiskSpace;
#ifdef UNICODE
	pGetDiskFreeSpaceEx = (P_GDFSE)GetProcAddress(GetModuleHandle(_T("kernel32.dll")),"GetDiskFreeSpaceExW");
#else
	pGetDiskFreeSpaceEx = (P_GDFSE)GetProcAddress(GetModuleHandle("kernel32.dll"),"GetDiskFreeSpaceExA");
#endif

	if ( pGetDiskFreeSpaceEx )
	{
		fResult = pGetDiskFreeSpaceEx(lpRootPathName,
			(PULARGE_INTEGER)&i64FreeBytesToCaller,
			(PULARGE_INTEGER)&i64TotalBytes,
			(PULARGE_INTEGER)&i64FreeBytes);

		if ( fResult )
		{
			// 将单位由byte转为G byte;
			dTotalNum = (double)i64TotalBytes/1024/1024/1024;
			dFreeNum = (double)i64FreeBytes/1024/1024/1024;
		}
	}
	else
	{
		fResult = GetDiskFreeSpace(lpRootPathName,
			&dwSectPerClust,
			&dwBytesPerSect,
			&dwFreeClusters,
			&dwTotalClusters);

		if ( fResult )
		{
			// 成功获得容量信息;
			i64TotalBytes = (__int64)dwTotalClusters * dwSectPerClust * dwBytesPerSect;
			i64FreeBytes = (__int64)dwFreeClusters * dwSectPerClust * dwBytesPerSect;

			// 将单位由byte转为G byte;
			dTotalNum = (double)i64TotalBytes/1024/1024/1024;
			dFreeNum = (double)i64FreeBytes/1024/1024/1024;
		}
	}

	return fResult;
}


/************************************************************************/
/*
	函数:GetEnableShareDirectory
	描述:返回指定相片类型可用的共享目录;
	参数:
		IN:		nPhotoType	相片类型;
		IN:		lpBranchId  分店域名;
		IN:		lpOrderNum  订单号;
		OUT:	lpEnableShareDirectory	可用的共享目录;
	返回:成功返回TRUE;
	注意:用于导入相片,最后返回的共享目录,使用MakeSuerDirectoryPathExists函数创建目录;
	调用约定:#

	测试:通过;
*/
/************************************************************************/
BOOL CBranchInfo::GetEnableShareDirectory(OUT double &dFreeNum, IN const int &nPhotoType, IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, OUT LPTSTR lpEnableShareDirectory)
{
	if ( m_TblNetShareInfo.size() == 0)
	{
		//OutputDebugString(_T("没有可用的共享目录\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"没有可用的共享目录"));
		return FALSE;
	}

	double dTotalNum = 0.0;
	BOOL bGetEnable = FALSE;
	BYTE byCurPriority = 0;
	TCHAR szOrderPath[MAX_PATH] = {0};
	//TCHAR szOldOrderPath[MAX_PATH] = {0};	// 记录上一次的订单文件夹路径;
	for ( NETSHAREINFO::const_iterator it = m_TblNetShareInfo.begin(); it != m_TblNetShareInfo.end(); it++)
	{
		//_stprintf_s(szOldOrderPath,_T("%s"),szOrderPath);
		if ( _tcscmp((*it)->szBranchId,lpBranchId) == 0 )
		{
			if ( (*it)->byPhotoType == nPhotoType )
			{
				// 判断目录下是否有订单文件夹;
				_stprintf_s(szOrderPath,_T("%s\\%s\\"),(*it)->szShareDirectory,lpOrderNum);
				// 存在且目录容量仍大于mincapacity可用;
				if ( PathFileExists(szOrderPath) )
				{
					if ( !GetDiskSpaceInfo((*it)->szShareDirectory,dTotalNum,dFreeNum) )
					{
						// 获取硬盘大小失败;
						//OutputDebugString(_T("获取硬盘大小失败\n"));
						//LOG4C_NO_FILENUM((LOG_NOTICE,"获取硬盘大小失败"));
						continue;
					}

					if ( dFreeNum > (*it)->byMinCapacity )
					{
						bGetEnable = TRUE;
						break;
					}
				}

				// 判断共享路径是否可用;
				if ( GetDiskSpaceInfo((*it)->szShareDirectory,dTotalNum,dFreeNum) )
				{
					if ( dFreeNum > (*it)->byMaxCapacity )
					{
						if ( byCurPriority < (*it)->byPriority )
						{
							// 最高权限且硬盘容量大小满足要求;
							byCurPriority = (*it)->byPriority;
							//_stprintf_s(szOrderPath,_T("%s\\%s\\"),(*it)->szShareDirectory, lpOrderNum);
							bGetEnable = TRUE;
						}					
					}
				}
			}
		}	
	}

	//////////////////////////////////////////////////////////////////////////
	// 返回结果;
	if(bGetEnable)
	{
#ifdef UNICODE
		CHAR szShareDirectory[MAX_PATH] = {0};
		unicode2acsii(szOrderPath,szShareDirectory);
		MakeSureDirectoryPathExists(szShareDirectory);
#else
		MyMakeSureDirectoryPathExists(szOrderPath);
#endif
		_stprintf_s(lpEnableShareDirectory,_tcslen(szOrderPath)+1,_T("%s"),szOrderPath);
	}
	else
	{
		//OutputDebugString(_T("没有符合的共享目录\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"没有符合的共享目录"));
	}

	return bGetEnable;
}

/************************************************************************/
/*
	函数:EasyCopyFile
	描述:将源文件拷贝到目标路径中;
	参数:
		IN:		lpOrderNum			相片所属订单号;
		IN:		lpExistingFileName	源文件;
		IN:		lpTargetDirectory   目标路径;
		IN:		bFailIfExists		若目录路径存在同名,是否覆盖;
	返回:成功返回TRUE;
	要求:
	注意:只拷贝一个文件,若要拷贝多个相同后缀的文件名,需要重新修改函数功能;
	示例:

	修改:增量备份的拷贝,需要在目标文件夹中创建该相片在源目录的子路径;
	日期:2015-04-25
*/
/************************************************************************/
BOOL CBranchInfo::EasyCopyFile(IN LPCTSTR lpOrderNum, IN LPCTSTR lpExistingFileName, IN LPCTSTR lpTargetDirectory, IN BOOL bFailIfExists /* = TRUE */)
{
	if ( !PathFileExists(lpTargetDirectory) )
	{
		return FALSE;
	}

	TCHAR szNewFileName[_MAX_PATH] = { 0 };
	TCHAR szDrive[_MAX_DRIVE] = { 0 };
	TCHAR szDir[_MAX_DIR] = { 0 };
	TCHAR szFna[_MAX_FNAME] = { 0 };
	TCHAR szExt[_MAX_EXT] = { 0 };

	StringCchPrintf(szNewFileName, _MAX_PATH, _T("%s"), lpExistingFileName);
	_tsplitpath_s(szNewFileName, szDrive, szDir, szFna, szExt);

	// 解析出订单号的子目录;
	int nIndex = 0;
	CString strDir = szDir;
	if ( (nIndex = strDir.Find(lpOrderNum)) != -1)
	{
		strDir = strDir.Mid(nIndex+_tcslen(lpOrderNum)+1);
		strDir.TrimRight(_T('\\'));

		if ( lpTargetDirectory[_tcslen(lpTargetDirectory) - 1] != _T('\\') )
		{
			if(!strDir.IsEmpty())
			{
				StringCchPrintf(szNewFileName, _MAX_PATH, _T("%s\\%s\\"), lpTargetDirectory, strDir);
			}
		}
		else
		{
			if(!strDir.IsEmpty())
			{
				StringCchPrintf(szNewFileName, _MAX_PATH, _T("%s%s\\"), lpTargetDirectory, strDir);
			}
		}

		CreateDirectory(szNewFileName,NULL);
	}
	else
	{
		//OutputDebugString(_T("未找到订单名,无效目录\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"未找到订单名,无效目录"));
	}

	if ( lpTargetDirectory[_tcslen(lpTargetDirectory) - 1] != _T('\\') )
	{
		if(strDir.IsEmpty())
			StringCchPrintf(szNewFileName, _MAX_PATH, _T("%s\\%s%s"), lpTargetDirectory, szFna, szExt);
		else
			StringCchPrintf(szNewFileName, _MAX_PATH, _T("%s\\%s\\%s%s"), lpTargetDirectory, strDir, szFna, szExt);
	}
	else
	{
		if(strDir.IsEmpty())
			StringCchPrintf(szNewFileName, _MAX_PATH, _T("%s%s%s"), lpTargetDirectory, szFna, szExt);
		else
			StringCchPrintf(szNewFileName, _MAX_PATH, _T("%s%s\\%s%s"), lpTargetDirectory, strDir, szFna, szExt);
	}

	return CopyFile(lpExistingFileName, szNewFileName, bFailIfExists);
}

/************************************************************************/
/* 
	函数:IsValideDiretory
	描述:判断一个即将要删除的目录是否为可以删除的目录,而非是共享根目录;
	参数:
		IN:		lpDirectory	目录;
	返回:
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::IsValideDiretory(IN LPCTSTR lpDirectory)
{
	BOOL bResult = TRUE;
	for ( NETSHAREINFO::const_iterator it = m_TblNetShareInfo.begin(); it != m_TblNetShareInfo.end(); it++)
	{
		if ( _tcscmp((*it)->szShareDirectory,lpDirectory) == 0)
		{
			bResult = FALSE;
			break;
		}
	}

	return bResult;
}

/************************************************************************/
/* 
	函数:DeleteDirectory
	描述:删除指定目录;
	参数:
		IN:		lpDirectory	要删除的目录;
	返回:
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::DeleteDirectory(IN LPCTSTR lpDiretory)// 可删除共享路径;
{
	// 判断参数有效性;
	if ( lpDiretory == NULL || _tcscmp(lpDiretory,_T("")) == 0)
		return FALSE;

#if 1 // 判断根目录是否存在,可以放在函数外,但有时忘记写判断,只能放在这里比较适合;
	if( !PathFileExists(lpDiretory))
		return FALSE;
#endif

	TString strPath = lpDiretory;
	if ( lpDiretory[_tcslen(lpDiretory)-1] != _T('\\'))
		strPath += _T("\\");

	TString strTempPath = strPath;
	strTempPath += _T("*");

	WIN32_FIND_DATA fileinfo = { 0 };
	HANDLE handle = FindFirstFile(strTempPath.c_str(), &fileinfo);

	if (NULL == handle && INVALID_HANDLE_VALUE == handle)
		return FALSE;

	do 
	{
		// '.'和 '..'的系统文件去除;
		if (_T('.') != fileinfo.cFileName[0])
		{
			TString strTemp = strPath + fileinfo.cFileName;
			SetFileAttributes(strTemp.c_str(), FILE_ATTRIBUTE_NORMAL);//去掉所有属性;
			if ((FILE_ATTRIBUTE_DIRECTORY & fileinfo.dwFileAttributes) == FILE_ATTRIBUTE_DIRECTORY)	// 目录;
			{
				DeleteDirectory(strTemp.c_str());
			}
			else
			{
				if(!DeleteFile(strTemp.c_str()))
				{
					DWORD dwError = GetLastError();
					//LOG4C_NO_FILENUM((LOG_NOTICE,"删除文件出错:%d",dwError));
				}
			}
		}
	} while (FindNextFile(handle, &fileinfo));
	FindClose(handle);

	if(!RemoveDirectory(strPath.c_str()))
	{
		DWORD dwError = GetLastError();
		//LOG4C_NO_FILENUM((LOG_NOTICE,"删除文件夹出错:%d",dwError));
		//OutputDebugString(_T("**************删除目录失败**************\n"));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:ReadOtherBranchOrderInfo
	描述:读取branchdindan.dat文件中的其他分店订单取件信息:
	参数:
		OUT:	AryOtherBranchOrderInfo 返回branchdindan.dat中的订单信息;
	返回:
	要求:
	注意:本店实例对象执行;
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::ReadOtherBranchOrderInfo(/*OUT CArray<CStringArray,CStringArray>& AryOtherBranchOrderInfo*/)
{
	CString strOrderFile;
	strOrderFile.Format(_T("%s\\%s"),g_ModulePath,_T("branchdindan.dat"));

	if ( !PathFileExists(strOrderFile) )
	{
		//OutputDebugString(_T("branchdindan.dat文件不存在\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"branchdindan.dat文件不存在"));
		return FALSE;
	}

	CFile fOrder;	
	if (!fOrder.Open(strOrderFile, CFile::modeRead))
	{
		//OutputDebugString(_T("读取branchdindan.bat文件失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"branchdindan.bat文件失败"));
		return FALSE;
	}

	int nMessageLen = fOrder.GetLength();
	BYTE *pData = new BYTE[nMessageLen];
	fOrder.Read(pData, nMessageLen);
	fOrder.Close();

	BYTE *szChatMessage = pData;
	int nSize = 0;
	memcpy(&nSize, szChatMessage + (nMessageLen - sizeof(int)), sizeof(int));
	CMemFile memfile;
	memfile.Attach(szChatMessage, nMessageLen);
	CArchive ar(&memfile, CArchive::load);

	CArray<CStringArray,CStringArray> AryOtherBranchOrderInfo;
	AryOtherBranchOrderInfo.SetSize(nSize);
	for (int i = 0; i < AryOtherBranchOrderInfo.GetSize(); i++)
	{
		// 三个元素：0==分店域名 + 1==订单号 + 2==订单取件完成时间(time5);
		AryOtherBranchOrderInfo.ElementAt(i).Serialize(ar);
	}
	ar.Close();
	memfile.Detach();
	delete[] pData;

	nSize = AryOtherBranchOrderInfo.GetSize();
	for ( int i = 0; i < nSize; i++)
	{
		CStringArray &AryOrder = AryOtherBranchOrderInfo.ElementAt(i);
		GetRemvoeOrderInfoAndRemove(AryOrder.ElementAt(0),AryOrder.ElementAt(1),AryOrder.ElementAt(2),1);
		GetRemvoeOrderInfoAndRemove(AryOrder.ElementAt(0),AryOrder.ElementAt(1),AryOrder.ElementAt(2),2);
		GetRemvoeOrderInfoAndRemove(AryOrder.ElementAt(0),AryOrder.ElementAt(1),AryOrder.ElementAt(2),3);
		GetRemvoeOrderInfoAndRemove(AryOrder.ElementAt(0),AryOrder.ElementAt(1),AryOrder.ElementAt(2),4);
		GetRemvoeOrderInfoAndRemove(AryOrder.ElementAt(0),AryOrder.ElementAt(1),AryOrder.ElementAt(2),5);
		GetRemvoeOrderInfoAndRemove(AryOrder.ElementAt(0),AryOrder.ElementAt(1),AryOrder.ElementAt(2),6);
		GetRemvoeOrderInfoAndRemove(AryOrder.ElementAt(0),AryOrder.ElementAt(1),AryOrder.ElementAt(2),7);
		GetRemvoeOrderInfoAndRemove(AryOrder.ElementAt(0),AryOrder.ElementAt(1),AryOrder.ElementAt(2),8);
		Sleep(0);
	}

	// 对branchdindan.dat处理完毕后,删除branchdindan.dat文件,等待下次新生成的文件;
	DeleteFile(strOrderFile);

	return TRUE;
}

/************************************************************************/
/* 
	函数:InitBranchInfo
	描述:初始化分店信息;
	参数:
		IN:		lpBranchDoMain	分店域名;
		IN:		lpBranchName	分店名;
		IN:		lpBranchIP		分店公网IP
	返回:
	要求:
	注意:
	示例:
*/
/************************************************************************/
void CBranchInfo::InitBranchInfo(IN LPCTSTR lpBranchDoMain, IN LPCTSTR lpBranchName, IN LPCTSTR lpBranchIP)
{
	// 分店信息;
	if (_tcscmp(lpBranchName, _T("")) != 0 && lpBranchName)
		_tcscpy_s(m_szBranchName, lpBranchName);

	if (_tcscmp(lpBranchDoMain, _T("")) != 0 && lpBranchDoMain)
		_tcscpy_s(m_szBranchDoMain, lpBranchDoMain);

	if (_tcscmp(lpBranchIP, _T("")) != 0 && lpBranchIP)
		_tcscpy_s(m_szBranchIP, lpBranchIP);
}

/************************************************************************/
/* 
	函数:InitCatalog
	描述:初始化数据库实例对象;
	参数:
		IN:		dwCatalogPort		数据库实例映射端口;
		IN:		lpCatalogSource		数据库实例地址;
		IN:		lpCatalogAccount	数据库实例登陆账号;
		IN:		lpCatalogPsw		数据库实例登陆密码;
		IN:		lpCatalogName		数据库名称;
	返回:成功连接数据库实例返回TRUE;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::InitCatalog(IN CONST DWORD &dwCatalogPort, IN LPCTSTR lpCatalogSource, IN LPCTSTR lpCatalogAccount, IN LPCTSTR lpCatalogPsw, IN LPCTSTR lpCatalogName)
{
	if ( IsOpen() )
		return TRUE;
	
	TCHAR szSQLConnt[MAX_PATH] = _T("");
	if (dwCatalogPort)
	{
		if ( _tcscmp(g_szDBAccount, _T("")) == 0 )
			_stprintf_s(szSQLConnt, DB_SW_CONN_WITH_PORT,lpCatalogSource, dwCatalogPort, lpCatalogName);
		else
			_stprintf_s(szSQLConnt, DB_SS_CONN_WITH_PORT,lpCatalogSource, dwCatalogPort, lpCatalogName, lpCatalogAccount, lpCatalogPsw);
	}
	else
	{
		if ( _tcscmp(g_szDBAccount, _T("")) == 0 )
			_stprintf_s(szSQLConnt, DB_SW_CONN_WITHOUT_PORT,lpCatalogSource, lpCatalogName);
		else
			_stprintf_s(szSQLConnt, DB_SS_CONN_WITHOUT_PORT,lpCatalogSource, lpCatalogName, lpCatalogAccount, lpCatalogPsw);
	}

	SetConn(szSQLConnt);

	BOOL bResult = OpenCatalog();
	if( !bResult )
	{
		//OutputDebugString(_T("打开数据库失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"打开数据库失败"));
	}
	else
	{
		if( !GetTblBranchId() )
		{
			//OutputDebugString(_T("获取域名表失败"));
			//LOG4C_NO_FILENUM((LOG_NOTICE,"获取域名表失败"));
		}
	}

	return bResult;
}

/************************************************************************/
/* 
	函数:CheckDirExistInTbl
	描述:检测在数据表里是否有共享目录的记录;
	参数:
		const int nType						共享目录类型：原片==1,初修片==2,精修片==3,设计片==4,原片备份==5,初修备份==6,精修备份==7,设计备份==8
		const CString& strDir				要查找的目录
	返回:成功获取返回TRUE:;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::CheckShareDirExistInTbl(const int nType, const CString& strDir)
{
	if(strDir == _T(""))
		return FALSE;

	if(nType == 1 || nType == 2)
	{
		int ncount = GetSelectCount(_T("NetShareInfo"), strDir);
		if(ncount != 0)
			return TRUE;
	}
	return FALSE;
}

/************************************************************************/
/* 
	函数:GetTblBranchId
	描述:获取path表中的分店域名;
	参数:
	返回:成功获取返回TRUE:;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblBranchId()
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("path1"));

	CArray<CStringArray, CStringArray> AryOfValues;
	if ( !GetTableValues(_T("path"), NULL, AryOfFields, AryOfValues) || !AryOfValues.GetSize())
	{
		//OutputDebugString(_T("获取path表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取path表失败"));
		return FALSE;
	}

	StringCchPrintf(m_szBranchDoMain,MAX_PATH,_T("%s"),AryOfValues.ElementAt(0).ElementAt(0));

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetTblVersion
	描述:获取Version表信息; 
	参数:
	返回:成功获取返回TRUE:
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblVersion()
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("version"));
	AryOfFields.Add(_T("check1"));
	AryOfFields.Add(_T("check2"));
	AryOfFields.Add(_T("check3"));
	AryOfFields.Add(_T("check4"));
	AryOfFields.Add(_T("edit1"));
	AryOfFields.Add(_T("edit2"));
	AryOfFields.Add(_T("edit3"));
	AryOfFields.Add(_T("edit4"));
	AryOfFields.Add(_T("bak1"));
	AryOfFields.Add(_T("bak2"));
	AryOfFields.Add(_T("bak3"));
	AryOfFields.Add(_T("bak4"));
	AryOfFields.Add(_T("bak5"));
	AryOfFields.Add(_T("bak6"));
	AryOfFields.Add(_T("bakserver1"));
	AryOfFields.Add(_T("bakserver2"));
	AryOfFields.Add(_T("bakserver3"));
	AryOfFields.Add(_T("bakserver4"));
	AryOfFields.Add(_T("bakserver5"));
	AryOfFields.Add(_T("baktime"));
	AryOfFields.Add(_T("delcheck1"));
	AryOfFields.Add(_T("delcheck2"));
	AryOfFields.Add(_T("delcheck3"));
	AryOfFields.Add(_T("delcheck4"));
	AryOfFields.Add(_T("deledit1"));
	AryOfFields.Add(_T("deledit2"));
	AryOfFields.Add(_T("deledit3"));
	AryOfFields.Add(_T("deledit4"));
	AryOfFields.Add(_T("bak11"));
	AryOfFields.Add(_T("bak22"));
	AryOfFields.Add(_T("bak33"));
	AryOfFields.Add(_T("bak44"));

	CArray<CStringArray, CStringArray> AryOfValues;
	if (!GetTableValues(_T("version"), NULL, AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取version表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取version表失败"));
		return FALSE;
	}

	// 获取version表成功;
	_stprintf_s(m_TblVersion.szVersion, _T("%s"), AryOfValues.ElementAt(0).ElementAt(0));
	m_TblVersion.bCheck1 = _ttoi(AryOfValues.ElementAt(0).ElementAt(1));
	m_TblVersion.bCheck2 = _ttoi(AryOfValues.ElementAt(0).ElementAt(2));
	m_TblVersion.bCheck3 = _ttoi(AryOfValues.ElementAt(0).ElementAt(3));
	m_TblVersion.bCheck4 = _ttoi(AryOfValues.ElementAt(0).ElementAt(4));

	m_TblVersion.nCheckMonth1 = _ttoi(AryOfValues.ElementAt(0).ElementAt(5));
	m_TblVersion.nCheckMonth2 = _ttoi(AryOfValues.ElementAt(0).ElementAt(6));
	m_TblVersion.nCheckMonth3 = _ttoi(AryOfValues.ElementAt(0).ElementAt(7));
	m_TblVersion.nCheckMonth4 = _ttoi(AryOfValues.ElementAt(0).ElementAt(8));

	m_TblVersion.bCheckbak1 = _ttoi(AryOfValues.ElementAt(0).ElementAt(9));
	m_TblVersion.bCheckbak2 = _ttoi(AryOfValues.ElementAt(0).ElementAt(10));
	m_TblVersion.bCheckbak3 = _ttoi(AryOfValues.ElementAt(0).ElementAt(11));
	m_TblVersion.bCheckbak4 = _ttoi(AryOfValues.ElementAt(0).ElementAt(12));
	//m_TblVersion.bCheckbak5 = _ttoi(AryOfValues.ElementAt(0).ElementAt(13));
	//m_TblVersion.bCheckbak6 = _ttoi(AryOfValues.ElementAt(0).ElementAt(14));

	_stprintf_s(m_TblVersion.szbakServer1, _T("%s"), AryOfValues.ElementAt(0).ElementAt(15));
	_stprintf_s(m_TblVersion.szbakServer2, _T("%s"), AryOfValues.ElementAt(0).ElementAt(16));
	_stprintf_s(m_TblVersion.szbakServer3, _T("%s"), AryOfValues.ElementAt(0).ElementAt(17));
	_stprintf_s(m_TblVersion.szbakServer4, _T("%s"), AryOfValues.ElementAt(0).ElementAt(18));
	//_stprintf_s(m_TblVersion.szbakServer5, _T("%s"), AryOfValues.ElementAt(0).ElementAt(19));
	//m_TblVersion.nbakTime = _ttoi(AryOfValues.ElementAt(0).ElementAt(20));

	m_TblVersion.bCheckbakdel1 = _ttoi(AryOfValues.ElementAt(0).ElementAt(21));
	m_TblVersion.bCheckbakdel2 = _ttoi(AryOfValues.ElementAt(0).ElementAt(22));
	m_TblVersion.bCheckbakdel3 = _ttoi(AryOfValues.ElementAt(0).ElementAt(23));
	m_TblVersion.bCheckbakdel4 = _ttoi(AryOfValues.ElementAt(0).ElementAt(24));

	m_TblVersion.nCheckbdMonth1 = _ttoi(AryOfValues.ElementAt(0).ElementAt(25));
	m_TblVersion.nCheckbdMonth2 = _ttoi(AryOfValues.ElementAt(0).ElementAt(26));
	m_TblVersion.nCheckbdMonth3 = _ttoi(AryOfValues.ElementAt(0).ElementAt(27));
	m_TblVersion.nCheckbdMonth4 = _ttoi(AryOfValues.ElementAt(0).ElementAt(28));

	m_TblVersion.bSubCheck1 = _ttoi(AryOfValues.ElementAt(0).ElementAt(29));
	m_TblVersion.bSubCheck2 = _ttoi(AryOfValues.ElementAt(0).ElementAt(30));
	m_TblVersion.bSubCheck3 = _ttoi(AryOfValues.ElementAt(0).ElementAt(31));
	m_TblVersion.bSubCheck4 = _ttoi(AryOfValues.ElementAt(0).ElementAt(32));
#if !IS_USE_VER1
	// 同时把本地的原始共享目录添加到m_TblNetShareInfo中;
	AddLocalShareDirectory();
#endif

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetTblCatalogInfo
	描述:获取分店数据库实例信息;
	参数:
	返回:
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblCatalogInfo()
{

	CStringArray AryOfFields;
	AryOfFields.Add(_T("enable"));
	AryOfFields.Add(_T("branch"));
	AryOfFields.Add(_T("branchid"));
	AryOfFields.Add(_T("clgname"));
	AryOfFields.Add(_T("clgport"));
	AryOfFields.Add(_T("clgsource"));
	AryOfFields.Add(_T("clgaccount"));
	AryOfFields.Add(_T("clgpassword"));

	CArray<CStringArray, CStringArray> AryOfValues;
	if (!GetTableValues(_T("CatalogInfo"), NULL, AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取CatalogInfo表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取CatalogInfo表失败"));
		return FALSE;
	}

	// 获取version表成功;
	for (int i = 0; i < AryOfValues.GetSize(); i++)
	{
		if( IsCatalogInfoExists(AryOfValues.ElementAt(i).ElementAt(2)) )
			continue;

		TblCatalogInfo *pCatalogInfo = new TblCatalogInfo;
		pCatalogInfo->bEnable = _ttoi(AryOfValues.ElementAt(i).ElementAt(0));
		_stprintf_s(pCatalogInfo->szBranch, _T("%s"), AryOfValues.ElementAt(i).ElementAt(1));
		_stprintf_s(pCatalogInfo->szBranchId, _T("%s"), AryOfValues.ElementAt(i).ElementAt(2));
		_stprintf_s(pCatalogInfo->szCatalogName, _T("%s"), AryOfValues.ElementAt(i).ElementAt(3));
		pCatalogInfo->dwCatalogPort = _ttoi(AryOfValues.ElementAt(i).ElementAt(4));
		_stprintf_s(pCatalogInfo->szCatalogSource, _T("%s"), AryOfValues.ElementAt(i).ElementAt(5));
		_stprintf_s(pCatalogInfo->szCatalogAccount, _T("%s"), AryOfValues.ElementAt(i).ElementAt(6));
		_stprintf_s(pCatalogInfo->szCatalogPassWord, _T("%s"), AryOfValues.ElementAt(i).ElementAt(7));
		
		m_TblCatalogInfo.push_back(pCatalogInfo);
	}

	return TRUE;
}

/************************************************************************/
/*
	函数:GetTblNetShareInfo
	描述:获取共享表的共享目录信息;
	参数:
	返回:
	要求:
	注意:如果当前连接的数据库是外网的(其他分店),则不读取这个共享表;
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblNetShareInfo()
{
	// 清除容器;
	RemoveNetShareInfo();
	AddLocalShareDirectory();

	CStringArray AryOfFields;
	AryOfFields.Add(_T("enable"));
	AryOfFields.Add(_T("branchid"));
	AryOfFields.Add(_T("sharePath"));
	AryOfFields.Add(_T("mincapacity"));
	AryOfFields.Add(_T("maxcapacity"));
	AryOfFields.Add(_T("photoType"));
	AryOfFields.Add(_T("priority"));

	CArray<CStringArray, CStringArray> AryOfValues;
	if (!GetTableValues(_T("NetShareInfo"), NULL, AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取NetShareInfo表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取NetShareInfo表失败"));
		return FALSE;
	}

	// 获取version表成功;
	for (int i = 0; i < AryOfValues.GetSize(); i++)
	{
		if( IsNetShareInfoExists(AryOfValues.ElementAt(i).ElementAt(1),AryOfValues.ElementAt(i).ElementAt(2)) )
			continue;

		TblNetShareInfo *pNetShareInfo = new TblNetShareInfo;
		pNetShareInfo->bEnable = _ttoi(AryOfValues.ElementAt(i).ElementAt(0));
		_stprintf_s(pNetShareInfo->szBranchId, _T("%s"), AryOfValues.ElementAt(i).ElementAt(1));
		_stprintf_s(pNetShareInfo->szShareDirectory, _T("%s"), AryOfValues.ElementAt(i).ElementAt(2));
		pNetShareInfo->byMinCapacity = _ttoi(AryOfValues.ElementAt(i).ElementAt(3));
		pNetShareInfo->byMaxCapacity = _ttoi(AryOfValues.ElementAt(i).ElementAt(4));
		pNetShareInfo->byPhotoType = _ttoi(AryOfValues.ElementAt(i).ElementAt(5));
		pNetShareInfo->byPriority = _ttoi(AryOfValues.ElementAt(i).ElementAt(6));
		m_TblNetShareInfo.push_back(pNetShareInfo);
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:IsNetShareInfoExists
	描述:域名共享信息是否已存在;
	参数:
		IN:		lpBranchId			共享目录应用的域名;
		IN:		lpShareDirectory	共享目录;
	返回:存在返回TRUE;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::IsNetShareInfoExists(IN LPCTSTR lpBranchId, IN LPCTSTR lpShareDirectory)
{
	BOOL bExists = FALSE;
	for ( NETSHAREINFO::const_iterator it = m_TblNetShareInfo.begin(); it != m_TblNetShareInfo.end(); it++)
	{
		if ( _tcscmp((*it)->szBranchId,lpBranchId) == 0 && _tcscmp((*it)->szShareDirectory,lpShareDirectory) == 0)
		{
			bExists = TRUE;
			break;
		}
	}

	return bExists;
}

/************************************************************************/
/* 
	函数:IsCatalogInfoExists
	描述:分店数据库实例是否存在;
	参数:
		IN:		lpBranchId			分店域名;
	返回:存在返回TRUE;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::IsCatalogInfoExists(IN LPCTSTR lpBranchId)
{
	BOOL bExists = FALSE;
	for ( CATALOGINFO::const_iterator it = m_TblCatalogInfo.begin(); it != m_TblCatalogInfo.end(); it++)
	{
		if ( _tcscmp((*it)->szBranchId,lpBranchId) == 0 )
		{
			bExists = TRUE;
			break;
		}
	}

	return bExists;
}


/************************************************************************/
/* 
	函数:GetTblIncrementBackup
	描述:获取增量备份的订单信息;
	参数:
		OUT:	AryOfValues
	返回:成功获取且大于0返回TRUE;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblIncrementBackup(OUT CArray<CStringArray, CStringArray> &AryOfValues, IN BOOL bIsBackup /* =  FALSE */)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("isbackup"));
	AryOfFields.Add(_T("branchid"));
	AryOfFields.Add(_T("opttime"));
	AryOfFields.Add(_T("[order]"));
	AryOfFields.Add(_T("photoType"));
	AryOfFields.Add(_T("[content]"));
	AryOfFields.Add(_T("userid"));
	AryOfFields.Add(_T("username"));
	AryOfFields.Add(_T("baktime"));


	if (!GetTableValues(_T("IncrementalBackup"), bIsBackup ? _T("isbackup = 1") : _T("isbackup = 0"), AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取IncrementalBackup表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取IncrementalBackup表失败"));
		return FALSE;
	}
	return TRUE;
}

#if TEST_CREATE_DIRECTORY	// 用于创建订单目录;
/************************************************************************/
/* 
	函数:GetTblPhotoManager
	描述:测试使用,获取PhotoManager表中的订单号; 
	参数:
	返回:
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblPhotoManager(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("[order]"));

	if (!GetTableValues(_T("PhotoManager"),NULL, AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取PhotoManager表失败\n"));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:CreateOrderDirectory
	描述:创建PhotoManager表中的订单目录; 
	参数:
	返回:
	要求:
	注意:
	示例:
*/
/************************************************************************/
void CBranchInfo::CreateOrderDirectory(IN LPCTSTR lpOrderNum)
{
	for (vector<TblNetShareInfo*>::const_iterator it = m_TblNetShareInfo.begin(); it != m_TblNetShareInfo.end(); it++)
	{
		if ( _tcscmp(m_szBranchDoMain,(*it)->szBranchId) == 0 )
		{
			CString strOrderPath = _T("");
			strOrderPath.Format(_T("%s\\%s"),(*it)->szShareDirectory,lpOrderNum);

			// 测试,先为测试删除创建所有的订单目录;
			if(!PathFileExists((*it)->szShareDirectory))continue;
			strOrderPath += _T("\\");

			//OutputDebugString(strOrderPath);
			//OutputDebugString(_T("\n"));
#ifdef UNICODE
			CHAR szShareDirectory[MAX_PATH] = {0};
			unicode2acsii(strOrderPath,szShareDirectory);
			MakeSureDirectoryPathExists(szShareDirectory);
#else
			MyMakeSureDirectoryPathExists(strOrderPath);
#endif

			LOG4C_NO_FILENUM((LOG_NOTICE,"创建目录[%s]成功",CW2A(strOrderPath)));
		}
	}
}
#endif

/************************************************************************/
/* 
	函数:GetTblAllPhotoManager
	描述:获取要删除的所有订单号;
	参数:
		OUT:	AryOfValues
	返回:成功获取且大于0返回TRUE;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblAllPhotoManager(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("branchid"));
	AryOfFields.Add(_T("[order]"));
	AryOfFields.Add(_T("takestatus"));
	AryOfFields.Add(_T("taketime"));

	AryOfFields.Add(_T("opdel"));
	AryOfFields.Add(_T("epdel"));
	AryOfFields.Add(_T("fpdel"));
	AryOfFields.Add(_T("dpdel"));

	AryOfFields.Add(_T("opbdel"));
	AryOfFields.Add(_T("epbdel"));
	AryOfFields.Add(_T("fpbdel"));
	AryOfFields.Add(_T("dpbdel"));

	AryOfFields.Add(_T("opdeltm"));
	AryOfFields.Add(_T("epdeltm"));
	AryOfFields.Add(_T("fpdeltm"));
	AryOfFields.Add(_T("dpdeltm"));

	AryOfFields.Add(_T("opbdeltm"));
	AryOfFields.Add(_T("epbdeltm"));
	AryOfFields.Add(_T("fpbdeltm"));
	AryOfFields.Add(_T("dpbdeltm"));

	if (!GetTableValues(_T("PhotoManager"), NULL, AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取PhotoManager表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取PhotoManager表 all失败 "));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetTblPhotoManager1
	描述:获取要删除的原片订单号;
	参数:
		OUT:	AryOfValues
	返回:成功获取且大于0返回TRUE;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblPhotoManager1(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("[branchid]"));
	AryOfFields.Add(_T("[order]"));
	AryOfFields.Add(_T("takestatus"));
	AryOfFields.Add(_T("taketime"));
	AryOfFields.Add(_T("opdel"));

	if (!GetTableValues(_T("PhotoManager"), _T("takestatus = 1 and opdel = 0"), AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取PhotoManager表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取PhotoManager表1失败"));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetTblPhotoManager2
	描述:获取要删除的初修片订单号;
	参数:
		OUT:	AryOfValues
	返回:成功获取且大于0返回TRUE;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblPhotoManager2(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("[branchid]"));
	AryOfFields.Add(_T("[order]"));
	AryOfFields.Add(_T("takestatus"));
	AryOfFields.Add(_T("taketime"));
	AryOfFields.Add(_T("epdel"));

	if (!GetTableValues(_T("PhotoManager"), _T("takestatus = 1 and epdel = 0"), AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取PhotoManager表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取PhotoManager表2失败"));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetTblPhotoManager3
	描述:获取要删除的精修片订单号;
	参数:
		OUT:	AryOfValues
	返回:成功获取且大于0返回TRUE;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblPhotoManager3(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("[branchid]"));
	AryOfFields.Add(_T("[order]"));
	AryOfFields.Add(_T("takestatus"));
	AryOfFields.Add(_T("taketime"));
	AryOfFields.Add(_T("fpdel"));

	if (!GetTableValues(_T("PhotoManager"), _T("takestatus = 1 and fpdel = 0"), AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取PhotoManager表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取PhotoManager表3失败"));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetTblPhotoManager4
	描述:获取要删除的设计片订单号;
	参数:
		OUT:	AryOfValues
	返回:成功获取且大于0返回TRUE;
	要求:
	注意:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblPhotoManager4(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("[branchid]"));
	AryOfFields.Add(_T("[order]"));
	AryOfFields.Add(_T("takestatus"));
	AryOfFields.Add(_T("taketime"));
	AryOfFields.Add(_T("dpdel"));

	if (!GetTableValues(_T("PhotoManager"), _T("takestatus = 1 and dpdel = 0"), AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取PhotoManager表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取PhotoManager表4失败"));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetTblPhotoManager5
	描述:获取要删除的备份原片订单号;
	参数:
		OUT:	AryOfValues
	返回:成功获取且大于0返回TRUE;
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblPhotoManager5(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("[branchid]"));
	AryOfFields.Add(_T("[order]"));
	AryOfFields.Add(_T("takestatus"));
	AryOfFields.Add(_T("taketime"));
	AryOfFields.Add(_T("opbdel"));

	if (!GetTableValues(_T("PhotoManager"), _T("takestatus = 1 and opbdel = 0"), AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取PhotoManager表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取PhotoManager表5失败"));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetTblPhotoManager6
	描述:获取要删除的备份初修片订单号;
	参数:
		OUT:	AryOfValues
	返回:成功获取且大于0返回TRUE;
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblPhotoManager6(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("[branchid]"));
	AryOfFields.Add(_T("[order]"));
	AryOfFields.Add(_T("takestatus"));
	AryOfFields.Add(_T("taketime"));
	AryOfFields.Add(_T("epbdel"));

	if (!GetTableValues(_T("PhotoManager"), _T("takestatus = 1 and epbdel = 0"), AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取PhotoManager表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取PhotoManager表6失败"));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetTblPhotoManager7
	描述:获取要删除的备份精修片订单号;
	参数:
		OUT:	AryOfValues
	返回:成功获取且大于0返回TRUE;
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblPhotoManager7(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("[branchid]"));
	AryOfFields.Add(_T("[order]"));
	AryOfFields.Add(_T("takestatus"));
	AryOfFields.Add(_T("taketime"));
	AryOfFields.Add(_T("fpbdel"));

	if (!GetTableValues(_T("PhotoManager"), _T("takestatus = 1 and fpbdel = 0"), AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取PhotoManager表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取PhotoManager表7失败"));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetTblPhotoManager8
	描述:获取要删除的备份设计片订单号;
	参数:
		OUT:	AryOfValues
	返回:成功获取且大于0返回TRUE;
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::GetTblPhotoManager8(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{
	CStringArray AryOfFields;
	AryOfFields.Add(_T("[branchid]"));
	AryOfFields.Add(_T("[order]"));
	AryOfFields.Add(_T("takestatus"));
	AryOfFields.Add(_T("taketime"));
	AryOfFields.Add(_T("dpbdel"));

	if (!GetTableValues(_T("PhotoManager"), _T("takestatus = 1 and dpbdel = 0"), AryOfFields, AryOfValues))
	{
		//OutputDebugString(_T("获取PhotoManager表失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取PhotoManager表8失败"));
		return FALSE;
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:AddLocalShareDirectory
	描述:添加本地固定名称的共享目录(早期版本软件使用);
	参数:#
	返回:#
	要求:
	注意:
*/
/************************************************************************/
void CBranchInfo::AddLocalShareDirectory()
{
	// 1.获取本机计算机名;
	DWORD dwLeng = 0;
	TCHAR szHost[MAX_PATH] = _T("");
	GetComputerName(NULL, &dwLeng);
	GetComputerName(szHost, &dwLeng);


	// 2.本机共享目录;
	TCHAR szShareDirectory[MAX_PATH] = { 0 };
#if 1
	_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), szHost, ORIGINAL);
	InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 1, 255);

	_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), szHost, EARLY);
	InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 2, 255);

	_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), szHost, FUTHER);
	InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 3, 255);

	_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), szHost, DESIGN);
	InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 4, 255);
#endif

#ifdef CHILD_VERSION
	// 3.其他备份目录;
		// 儿童版本;
		_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), m_TblVersion.szbakServer1, _T("客户原片备份(儿童管理软件)$"));
		InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 5, 255);

		_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), m_TblVersion.szbakServer2, _T("修好的片备份(儿童管理软件)$"));
		InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 6, 255);

		_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), m_TblVersion.szbakServer3, _T("精修好的片备份(儿童管理软件)$"));
		InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 7, 255);

		_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), m_TblVersion.szbakServer4, _T("设计好的片备份(儿童管理软件)$"));
		InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 8, 255);
#else
		// 婚纱版本;
		_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), m_TblVersion.szbakServer1, _T("客户原片备份(管理软件)$"));
		InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 5, 255);

		_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), m_TblVersion.szbakServer2, _T("修好的片备份(管理软件)$"));
		InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 6, 255);

		_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), m_TblVersion.szbakServer3, _T("精修好的片备份(管理软件)$"));
		InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 7, 255);

		_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), m_TblVersion.szbakServer4, _T("设计好的片备份(管理软件)$"));
		InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 35, 8, 255);
#endif


}

/************************************************************************/
/* 
	函数:InsertNetShareInfo
	描述:添加新的共享目录信息;
	参数:
		IN:		lpShareDirectory
		IN:		lpBranchId
		IN:		nMinCapacity
		IN:		nMaxCapacity
		IN:		nPhotoType
		IN:		nPriority
	返回:成功添加返回TRUE;
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::InsertNetShareInfo(IN LPCTSTR lpShareDirectory, IN LPCTSTR lpBranchId, IN CONST BYTE &nMinCapacity, IN CONST BYTE &nMaxCapacity, IN CONST BYTE &nPhotoType, IN CONST BYTE &nPriority)
{
	if (PathFileExists(lpShareDirectory))
	{
		TblNetShareInfo *pNetShareInfo = new TblNetShareInfo;
		pNetShareInfo->bEnable = TRUE;
		_stprintf_s(pNetShareInfo->szBranchId, _T("%s"), m_szBranchDoMain);
		_stprintf_s(pNetShareInfo->szShareDirectory, _T("%s"), lpShareDirectory);
		pNetShareInfo->byMinCapacity = nMinCapacity;
		pNetShareInfo->byMaxCapacity = nMaxCapacity;
		pNetShareInfo->byPhotoType = nPhotoType;
		pNetShareInfo->byPriority = nPriority;

		m_TblNetShareInfo.push_back(pNetShareInfo);
		return TRUE;
	}

	return FALSE;
}

//////////////////////////////////////////////////////////////////////////
/************************************************************************/
/* 
	函数:StartThread
	描述:启动工作者线程;
	参数:
	返回:
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::StartThread()
{
	//获取备份目录
	m_bakDirArr.RemoveAll();
	GetBackupOfSaveDir(m_bakDirArr);

	//////////////////////////////////////////////////////////////////////////
	// 增量备份线程;
	if ( m_hIncrementCtrl == NULL )
	{
		m_hIncrementCtrl = CreateEvent(NULL, TRUE, FALSE, NULL);
		if ( m_hIncrementCtrl == NULL )
		{
			// 创建事件失败;
			//OutputDebugString(_T("创建增量备份线程事件失败\n"));
			//LOG4C_NO_FILENUM((LOG_NOTICE,"创建增量备份线程事件失败"));
			return FALSE;
		}
	}

	if ( m_hIncrement == NULL )
	{
		m_hIncrement = CreateThread(NULL, 0, ThreadOfIncrement, this, 0, NULL);
		if ( m_hIncrement == NULL )
		{
			// 创建线程失败;
			//OutputDebugString(_T("创建增量备份线程失败\n"));
			//LOG4C_NO_FILENUM((LOG_NOTICE,"创建增量备份线程失败"));
			return FALSE;
		}
	}


	/*
	//////////////////////////////////////////////////////////////////////////
	// 订单相片删除线程;
	if (m_hRemoveCtrl == NULL)
	{
		m_hRemoveCtrl = CreateEvent(NULL, TRUE, FALSE, NULL);
		if (m_hRemoveCtrl == NULL)
		{
			// 创建事件失败;
			//OutputDebugString(_T("创建订单删除线程事件失败\n"));
			//LOG4C_NO_FILENUM((LOG_NOTICE,"创建订单删除线程事件失败"));
			return FALSE;
		}
	}

	if (m_hRemove == NULL)
	{
		m_hRemove = CreateThread(NULL, 0, ThreadRemove, this, 0, NULL);
		if (m_hRemove == NULL)
		{
			// 创建线程失败;
			//OutputDebugString(_T("创建订单删除线程失败\n"));
			//LOG4C_NO_FILENUM((LOG_NOTICE,"创建订单删除线程失败"));
			return FALSE;
		}
	}
	*/

	return TRUE;
}

/************************************************************************/
/* 
	函数:StartThread_Tm
	描述:启动工作线程(计时器线程)
	参数:
	返回:
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::StartThread_Tm()
{
	// 计时器;
	SYSTEMTIME st;
	FILETIME ftLocal, ftUTC;
	LARGE_INTEGER liUTC;

	st.wYear = 2015;		// Year
	st.wMonth = 4;			// January
	st.wDayOfWeek = 0;		// Ignored
	st.wDay = 1;			// The first of the month
	st.wHour = 23;			// 1PM
	st.wMinute = 0;			// 0 minutes into the hour
	st.wSecond = 0;			// 0 seconds into the minute
	st.wMilliseconds = 0;   // 0 milliseconds into the second

	SystemTimeToFileTime(&st, &ftLocal);

	// Convert local time to UTC time.
	LocalFileTimeToFileTime(&ftLocal, &ftUTC);
	// Convert FILETIME to LARGE_INTEGER because of different alignment.
	liUTC.LowPart = ftUTC.dwLowDateTime;
	liUTC.HighPart = ftUTC.dwHighDateTime;
	liUTC.QuadPart = -(2 * 10000000);
	const int nTimerUnitsPerSecond = 10000000;

	//////////////////////////////////////////////////////////////////////////
	// 增量备份线程;
	m_bIncrementTm = FALSE;
	m_hIncrementWaitableTm = CreateWaitableTimer(NULL, FALSE, NULL);
	
#if _DEBUG
	SetWaitableTimer(m_hIncrementWaitableTm, &liUTC, 3 * 1000, NULL, NULL, FALSE);	// 3秒执行一次;
#else
	SetWaitableTimer(m_hIncrementWaitableTm, &liUTC, 3 * 60 * 60 * 1000, NULL, NULL, FALSE);	// 3小时执行一次;
#endif

	
	m_hIncrement = CreateThread(NULL, 0, ThreadOfIncrement_Tm, this, 0, NULL);
	if (m_hIncrement == NULL)
	{
		//OutputDebugString(_T("创建增量备份线程失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"创建增量备份线程失败"));
		return FALSE;
	}
/*
	//////////////////////////////////////////////////////////////////////////
	// 订单相片删除线程;
	m_bRemoveTm = FALSE;
	m_hRemoveWaitableTm = CreateWaitableTimer(NULL, FALSE, NULL);
#if _DEBUG
	SetWaitableTimer(m_hRemoveWaitableTm, &liUTC, 3 * 1000, NULL, NULL, FALSE);	// 3秒执行一次;
#else
	SetWaitableTimer(m_hRemoveWaitableTm, &liUTC, 3 * 60 * 60 * 1000, NULL, NULL, FALSE);	// 3小时执行一次;
#endif

	
	m_hRemove = CreateThread(NULL, 0, ThreadRemove_Tm, this, 0, NULL);
	if (m_hRemove == NULL)
	{
		//OutputDebugString(_T("创建订单删除线程失败\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"创建订单删除线程失败"));
		return FALSE;
	}
	*/

	return TRUE;
}

/************************************************************************/
/* 
	函数:EndOfThread
	描述:结束线程
	参数:
	返回:
	要求:
	注意:
*/
/************************************************************************/
VOID CBranchInfo::EndOfThread()
{
	//////////////////////////////////////////////////////////////////////////
	// 停止增量备份线程;
	if ( m_hIncrementCtrl )
		SetEvent(m_hIncrementCtrl);

	if ( m_hIncrement )
	{
		WaitForSingleObject(m_hIncrement, INFINITE);
		CloseHandle(m_hIncrement);
		m_hIncrement = NULL;
	}

	if ( m_hIncrementCtrl )
	{
		CloseHandle(m_hIncrementCtrl);
		m_hIncrementCtrl = NULL;
	}

	/*
	//////////////////////////////////////////////////////////////////////////
	// 停止订单删除线程;
	if ( m_hRemoveCtrl )
	{
		SetEvent(m_hRemoveCtrl);
	}

	if (m_hRemove)
	{
		WaitForSingleObject(m_hRemove, INFINITE);
		CloseHandle(m_hRemove);
		m_hRemove = NULL;
	}

	if (m_hRemoveCtrl)
	{
		CloseHandle(m_hRemoveCtrl);
		m_hRemoveCtrl = NULL;
	}
	*/
}

/************************************************************************/
/* 
	函数:EndOfThread_Tm
	描述:结束线程(计时器线程)
	参数:
	返回:
	要求:
	注意:
*/
/************************************************************************/
VOID CBranchInfo::EndOfThread_Tm()
{
	// 重置等待时间,立即返回;
	LARGE_INTEGER li;
	const int nTimerUnitsPerSecond = 10000000;
	li.QuadPart = 1 * nTimerUnitsPerSecond;

	//////////////////////////////////////////////////////////////////////////
	// 停止增量备份线程;
	m_bIncrementTm = TRUE;
	SetWaitableTimer(m_hIncrementWaitableTm, &li, NULL, NULL, NULL, FALSE);

	if (m_hIncrement)
	{
		WaitForSingleObject(m_hIncrement, INFINITE);
		CloseHandle(m_hIncrement);
		m_hIncrement = NULL;
	}

	if (m_hIncrementWaitableTm)
	{
		CloseHandle(m_hIncrementWaitableTm);
		m_hIncrementWaitableTm = NULL;
	}

	/*
	//////////////////////////////////////////////////////////////////////////
	// 停止订单删除线程;
	m_bRemoveTm = TRUE;
	SetWaitableTimer(m_hRemoveWaitableTm, &li, NULL, NULL, NULL, FALSE);

	if (m_hRemove)
	{
		WaitForSingleObject(m_hRemove, INFINITE);
		CloseHandle(m_hRemove);
		m_hRemove = NULL;
	}

	if (m_hRemoveWaitableTm)
	{
		CloseHandle(m_hRemoveWaitableTm);
		m_hRemoveWaitableTm = NULL;
	}
	*/
}

/************************************************************************/
/* 
	函数:ThreadOfIncrement
	描述:增量备份线程;
	参数:
	返回:
	要求:
	注意:
*/
/************************************************************************/
DWORD CBranchInfo::ThreadOfIncrement(LPVOID lpParameter)
{
	//OutputDebugString(_T("增量备份线程启动\n"));
/*
	CBranchInfo *pInstance = (CBranchInfo*)lpParameter;
	do 
	{
		pInstance->IncrementWork();
	} while (WAIT_TIMEOUT == WaitForSingleObject(pInstance->m_hIncrementCtrl, 15000) );
*/
	//OutputDebugString(_T("增量备份线程退出\n"));

	return 0L;
}

/************************************************************************/
/* 
	函数:ThreadRemove
	描述:自动删除线程
	参数:
	返回:
	要求:
	注意:
*/
/************************************************************************/
DWORD CBranchInfo::ThreadRemove(LPVOID lpParameter)
{
	//OutputDebugString(_T("删除订单线程启动\n"));

	int nSize = 0;
	CBranchInfo *pInstance = (CBranchInfo*)lpParameter;
	do 
	{
		// 读取PhotoManager表信息;
		CArray<CStringArray, CStringArray> AryOfRemvoeOrder;

#if TEST_CREATE_DIRECTORY
		pInstance->GetTblPhotoManager(AryOfRemvoeOrder);
		nSize = AryOfRemvoeOrder.GetSize();
		for ( int i = 0; i < nSize; i++)
		{
			pInstance->CreateOrderDirectory(AryOfRemvoeOrder.ElementAt(i).ElementAt(0));
			Sleep(0);
		}

		SetEvent(pInstance->m_hRemoveCtrl);
		LOG4C_NO_FILENUM((LOG_NOTICE,"创建目录结束,线程退出~~"));
#else
		AryOfRemvoeOrder.RemoveAll();
		pInstance->GetTblPhotoManager1(AryOfRemvoeOrder);
		nSize = AryOfRemvoeOrder.GetSize();
		for ( int i = 0; i < nSize; i++)
		{
			pInstance->GetRemvoeOrderInfoAndRemove(AryOfRemvoeOrder.ElementAt(i).ElementAt(0),AryOfRemvoeOrder.ElementAt(i).ElementAt(1),AryOfRemvoeOrder.ElementAt(i).ElementAt(3),1);
			Sleep(0);
		}

		AryOfRemvoeOrder.RemoveAll();
		pInstance->GetTblPhotoManager2(AryOfRemvoeOrder);
		nSize = AryOfRemvoeOrder.GetSize();
		for ( int i = 0; i < nSize; i++)
		{
			pInstance->GetRemvoeOrderInfoAndRemove(AryOfRemvoeOrder.ElementAt(i).ElementAt(0),AryOfRemvoeOrder.ElementAt(i).ElementAt(1),AryOfRemvoeOrder.ElementAt(i).ElementAt(3),2);
			Sleep(0);
		}

		AryOfRemvoeOrder.RemoveAll();
		pInstance->GetTblPhotoManager3(AryOfRemvoeOrder);
		nSize = AryOfRemvoeOrder.GetSize();
		for ( int i = 0; i < nSize; i++)
		{
			pInstance->GetRemvoeOrderInfoAndRemove(AryOfRemvoeOrder.ElementAt(i).ElementAt(0),AryOfRemvoeOrder.ElementAt(i).ElementAt(1),AryOfRemvoeOrder.ElementAt(i).ElementAt(3),3);
			Sleep(0);
		}

		AryOfRemvoeOrder.RemoveAll();
		pInstance->GetTblPhotoManager4(AryOfRemvoeOrder);
		nSize = AryOfRemvoeOrder.GetSize();
		for ( int i = 0; i < nSize; i++)
		{
			pInstance->GetRemvoeOrderInfoAndRemove(AryOfRemvoeOrder.ElementAt(i).ElementAt(0),AryOfRemvoeOrder.ElementAt(i).ElementAt(1),AryOfRemvoeOrder.ElementAt(i).ElementAt(3),4);
			Sleep(0);
		}

		AryOfRemvoeOrder.RemoveAll();
		pInstance->GetTblPhotoManager5(AryOfRemvoeOrder);
		nSize = AryOfRemvoeOrder.GetSize();
		for ( int i = 0; i < nSize; i++)
		{
			pInstance->GetRemvoeOrderInfoAndRemove(AryOfRemvoeOrder.ElementAt(i).ElementAt(0),AryOfRemvoeOrder.ElementAt(i).ElementAt(1),AryOfRemvoeOrder.ElementAt(i).ElementAt(3),5);
			Sleep(0);
		}

		AryOfRemvoeOrder.RemoveAll();
		pInstance->GetTblPhotoManager6(AryOfRemvoeOrder);
		nSize = AryOfRemvoeOrder.GetSize();
		for ( int i = 0; i < nSize; i++)
		{
			pInstance->GetRemvoeOrderInfoAndRemove(AryOfRemvoeOrder.ElementAt(i).ElementAt(0),AryOfRemvoeOrder.ElementAt(i).ElementAt(1),AryOfRemvoeOrder.ElementAt(i).ElementAt(3),6);
			Sleep(0);
		}

		AryOfRemvoeOrder.RemoveAll();
		pInstance->GetTblPhotoManager7(AryOfRemvoeOrder);
		nSize = AryOfRemvoeOrder.GetSize();
		for ( int i = 0; i < nSize; i++)
		{
			pInstance->GetRemvoeOrderInfoAndRemove(AryOfRemvoeOrder.ElementAt(i).ElementAt(0),AryOfRemvoeOrder.ElementAt(i).ElementAt(1),AryOfRemvoeOrder.ElementAt(i).ElementAt(3),7);
			Sleep(0);
		}

		AryOfRemvoeOrder.RemoveAll();
		pInstance->GetTblPhotoManager8(AryOfRemvoeOrder);
		nSize = AryOfRemvoeOrder.GetSize();
		for ( int i = 0; i < nSize; i++)
		{
			pInstance->GetRemvoeOrderInfoAndRemove(AryOfRemvoeOrder.ElementAt(i).ElementAt(0),AryOfRemvoeOrder.ElementAt(i).ElementAt(1),AryOfRemvoeOrder.ElementAt(i).ElementAt(3),8);
			Sleep(0);
		}
#endif
	} while (WAIT_TIMEOUT == WaitForSingleObject(pInstance->m_hRemoveCtrl, 15000) );

	//OutputDebugString(_T("删除订单线程退出\n"));
	return 0L;
}

/************************************************************************/
/* 
	函数:ThreadOfIncrement_Tm
	描述:增量备份线程(计时器线程)
	参数:
	返回:
	要求:
	注意:
*/
/************************************************************************/
DWORD CBranchInfo::ThreadOfIncrement_Tm(LPVOID lpParameter)
{
	CBranchInfo *pInstance = (CBranchInfo*)lpParameter;
	while (!pInstance->m_bIncrementTm)
	{
		WaitForSingleObject(pInstance->m_hIncrementWaitableTm, INFINITE);
	}
	return 0L;
}

/************************************************************************/
/* 
	函数:ThreadRemove_Tm
	描述:自动删除线程(计时器线程)
	参数:
	返回:
	要求:
	注意:
*/
/************************************************************************/
DWORD CBranchInfo::ThreadRemove_Tm(LPVOID lpParameter)
{
	CBranchInfo *pInstance = (CBranchInfo*)lpParameter;
	while (!pInstance->m_bRemoveTm)
	{
		WaitForSingleObject(pInstance->m_hRemoveWaitableTm, INFINITE);
	}
	return 0L;
}

/************************************************************************/
/* 
	函数:Separator
	描述:根据分隔符解析出目标字符串;
	参数:
		IN:		lpSeparator  源字符串的分隔符;
		IN:		lpString	 源字符串;
		OUT:	ResultArray	 解析出的字符串数组;
	返回:
	要求:
	注意:
*/
/************************************************************************/
void CBranchInfo::Separator(IN LPCTSTR lpSeparator, IN LPCTSTR lpString, OUT CStringArray &ResultArray)
{
	CString strSrc = lpString;
	strSrc.TrimLeft(lpSeparator);
	strSrc.TrimRight(lpSeparator);
	strSrc += lpSeparator;

	int nIndex = 0;
	do 
	{
		nIndex = strSrc.Find(lpSeparator);
		if ( -1 != nIndex )
		{
			CString strImage = strSrc.Left(nIndex);
			strSrc = strSrc.Mid(nIndex+1);
			if ( PathFileExists(strImage) )
			{
				ResultArray.Add(strImage);
			}
		}
	} while ( -1 != nIndex );
}

/************************************************************************/
/* 
	函数:FindImageShareDirectory
	描述:根据相片名称,订单号,相片类型在共享目录数组中查找出相片的实现路径;
	参数:
		IN;		lpBranchId			相片所属分店;
		IN:		byPhotoType			相片类型;
		IN:		lpImage				相片名称,带护展名; 
		IN:		lpOrderNum			相片所在的订单号;
		OUT:	lpShareDirectory	若相片存在,这里为相片的实际路径;

	返回:相片存在返回TRUE,否则FALSE;
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::FindImageShareDirectory(IN LPCTSTR lpBranchId, IN const BYTE &byPhotoType, IN LPCTSTR lpImage, IN LPCTSTR lpOrderNum, OUT LPTSTR lpShareDirectory)
{
	BOOL bExists = FALSE;
	TblNetShareInfo *pNetShareInfo = NULL;
	for (NETSHAREINFO::const_iterator it = m_TblNetShareInfo.begin(); it != m_TblNetShareInfo.end(); it++)
	{
		pNetShareInfo = *it;
		if ( _tcscmp(pNetShareInfo->szBranchId,lpBranchId) == 0 )
		{
			if ( pNetShareInfo->byPhotoType == byPhotoType )
			{
				CString strImagePath = _T("");
				strImagePath.Format(_T("%s\\%s"),pNetShareInfo->szShareDirectory,lpOrderNum);
				
				TCHAR szDirectory[MAX_PATH] = {0};
				if( FindFileNameFromSpecialDirectory(strImagePath,lpImage,szDirectory) )	// 返回第一个找到的文件名的路径;
				{
					// 同一文件名,可能同时存在多种后缀的相片,只要存在其中一种格式即可;
					strImagePath.Format(_T("%s\\%s"),szDirectory,lpImage);
					if ( PathFileExists(strImagePath + _T(".jpg")) )
					{
						bExists = TRUE;
						_stprintf_s(lpShareDirectory, MAX_PATH, _T("%s.jpg"), strImagePath);
					}
					else if ( PathFileExists(strImagePath + _T(".raw")) )
					{
						bExists = TRUE;
						_stprintf_s(lpShareDirectory, MAX_PATH, _T("%s.raw"), strImagePath);
					}
					else if ( PathFileExists(strImagePath + _T(".cr2")) )
					{
						bExists = TRUE;
						_stprintf_s(lpShareDirectory, MAX_PATH, _T("%s.cr2"), strImagePath);
					}
					else if ( PathFileExists(strImagePath + _T(".nef")) )
					{
						bExists = TRUE;
						_stprintf_s(lpShareDirectory, MAX_PATH, _T("%s.nef"), strImagePath);
					}

					if ( bExists )
					{
						break;
					}
				}
			}
		}
	}

	return bExists;
}

/************************************************************************/
/* 
	函数:FindImageShareDirectory
	描述:根据相片名称,订单号,相片类型在共享目录数组中查找出相片的实现路径;
	参数:
		IN:		byPhotoType			相片类型;
		IN:		lpImage				相片名称,不带后缀; 
		IN:		lpOrderNum			相片所在的订单号;
		OUT:	AryOfShareDirectory	若相片存在,这里为相片(多种格式)的实际路径数组;

	返回:相片存在返回TRUE,否则FALSE;
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::FindImageShareDirectory(IN const BYTE &byPhotoType, IN LPCTSTR lpImage, IN LPCTSTR lpOrderNum, OUT CStringArray &AryOfShareDirectory)
{
	// lpImage只是文件名,无后缀;
	BOOL bExists = FALSE;
	TblNetShareInfo *pNetShareInfo = NULL;
	for (NETSHAREINFO::const_iterator it = m_TblNetShareInfo.begin(); it != m_TblNetShareInfo.end(); it++)
	{
		pNetShareInfo = *it;
		if ( _tcscmp(pNetShareInfo->szBranchId,m_szBranchDoMain) == 0 )
		{
			if ( pNetShareInfo->byPhotoType == byPhotoType )
			{
				CString strImagePaht = _T("");
				strImagePaht.Format(_T("%s\\%s\\%s"),pNetShareInfo->szShareDirectory,lpOrderNum,lpImage);

				if ( PathFileExists(strImagePaht + _T(".jpg")) )
				{
					bExists = TRUE;
					AryOfShareDirectory.Add(CString(strImagePaht +  _T(".jpg")));
				}

				if ( PathFileExists(strImagePaht + _T(".raw")) )
				{
					bExists = TRUE;
					AryOfShareDirectory.Add(CString(strImagePaht +  _T(".raw")));
				}

				if ( PathFileExists(strImagePaht + _T(".cr2")) )
				{
					bExists = TRUE;
					AryOfShareDirectory.Add(CString(strImagePaht +  _T(".cr2")));
				}

				if ( PathFileExists(strImagePaht + _T(".nef")) )
				{
					bExists = TRUE;
					AryOfShareDirectory.Add(CString(strImagePaht +  _T(".nef")));
				}

				if(bExists) break;
			}
		}
	}

	return bExists;
}

/************************************************************************/
/* 
	函数:GetIncrementContentAndBackup
	描述:解析出增量表里的content字段保存的相片路径,并增量备份;
	参数:
		IN:		lpBranchId	分店id;
		IN:		lpOpTm		操作时间;
		IN:		lpOrder		订单号;
		IN:		byPhotoType	相片类型;
		IN:		lpIncrementContent	content字段的相片信息;
	返回:
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::GetIncrementContentAndBackup(IN LPCTSTR lpBranchId, IN LPCTSTR lpOpTm, IN LPCTSTR lpOrder, IN CONST BYTE &byPhotoType, IN LPCTSTR lpIncrementContent)
{
	if ( byPhotoType > 8) return FALSE;

	if ( lpOrder == NULL || lpOrder[0] == '\0')
	{
		// 订单为空时,造成函数运行缓慢;
		return FALSE;
	}

	// 1.解析出增量相片的路径;
	CStringArray AryOfImagePath;
	CString strIncrementContent;
	strIncrementContent.Format(_T("%s"), lpIncrementContent);

#if 1
	// content里的内容只是相片名称;
	// 首先实现的是有后缀名的相片;
	strIncrementContent.TrimLeft(_T("|"));
	strIncrementContent.TrimRight(_T("|"));
	strIncrementContent += _T("|");

	int nIndex = 0;

	do 
	{
		nIndex = strIncrementContent.Find(_T('|'));
		if ( nIndex != -1 )
		{
			CString strImage = strIncrementContent.Left(nIndex);
			strIncrementContent = strIncrementContent.Mid(nIndex+1);

			// 在所有共享目录下查找该相片路径;
#if 1
			TCHAR szShareDirectory[MAX_PATH] = {0};
			// 根据文件名到订单目录下查找相片,返回相片的路径;
			// 若两个子目录下都有相片文件名的,只会返回第一个找到的文件的完整路径;
			if (FindImageShareDirectory(lpBranchId,byPhotoType,strImage,lpOrder,szShareDirectory))
			{
				AryOfImagePath.Add(szShareDirectory);
			}
#else
			FindImageShareDirectory(byPhotoType,strImage,lpOrder,AryOfImagePath);
#endif

		}
	} while ( nIndex != -1);
#endif

#if 0// content里的内容:"\\lyfz-pc\共享1\001.jpg|\\lyfz-pc\共享1\002.jpg"
	strIncrementContent.TrimLeft(_T("|"));
	strIncrementContent.TrimRight(_T("|"));
	strIncrementContent += _T("|");

	int nIndex = 0;

	do 
	{
		nIndex = strIncrementContent.Find(_T('|'));
		if ( nIndex != -1 )
		{
			CString strImage = strIncrementContent.Left(nIndex);
			strIncrementContent = strIncrementContent.Mid(nIndex+1);

			if (PathFileExists(strImage))
			{
				AryOfImagePath.Add(strImage);
			}
		}
	} while ( nIndex != -1);
#endif

#if 0
	// 另一种形式:"?\\lyf\共享1\:001.jpg|002.jpg|003.jpg?\\lyfz-server\共享1:001.jpg|002.jpg?"
	strIncrementContent.TrimLeft(_T("?"));
	strIncrementContent.TrimRight(_T("?"));
	strIncrementContent += _T("?");

	int nIndex = 0;
	do 
	{
		nIndex = strIncrementContent.Find(_T('?'));
		if ( -1 != nIndex )
		{
			CString strSubIncrement = strIncrementContent.Left(nIndex);
			strIncrementContent = strSubIncrement.Mid(nIndex+1);

			CString strShareDirectory;
			nIndex = strSubIncrement.Find(_T(':'));
			if ( -1 != nIndex )
			{
				strShareDirectory = strSubIncrement.Left(nIndex);
				strShareDirectory.TrimRight(_T('\\'));
				strShareDirectory += _T("\\");
				strShareDirectory += lpOrder;
				strShareDirectory += _T("\\");
				strSubIncrement = strSubIncrement.Mid(nIndex+1);
				strSubIncrement.TrimRight(_T('|'));
				strSubIncrement += _T("|");
				do 
				{
					nIndex = strSubIncrement.Find(_T('|'));
					if ( -1 != nIndex)
					{
						CString strImage = strSubIncrement.Left(nIndex);
						strSubIncrement = strSubIncrement.Mid(nIndex+1);
						if ( PathFileExists(strShareDirectory+strImage) )
						{
							AryOfImagePath.Add(strShareDirectory+strImage);
						}
					}
				} while ( -1 != nIndex );
			}
		}
	} while (-1 != nIndex);
#endif

	if ( AryOfImagePath.GetSize() == 0)
		return FALSE;
	
	// 获取增量相片的总大小;
	UINT64 uFilesSize = EasyGetSizeOfFiles(AryOfImagePath);
	UINT64 nCapacity = uFilesSize/(1024*1024*1024);

	// 开始备份;
	double dFreeNum;
	TCHAR szEnableShareDirectory[MAX_PATH] = {0};

	if ( !GetEnableShareDirectory(dFreeNum,byPhotoType+4,lpBranchId,lpOrder,szEnableShareDirectory) )	// byPhotoType要增加4,移动到备份类型;
	{
		//OutputDebugString(_T("无可用共享目录\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"无可用共享目录"));
		return FALSE;
	}

	if ( dFreeNum > nCapacity )	// 一般增量备份的相片大小,不会超过5g,一般可以不判断;
	{
		// 判断是否存在当天日期文件;
		CString strDate = lpOpTm;
		strDate = strDate.Left(10);

		CString strDatePath = szEnableShareDirectory;
		strDatePath += strDate;
		strDatePath += _T("\\");

#ifdef UNICODE
		CHAR szShareDirectory[MAX_PATH] = {0};
		unicode2acsii(strDatePath,szShareDirectory);
		MakeSureDirectoryPathExists(szShareDirectory);
#else
		MyMakeSureDirectoryPathExists(strDatePath);
#endif
		for ( int i = 0; i < AryOfImagePath.GetSize(); i++)
		{
			// 存储的目录，需要提取出订单号以下出现的各种子目录名;
			EasyCopyFile(lpOrder, AryOfImagePath.ElementAt(i), strDatePath);
		}

		// 更新数据库;
		// --产生个问题,因为如果是多店的话,连接的不是本店的数据库,但是备份的时候把分店的相片备份了;
		if ( m_bIsOur )
		{
			strDate.Format(_T("update [IncrementalBackup] set [isbackup] = 1,[baktime] = getdate() where [branchid] = '%s' and [order] = '%s' and photoType = %d and content = '%s|'"),lpBranchId,lpOrder,byPhotoType,lpIncrementContent);
			Execute(strDate);
		}
	}

	return TRUE;
}

/************************************************************************/
/* 
	函数:GetRemvoeOrderInfoAndRemove
	描述:获取取件OK,且未删除过的相片的订单路径,并删除达到要求时间的订单相片;
	参数:
		IN:		lpOrderNum	要删除的订单号;
		IN:		lpOpTm		要删除的订单号的取件时间;
		IN:		byPhotoType	要删除的订单号的相片类型;
	返回:
	要求:
	注意:
		1.如果要删除存储在本店中的分店订单相片,必须在NetShareInfo表中添加分店路径,且用到的域名是本店的域名;
*/
/************************************************************************/
BOOL CBranchInfo::GetRemvoeOrderInfoAndRemove(IN LPCTSTR lpBranchId, IN LPCTSTR lpOrderNum, IN LPCTSTR lpOpTm, IN const BYTE &byPhotoType)
{
	// 1.订单号不能为空,否则会删除根目录全部文件;
	if ( lpOrderNum == NULL || _tcscmp(lpOrderNum,_T("")) == 0)
	{
		//OutputDebugString(_T("订单不能为空!\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"订单不能为空"));
		return FALSE;
	}

	// 2.判断时间的有效性; 
	if (!IsValidDate(lpOpTm))
	{
		//OutputDebugString(_T("日期无效!\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"分店[%s]订单[%s] 日期无效",CW2A(lpBranchId),CW2A(lpOrderNum)));
		return FALSE;
	}

	// 3.是否达到删除时间;
	int nMonths = 0;
	switch ( byPhotoType )
	{
	case 1:
		nMonths = m_TblVersion.nCheckMonth1;
		if ( !m_TblVersion.bCheck1 )return FALSE;
		break;
	case 2:
		nMonths = m_TblVersion.nCheckMonth2;
		if ( !m_TblVersion.bCheck2 )return FALSE;
		break;
	case 3:
		nMonths = m_TblVersion.nCheckMonth3;
		if ( !m_TblVersion.bCheck3 )return FALSE;
		break;
	case 4:
		nMonths = m_TblVersion.nCheckMonth4;
		if ( !m_TblVersion.bCheck4 )return FALSE;
		break;
		//////////////////////////////////////////////////////////////////////////
	case 5:
		nMonths = m_TblVersion.nCheckbdMonth1;
		if ( !m_TblVersion.bCheckbak1 )return FALSE;
		break;
	case 6:
		nMonths = m_TblVersion.nCheckbdMonth2;
		if ( !m_TblVersion.bCheckbak2 )return FALSE;
		break;
	case 7:
		nMonths = m_TblVersion.nCheckbdMonth3;
		if ( !m_TblVersion.bCheckbak3 )return FALSE;
		break;
	case 8:
		nMonths = m_TblVersion.nCheckbdMonth4;
		if ( !m_TblVersion.bCheckbak4 )return FALSE;
		break;
	default:
		break;
	}

	if ( nMonths <= 0)
	{
		return FALSE;
	}

	CString strTakeTime = lpOpTm;
	COleDateTime reachtm(_ttoi(strTakeTime.Left(4)), _ttoi(strTakeTime.Mid(5,2)),_ttoi(strTakeTime.Mid(8,2)),0,0,0);

	COleDateTimeSpan sp(nMonths * 30, 0, 0, 0);
	reachtm += sp;

	COleDateTime curtm = COleDateTime::GetCurrentTime();
	
	// 取件日期+天数 的日期 < 今天;  
	if (reachtm > curtm )
	{
		//OutputDebugString(lpOrderNum);
		//OutputDebugString(_T("未达到删除日期----------------\n"));
		//LOG4C_NO_FILENUM((LOG_NOTICE,"%s:未达到删除日期",CW2A(lpOrderNum)));
		return FALSE;
	}

	//OutputDebugString(lpOrderNum);
	//OutputDebugString(_T("已达到删除日期------------------\n"));
	//LOG4C_NO_FILENUM((LOG_NOTICE,"%s:已达到删除日期",CW2A(lpOrderNum)));
	// 4.获取订单路径并删除;
	//CStringArray AryOfRemoveDirectory;
	BOOL bRemove = TRUE;
	for (NETSHAREINFO::const_iterator it = m_TblNetShareInfo.begin(); it != m_TblNetShareInfo.end(); it++)
	{
		//if ( _tcscmp(m_szBranchDoMain,(*it)->szBranchId) == 0 )
		if ( _tcscmp(lpBranchId,(*it)->szBranchId) == 0 )
		{
			if ( (*it)->byPhotoType != byPhotoType)continue;

			CString strOrderPath = _T("");
			strOrderPath.Format(_T("%s\\%s"),(*it)->szShareDirectory,lpOrderNum);

			if ( PathFileExists(strOrderPath) )
			{
				if( DeleteDirectory(strOrderPath) )
				{
					bRemove = FALSE;
				}
#if 0 // 删除不了网络路径;
				strOrderPath += _T("\0\0");

				SHFILEOPSTRUCT lpsh;
				ZeroMemory(&lpsh, sizeof(lpsh));
				lpsh.hwnd = HWND_DESKTOP;
				lpsh.fFlags = FOF_NOCONFIRMATION | FOF_SIMPLEPROGRESS;
				lpsh.wFunc = FO_DELETE;
				lpsh.pFrom = strOrderPath;

				//AryOfRemoveDirectory.Add(strOrderPath);
				int nResult = SHFileOperation(&lpsh);
				//if (0 == SHFileOperation(&lpsh))
				if ( nResult == 0)
				{
					OutputDebugString(_T("删除订单目录成功\n"));
				}
				else
				{
					DWORD dw = GetLastError();
					bRemove = FALSE;
				}
#endif
			}
			else
			{
				//OutputDebugString(_T("没有该订单路径"));
				//OutputDebugString(strOrderPath);
				//OutputDebugString(_T("#\n"));
				//LOG4C_NO_FILENUM((LOG_NOTICE,"%s:没有该订单路径",CW2A(strOrderPath)));
			}
		}
	}

	// 5.再次检查是否删除完;
	if ( !bRemove && m_bIsOur )
	{
		switch ( byPhotoType )
		{
		case 1:
			strTakeTime.Format(_T("update [PhotoManager] set [opdel] = 1,[opdeltm] = getdate() where [order] = '%s'"), lpOrderNum);
			break;
		case 2:
			strTakeTime.Format(_T("update [PhotoManager] set [epdel] = 1,[epdeltm] = getdate() where [order] = '%s'"), lpOrderNum);
			break;
		case 3:
			strTakeTime.Format(_T("update [PhotoManager] set [fpdel] = 1,[fpdeltm] = getdate() where [order] = '%s'"), lpOrderNum);
			break;
		case 4:
			strTakeTime.Format(_T("update [PhotoManager] set [dpdel] = 1,[dpdeltm] = getdate() where [order] = '%s'"), lpOrderNum);
			break;
			//////////////////////////////////////////////////////////////////////////
		case 5:
			strTakeTime.Format(_T("update [PhotoManager] set [opbdel] = 1,[opbdeltm] = getdate() where [order] = '%s'"), lpOrderNum);
			break;
		case 6:
			strTakeTime.Format(_T("update [PhotoManager] set [epbdel] = 1,[epbdeltm] = getdate() where [order] = '%s'"), lpOrderNum);
			break;
		case 7:
			strTakeTime.Format(_T("update [PhotoManager] set [fpbdel] = 1,[fpbdeltm] = getdate() where [order] = '%s'"), lpOrderNum);
			break;
		case 8:
			strTakeTime.Format(_T("update [PhotoManager] set [dpbdel] = 1,[dpbdeltm] = getdate() where [order] = '%s'"), lpOrderNum);
			break;
		default:
			break;
		}
		
		Execute(strTakeTime);
	}
	
	return TRUE;
}

/************************************************************************/
/* 
	函数:FindFileNameFromSpecialDirectory
	描述:查找指定目录下的文件名是否存在(无文件后缀名),并返回结果路径;
	参数:
		IN:		lpSpecialDirectory 指定要查找的目录;
		IN:		lpFileName文件名(无后缀扩展名);
		OUT:	lpResult 返回结果路径;
	返回:
	注意:
	要求:
	示例:
*/
/************************************************************************/
BOOL CBranchInfo::FindFileNameFromSpecialDirectory(IN LPCTSTR lpSpecialDirectory, IN LPCTSTR lpFileName, OUT LPTSTR lpResult)
{
	if ( lpSpecialDirectory == NULL || _tcscmp(lpSpecialDirectory,_T("")) == 0 ){
		return FALSE;
	}

	CString strPath = lpSpecialDirectory;
	if ( !PathFileExists(strPath) ){
		return FALSE;
	}

	strPath.TrimRight(_T("\\"));
	strPath += _T("\\*");

	WIN32_FIND_DATA fileInfo = {0};
	HANDLE handle = FindFirstFile(strPath,&fileInfo);

	BOOL bFind = FALSE;
	if ( NULL != handle && INVALID_HANDLE_VALUE != handle )
	{
		do 
		{
			// '.'和 '..'的系统文件去除;
			if (_T('.') != fileInfo.cFileName[0])
			{
				if ((FILE_ATTRIBUTE_DIRECTORY & fileInfo.dwFileAttributes) != FILE_ATTRIBUTE_DIRECTORY)
				{
					strPath.Format(_T("%s"),fileInfo.cFileName);
					strPath = strPath.Left(strPath.ReverseFind(_T('.')));
					if ( strPath.CompareNoCase(lpFileName) == 0 )
					{
						_stprintf_s(lpResult,MAX_PATH,_T("%s"),lpSpecialDirectory);
						bFind = TRUE;
						break;
					}
				}
				else	// 非目录;
				{
					strPath.Format(_T("%s\\%s"),lpSpecialDirectory,fileInfo.cFileName);
					if( FindFileNameFromSpecialDirectory(strPath,lpFileName,lpResult) )
					{
						bFind = TRUE;
						break;
					}
				}

			}
		} while ( FindNextFile(handle,&fileInfo) );

		FindClose(handle);
	}

	return bFind;
}

//获取备份的保存目录
BOOL CBranchInfo::GetBackupOfSaveDir(OUT CArray<CStringArray, CStringArray> &AryOfValues)
{

	//select bak1,bak2,bak3,bak4,bakserver1,bakserver2,bakserver3,bakserver4 from version
	CStringArray AryOfFields;
	AryOfFields.Add(_T("bakserver1"));
	AryOfFields.Add(_T("bakserver2"));
	AryOfFields.Add(_T("bakserver3"));
	AryOfFields.Add(_T("bakserver4"));

	if (!GetTableValues(_T("[version]"), NULL, AryOfFields, AryOfValues))
	{
		//LOG4C_NO_FILENUM((LOG_NOTICE,"获取version表失败"));
		return FALSE;
	}

	return TRUE;
}