lyfz_repos/经典版源码/lyfFTPServer/trunk/FTPServer Ver 1/BranchInfo.cpp

#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"

#define IS_USE_VER1	0

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

CBranchInfo::CBranchInfo()
{
	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();

	//////////////////////////////////////////////////////////////////////////
}

CBranchInfo::~CBranchInfo(void)
{
}

/************************************************************************/
/* 
	函数: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(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"));
		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"));
						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)
	{
		MakeSureDirectoryPathExists(szOrderPath);
		_stprintf_s(lpEnableShareDirectory,_tcslen(szOrderPath)+1,_T("%s"),szOrderPath);
	}
	else
	{
		OutputDebugString(_T("没有符合的共享目录\n"));
	}

	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"));
	}

	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;
}

/************************************************************************/
/* 
	函数: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)
{
	TCHAR szSQLConnt[MAX_PATH] = _T("");
	if (dwCatalogPort)
	{
		_stprintf_s(szSQLConnt, _T("driver={SQL Server};Server=%s,%d;database=%s;uid=%s;pwd=%s"),
			lpCatalogSource, dwCatalogPort, lpCatalogName, lpCatalogAccount, lpCatalogPsw);
	}
	else
	{
		_stprintf_s(szSQLConnt, _T("driver={SQL Server};Server=%s;database=%s;uid=%s;pwd=%s"),
			lpCatalogSource, lpCatalogName, lpCatalogAccount, lpCatalogPsw);
	}

	SetConn(szSQLConnt);

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

	return bResult;
}

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

	CArray<CStringArray, CStringArray> AryOfValues;
	if (!GetTableValues(_T("path"), NULL, AryOfFields, AryOfValues))
	{
		OutputDebugString(_T("获取path表失败\n"));
		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"));
		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
	描述:获取分店数据库实例信息;
	参数:
	返回:
	要求:
	注意:
	示例:


[enable]	
[branch]	
[branchid]	
[clgname]	
[clgport]	
[clgsource]	
[clgaccount]
[clgpassword]

*/
/************************************************************************/
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"));
		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()
{
	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"));
		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)
{
	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"), _T("isbackup = 0"), AryOfFields, AryOfValues))
	{
		OutputDebugString(_T("获取IncrementalBackup表失败\n"));
		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"));
			MakeSureDirectoryPathExists(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"));
		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"));
		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"));
		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"));
		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"));
		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"));
		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"));
		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"));
		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"));
		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 };
	_stprintf_s(szShareDirectory, _T("\\\\%s\\%s"), szHost, ORIGINAL);
	InsertNetShareInfo(szShareDirectory, _T("需要读取加密狗的域名"), 5, 30, 1, 255);

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

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

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

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

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

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

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

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

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

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

/************************************************************************/
/* 
	函数: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;
}

/************************************************************************/
/* 
	函数: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:		byPhotoType			相片类型;
		IN:		lpImage				相片名称,带护展名; 
		IN:		lpOrderNum			相片所在的订单号;
		OUT:	lpShareDirectory	若相片存在,这里为相片的实际路径;

	返回:相片存在返回TRUE,否则FALSE;
	要求:
	注意:
*/
/************************************************************************/
BOOL CBranchInfo::FindImageShareDirectory(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,m_szBranchDoMain) == 0 )
		{
			if ( pNetShareInfo->byPhotoType == byPhotoType )
			{
				CString strImagePaht = _T("");
				strImagePaht.Format(_T("%s\\%s\\%s"),pNetShareInfo->szShareDirectory,lpOrderNum,lpImage);
				
				if ( PathFileExists(strImagePaht) )
				{
					bExists = TRUE;
					_stprintf_s(lpShareDirectory, MAX_PATH, _T("%s"), strImagePaht);
					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;

	// 1.解析出增量相片的路径;
	CStringArray AryOfImagePath;
	CString strIncrementContent = 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(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,lpOrder,lpBranchId,szEnableShareDirectory) )
	{
		OutputDebugString(_T("无可用共享目录\n"));
		return FALSE;
	}

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

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

		MakeSureDirectoryPathExists(strDatePath);
		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'"),lpBranchId,lpOrder);
			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"));
		return FALSE;
	}

	// 2.判断时间的有效性; 
	if (!IsValidDate(lpOpTm))
	{
		OutputDebugString(_T("日期无效!\n"));
		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;
	}

	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"));
		return FALSE;
	}

	OutputDebugString(lpOrderNum);
	OutputDebugString(_T("已达到删除日期------------------\n"));
	// 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"));
			}
		}
	}

	// 5.再次检查是否删除完;
	if ( !bRemove )
	{
		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;
}