lyfz_repos/经典版源码/lyfzServer/trunk/lyfzClassicServer/CreateSmallPhoto.cpp

#include "stdafx.h"
#include "CreateSmallPhoto.h"
#include <process.h>
#include <afxdb.h>
#include "./helper/ffsco.h"
#include "BranchInfo.h"

#include <comutil.h>
#pragma comment(lib, "comsuppw.lib")

#include "IMGCommon.h"

using namespace helper_coffs;

unsigned __stdcall WorkThread(LPVOID lpParam);

CreateSmallPhoto::CreateSmallPhoto()
{
	m_hExitEvent = NULL;
	m_hThread = NULL;
	lCreating = 0;
	m_ctrl_process = NULL;
	m_pWnd = NULL;
}

CreateSmallPhoto::~CreateSmallPhoto()
{
	TerminateThread();
}

//-----------------------------------------------------------------------
/*
// 函数：GetOrderNumFromDB
// 描述：从数据库里获取订单号
// 参数：
		CStringArray& orderArr		返回未取件的订单号
		CString* pField				条件限制的字段
// 返回：
*/
//-----------------------------------------------------------------------
void CreateSmallPhoto::GetOrdersFromDB(OUT CStringArray& orderArr, IN CString* pField)
{
	CDatabase *pdb = NULL;
	ODBCConnGuard ConnGuard(pdb, -1, 3000);
	if ( NULL == pdb )
		return;

	CRecordset myset(pdb);
	CString	sql = "select id from dindan";
	if(pField && (*pField) != _T(""))
		sql += " where " + (*pField);
	myset.Open(CRecordset::forwardOnly, sql);
	while (!myset.IsEOF())
	{
		CString strOrder = _T("");
		myset.GetFieldValue("id", strOrder);
		if(strOrder != _T(""))
			orderArr.Add(strOrder);
		myset.MoveNext();
	}
	myset.Close();
}


/************************************************************************/
/* 
	函数: CreatePhoto
	描述: 生成小图
	参数:
		IN LPCTSTR lpDir,					目录
		IN BOOL bMPhoto						是否生成m图
	返回:
	示例:
	注意:
*/
/************************************************************************/
BOOL CreateSmallPhoto::CreatePhoto(IN CString& strDir, IN BOOL bMPhoto)
{
	//先删除ok文件
	DelOKFiles(&strDir);

	// 如果不是客户原片或修好的片目录,设置bMPhoto参数为0,不生成M缩略图;
	if (strDir.Find("客户原片(管理软件)$") == -1 && strDir.Find("修好的片(管理软件)$") == -1)
		bMPhoto = 0;

	ffsco o;
	o.dirs(1);
	o.find(LPCSTR(strDir), LPCSTR("*.*"));
	ffsco::typeT coo;
	ffsco::typeT::iterator it;
	coo = o.co_file();
	int oldsize = coo.size();
	int nFileCount = 0;
	CString path(_T("")), temp(_T("")), spath(_T("")), mpath(_T(""));
	for (it = coo.begin(); coo.end() != it; it++)
	{
		try
		{
			if(WaitForSingleObject(m_hExitEvent, 0) == WAIT_OBJECT_0)
				break;

			// 遍历到的jpg文件如果是缩略图则不处理,继续遍历;
			path = (*it).c_str();
			temp = path.Right(path.GetLength() - path.ReverseFind('\\') - 1);
			if (temp.GetAt(0) == 's')continue;
			if (temp.GetAt(0) == 'm')continue;

			spath = path.Left(path.ReverseFind('\\') + 1);
			mpath = spath;
			spath += "s";
			mpath += "m";

			spath += path.Right(path.GetLength() - path.ReverseFind('\\') - 1);
			mpath += path.Right(path.GetLength() - path.ReverseFind('\\') - 1);

			Image* pImg = NULL;
			IMGCommon::LoadImgFromFile(&pImg, path);

			if (pImg == NULL)
				continue;

			IMGCommon::ImgThumbnail(pImg, SET_PIX(100,100), spath, 100);
			if (bMPhoto)
				IMGCommon::ImgThumbnail(pImg, SET_PIX(2000,2000), mpath, 100);

			if (pImg)
				delete pImg;
			pImg = NULL;
		}
		catch (...)
		{
			WriteTextLog("出错在函数CreatePhoto中");
		}
	}

	CreateOKFiles(strDir);

	return TRUE;
}

/************************************************************************/
/* 
	函数:IsCreateMImage
	描述:选片时是否使用m缩略图来代替原片放大使用;
	参数:
		Image **img,
		CString path
	返回: TRUE,FALSE
*/
/************************************************************************/
BOOL CreateSmallPhoto::IsCreateMImage()
{
	BOOL bRet = FALSE;
	if (g_bSteal == 0)
	{
		CDatabase *pdb = NULL;
		ODBCConnGuard ConnGuard(pdb, -1, 3000);
		if ( NULL == pdb )
			return FALSE;
		CRecordset myset(pdb);
		CString	sql = "select * from version";
		myset.Open(CRecordset::forwardOnly, sql);
		myset.GetFieldValue("setcheck15", sql);			// 选片时是否使用m缩略图来代替原片放大使用;
		myset.Close();
		bRet = atoi(sql);
	}
	return bRet;
}

