lyfz_repos/经典版源码/lyfzServer/branches/713/PhotoDelMgr.cpp

// PhotoDelMgr.cpp : 实现文件
//

#include "stdafx.h"
#include "DBServer.h"
#include "PhotoDelMgr.h"
#include "Global.h"
#include "BranchInfo.h"
#include "PhotoDelLog.h"
#include "mysqldata.h"
#include "DelPhotoModel\DelFilesFactory.h"
#include "DelPhotoModel\DelFilesInterface.h"

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

CPhotoDelMgr* g_pPhotoDelMgr;


#define MSG_SHOWPROMPTING		WM_USER + 101
// CPhotoDelMgr 对话框

IMPLEMENT_DYNAMIC(CPhotoDelMgr, CDialog)

CPhotoDelMgr::CPhotoDelMgr(CWnd* pParent /*=NULL*/)
	: CDialog(CPhotoDelMgr::IDD, pParent)
{
	m_pFactory = NULL;
	m_pInterface = NULL;
	m_lpCurrSel = NULL;

	m_pdb = NULL;
	memset(m_szConnect, 0, sizeof(TCHAR)*MAX_PATH);
}

CPhotoDelMgr::~CPhotoDelMgr()
{
	if(m_pInterface)
		m_pInterface->Release();

	if(m_pFactory)
		m_pFactory->Release();

	m_vCurrSelLog.clear();
	CleareLog(m_vPickupLog);
	ClearBakDirInfo();

	if(m_pdb)
		delete m_pdb;
	m_pdb = NULL;
}

void CPhotoDelMgr::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_DelInfo_List, m_DelList);
	DDX_Control(pDX, IDC_DelType_LIST, m_PhotoTypeList);
	DDX_Control(pDX, IDC_Start_Date, m_StartTime);
	DDX_Control(pDX, IDC_End_Date, m_EndTime);
	DDX_Control(pDX, IDC_DELTIPS_RICHEDIT, m_DelTips);
}


BEGIN_MESSAGE_MAP(CPhotoDelMgr, CDialog)
	ON_BN_CLICKED(IDC_StartDel_Btn, &CPhotoDelMgr::OnBnClickedStartdelBtn)
	ON_BN_CLICKED(IDC_SelectAll_Btn, &CPhotoDelMgr::OnBnClickedSelectallBtn)
	ON_BN_CLICKED(IDC_DeleteLog_Btn, &CPhotoDelMgr::OnBnClickedDeletelogBtn)
	ON_BN_CLICKED(IDC_UnAllSel_Btn, &CPhotoDelMgr::OnBnClickedUnallselBtn)
	ON_BN_CLICKED(IDC_SetAutoDel_Btn, &CPhotoDelMgr::OnBnClickedSetAutodelBtn)
	ON_BN_CLICKED(IDC_Refresh_Btn, &CPhotoDelMgr::OnBnClickedRefreshBtn)
	ON_NOTIFY(NM_CLICK, IDC_DelInfo_List, &CPhotoDelMgr::OnNMClickDelinfoList)
	ON_NOTIFY(NM_CLICK, IDC_DelType_LIST, &CPhotoDelMgr::OnNMClickDeltypeList)
	ON_MESSAGE(MSG_SHOWPROMPTING, &CPhotoDelMgr::ShowPrompting)
END_MESSAGE_MAP()

BOOL CPhotoDelMgr::OnInitDialog()
{
	CDialog::OnInitDialog();
	g_pPhotoDelMgr = this;

#ifndef ENTERPRISE_VERSION
	m_DelList.InsertColumn( 0, TEXT("主机名"), LVCFMT_LEFT, 100 );
#else
	m_DelList.InsertColumn( 0, TEXT("店名"), LVCFMT_LEFT, 100 );
#endif
	m_DelList.InsertColumn( 1, TEXT("域名"), LVCFMT_LEFT, 200 );
	m_DelList.InsertColumn( 2, TEXT("订单号"), LVCFMT_LEFT, 70 );
	m_DelList.InsertColumn( 3, TEXT("取件"), LVCFMT_LEFT, 70 );
	m_DelList.InsertColumn( 4, TEXT("时间"), LVCFMT_LEFT, 70 );
	m_DelList.SetExtendedStyle(LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT | LVS_EX_ONECLICKACTIVATE | LVS_EX_GRIDLINES);

	m_PhotoTypeList.InsertColumn( 0, TEXT("类型"), LVCFMT_LEFT, 100 );
	m_PhotoTypeList.InsertColumn( 1, TEXT("已删除"), LVCFMT_LEFT, 70 );
	m_PhotoTypeList.SetExtendedStyle(LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT | LVS_EX_ONECLICKACTIVATE | LVS_EX_GRIDLINES);

	CTime currtime = CTime::GetCurrentTime();
	m_EndTime.SetTime(&currtime);
	CTimeSpan timespan(30,0,0,0);
	CTime endtime = currtime - timespan;
	m_StartTime.SetTime(&endtime);

	
	GetBranchInfo(m_BranchArr);
	OnBnClickedRefreshBtn();
	LoadDelPhotoModule(g_hDllInst);
	GetShareBackupDir();
	return TRUE;
}

// CPhotoDelMgr 消息处理程序
//开始删除
void CPhotoDelMgr::OnBnClickedStartdelBtn()
{
	if(m_pInterface && m_pInterface->IsDeleting())
	{
		MessageBox(_T("正在处理删除工作中，请稍后再试"));
		return;
	}

	// TODO: 在此添加控件通知处理程序代码
	if (AfxMessageBox("是否删除选中的已取件相片?", MB_YESNO | MB_ICONINFORMATION) != IDYES)
		return;

	int nCount = m_DelList.GetItemCount();
	for(int i = 0; i<nCount; i++)
	{
		if(m_DelList.GetCheck(i) == TRUE)
		{
			CString strDomain = m_DelList.GetItemText(i, 1);
			CString strOrder = m_DelList.GetItemText(i, 2);

			std::vector<LPSPICKUPINFO>::iterator iter = m_vPickupLog.begin();
			for(; iter != m_vPickupLog.end();)
			{
				LPSPICKUPINFO lp = (*iter);
				if(lp != NULL && lp->bTakestatus && lp->strBranchid == strDomain && lp->strOrder == strOrder)
				{
					
					//把勾选了的已取件订单添加到删除集里
					if(lp->bOpNeedDel)
						AddDelData(strDomain, strOrder, 1);
					if(lp->bEpNeedDel)
						AddDelData(strDomain, strOrder, 2);
					if(lp->bFpNeedDel)
						AddDelData(strDomain, strOrder, 3);
					if(lp->bDpNeedDel)
						AddDelData(strDomain, strOrder, 4);
					if(lp->bOpbNeedDel)
						AddDelData(strDomain, strOrder, 5);
					if(lp->bEpbNeedDel)
						AddDelData(strDomain, strOrder, 6);
					if(lp->bFpbNeedDel)
						AddDelData(strDomain, strOrder, 7);
					if(lp->bDpbNeedDel)
						AddDelData(strDomain, strOrder, 8);
				}
				++iter;
			}
		}
	}

	//开始删除相片
	if(m_pInterface && !m_pInterface->IsDeleting())
		m_pInterface->StartDelFiles(DelFinish);
}

//去掉全选
void CPhotoDelMgr::OnBnClickedUnallselBtn()
{
	// TODO: 在此添加控件通知处理程序代码
	int nNum = m_DelList.GetItemCount();
	for(int i=0; i<nNum; i++)
		m_DelList.SetCheck(i, FALSE);
	m_vCurrSelLog.clear();
}


//全选
void CPhotoDelMgr::OnBnClickedSelectallBtn()
{
	// TODO: 在此添加控件通知处理程序代码
	int nNum = m_DelList.GetItemCount();
	for(int i=0; i<nNum; i++)
		m_DelList.SetCheck(i, TRUE);

	m_vCurrSelLog.clear();
	std::vector<LPSPICKUPINFO>::iterator it = m_vPickupLog.begin();
	for(;it != m_vPickupLog.end();)
	{
		if((*it) != NULL)
			m_vCurrSelLog.push_back((*it));
		++it;
	}
}

//查看删除记录
void CPhotoDelMgr::OnBnClickedDeletelogBtn()
{
	// TODO: 在此添加控件通知处理程序代码
	PhotoDelLog dlg;
	dlg.m_pBranchArr = &m_BranchArr;
	dlg.m_pdb = m_pdb;
	dlg.m_plock = &m_lock;
	dlg.DoModal();
}

void CPhotoDelMgr::OnDestroy()
{
	
}

//加载列表数据
void CPhotoDelMgr::LoadListData()
{
	m_lock.lock();
	if(m_pdb == NULL)
	{
		m_lock.unlock();
		return;
	}

	CleareLog(m_vPickupLog);

	CString strTimeFielded = _T("");
	if(!GetTimeField(strTimeFielded))
	{
		m_lock.unlock();
		return;
	}

	//已取件记录
	CString sql = _T("");
	sql = _T("SELECT [branchid],[order],[takestatus],[taketime],\
[opdel],[epdel],[fpdel],[dpdel],\
[opbdel],[epbdel],[fpbdel],[dpbdel],\
[opdeltm],[epdeltm],[fpdeltm],[dpdeltm],\
[opbdeltm],[epbdeltm],[fpbdeltm],[dpbdeltm] FROM [PhotoManager] where [takestatus]='True' and ") + strTimeFielded;

	try
	{
		CRecordset myset;
		myset.m_pDatabase = m_pdb;
		myset.Open(CRecordset::forwardOnly, sql);
		int ii = 0;
		while (!myset.IsEOF())
		{
			LPSPICKUPINFO lp = new SPICKUPINFO;
			CString strValue = _T("");
			myset.GetFieldValue(_T("branchid"), lp->strBranchid);			/* 分店id 域名*/
			lp->strName = CPhotoDelMgr::GetBranchNameForDomain(&m_BranchArr, lp->strBranchid);
			myset.GetFieldValue(_T("order"), lp->strOrder);						/* 主键订单号(唯一) */
			myset.GetFieldValue(_T("takestatus"), strValue);				/* 取件状态:0未取,1已取 */
			lp->bTakestatus = _ttoi(strValue);
			myset.GetFieldValue(_T("taketime"), lp->strTaketime);			/* 整个订单的取件时间 */

			myset.GetFieldValue(_T("opdel"), strValue);						/* 原片删除状态 */
			lp->bOpdel = _ttoi(strValue);
			myset.GetFieldValue(_T("epdel"), strValue);						/* 初修删除状态 */
			lp->bEpdel = _ttoi(strValue);
			myset.GetFieldValue(_T("fpdel"), strValue);						/* 精修删除状态 */
			lp->bFpdel = _ttoi(strValue);
			myset.GetFieldValue(_T("dpdel"), strValue);						/* 设计删除状态 */
			lp->bDpdel = _ttoi(strValue);

			myset.GetFieldValue(_T("opbdel"), strValue);					/* 原片备份删除状态 */
			lp->bOpbdel = _ttoi(strValue);
			myset.GetFieldValue(_T("epbdel"), strValue);					/* 初修备份删除状态 */
			lp->bEpbdel = _ttoi(strValue);
			myset.GetFieldValue(_T("fpbdel"), strValue);					/* 精修备份删除状态 */
			lp->bFpbdel = _ttoi(strValue);
			myset.GetFieldValue(_T("dpbdel"), strValue);					/* 设计备份删除状态 */
			lp->bDpbdel = _ttoi(strValue);

			myset.GetFieldValue(_T("opdeltm"), lp->strOpdeltm);					/* 原片删除时间 */
			myset.GetFieldValue(_T("epdeltm"), lp->strEpdeltm);					/* 初修删除时间 */
			myset.GetFieldValue(_T("fpdeltm"), lp->strFpdeltm);					/* 精修删除时间 */
			myset.GetFieldValue(_T("dpdeltm"), lp->strDpdeltm);					/* 设计删除时间 */

			myset.GetFieldValue(_T("opbdeltm"), lp->strOpbdeltm);					/* 原片备份删除时间 */
			myset.GetFieldValue(_T("epbdeltm"), lp->strEpbdeltm);					/* 初修备份删除时间 */
			myset.GetFieldValue(_T("fpbdeltm"), lp->strFpbdeltm);					/* 精修备份删除时间 */
			myset.GetFieldValue(_T("dpbdeltm"), lp->strDpbdeltm);					/* 设计备份删除时间 */

			//是否已取件
			if(!lp->bTakestatus)
			{
				delete lp;
				myset.MoveNext();
				continue;
			}

			//是否全部已删除
			if(lp->bOpdel && lp->bEpdel && lp->bFpdel && lp->bDpdel && lp->bOpbdel && lp->bEpbdel && lp->bFpbdel && lp->bDpbdel)
			{
				delete lp;
				myset.MoveNext();
				continue;
			}

			m_vPickupLog.push_back(lp);
			myset.MoveNext();
		}
	}
	catch (CException* e)
	{
		m_lock.unlock();
		CleareLog(m_vPickupLog);

		TCHAR szError[1024] = { 0 };
		e->GetErrorMessage(szError, 1024);
		WriteLogin(CString(szError));
		e->Delete();
	}
	m_lock.unlock();
}