/************************************************************************/
/* 
	函数:Work
	描述:
	参数:
	返回: 
*/
/************************************************************************/
void CreateSmallPhoto::Work()
{
	// 选片时是否使用m缩略图来代替原片放大使用;
	BOOL bMphoto = IsCreateMImage();

	//读取所有未取件的订单号
	CStringArray orderArr;
	CString strField = _T("status3='未取'");
	GetOrdersFromDB(orderArr, &strField);
	if(orderArr.GetSize() == 0)
	{
		WriteTextLog("没有获取到订单号");
		return;
	}

	//组合目录
	CString initialPhotoPath = _T("");
	CString initialModifyPath = _T("");
	CString designPhotoPath = _T("");
	CString excellentModifyPath = _T("");

	char server[50] = {0};
	DWORD leng = 50;
	::GetComputerName(server, &leng);

	initialPhotoPath = initialModifyPath = designPhotoPath = excellentModifyPath = server;
	initialPhotoPath = "\\\\" + initialPhotoPath + "\\客户原片(管理软件)$";
	initialModifyPath = "\\\\" + initialModifyPath + "\\修好的片(管理软件)$";
	designPhotoPath = "\\\\" + designPhotoPath + "\\设计好的片(管理软件)$";
	excellentModifyPath = "\\\\" + excellentModifyPath + "\\精修好的片(管理软件)$";

	GetPathFromNetShareName("客户原片(管理软件)$", initialPhotoPath);
	GetPathFromNetShareName("修好的片(管理软件)$", initialModifyPath);
	GetPathFromNetShareName("设计好的片(管理软件)$", designPhotoPath);
	GetPathFromNetShareName("精修好的片(管理软件)$", excellentModifyPath);

	initialPhotoPath.MakeLower();
	initialModifyPath.MakeLower();
	designPhotoPath.MakeLower();
	excellentModifyPath.MakeLower();

	//
	CStringArray pathArr;
	int i = 0;
	try
	{
		//筛选需要生成小图的目录
		if(CBranchInfo::GetInstance()->m_TblNetShareInfo.size() != 0)
		{
			vector<TblNetShareInfo*>::iterator iter = CBranchInfo::GetInstance()->m_TblNetShareInfo.begin();
			for(; iter != CBranchInfo::GetInstance()->m_TblNetShareInfo.end();)
			{
				TblNetShareInfo* p = (*iter);
				if(p != NULL)
				{
					CString strDir = p->szShareDirectory;
					if(strDir.Find(_T("$\\")) != -1)
						strDir = strDir.TrimRight(_T("\\"));

					ScreeningDir(&strDir, &orderArr, pathArr);
				}
				++iter;
			}

			CString patharray[2] = { designPhotoPath, excellentModifyPath };
			for (i = 0; i < 2; i++)
				ScreeningDir(&patharray[i], &orderArr, pathArr);
		}

		strField.Format(_T("订单:0/%d"), pathArr.GetSize());
		if (m_ctrl_process)
			m_ctrl_process->SetRange(0, pathArr.GetSize());
		if ( m_pWnd )
			m_pWnd->SetWindowText(strField);

		// 生成小图;
		for(int i = 0; i < pathArr.GetSize(); i++)
		{
			if(WaitForSingleObject(m_hExitEvent, 0) == WAIT_OBJECT_0)
				break;

			CreatePhoto(pathArr.ElementAt(i), bMphoto);
			if (m_ctrl_process)
				m_ctrl_process->SetPos(i+1);
			if ( m_pWnd )
			{
				strField.Format(_T("订单:%d/%d"), i+1, pathArr.GetSize());
				m_pWnd->SetWindowText(strField);
			}
		}
	}
	catch (...)
	{
		WriteTextLog("出错在函数CreateSmallPhoto::GenThumb中");
	}
	InterlockedExchange(&lCreating, FALSE);
	_endthreadex(0);
	TerminateThread();
	return;
}