void CPhotoDelMgr::FillData()
{
	if(m_vPickupLog.size() == 0)
		return;

	m_DelList.DeleteAllItems();
	std::vector<LPSPICKUPINFO>::iterator iter = m_vPickupLog.begin();
	for(;iter != m_vPickupLog.end();)
	{
		LPSPICKUPINFO lp = (*iter);
		if(lp != NULL)
		{
			CString strName = GetBranchNameForDomain(&m_BranchArr, lp->strBranchid);
			int nRow = m_DelList.InsertItem(LVIF_TEXT|LVIF_PARAM, 0, strName,0,0,2,0);
			m_DelList.SetItemText(nRow, 1, lp->strBranchid);
			m_DelList.SetItemText(nRow, 2, lp->strOrder);
			m_DelList.SetItemText(nRow, 3, TEXT("已取"));
			m_DelList.SetItemText(nRow, 4, lp->strTaketime);
		}
		++iter;
	}
	if(m_DelList.GetItemCount() == 0)
		return;

	//FillPhotoType(0);
}

/************************************************************************/
/* 
	函数:FillPhotoType
	描述:填充类型列表
	参数:
		IN const int nIdx			数组索引
	返回:
*/
/************************************************************************/
void CPhotoDelMgr::FillPhotoType(IN const int nIdx)
{
	LPSPICKUPINFO lp = m_vPickupLog[nIdx];
	if(lp == NULL)
		return;

	m_PhotoTypeList.DeleteAllItems();
	int nRow = 0;
	nRow = m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, 0, _T("原片"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bEpdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bEpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("初修"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bEpdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bEpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("精修"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bFpdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bFpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("设计"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bDpdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bDpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("原片备份"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bOpbdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bOpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("初修备份"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bEpbdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bEpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("精修备份"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bFpbdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bFpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, 0, _T("设计备份"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bDpbdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bDpbNeedDel);
}

/************************************************************************/
/* 
	函数:FillPhotoType
	描述:填充类型列表
	参数:
		IN const LPSPICKUPINFO lp		取件信息
	返回:
*/
/************************************************************************/
void CPhotoDelMgr::FillPhotoType(IN const LPSPICKUPINFO lp)
{
	m_PhotoTypeList.DeleteAllItems();

	if(lp == NULL)
		return;

	int nRow = 0;
	nRow = m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, 0, _T("原片"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bOpdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bOpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("初修"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bEpdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bEpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("精修"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bFpdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bFpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("设计"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bDpdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bDpNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("原片备份"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bOpbdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bOpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("初修备份"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bEpbdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bEpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("精修备份"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bFpbdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bFpbNeedDel);

	++nRow;
	m_PhotoTypeList.InsertItem(LVIF_TEXT|LVIF_PARAM, nRow, _T("设计备份"),0,0,2,0);
	m_PhotoTypeList.SetItemText(nRow, 1, ((lp->bDpbdel == TRUE)?_T("已删"):_T("未删")));
	m_PhotoTypeList.SetCheck(nRow, lp->bDpbNeedDel);
}

/************************************************************************/
/* 
	函数:GetTimeField
	描述:获取日期限制条件
	参数:
		OUT CString& strField				输出条件
	返回:
*/
/************************************************************************/
int	 CPhotoDelMgr::GetTimeField(OUT CString& strField)
{
	CTime startTime, endTime, currTime;
	CString strStart(_T("")), strEnd(_T(""));

	m_StartTime.GetTime(startTime);
	strStart = startTime.Format(_T("%Y-%m-%d"));
	m_EndTime.GetTime(endTime);
	strEnd = endTime.Format(_T("%Y-%m-%d"));

	currTime = CTime::GetCurrentTime();
	if(startTime > currTime || endTime > currTime)
	{
		MessageBox(_T("设置的日期不能比当前大"));
		return 0;
	}

	if(startTime > endTime)
	{
		MessageBox(_T("起始日期不能比结束日期"));
		return 0;
	}
	strField = _T("(taketime>='") + strStart + _T("' and taketime<='") + strEnd + _T("')");
	return 1;
}

/************************************************************************/
/* 
	函数:CleareLog
	描述:清除
	参数:
		N std::vector<LPSPICKUPINFO>& vLog			清除已取件集
	返回:
*/
/************************************************************************/
void CPhotoDelMgr::CleareLog(IN std::vector<LPSPICKUPINFO>& vLog)
{
	std::vector<LPSPICKUPINFO>::iterator iter = vLog.begin();
	for(;iter != vLog.end();)
	{
		if((*iter) != NULL)
			delete (*iter);
		++iter;
	}
	vLog.clear();
}

/************************************************************************/
/* 
	函数:LoadDelPhotoModule
	描述:加载删除管理模块
	参数:
		IN HINSTANCE hInstance		dll实例句柄
	返回:1成功，0失败
*/
/************************************************************************/
int	 CPhotoDelMgr::LoadDelPhotoModule(IN HINSTANCE hInstance)
{
	if(hInstance == NULL)
		return 0;

	HRESULT hr = NULL;
	if(hInstance && m_pFactory && m_pInterface)
		return 1;

	GetClassDelFileObject getDelFileObj = NULL;
	getDelFileObj = (GetClassDelFileObject)GetProcAddress(hInstance, "GetClassDelFileObject");
	if(getDelFileObj == NULL)
	{
		OutputDebugString(_T("打开GetClassDelFileObject失败\n"));
		return 0;
	}

	if(m_pFactory == NULL)
	{
		hr = getDelFileObj(CLSID_SC_DELFILESINTERFACE, IID_IClassFactory, (void**)&m_pFactory);
		if(FAILED(hr))
		{
			OutputDebugString(_T("获取CSC_DelfilesFactory指针失败\n"));
			return 0;
		}
	}

	if(m_pInterface == NULL)
	{
		hr = m_pFactory->CreateInstance(NULL, IID_IUnknown, (void**)&m_pInterface);
		if(FAILED(hr))
		{
			OutputDebugString(_T("创建ISC_DelFilesInterface失败\n"));
			m_pFactory->Release();
			return 0;
		}
	}
	return 1;
}

/************************************************************************/
/* 
	函数:OnBnClickedSetAutodelBtn
	描述:设置自动删除
	参数:
	返回:1成功，0失败
*/
/************************************************************************/
void CPhotoDelMgr::OnBnClickedSetAutodelBtn()
{
	// TODO: 在此添加控件通知处理程序代码
}

/************************************************************************/
/* 
	函数:OnBnClickedRefreshBtn
	描述:刷新信息
	参数:
	返回:1成功，0失败
*/
/************************************************************************/
void CPhotoDelMgr::OnBnClickedRefreshBtn()
{
	// TODO: 在此添加控件通知处理程序代码
	LoadListData();
	FillData();
}

/************************************************************************/
/* 
	函数:OnNMClickDeltypeList
	描述:点击取件列表
	参数:
	返回:
*/
/************************************************************************/
void CPhotoDelMgr::OnNMClickDelinfoList(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
	// TODO: 在此添加控件通知处理程序代码
	m_PhotoTypeList.DeleteAllItems();
	if(pNMItemActivate->iItem != -1)
	{
		//选取才显示相片类型
		CString strDomain = m_DelList.GetItemText(pNMItemActivate->iItem, 1);
		CString strOrder = m_DelList.GetItemText(pNMItemActivate->iItem, 2);
		
		std::vector<LPSPICKUPINFO>::iterator it = m_vPickupLog.begin();
		for(;it != m_vPickupLog.end();)
		{
			if((*it) != NULL && (*it)->bTakestatus && (*it)->strBranchid == strDomain && (*it)->strOrder == strOrder)
			{
				m_lpCurrSel = (*it);
				FillPhotoType(m_lpCurrSel);
				break;
			}
			++it;
		}
	}
	else
		m_lpCurrSel = NULL;

	if(m_lpCurrSel == NULL)
	{
		*pResult = 0;
		return;
	}

	//判断是否点击在listctrl的checkbox上
	DWORD dwPos = GetMessagePos();
	CPoint point(LOWORD(dwPos), HIWORD(dwPos));
	m_DelList.ScreenToClient(&point);

	LVHITTESTINFO lvinfo;
	lvinfo.pt = point;
	lvinfo.flags = LVHT_ABOVE;

	UINT nFlag;
	int nItem = m_DelList.HitTest(point, &nFlag);

	//判断是否点在checkbox上
	if(nFlag == LVHT_ONITEMSTATEICON)
	{
		//选取才显示相片类型
		BOOL bFind = FALSE;
		std::vector<LPSPICKUPINFO>::iterator iter = m_vCurrSelLog.begin();
		for(;iter != m_vCurrSelLog.end();)
		{
			//是否已存在当前选择并且勾选的记录集
			if(m_lpCurrSel->strBranchid == (*iter)->strBranchid && m_lpCurrSel->strOrder == (*iter)->strOrder)
			{
				//存在不添加
				bFind = TRUE;
				break;
			}
			++iter;
		}

		//非为勾选
		if(!m_DelList.GetCheck(pNMItemActivate->iItem))
		{
			//勾选上，数组里没找到才添加
			if(!bFind)
				m_vCurrSelLog.push_back(m_lpCurrSel);
		}
		else
		{
			//去掉勾选，同时在当前选择数组里删除
			if(bFind)
				m_vCurrSelLog.erase(iter);
		}
	}
	*pResult = 0;
}


/************************************************************************/
/* 
	函数:OnNMClickDeltypeList
	描述:点击类型列表
	参数:
	返回:
*/
/************************************************************************/
void CPhotoDelMgr::OnNMClickDeltypeList(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
	// TODO: 在此添加控件通知处理程序代码
	if(!m_lpCurrSel)
	{
		*pResult = 0;
		return;
	}

	//判断是否点击在listctrl的checkbox上
	DWORD dwPos = GetMessagePos();
	CPoint point(LOWORD(dwPos), HIWORD(dwPos));
	m_PhotoTypeList.ScreenToClient(&point);

	LVHITTESTINFO lvinfo;
	lvinfo.pt = point;
	lvinfo.flags = LVHT_ABOVE;

	UINT nFlag;
	int nItem = m_PhotoTypeList.HitTest(point, &nFlag);

	//判断是否点在checkbox上
	if(nFlag == LVHT_ONITEMSTATEICON)
	{
		BOOL bDeled = FALSE;
		//设置是否需要删除
		BOOL bNeedDel = !m_PhotoTypeList.GetCheck(pNMItemActivate->iItem);
		int nType = pNMItemActivate->iItem + 1;
		switch(nType)
		{
		case 1:
			//勾选了已删除过的相片类型无效
			if(bNeedDel && m_lpCurrSel->bOpdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bOpNeedDel = bNeedDel;
			break;
		case 2:
			if(bNeedDel && m_lpCurrSel->bEpdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bEpNeedDel = bNeedDel;
			break;
		case 3:
			if(bNeedDel && m_lpCurrSel->bFpdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bFpNeedDel = bNeedDel;
			break;
		case 4:
			if(bNeedDel && m_lpCurrSel->bDpdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bDpNeedDel = bNeedDel;
			break;
		case 5:
			if(bNeedDel && m_lpCurrSel->bOpbdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bOpbNeedDel = bNeedDel;
			break;
		case 6:
			if(bNeedDel && m_lpCurrSel->bEpbdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bEpbNeedDel = bNeedDel;
			break;
		case 7:
			if(bNeedDel && m_lpCurrSel->bFpbdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bFpbNeedDel = bNeedDel;
			break;
		case 8:
			if(bNeedDel && m_lpCurrSel->bDpbdel)
				bDeled = TRUE;
			else
				m_lpCurrSel->bDpbNeedDel = bNeedDel;
			break;
		}

		if(bDeled)
		{
			m_PhotoTypeList.SetCheck(pNMItemActivate->iItem, TRUE);
			MessageBox(_T("此选项的相片已删"));
		}
	}
	*pResult = 0;
}

/************************************************************************/
/* 
	函数:AddDelData
	描述:添加删除数据
	参数:
	返回:
*/
/************************************************************************/
void CPhotoDelMgr::AddDelData(IN LPCTSTR lpDomain, IN LPCTSTR lpOrder, IN const BYTE nType)
{
	if(m_pInterface == NULL)
		return;

	if(lpDomain == NULL || (_tcscmp(lpDomain, _T("")) == 0) || lpOrder == NULL || (_tcscmp(lpOrder, _T("")) == 0))
		return;

	if(nType > 4)
	{
		std::vector<LPSBAKDIRINFO>::iterator it = m_vBackupDirInfos.begin();
		for(;it != m_vBackupDirInfos.end(); ++it)
		{
			LPSBAKDIRINFO lp = (*it);
			if(lp == NULL)
				continue;
		
			if(lp->byPhotoType != nType)
				continue;

			TCHAR szDir[MAX_PATH] = {0};
			memset(szDir, 0, sizeof(TCHAR)*MAX_PATH);
#ifndef ENTERPRISE_VERSION
			if( _tcscmp(lpDomain, g_sdomain) == 0)
			_stprintf(szDir, _T("%s\\%s"), lp->strDir, lpOrder);
#else
			//集团版
			//域名相同为本店订单，不同为分店
			if( _tcscmp(lpDomain, g_sdomain) == 0)
				_stprintf(szDir, _T("%s\\%s"), lp->strDir, lpOrder);
			else
				_stprintf(szDir, _T("%s\\%s\\%s"), lp->strDir, lpDomain, lpOrder);
#endif //#ifndef ENTERPRISE_VERSION
			m_pInterface->AddDelData(lpDomain, lpOrder, szDir, nType, TRUE);
		}
	}
	else
	{
		//获取共享目录
		vector<TblNetShareInfo*>::iterator it = CBranchInfo::GetInstance()->m_TblNetShareInfo.begin();
		for(; it != CBranchInfo::GetInstance()->m_TblNetShareInfo.end(); it++)
		{
			TblNetShareInfo* p = (*it);
			if(p != NULL)
			{
				if (p->byPhotoType != nType)
					continue;

				if(_tcscmp(_T(""), p->szBranchId) == 0)
					continue;

				TCHAR szDir[MAX_PATH] = {0};
				memset(szDir, 0, sizeof(TCHAR)*MAX_PATH);

#ifndef ENTERPRISE_VERSION
				if( _tcscmp(lpDomain, p->szBranchId) != 0)
					continue;

				_stprintf(szDir, _T("%s\\%s"), p->szShareDirectory, lpOrder);
#else
				//集团版
				//域名相同为本店订单，不同为分店
				if( _tcscmp(lpDomain, p->szBranchId) == 0)
					_stprintf(szDir, _T("%s\\%s"), p->szShareDirectory, lpOrder);
				else
					_stprintf(szDir, _T("%s\\%s\\%s"), p->szShareDirectory, lpDomain, lpOrder);
#endif //#ifndef ENTERPRISE_VERSION
				m_pInterface->AddDelData(lpDomain, lpOrder, szDir, nType, TRUE);
			}
		}
	}
}

/************************************************************************/
/* 
	函数:GetBranchInfo
	描述:获取分店信息
	参数:
		OUT CArray<CStringArray, CStringArray>& arr		返回分店组
	返回:
*/
/************************************************************************/
void  CPhotoDelMgr::GetBranchInfo(OUT CArray<CStringArray, CStringArray>& arr)
{
#ifndef ENTERPRISE_VERSION
	arr.SetSize(1, 1);
	arr.ElementAt(0).Add(g_sdomain);
	arr.ElementAt(0).Add(g_localname);
	//添加4个空字符只是匹配branchinfo.dat读以的格式
	arr.ElementAt(0).Add(_T(""));
	arr.ElementAt(0).Add(_T(""));
	arr.ElementAt(0).Add(_T(""));
	arr.ElementAt(0).Add(_T(""));
#else
	try
	{
		CFile fp;
		CString path = g_mainpath + _T("\\branchinfo.dat");
		if (::PathFileExists(path) == 0)
			return;

		fp.Open(path, CFile::modeRead);

		DWORD leng = fp.GetLength();
		if (leng < sizeof(DWORD) * 2)
		{
			fp.Close();
			return;
		}

		DWORD flag = 0;
		//fp.Seek(-sizeof(DWORD), CFile::end);
		fp.Seek(-(int)sizeof(DWORD), CFile::end);
		fp.Read(&flag, sizeof(DWORD));
		if (flag != 889900)
		{
			fp.Close();
			return;
		}

		fp.SeekToBegin();

		DWORD arraysize;
		fp.Read(&arraysize, sizeof(DWORD));
		if (arraysize > 20)
		{
			fp.Close();
			return;
		}

		BYTE *pData = new BYTE[leng - sizeof(DWORD)];
		fp.Read(pData, leng - sizeof(DWORD));
		fp.Close();

		CMemFile memfile;
		memfile.Attach(pData, leng - sizeof(DWORD));
		CArchive ar(&memfile, CArchive::load);
		arr.SetSize(arraysize, 1);
		for (int ii = 0; ii < arr.GetSize(); ii++)
			arr.ElementAt(ii).Serialize(ar);

		ar.Close();
		memfile.Detach();
		delete[]pData;
	}
	catch (...)
	{
	}
#endif
}

/************************************************************************/
/* 
	函数:GetBranchInfo
	描述:获取分店信息
	参数:
		IN CArray<CStringArray, CStringArray>& arr,		分店组
		IN const CString& strDomain						域名
	返回:CString										店名
*/
/************************************************************************/
CString CPhotoDelMgr::GetBranchNameForDomain(IN CArray<CStringArray, CStringArray>* pArr, IN const CString& strDomain)
{
	if(pArr == NULL)
		return _T("");

	for(int i=0; i<pArr->GetSize(); i++)
	{
		if(pArr->ElementAt(i).ElementAt(0) == strDomain)
			return pArr->ElementAt(i).ElementAt(1);
	}
	return _T("");
}

/************************************************************************/
/* 
	函数:GetBranchInfo
	描述:获取分店信息
	参数:
		IN CArray<CStringArray, CStringArray>& arr,		分店组
		IN const CString& strName						店名
	返回:CString										域名
*/
/************************************************************************/
CString CPhotoDelMgr::GetDomainForBranchName(IN CArray<CStringArray, CStringArray>* pArr, IN const CString& strName)
{
	if(pArr == NULL)
		return _T("");

	for(int i=0; i<pArr->GetSize(); i++)
	{
		if(pArr->ElementAt(i).ElementAt(1) == strName)
			return pArr->ElementAt(i).ElementAt(1);
	}
	return _T("");
}

/************************************************************************/
/* 
	函数:OpenDb
	描述:连接数据库
	参数:
		IN LPCTSTR lpConnect					连接数据库字串
	返回:1成功，0失败
*/
/************************************************************************/
int	CPhotoDelMgr::OpenDb(IN LPCTSTR lpConnect)
{
#ifdef _UNICODE
	if(lpConnect == NULL || wcscmp(lpConnect, _T("")) == 0)
		return 0;
#else
	if(lpConnect == NULL || strcmp(lpConnect, "") == 0)
		return 0;
#endif //#ifdef _UNICODE

	m_lock.lock();
	if(m_pdb)
	{
		m_lock.unlock();
		return 1;
	}
	
#ifdef _UNICODE
	wcscpy(m_szConnect, lpConnect);
#else
	strcpy(m_szConnect, lpConnect);
#endif //#ifdef _UNICODE

	if (m_pdb == NULL)
	{
		try
		{
			m_pdb = new CDatabase;
			m_pdb->OpenEx(m_szConnect, CDatabase::noOdbcDialog);
		}
		catch (CDBException* e)
		{
			//m_strConnectErrorDescriptor = e->m_strError;
			m_lock.unlock();
			delete m_pdb;
			m_pdb = NULL;

			//OutputDebugString(e->m_strError);
			//LOG4C_NO_FILENUM((LOG_NOTICE,"打开数据库失败:%s",CW2A(e->m_strError)));
#ifdef _DEBUG
			e->ReportError();
#endif //#ifdef _DEBUG
			e->Delete();
			return FALSE;
		}
	}

	m_lock.unlock();
	return 1;
}


/************************************************************************/
/* 
	函数:DelFinish
	描述:删除完成回调函数
	参数:
		LPVOID,				回调传回值
		LPVOID,
		LPVOID,
		LPVOID,
		LPVOID
	返回:1成功，0失败
*/
/************************************************************************/
int CPhotoDelMgr::DelFinish(IN LPVOID lpParam1, IN LPVOID lpParam2, IN LPVOID lpParam3, IN LPVOID lpParam4, IN LPVOID lpParam5, IN LPVOID lpParam6)
{
	AfxSetResourceHandle(g_Instance);
	return g_pPhotoDelMgr->DelFinishPro(lpParam1, lpParam2, lpParam3, lpParam4, lpParam5, lpParam6);
}

/************************************************************************/
/* 
	函数:DelFinishPro
	描述:删除完成回调函数
	参数:
		LPVOID,				回调传回值
		LPVOID,
		LPVOID,
		LPVOID,
		LPVOID
	返回:1成功，0失败
*/
/************************************************************************/
int CPhotoDelMgr::DelFinishPro(IN LPVOID lpParam1, IN LPVOID lpParam2, IN LPVOID lpParam3, IN LPVOID lpParam4, IN LPVOID lpParam5, IN LPVOID lpParam6)
{
	BYTE byType = *((BYTE*)lpParam1);
	BOOL bSuccess = *((BOOL*)lpParam5);

	TCHAR szDomain[64] = {0};
	TCHAR szOrderNum[64] = {0};
	TCHAR szDir[MAX_PATH] = {0};

	_stprintf(szDomain, _T("%s") , (TCHAR*)lpParam2);
	_stprintf(szOrderNum, _T("%s") , (TCHAR*)lpParam3);
	_stprintf(szDir, _T("%s") , (TCHAR*)lpParam4);

	CString strShow = _T("");
	if(!bSuccess)
	{
		strShow.Format(_T("%s不存在订单%s，删除失败\n"), szDir, szOrderNum);
		SendMessage(MSG_SHOWPROMPTING, (WPARAM)&strShow, 0);
		return 0;
	}

	CString updateSql = _T("");
	switch ( byType )
	{
	case 1:
		updateSql.Format(_T("update [PhotoManager] set [opdel] = 1,[opdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 2:
		updateSql.Format(_T("update [PhotoManager] set [epdel] = 1,[epdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 3:
		updateSql.Format(_T("update [PhotoManager] set [fpdel] = 1,[fpdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 4:
		updateSql.Format(_T("update [PhotoManager] set [dpdel] = 1,[dpdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
		//////////////////////////////////////////////////////////////////////////
	case 5:
		updateSql.Format(_T("update [PhotoManager] set [opbdel] = 1,[opbdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 6:
		updateSql.Format(_T("update [PhotoManager] set [epbdel] = 1,[epbdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 7:
		updateSql.Format(_T("update [PhotoManager] set [fpbdel] = 1,[fpbdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	case 8:
		updateSql.Format(_T("update [PhotoManager] set [dpbdel] = 1,[dpbdeltm] = getdate() where [order] = '%s' and [branchid] = '%s'"), szOrderNum, szDomain);
		break;
	default:
		break;
	}

	try
	{
		m_lock.lock();
		//更新相片管理表
		m_pdb->ExecuteSQL(updateSql);
	}
	catch (CDBException * e)
	{
		m_lock.unlock();
		WriteError(updateSql + "操作数据库失败" + e->m_strError);
#ifdef _DEBUG
		e->ReportError();
#endif
		e->Delete();
		return 0;
	}
	m_lock.unlock();

	//更新列表
	std::vector<LPSPICKUPINFO>::iterator it = m_vCurrSelLog.begin();
	for(;it != m_vCurrSelLog.end();)
	{
		LPSPICKUPINFO lp = (*it);
		if(lp !=  NULL)
		{
			if(lp->strBranchid.CompareNoCase(szDomain) == 0 && lp->strOrder.CompareNoCase(szOrderNum) == 0)
			{
				strShow.Format(_T("%s的%s订单，已删除\n"), szDir, szOrderNum);
				SendMessage(MSG_SHOWPROMPTING, (WPARAM)&strShow, 0);
				switch(byType)
				{
				case 1:
					lp->bOpdel = TRUE;
					lp->bOpNeedDel = FALSE;
					break;
				case 2:
					lp->bEpdel = TRUE;
					lp->bEpNeedDel = FALSE;
					break;
				case 3:
					lp->bFpdel = TRUE;
					lp->bFpNeedDel = FALSE;
					break;
				case 4:
					lp->bDpdel = TRUE;
					lp->bDpNeedDel = FALSE;
					break;
				case 5:
					lp->bOpbdel = TRUE;
					lp->bOpbNeedDel = FALSE;
					break;
				case 6:
					lp->bEpbdel = TRUE;
					lp->bEpbNeedDel = FALSE;
					break;
				case 7:
					lp->bFpbdel = TRUE;
					lp->bFpbNeedDel = FALSE;
					break;
				case 8:
					lp->bDpbdel = TRUE;
					lp->bDpbNeedDel = FALSE;
					break;
				}
				FillPhotoType(lp);

				int nCount = m_DelList.GetItemCount();
				for(int i=0; i<nCount; i++)
				{
					if(m_DelList.GetCheck(i) == TRUE)
					{
						CString strDomain = m_DelList.GetItemText(i, 1);
						CString strOrder = m_DelList.GetItemText(i, 2);
						if(strDomain.CompareNoCase(szDomain) == 0 && strOrder.CompareNoCase(szOrderNum) == 0)
						{
							m_DelList.SetCheck(i, FALSE);
							break;
						}
					}
				}
				break;
			}
		}
		++it;
	}

	return 1;
}

/************************************************************************/
/* 
	函数:GetShareBackupDir
	描述:获取备份共享目录
	参数:
	返回:
*/
/************************************************************************/
void CPhotoDelMgr::GetShareBackupDir()
{
	ClearBakDirInfo();

	CAutoLock autolock(&m_lock);
	try
	{
		CRstversion rsSt;
		rsSt.m_pDatabase = m_pdb;
		rsSt.Open();
		if (!rsSt.IsEOF())
		{
			CString strPath = _T("");
			LPSBAKDIRINFO lp = new SBAKDIRINFO;
			lp->byPhotoType = 5;
			MakeBackupDir(lp->byPhotoType, rsSt.m_bakserver1, strPath);
			lp->strDir = strPath;
			m_vBackupDirInfos.push_back(lp);

			lp = new SBAKDIRINFO;
			lp->byPhotoType = 6;
			MakeBackupDir(lp->byPhotoType, rsSt.m_bakserver2, strPath);
			lp->strDir = strPath;
			m_vBackupDirInfos.push_back(lp);

			lp = new SBAKDIRINFO;
			lp->byPhotoType = 7;
			MakeBackupDir(lp->byPhotoType, rsSt.m_bakserver3, strPath);
			lp->strDir = strPath;
			m_vBackupDirInfos.push_back(lp);

			lp = new SBAKDIRINFO;
			lp->byPhotoType = 8;
			MakeBackupDir(lp->byPhotoType, rsSt.m_bakserver4, strPath);
			lp->strDir = strPath;
			m_vBackupDirInfos.push_back(lp);
		}
		rsSt.Close();
	}
	catch (CException* e)
	{
		TCHAR szError[1024] = {0};
		e->GetErrorMessage(szError, 1024);
		CString strError = _T("");
		strError.Format(_T("获取备份共享目录：%s"), szError);
		WriteLogin(strError);
		e->Delete();
	}
}

void CPhotoDelMgr::ClearBakDirInfo()
{
	std::vector<LPSBAKDIRINFO>::iterator it = m_vBackupDirInfos.begin();
	for(; it != m_vBackupDirInfos.end(); ++it)
	{
		if((*it) != NULL)
			delete (*it);
	}
	m_vBackupDirInfos.clear();
}
/************************************************************************/
/* 
	函数:MakeBackupDir
	描述:生成备份目录
	参数:
		IN CONST CString& str,				// 可能是共享计算机名/目录/ip地址
		OUT CString& strPath				// 返回备份目录
	返回:
*/
/************************************************************************/
void CPhotoDelMgr::MakeBackupDir(IN CONST int nType, IN CONST CString& str, OUT CString& strPath)
{
	if(str == _T("")) 
		return;

	CString strTemp = str;
	strTemp.MakeLower();

	CString strFolderName = _T("");
#ifdef CHILD_VERSION
	switch(nType)
	{
	case 5:
		strFolderName = _T("客户原片备份(儿童管理软件)$");
		break;
	case 6:
		strFolderName = _T("修好的片备份(儿童管理软件)$");
		break;
	case 7:
		strFolderName = _T("精修好的片备份(儿童管理软件)$");
		break;
	case 8:
		strFolderName = _T("设计好的片备份(儿童管理软件)$");
		break;
	}
#else
	switch(nType)
	{
	case 5:
		strFolderName = _T("客户原片备份(管理软件)$");
		break;
	case 6:
		strFolderName = _T("修好的片备份(管理软件)$");
		break;
	case 7:
		strFolderName = _T("精修好的片备份(管理软件)$");
		break;
	case 8:
		strFolderName = _T("设计好的片备份(管理软件)$");
		break;
	}
#endif
	
	char szServer[50] = {0};
	DWORD leng = 50;
	::GetComputerName(szServer, &leng);
	CString strMainName = szServer;
	strMainName.MakeLower();
	if(strTemp.Find(strFolderName) != -1)				//目录
	{
		if(strTemp.Find(_T(":\\")) != -1 || strTemp.Find(_T("\\\\")) != -1)				// 绝对路径: D:\...\... (相对: \\...\...)
			strPath = strTemp;
	}
	else if(strTemp.CompareNoCase(strMainName) == 0)				//是否为计算机名
	{
		strMainName.TrimLeft(_T("\\\\"));
		strMainName.TrimRight(_T("\\"));
		strPath = _T("\\\\") + strMainName + _T("\\") + strFolderName;
	}
	else		//ip地址
	{
		if(strTemp.GetLength() <= 16)
		{
			CString strip = strTemp;
			int nCount = 0;
			while(1)
			{
				int nPos = strip.Find(_T("."));
				if(nPos == -1)
					break;

				strip = strip.Right((strip.GetLength() - 1) - nPos);
				if(strip == _T(""))
					break;
				++nCount;
			}

			if(nCount == 3)
				strTemp = strPath;
		}
	}
	if(strPath != _T(""))
		strPath.MakeLower();
}

//提示信息
LRESULT CPhotoDelMgr::ShowPrompting(WPARAM wParam, LPARAM lParam)
{
	int nShowType = lParam;
	CString strMSG = *(CString*)wParam;

	static CHARFORMAT cf;
	cf.cbSize = sizeof(CHARFORMAT); 

	static COleDateTime oletime;
	oletime=COleDateTime::GetCurrentTime();

	strMSG.Format(_T("%s: #%s.\r"),oletime.Format(_T("%Y/%m/%d %H:%M:%S")),strMSG);
	//strMSG += ".\r";
	if ( nShowType == 1) // 错误信息提示
	{
		// 显示前,设置字体颜色;
		//m_EditShow.GetDefaultCharFormat(cf);
		m_DelTips.GetDefaultCharFormat(cf);
		cf.dwMask=CFM_COLOR|CFM_FACE|CFM_SIZE|CFM_BOLD; 
		cf.dwEffects = (unsigned long)~(CFE_UNDERLINE | CFE_BOLD | CFE_AUTOCOLOR);
		//cf.dwEffects ^= CFE_AUTOCOLOR;
		cf.crTextColor = RGB(255, 0, 0); 
		cf.yHeight = 180;
		memset(cf.szFaceName, 0, LF_FACESIZE);
		//	memcpy(cf.szFaceName, "楷体_GB2312", sizeof("楷体_GB2312"));
		memcpy(cf.szFaceName, _T("宋体"), sizeof(_T("宋体")));
		m_DelTips.SetSelectionCharFormat(cf);

		m_DelTips.SetSel(-1,-1);
		m_DelTips.ReplaceSel(strMSG);
	}
	else	// 成功信息提示;
	{
		m_DelTips.GetDefaultCharFormat(cf);
		cf.dwMask=CFM_COLOR|CFM_FACE|CFM_SIZE|CFM_BOLD; 
		cf.dwEffects = (unsigned long)~(CFE_UNDERLINE | CFE_BOLD | CFE_AUTOCOLOR);
		//cf.dwEffects ^= CFE_AUTOCOLOR;
		cf.crTextColor = RGB(0, 0, 255); 
		cf.yHeight = 180;
		memset(cf.szFaceName, 0, LF_FACESIZE);
		//	memcpy(cf.szFaceName, "楷体_GB2312", sizeof("楷体_GB2312"));
		memcpy(cf.szFaceName, _T("宋体"), sizeof(_T("宋体")));
		m_DelTips.SetSelectionCharFormat(cf);

		m_DelTips.SetSel(-1,-1);
		m_DelTips.ReplaceSel(strMSG);
	}

	m_DelTips.PostMessage(WM_VSCROLL, SB_BOTTOM,0);
	return 0;
}