/************************************************************************/
/* 
	函数:ScreeningDir
	描述: 筛选目录
	参数:
		IN const CString* pDir,					需要检测的根目录
		IN CStringArray* pOrderArr,				订单号集
		OUT CStringArray& dirArr				返回需要生成小图的目录
	返回: TRUE,FALSE
*/
/************************************************************************/
BOOL CreateSmallPhoto::ScreeningDir(IN const CString* pDir, IN CStringArray* pOrderArr, OUT CStringArray& dirArr)
{
	if(pDir == NULL || pOrderArr == NULL)
		return FALSE;
#if 0
	ffsco o;
	o.dirs(0);
	o.find(LPCSTR((*pDir)), LPCSTR("*.*"));
	ffsco::typeT coo;
	ffsco::typeT::iterator it;
	coo = o.co_dir();
	int oldsize = 0;
	CString path(_T("")), temp(_T("")), spath(_T("")), mpath(_T(""));
	CString strOldPath = _T("");
	for (it = coo.begin(); coo.end() != it; it++)
	{
		if(WaitForSingleObject(m_hExitEvent, 0) == WAIT_OBJECT_0)
			break;

		path = it->c_str();
		path.MakeLower();
		if(path.CompareNoCase(strOldPath) == 0)
			continue;

		if(!PathFileExists(path))
			continue;

		if(path.GetAt(path.GetLength() - 1) != '\\')
			path += _T("\\");

		BOOL bNeed = FALSE;
		//先检测目录是否是要生成小图的目录
		for(int i=0; i<pOrderArr->GetSize(); i++)
		{
			CString strOrderNum = _T("\\") + pOrderArr->ElementAt(i) + _T("\\");
			if(path.Find(strOrderNum) != -1)
			{
				bNeed = TRUE;
				break;
			}
		}

		if(!bNeed)
			continue;

		//删除要生成小图的目录里的ok文件
	//	DelOKFiles(&path);
		dirArr.Add(it->c_str());
		strOldPath = it->c_str();
	}
#else
	CString strRootDirecotry = *pDir;
	CString strOrderDirectory = _T("");

	strRootDirecotry.TrimRight(_T('\\'));
	for ( int i = 0; i < pOrderArr->GetSize(); i++ )
	{
		if(WaitForSingleObject(m_hExitEvent, 0) == WAIT_OBJECT_0)
			break;

		strOrderDirectory.Format(_T("%s\\%s"), strRootDirecotry, pOrderArr->ElementAt(i));
		if ( PathFileExists(strOrderDirectory) )
			dirArr.Add(strOrderDirectory);
	}
#endif
	return TRUE;
}

/************************************************************************/
/* 
	函数:DelOKFiles
	描述: 删除ok文件
	参数:
		IN CString* pPath				
	返回: TRUE,FALSE
*/
/************************************************************************/
BOOL CreateSmallPhoto::DelOKFiles(IN CString* pPath)
{
	if(pPath == NULL || (*pPath) == _T(""))
		return FALSE;

	ffsco o;
	o.dirs(1);
	o.find(LPCSTR((*pPath)), LPCSTR("*.*"));
	ffsco::typeT coo;
	ffsco::typeT::iterator it;
	coo = o.co_dir();
	int oldsize = coo.size();
	CString path(_T("")), temp(_T("")), spath(_T("")), mpath(_T(""));
	CString strOldPath = _T("");
	for (it = coo.begin(); coo.end() != it; it++)
	{
		CString str = it->c_str();
		if(str.GetAt(str.GetLength() - 1) != '\\')
			str += _T("\\");

		CString strTmp1 = str;
		CString strTmp2 = str;
		strTmp1 += _T("ok");
		strTmp2 += _T("ok.dat");
		if(PathFileExists(strTmp1))
			DeleteFile(strTmp1);		// 删除ok文件;
		if(PathFileExists(strTmp2))
			DeleteFile(strTmp2);		// 删除ok文件;
	}
	return TRUE;
}

unsigned __stdcall WorkThread(LPVOID lpParam)
{
	CreateSmallPhoto* p = (CreateSmallPhoto*)lpParam;
	if(p != NULL)
		p->Work();
	return 0;
}

void CreateSmallPhoto::StartThread(CProgressCtrl &ctrl, CWnd *pWnd)
{
	m_ctrl_process = &ctrl;
	m_pWnd = pWnd;
	TerminateThread();
	lCreating = 1;
	m_hExitEvent = CreateEvent(0, TRUE, FALSE, NULL);
	unsigned int lThreadID = 0;
	m_hThread = (HANDLE)_beginthreadex(NULL, 0, WorkThread, (LPVOID)this, 0/* CREATE_SUSPENDED*/, &lThreadID);
}

void CreateSmallPhoto::TerminateThread()
{
	if(m_hExitEvent)
		SetEvent(m_hExitEvent);

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

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

/************************************************************************/
/* 
	函数:CreateOKFiles
	描述: 生成ok文件
	参数:
		IN CString& strDir,					要生成ok文件的目录
		IN int nOldSize						文件数量
	返回: TRUE,FALSE
*/
/************************************************************************/
void CreateSmallPhoto::CreateOKFiles(IN CString& strDir, IN int nOldSize)
{
	if(strDir == _T(""))
		return;

	try
	{
		CString strPath = _T("");
		CString strTmpDir = strDir;
		if(strDir.GetAt(strDir.GetLength() - 1) != '\\')
			strDir += _T("\\");
		
		ffsco o;
		o.dirs(1);
		o.find(LPCSTR(strDir), LPCSTR("*.*"));
		ffsco::typeT cooDir;
		ffsco::typeT::iterator it;
		cooDir = o.co_dir();
		for(it=cooDir.begin(); it!=cooDir.end(); it++)
		{
			strPath = it->c_str();
			if(strPath.GetAt(strPath.GetLength() - 1) != '\\')
				strPath += _T("\\");

			strPath += _T("ok");
			CFile fp;
			fp.Open(strPath, CFile::modeCreate | CFile::modeWrite);
			fp.Close();
		}
	}
	catch (...)
	{
		WriteTextLog("出错在函数CreateOKFiles中");
	}
}