#include "LogDao.h"
#include "../Toast.h"
#include "../LanguageManager.h"
#include "../global.h"
#include <direct.h>
#include <io.h>
#include "../utils/TimeHelper.h"
#include "turbojpeg.h"
#include "../config/bean/CoverCfg.h"
#include <fstream>

LogDao::LogDao()
	:m_pDB(nullptr)
	,m_CurrentShowJob(NULL)
	, m_ImageThread(INVALID_HANDLE_VALUE)
	, m_ImageFlag(false)
	, m_ExportThread(INVALID_HANDLE_VALUE)
	, m_ExportProgress(0)
	, m_ExportFlag(false)
	, m_pImgDB(nullptr)
	, m_ShowAxisLog(NULL)
	, m_IsFindingRecord(false)
{
}


LogDao::~LogDao()
{
	DeleteCriticalSection(&m_FocusStatusCS);
	DeleteCriticalSection(&m_InfraredTempCS);
	DeleteCriticalSection(&m_ScannerStatusCS);
	DeleteCriticalSection(&m_AxisLogCs);
	DeleteCriticalSection(&m_AlarmCs);
	DeleteCriticalSection(&m_LogImageCs);
	DeleteCriticalSection(&m_StatusCs);
	DeleteCriticalSection(&m_JobCs);
	DeleteCriticalSection(&m_LogCs);
	DeleteCriticalSection(&m_DbCs);
	DeleteCriticalSection(&m_ImgDbCs);

	for (map<int, SQLite::Database*>::iterator it = m_DBMap.begin(); it != m_DBMap.end(); it++)
	{
		SQLite::Database* db = it->second;
		delete db;
	}
}

void LogDao::Init()
{
	InitializeCriticalSection(&m_DbCs);
	InitializeCriticalSection(&m_ImgDbCs);
	InitializeCriticalSection(&m_LogCs);
	InitializeCriticalSection(&m_JobCs);
	InitializeCriticalSection(&m_StatusCs);
	InitializeCriticalSection(&m_LogImageCs);
	InitializeCriticalSection(&m_AlarmCs);
	InitializeCriticalSection(&m_AxisLogCs);
	InitializeCriticalSection(&m_ScannerStatusCS);
	InitializeCriticalSection(&m_InfraredTempCS);
	InitializeCriticalSection(&m_FocusStatusCS);
	InitializeCriticalSection(&m_FindRecordCS);
	m_RootPath = g_AppPath + "log/";
	if (_access(m_RootPath.c_str(), 0) != 0) {
		_mkdir(m_RootPath.c_str());
	}
	SYSTEMTIME tnow;
	GetLocalTime(&tnow);
	char buffer[128];
	sprintf_s(buffer, sizeof(buffer), "%s%04d.hbd", m_RootPath.c_str(),tnow.wYear);
	string databasepath = string(buffer);
	m_pDB = new SQLite::Database(databasepath, SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE);
	m_pDB->exec("PRAGMA key = '!hbd_admin'");
	m_DBMap[tnow.wYear] = m_pDB;

	sprintf_s(buffer, sizeof(buffer), "%s%04d-img.hbd", m_RootPath.c_str(), tnow.wYear);
	string imgpath = string(buffer);
	m_pImgDB = new SQLite::Database(imgpath, SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE);
	m_pImgDB->exec("PRAGMA key = '!hbd_admin'");
	m_ImgDBMap[tnow.wYear] = m_pImgDB;

	for (int i = 2018; i < tnow.wYear; i++) {
		databasepath = m_RootPath + to_string(i) + ".hbd";
		int rel = _access(databasepath.c_str(), 0);
		if (rel != 0)continue;
		SQLite::Database *tmp = nullptr;
		tmp = new SQLite::Database(databasepath, SQLite::OPEN_READWRITE);
		tmp->exec("PRAGMA key = '!hbd_admin'");
		if (!tmp)
			continue;
		m_DBMap[i] = tmp;
	}

	for (int i = 2018; i < tnow.wYear; i++) {
		imgpath = m_RootPath + to_string(i) + "-img.hbd";
		int rel = _access(imgpath.c_str(), 0);
		if (rel != 0)continue;
		SQLite::Database *tmp = nullptr;
		tmp = new SQLite::Database(imgpath, SQLite::OPEN_READWRITE);
		tmp->exec("PRAGMA key = '!hbd_admin'");
		if (!tmp)
			continue;
		m_ImgDBMap[i] = tmp;
	}

	SQLite::Transaction transaction(*m_pDB);
	LogBean::CreateIfNoExist(m_pDB);
	JobBean::CreateIfNoExist(m_pDB);
	LayerStatus::CreateIfNoExist(m_pDB);
	LogImage::CreateIfNoExist(m_pDB);
	PartAddition::CreateIfNoExist(m_pDB);
	AxisLog::CreateIfNoExist(m_pDB);
	ScannerStatus::CreateIfNoExist(m_pDB);
	ScannerPowerLog::CreateIfNoExist(m_pDB);
	FocusStatus::CreateIfNoExist(m_pDB);
	InfraredTempLog::CreateIfNoExist(m_pDB);
	PartPosBean::CreateIfNoExist(m_pDB);
	m_pDB->exec(HistoryAlarm::GetCreateSql());
	m_pDB->exec(HistoryAlarm::GetIndexSql());
	transaction.commit();

	LogImage::CreateIfNoExist(m_pImgDB);
	IFImage::CreateIfNoExist(m_pImgDB);
	ImageInfo::CreateIfNoExist(m_pImgDB);
}

void LogDao::GetLogs(struct tm &begin, struct tm &end)
{
	begin.tm_hour = 0;
	begin.tm_min = 0;
	begin.tm_sec = 0;
	end.tm_hour = 23;
	end.tm_min = 59;
	end.tm_sec = 59;
	time_t tbegin = mktime(&begin);
	time_t tend = mktime(&end);

	if (tbegin > tend)
	{
		g_Toast->AddToast(new ToastBean(_(u8"结束日期要大于开始日期").c_str(), 3000));
		return;
	}
	EnterCriticalSection(&m_LogCs);
	m_Logs.clear();
	LeaveCriticalSection(&m_LogCs);

	char sql[1024];
	if (m_DBMap.find(begin.tm_year + 1900) != m_DBMap.end())
	{
		sprintf_s(sql, sizeof(sql), "SELECT * FROM %s WHERE %s BETWEEN %lld AND %lld",
			LogBean::LOG_TABLE_NAME.c_str(), LogBean::LOG_FIELD_INSERT_TIME.c_str(), tbegin, tend);

		string level, content;
		time_t date;
		char buffer[1024];
		EnterCriticalSection(&m_DbCs);
		
		try {
			SQLite::Statement query(*m_DBMap[begin.tm_year + 1900], sql);
			while (query.executeStep()) {
				level = query.getColumn(LogBean::LOG_FIELD_LEVEL.c_str()).getString();
				date = query.getColumn(LogBean::LOG_FIELD_INSERT_TIME.c_str()).getInt64();
				content = query.getColumn(LogBean::LOG_FIELD_CONTENT.c_str()).getString();
				sprintf_s(buffer, sizeof(buffer), "%s %s %s", level.c_str(), TimeHelper::Time2Str(date).c_str(), content.c_str());
				EnterCriticalSection(&m_LogCs);
				m_Logs.push_back(string(buffer));
				LeaveCriticalSection(&m_LogCs);
			}
		}
		catch (SQLite::Exception &e)
		{
			g_log->TraceError(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
	}

	if (begin.tm_year != end.tm_year)
	{
		if (m_DBMap.find(end.tm_year + 1900) == m_DBMap.end())return;
		sprintf_s(sql, sizeof(sql), "SELECT * FROM %s WHERE %s BETWEEN %lld AND %lld",
			LogBean::LOG_TABLE_NAME.c_str(), LogBean::LOG_FIELD_INSERT_TIME.c_str(), tbegin, tend);

		char buffer[1024];
		string level, content;
		time_t date;
		EnterCriticalSection(&m_DbCs);
	
		try {
			SQLite::Statement query(*m_DBMap[end.tm_year + 1900], sql);
			while (query.executeStep()) {
				level = query.getColumn(LogBean::LOG_FIELD_LEVEL.c_str()).getString();
				date = query.getColumn(LogBean::LOG_FIELD_INSERT_TIME.c_str()).getInt64();
				content = query.getColumn(LogBean::LOG_FIELD_CONTENT.c_str()).getString();
				sprintf_s(buffer, sizeof(buffer), "%s %s %s", level.c_str(), TimeHelper::Time2Str(date).c_str(), content.c_str());
				EnterCriticalSection(&m_LogCs);
				m_Logs.push_back(string(buffer));
				LeaveCriticalSection(&m_LogCs);
			}
		}
		catch (SQLite::Exception &e)
		{
			g_log->TraceError(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
	}
}


void LogDao::AddLog(string prefix, string content)
{
	time_t tnow;
	time(&tnow);
	char sqlbuf[1024];
	sprintf_s(sqlbuf, sizeof(sqlbuf), u8"INSERT INTO %s(%s,%s,%s) VALUES(%lld,'%s', '%s')",
		LogBean::LOG_TABLE_NAME.c_str(),
		LogBean::LOG_FIELD_INSERT_TIME.c_str(),
		LogBean::LOG_FIELD_LEVEL.c_str(),
		LogBean::LOG_FIELD_CONTENT.c_str(),
		tnow,
		prefix.c_str(),
		content.c_str()
	);
	EnterCriticalSection(&m_DbCs);
	try {
		m_pDB->exec(sqlbuf);
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

bool LogDao::GetCheckJob(string uid, JobBean& bean)
{
	char sql[1024];
	sprintf_s(sql, sizeof(sql), "SELECT * FROM %s WHERE %s IN (SELECT MAX(%s) FROM %s WHERE %s='%s') AND %s=0 AND %s=0",
		JobBean::JOB_TABLE_NAME.c_str(), JobBean::JOB_FIELD_INSERT_TIME.c_str(), 
		JobBean::JOB_FIELD_INSERT_TIME.c_str(), JobBean::JOB_TABLE_NAME.c_str(),JobBean::JOB_FIELD_UID.c_str(), 
		uid.c_str(), JobBean::JOB_FIELD_IS_INVALID.c_str(), JobBean::JOB_FIELD_IS_FINISH.c_str());
	bool rel = false;
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*m_pDB, sql);
		if (query.executeStep()) {
			bean.m_Id = query.getColumn(JobBean::JOB_FIELD_ID.c_str()).getInt();
			bean.m_InsertTime = query.getColumn(JobBean::JOB_FIELD_INSERT_TIME.c_str()).getInt64();
			bean.m_Uid = query.getColumn(JobBean::JOB_FIELD_UID.c_str()).getString();
			bean.m_TaskID = query.getColumn(JobBean::JOB_TASK_ID.c_str()).getString();
			bean.m_Name = query.getColumn(JobBean::JOB_FIELD_NAME.c_str()).getString();
			bean.m_StartTime = query.getColumn(JobBean::JOB_FIELD_START_TIME.c_str()).getInt64();
			bean.m_LastPauseTime = query.getColumn(JobBean::JOB_FIELD_LAST_PAUSE_TIME.c_str()).getInt64();
			bean.m_StopTime = query.getColumn(JobBean::JOB_FIELD_STOP_TIME.c_str()).getInt64();
			bean.m_DeoxygenSecond = query.getColumn(JobBean::JOB_FIELD_DEOXYGEN_SECOND.c_str()).getUInt();
			bean.m_SpendSecond = query.getColumn(JobBean::JOB_FIELD_SPEND_SECOND.c_str()).getUInt();
			bean.m_PrintSecond = query.getColumn(JobBean::JOB_FIELD_PRINT_SECOND.c_str()).getUInt();
			bean.m_FirstStartIndex = query.getColumn(JobBean::JOB_FIELD_FIRST_START_INDEX.c_str()).getUInt();
			bean.m_StartMoldPos = query.getColumn(JobBean::JOB_FIELD_START_MOLD_POS.c_str()).getDouble();
			bean.m_MoldPos = query.getColumn(JobBean::JOB_FIELD_MOLD_POS.c_str()).getDouble();
			bean.m_PrintedLayerIndex = query.getColumn(JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str()).getUInt();
			bean.m_IsFinished = (query.getColumn(JobBean::JOB_FIELD_IS_FINISH.c_str()).getInt() > 0 ? true : false);
			bean.m_IsContinue = (query.getColumn(JobBean::JOB_FIELD_IS_CONTINUE.c_str()).getInt() > 0 ? true : false);
			bean.m_IsInvalid = (query.getColumn(JobBean::JOB_FIELD_IS_INVALID.c_str()).getInt() > 0 ? true : false);
			rel = true;
		}
		else rel = false;
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
		rel = false;
	}
	LeaveCriticalSection(&m_DbCs);
	return rel;
}

void LogDao::UpdateJobInvalid(long jid)
{
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "UPDATE %s SET %s=1 WHERE %s=%d", 
		JobBean::JOB_TABLE_NAME.c_str(),
		JobBean::JOB_FIELD_IS_INVALID.c_str(),
		JobBean::JOB_FIELD_ID.c_str(),jid);
	EnterCriticalSection(&m_DbCs);
	try
	{
		m_pDB->exec(buffer);
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::LogJobStart(JobBean* job)
{
	if (job == NULL)return;
	if (job->m_Uid.empty())return;
	char sqlbuf[1024];
	EnterCriticalSection(&m_DbCs);
	try {
		if (!job->m_IsContinue)
		{
			sprintf_s(sqlbuf, sizeof(sqlbuf), "INSERT INTO %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) VALUES(%lld,'%s','%s','%s',%lld,%lld,%d,%d,%d,%f,%lf,%d,%d,%d,%d)",
				JobBean::JOB_TABLE_NAME.c_str(),
				JobBean::JOB_FIELD_INSERT_TIME.c_str(),
				JobBean::JOB_TASK_ID.c_str(),
				JobBean::JOB_FIELD_UID.c_str(),
				JobBean::JOB_FIELD_NAME.c_str(),
				JobBean::JOB_FIELD_START_TIME.c_str(),
				JobBean::JOB_FIELD_STOP_TIME.c_str(),
				JobBean::JOB_FIELD_DEOXYGEN_SECOND.c_str(),
				JobBean::JOB_FIELD_SPEND_SECOND.c_str(),
				JobBean::JOB_FIELD_FIRST_START_INDEX.c_str(),
				JobBean::JOB_FIELD_START_MOLD_POS.c_str(),
				JobBean::JOB_FIELD_MOLD_POS.c_str(),
				JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str(),
				JobBean::JOB_FIELD_IS_FINISH.c_str(),
				JobBean::JOB_FIELD_IS_CONTINUE.c_str(),
				JobBean::JOB_FIELD_IS_INVALID.c_str(),
				job->m_InsertTime,
				job->m_TaskID.c_str(),
				job->m_Uid.c_str(),
				job->m_Name.c_str(),
				job->m_StartTime,
				job->m_StopTime,
				job->m_DeoxygenSecond,
				job->m_SpendSecond,
				job->m_FirstStartIndex,
				job->m_StartMoldPos,
				job->m_MoldPos,
				job->m_PrintedLayerIndex,
				job->m_IsFinished?1:0,
				job->m_IsContinue?1:0,
				job->m_IsInvalid?1:0
			);
			if (m_pDB->exec(sqlbuf))
			{
				sprintf_s(sqlbuf, sizeof(sqlbuf), "SELECT last_insert_rowid() FROM %s", JobBean::JOB_TABLE_NAME.c_str());
				SQLite::Statement query(*m_pDB, string(sqlbuf));
				if (query.executeStep()) {
					job->m_Id = query.getColumn(0).getInt();
				}
			}
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::UpdateJobPauseTime(JobBean* job) {
	int ret = 0;
	char sqlbuf[1024];
	sprintf_s(sqlbuf, sizeof(sqlbuf), "UPDATE %s SET %s=%lld WHERE %s=%d",
		JobBean::JOB_TABLE_NAME.c_str(), JobBean::JOB_FIELD_LAST_PAUSE_TIME.c_str(), job->m_LastPauseTime, JobBean::JOB_FIELD_ID.c_str(), job->m_Id);
	EnterCriticalSection(&m_DbCs);
	try {
		ret = m_pDB->exec(sqlbuf);
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::UpdateJobAfterPrintLayer(JobBean* job)
{
	char sqlbuf[1024];
	sprintf_s(sqlbuf, sizeof(sqlbuf), "UPDATE %s SET %s=%lld,%s=%d,%s=%d,%s=%lf,%s=%d,%s=%d WHERE %s=%d",
		JobBean::JOB_TABLE_NAME.c_str(),
		JobBean::JOB_FIELD_STOP_TIME.c_str(), job->m_StopTime,
		JobBean::JOB_FIELD_SPEND_SECOND.c_str(), job->m_SpendSecond+(int)job->m_CurrentPrintedTime,
		JobBean::JOB_FIELD_PRINT_SECOND.c_str(), job->m_PrintSecond + (int)job->m_EveryPrintedTime,
		JobBean::JOB_FIELD_MOLD_POS.c_str(),job->m_MoldPos,
		JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str(),job->m_PrintedLayerIndex,
		JobBean::JOB_FIELD_IS_FINISH.c_str(),job->m_IsFinished,
		JobBean::JOB_FIELD_ID.c_str(), job->m_Id
	);
	EnterCriticalSection(&m_DbCs);
	try {
		m_pDB->exec(sqlbuf);
	}
	catch (SQLite::Exception e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::GetJobsByTaskId(string taskid, vector<JobBean*>& jobs)
{
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s='%s' ORDER BY %s",
		JobBean::JOB_TABLE_NAME.c_str(), JobBean::JOB_TASK_ID.c_str(),
		taskid.c_str(), JobBean::JOB_FIELD_INSERT_TIME.c_str());
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*m_pDB, buffer);
		while (query.executeStep()) {
			JobBean* job = new JobBean;
			job->m_Id = query.getColumn(JobBean::JOB_FIELD_ID.c_str()).getInt();
			job->m_InsertTime = query.getColumn(JobBean::JOB_FIELD_INSERT_TIME.c_str()).getInt64();
			job->m_TaskID = query.getColumn(JobBean::JOB_TASK_ID.c_str()).getString();
			job->m_Uid = query.getColumn(JobBean::JOB_FIELD_UID.c_str()).getString();
			job->m_Name = query.getColumn(JobBean::JOB_FIELD_NAME.c_str()).getString();
			job->m_StartTime = query.getColumn(JobBean::JOB_FIELD_START_TIME.c_str()).getInt64();
			job->m_LastPauseTime = query.getColumn(JobBean::JOB_FIELD_LAST_PAUSE_TIME.c_str()).getInt64();
			job->m_StopTime = query.getColumn(JobBean::JOB_FIELD_STOP_TIME.c_str()).getInt64();
			job->m_DeoxygenSecond = query.getColumn(JobBean::JOB_FIELD_DEOXYGEN_SECOND.c_str()).getUInt();
			job->m_SpendSecond = query.getColumn(JobBean::JOB_FIELD_SPEND_SECOND.c_str()).getUInt();
			job->m_PrintSecond = query.getColumn(JobBean::JOB_FIELD_PRINT_SECOND.c_str()).getUInt();
			job->m_FirstStartIndex = query.getColumn(JobBean::JOB_FIELD_FIRST_START_INDEX.c_str()).getUInt();
			job->m_StartMoldPos = query.getColumn(JobBean::JOB_FIELD_START_MOLD_POS.c_str()).getDouble();
			job->m_MoldPos = query.getColumn(JobBean::JOB_FIELD_MOLD_POS.c_str()).getDouble();
			job->m_PrintedLayerIndex = query.getColumn(JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str()).getUInt();
			job->m_IsFinished = (query.getColumn(JobBean::JOB_FIELD_IS_FINISH.c_str()).getInt() > 0 ? true : false);
			job->m_IsContinue = (query.getColumn(JobBean::JOB_FIELD_IS_CONTINUE.c_str()).getInt() > 0 ? true : false);
			job->m_IsInvalid = (query.getColumn(JobBean::JOB_FIELD_IS_INVALID.c_str()).getInt() > 0 ? true : false);
			jobs.push_back(job);
		}
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceInfo(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::GetJobsByTime(struct tm& begin, struct tm& end, vector<JobBean*>& jobs)
{
	begin.tm_hour = 0;
	begin.tm_min = 0;
	begin.tm_sec = 0;
	end.tm_hour = 23;
	end.tm_min = 59;
	end.tm_sec = 59;
	time_t tbegin = mktime(&begin);
	time_t tend = mktime(&end);

	char buffer[1024];
	if (begin.tm_year == end.tm_year)
	{
		if (m_DBMap.find(begin.tm_year + 1900) == m_DBMap.end())return;

		sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s BETWEEN %lld AND %lld ORDER BY %s",
			JobBean::JOB_TABLE_NAME.c_str(), JobBean::JOB_FIELD_INSERT_TIME.c_str(),
			tbegin, tend, JobBean::JOB_FIELD_INSERT_TIME.c_str());
		EnterCriticalSection(&m_DbCs);
		try {
			SQLite::Statement query(*m_DBMap[begin.tm_year + 1900], buffer);
			while (query.executeStep()) {
				JobBean* job = new JobBean;
				job->m_Id = query.getColumn(JobBean::JOB_FIELD_ID.c_str()).getInt();
				job->m_InsertTime = query.getColumn(JobBean::JOB_FIELD_INSERT_TIME.c_str()).getInt64();
				job->m_TaskID = query.getColumn(JobBean::JOB_TASK_ID.c_str()).getString();
				job->m_Uid = query.getColumn(JobBean::JOB_FIELD_UID.c_str()).getString();
				job->m_Name = query.getColumn(JobBean::JOB_FIELD_NAME.c_str()).getString();
				job->m_StartTime = query.getColumn(JobBean::JOB_FIELD_START_TIME.c_str()).getInt64();
				job->m_LastPauseTime = query.getColumn(JobBean::JOB_FIELD_LAST_PAUSE_TIME.c_str()).getInt64();
				job->m_StopTime = query.getColumn(JobBean::JOB_FIELD_STOP_TIME.c_str()).getInt64();
				job->m_DeoxygenSecond = query.getColumn(JobBean::JOB_FIELD_DEOXYGEN_SECOND.c_str()).getUInt();
				job->m_SpendSecond = query.getColumn(JobBean::JOB_FIELD_SPEND_SECOND.c_str()).getUInt();
				job->m_PrintSecond = query.getColumn(JobBean::JOB_FIELD_PRINT_SECOND.c_str()).getUInt();
				job->m_FirstStartIndex = query.getColumn(JobBean::JOB_FIELD_FIRST_START_INDEX.c_str()).getUInt();
				job->m_StartMoldPos = query.getColumn(JobBean::JOB_FIELD_START_MOLD_POS.c_str()).getDouble();
				job->m_MoldPos = query.getColumn(JobBean::JOB_FIELD_MOLD_POS.c_str()).getDouble();
				job->m_PrintedLayerIndex = query.getColumn(JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str()).getUInt();
				job->m_IsFinished = (query.getColumn(JobBean::JOB_FIELD_IS_FINISH.c_str()).getInt() > 0 ? true : false);
				job->m_IsContinue = (query.getColumn(JobBean::JOB_FIELD_IS_CONTINUE.c_str()).getInt() > 0 ? true : false);
				job->m_IsInvalid = (query.getColumn(JobBean::JOB_FIELD_IS_INVALID.c_str()).getInt() > 0 ? true : false);
				job->m_YearBelong = begin.tm_year + 1900;
				jobs.push_back(job);
			}
		}
		catch (SQLite::Exception& e)
		{
			g_log->TraceInfo(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
	}
	else {
		if (m_DBMap.find(begin.tm_year + 1900) == m_DBMap.end())return;
		sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s BETWEEN %lld AND %lld ORDER BY %s",
			JobBean::JOB_TABLE_NAME.c_str(), JobBean::JOB_FIELD_INSERT_TIME.c_str(),
			tbegin, tend, JobBean::JOB_FIELD_INSERT_TIME.c_str());
		EnterCriticalSection(&m_DbCs);
		try {
			SQLite::Statement query(*m_DBMap[begin.tm_year + 1900], buffer);
			while (query.executeStep()) {
				JobBean* job = new JobBean;
				job->m_Id = query.getColumn(JobBean::JOB_FIELD_ID.c_str()).getInt();
				job->m_InsertTime = query.getColumn(JobBean::JOB_FIELD_INSERT_TIME.c_str()).getInt64();
				job->m_TaskID = query.getColumn(JobBean::JOB_TASK_ID.c_str()).getString();
				job->m_Uid = query.getColumn(JobBean::JOB_FIELD_UID.c_str()).getString();
				job->m_Name = query.getColumn(JobBean::JOB_FIELD_NAME.c_str()).getString();
				job->m_StartTime = query.getColumn(JobBean::JOB_FIELD_START_TIME.c_str()).getInt64();
				job->m_LastPauseTime = query.getColumn(JobBean::JOB_FIELD_LAST_PAUSE_TIME.c_str()).getInt64();
				job->m_StopTime = query.getColumn(JobBean::JOB_FIELD_STOP_TIME.c_str()).getInt64();
				job->m_DeoxygenSecond = query.getColumn(JobBean::JOB_FIELD_DEOXYGEN_SECOND.c_str()).getUInt();
				job->m_SpendSecond = query.getColumn(JobBean::JOB_FIELD_SPEND_SECOND.c_str()).getUInt();
				job->m_PrintSecond = query.getColumn(JobBean::JOB_FIELD_PRINT_SECOND.c_str()).getUInt();
				job->m_FirstStartIndex = query.getColumn(JobBean::JOB_FIELD_FIRST_START_INDEX.c_str()).getUInt();
				job->m_StartMoldPos = query.getColumn(JobBean::JOB_FIELD_START_MOLD_POS.c_str()).getDouble();
				job->m_MoldPos = query.getColumn(JobBean::JOB_FIELD_MOLD_POS.c_str()).getDouble();
				job->m_PrintedLayerIndex = query.getColumn(JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str()).getUInt();
				job->m_IsFinished = (query.getColumn(JobBean::JOB_FIELD_IS_FINISH.c_str()).getInt() > 0 ? true : false);
				job->m_IsContinue = (query.getColumn(JobBean::JOB_FIELD_IS_CONTINUE.c_str()).getInt() > 0 ? true : false);
				job->m_IsInvalid = (query.getColumn(JobBean::JOB_FIELD_IS_INVALID.c_str()).getInt() > 0 ? true : false);
				job->m_YearBelong = begin.tm_year + 1900;
				jobs.push_back(job);
			}
		}
		catch (SQLite::Exception& e)
		{
			g_log->TraceInfo(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
		if (m_DBMap.find(end.tm_year + 1900) == m_DBMap.end())return;
		EnterCriticalSection(&m_DbCs);
		try {
			SQLite::Statement query2(*m_DBMap[end.tm_year + 1900], buffer);
			while (query2.executeStep()) {
				JobBean* job = new JobBean;
				job->m_Id = query2.getColumn(JobBean::JOB_FIELD_ID.c_str()).getInt();
				job->m_InsertTime = query2.getColumn(JobBean::JOB_FIELD_INSERT_TIME.c_str()).getInt64();
				job->m_TaskID = query2.getColumn(JobBean::JOB_TASK_ID.c_str()).getString();
				job->m_Uid = query2.getColumn(JobBean::JOB_FIELD_UID.c_str()).getString();
				job->m_Name = query2.getColumn(JobBean::JOB_FIELD_NAME.c_str()).getString();
				job->m_StartTime = query2.getColumn(JobBean::JOB_FIELD_START_TIME.c_str()).getInt64();
				job->m_LastPauseTime = query2.getColumn(JobBean::JOB_FIELD_LAST_PAUSE_TIME.c_str()).getInt64();
				job->m_StopTime = query2.getColumn(JobBean::JOB_FIELD_STOP_TIME.c_str()).getInt64();
				job->m_DeoxygenSecond = query2.getColumn(JobBean::JOB_FIELD_DEOXYGEN_SECOND.c_str()).getUInt();
				job->m_SpendSecond = query2.getColumn(JobBean::JOB_FIELD_SPEND_SECOND.c_str()).getUInt();
				job->m_PrintSecond = query2.getColumn(JobBean::JOB_FIELD_PRINT_SECOND.c_str()).getUInt();
				job->m_FirstStartIndex = query2.getColumn(JobBean::JOB_FIELD_FIRST_START_INDEX.c_str()).getUInt();
				job->m_StartMoldPos = query2.getColumn(JobBean::JOB_FIELD_START_MOLD_POS.c_str()).getDouble();
				job->m_MoldPos = query2.getColumn(JobBean::JOB_FIELD_MOLD_POS.c_str()).getDouble();
				job->m_PrintedLayerIndex = query2.getColumn(JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str()).getUInt();
				job->m_IsFinished = (query2.getColumn(JobBean::JOB_FIELD_IS_FINISH.c_str()).getInt() > 0 ? true : false);
				job->m_IsContinue = (query2.getColumn(JobBean::JOB_FIELD_IS_CONTINUE.c_str()).getInt() > 0 ? true : false);
				job->m_IsInvalid = (query2.getColumn(JobBean::JOB_FIELD_IS_INVALID.c_str()).getInt() > 0 ? true : false);
				job->m_YearBelong = end.tm_year + 1900;
				jobs.push_back(job);
			}
		}
		catch (SQLite::Exception& e)
		{
			g_log->TraceInfo(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
	}
}

void LogDao::GetJobs(struct tm &begin, struct tm &end)
{
	begin.tm_hour = 0;
	begin.tm_min = 0;
	begin.tm_sec = 0;
	end.tm_hour = 23;
	end.tm_min = 59;
	end.tm_sec = 59;
	time_t tbegin = mktime(&begin);
	time_t tend = mktime(&end);

	if (tbegin > tend)
	{
		g_Toast->AddToast(new ToastBean(g_LngManager->Toast_CheckDate->ShowText(), 3000));
		return;
	}

	EnterCriticalSection(&m_JobCs);
	for (size_t i = 0; i < m_JobBaens.size(); ++i) {
		delete m_JobBaens[i];
		m_JobBaens[i] = NULL;
	}
	m_JobBaens.clear();
	LeaveCriticalSection(&m_JobCs);

	char buffer[1024];
	if (begin.tm_year == end.tm_year)
	{
		sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s BETWEEN %lld AND %lld ORDER BY %s",
			JobBean::JOB_TABLE_NAME.c_str(), JobBean::JOB_FIELD_INSERT_TIME.c_str(),
			tbegin, tend, JobBean::JOB_FIELD_INSERT_TIME.c_str());
		string selectStr = string(buffer);
		if (begin.tm_mon == 0 && (m_DBMap.find(begin.tm_year + 1900 - 1) != m_DBMap.end())) {
			EnterCriticalSection(&m_DbCs);
			SQLite::Statement query(*m_DBMap[begin.tm_year + 1900 - 1], selectStr);
			while (query.executeStep()) {
				JobBean* job = new JobBean;
				job->m_Id = query.getColumn(JobBean::JOB_FIELD_ID.c_str()).getInt();
				job->m_InsertTime = query.getColumn(JobBean::JOB_FIELD_INSERT_TIME.c_str()).getInt64();
				job->m_TaskID = query.getColumn(JobBean::JOB_TASK_ID.c_str()).getString();
				job->m_Uid = query.getColumn(JobBean::JOB_FIELD_UID.c_str()).getString();
				job->m_Name = query.getColumn(JobBean::JOB_FIELD_NAME.c_str()).getString();
				job->m_StartTime = query.getColumn(JobBean::JOB_FIELD_START_TIME.c_str()).getInt64();
				job->m_LastPauseTime = query.getColumn(JobBean::JOB_FIELD_LAST_PAUSE_TIME.c_str()).getInt64();
				job->m_StopTime = query.getColumn(JobBean::JOB_FIELD_STOP_TIME.c_str()).getInt64();
				job->m_DeoxygenSecond = query.getColumn(JobBean::JOB_FIELD_DEOXYGEN_SECOND.c_str()).getUInt();
				job->m_SpendSecond = query.getColumn(JobBean::JOB_FIELD_SPEND_SECOND.c_str()).getUInt();
				job->m_PrintSecond = query.getColumn(JobBean::JOB_FIELD_PRINT_SECOND.c_str()).getUInt();
				job->m_FirstStartIndex = query.getColumn(JobBean::JOB_FIELD_FIRST_START_INDEX.c_str()).getUInt();
				job->m_StartMoldPos = query.getColumn(JobBean::JOB_FIELD_START_MOLD_POS.c_str()).getDouble();
				job->m_MoldPos = query.getColumn(JobBean::JOB_FIELD_MOLD_POS.c_str()).getDouble();
				job->m_PrintedLayerIndex = query.getColumn(JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str()).getUInt();
				job->m_IsFinished = (query.getColumn(JobBean::JOB_FIELD_IS_FINISH.c_str()).getInt() > 0 ? true : false);
				job->m_IsContinue = (query.getColumn(JobBean::JOB_FIELD_IS_CONTINUE.c_str()).getInt() > 0 ? true : false);
				job->m_IsInvalid = (query.getColumn(JobBean::JOB_FIELD_IS_INVALID.c_str()).getInt() > 0 ? true : false);
				job->m_YearBelong = begin.tm_year + 1900 - 1;
				EnterCriticalSection(&m_JobCs);
				m_JobBaens.push_back(job);
				LeaveCriticalSection(&m_JobCs);
			}
			LeaveCriticalSection(&m_DbCs);
		}
		if (m_DBMap.find(begin.tm_year + 1900) == m_DBMap.end())return;

		sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s BETWEEN %lld AND %lld ORDER BY %s",
			JobBean::JOB_TABLE_NAME.c_str(), JobBean::JOB_FIELD_INSERT_TIME.c_str(),
			tbegin, tend, JobBean::JOB_FIELD_INSERT_TIME.c_str());
		
		EnterCriticalSection(&m_DbCs);
		try {
			SQLite::Statement query(*m_DBMap[begin.tm_year + 1900], selectStr);
			while (query.executeStep()) {
				JobBean* job = new JobBean;
				job->m_Id = query.getColumn(JobBean::JOB_FIELD_ID.c_str()).getInt();
				job->m_InsertTime = query.getColumn(JobBean::JOB_FIELD_INSERT_TIME.c_str()).getInt64();
				job->m_TaskID = query.getColumn(JobBean::JOB_TASK_ID.c_str()).getString();
				job->m_Uid = query.getColumn(JobBean::JOB_FIELD_UID.c_str()).getString();
				job->m_Name = query.getColumn(JobBean::JOB_FIELD_NAME.c_str()).getString();
				job->m_StartTime = query.getColumn(JobBean::JOB_FIELD_START_TIME.c_str()).getInt64();
				job->m_LastPauseTime = query.getColumn(JobBean::JOB_FIELD_LAST_PAUSE_TIME.c_str()).getInt64();
				job->m_StopTime = query.getColumn(JobBean::JOB_FIELD_STOP_TIME.c_str()).getInt64();
				job->m_DeoxygenSecond = query.getColumn(JobBean::JOB_FIELD_DEOXYGEN_SECOND.c_str()).getUInt();
				job->m_SpendSecond = query.getColumn(JobBean::JOB_FIELD_SPEND_SECOND.c_str()).getUInt();
				job->m_PrintSecond = query.getColumn(JobBean::JOB_FIELD_PRINT_SECOND.c_str()).getUInt();
				job->m_FirstStartIndex = query.getColumn(JobBean::JOB_FIELD_FIRST_START_INDEX.c_str()).getUInt();
				job->m_StartMoldPos = query.getColumn(JobBean::JOB_FIELD_START_MOLD_POS.c_str()).getDouble();
				job->m_MoldPos = query.getColumn(JobBean::JOB_FIELD_MOLD_POS.c_str()).getDouble();
				job->m_PrintedLayerIndex = query.getColumn(JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str()).getUInt();
				job->m_IsFinished = (query.getColumn(JobBean::JOB_FIELD_IS_FINISH.c_str()).getInt() > 0 ? true : false);
				job->m_IsContinue = (query.getColumn(JobBean::JOB_FIELD_IS_CONTINUE.c_str()).getInt() > 0 ? true : false);
				job->m_IsInvalid = (query.getColumn(JobBean::JOB_FIELD_IS_INVALID.c_str()).getInt() > 0 ? true : false);
				job->m_YearBelong = begin.tm_year + 1900;
				EnterCriticalSection(&m_JobCs);
				m_JobBaens.push_back(job);
				LeaveCriticalSection(&m_JobCs);;
			}
		}
		catch (SQLite::Exception& e)
		{
			g_log->TraceInfo(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
	}
	else {
		if (m_DBMap.find(begin.tm_year + 1900) == m_DBMap.end())return;
		sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s BETWEEN %lld AND %lld ORDER BY %s",
			JobBean::JOB_TABLE_NAME.c_str(), JobBean::JOB_FIELD_INSERT_TIME.c_str(),
			tbegin, tend, JobBean::JOB_FIELD_INSERT_TIME.c_str());
		
		EnterCriticalSection(&m_DbCs);
		try {
			SQLite::Statement query(*m_DBMap[begin.tm_year + 1900], buffer);
			while (query.executeStep()) {
				JobBean* job = new JobBean;
				job->m_Id = query.getColumn(JobBean::JOB_FIELD_ID.c_str()).getInt();
				job->m_InsertTime = query.getColumn(JobBean::JOB_FIELD_INSERT_TIME.c_str()).getInt64();
				job->m_TaskID = query.getColumn(JobBean::JOB_TASK_ID.c_str()).getString();
				job->m_Uid = query.getColumn(JobBean::JOB_FIELD_UID.c_str()).getString();
				job->m_Name = query.getColumn(JobBean::JOB_FIELD_NAME.c_str()).getString();
				job->m_StartTime = query.getColumn(JobBean::JOB_FIELD_START_TIME.c_str()).getInt64();
				job->m_LastPauseTime = query.getColumn(JobBean::JOB_FIELD_LAST_PAUSE_TIME.c_str()).getInt64();
				job->m_StopTime = query.getColumn(JobBean::JOB_FIELD_STOP_TIME.c_str()).getInt64();
				job->m_DeoxygenSecond = query.getColumn(JobBean::JOB_FIELD_DEOXYGEN_SECOND.c_str()).getUInt();
				job->m_SpendSecond = query.getColumn(JobBean::JOB_FIELD_SPEND_SECOND.c_str()).getUInt();
				job->m_PrintSecond = query.getColumn(JobBean::JOB_FIELD_PRINT_SECOND.c_str()).getUInt();
				job->m_FirstStartIndex = query.getColumn(JobBean::JOB_FIELD_FIRST_START_INDEX.c_str()).getUInt();
				job->m_StartMoldPos = query.getColumn(JobBean::JOB_FIELD_START_MOLD_POS.c_str()).getDouble();
				job->m_MoldPos = query.getColumn(JobBean::JOB_FIELD_MOLD_POS.c_str()).getDouble();
				job->m_PrintedLayerIndex = query.getColumn(JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str()).getUInt();
				job->m_IsFinished = (query.getColumn(JobBean::JOB_FIELD_IS_FINISH.c_str()).getInt() > 0 ? true : false);
				job->m_IsContinue = (query.getColumn(JobBean::JOB_FIELD_IS_CONTINUE.c_str()).getInt() > 0 ? true : false);
				job->m_IsInvalid = (query.getColumn(JobBean::JOB_FIELD_IS_INVALID.c_str()).getInt() > 0 ? true : false);
				job->m_YearBelong = begin.tm_year + 1900;
				EnterCriticalSection(&m_JobCs);
				m_JobBaens.push_back(job);
				LeaveCriticalSection(&m_JobCs);
			}
		}
		catch (SQLite::Exception& e)
		{
			g_log->TraceInfo(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
		if (m_DBMap.find(end.tm_year + 1900) == m_DBMap.end())return;
		
		EnterCriticalSection(&m_DbCs);
		try {
			SQLite::Statement query2(*m_DBMap[end.tm_year + 1900], buffer);
			while (query2.executeStep()) {
				JobBean* job = new JobBean;
				job->m_Id = query2.getColumn(JobBean::JOB_FIELD_ID.c_str()).getInt();
				job->m_InsertTime = query2.getColumn(JobBean::JOB_FIELD_INSERT_TIME.c_str()).getInt64();
				job->m_TaskID = query2.getColumn(JobBean::JOB_TASK_ID.c_str()).getString();
				job->m_Uid = query2.getColumn(JobBean::JOB_FIELD_UID.c_str()).getString();
				job->m_Name = query2.getColumn(JobBean::JOB_FIELD_NAME.c_str()).getString();
				job->m_StartTime = query2.getColumn(JobBean::JOB_FIELD_START_TIME.c_str()).getInt64();
				job->m_LastPauseTime = query2.getColumn(JobBean::JOB_FIELD_LAST_PAUSE_TIME.c_str()).getInt64();
				job->m_StopTime = query2.getColumn(JobBean::JOB_FIELD_STOP_TIME.c_str()).getInt64();
				job->m_DeoxygenSecond = query2.getColumn(JobBean::JOB_FIELD_DEOXYGEN_SECOND.c_str()).getUInt();
				job->m_SpendSecond = query2.getColumn(JobBean::JOB_FIELD_SPEND_SECOND.c_str()).getUInt();
				job->m_PrintSecond = query2.getColumn(JobBean::JOB_FIELD_PRINT_SECOND.c_str()).getUInt();
				job->m_FirstStartIndex = query2.getColumn(JobBean::JOB_FIELD_FIRST_START_INDEX.c_str()).getUInt();
				job->m_StartMoldPos = query2.getColumn(JobBean::JOB_FIELD_START_MOLD_POS.c_str()).getDouble();
				job->m_MoldPos = query2.getColumn(JobBean::JOB_FIELD_MOLD_POS.c_str()).getDouble();
				job->m_PrintedLayerIndex = query2.getColumn(JobBean::JOB_FIELD_PRINTED_LAYER_INDEX.c_str()).getUInt();
				job->m_IsFinished = (query2.getColumn(JobBean::JOB_FIELD_IS_FINISH.c_str()).getInt() > 0 ? true : false);
				job->m_IsContinue = (query2.getColumn(JobBean::JOB_FIELD_IS_CONTINUE.c_str()).getInt() > 0 ? true : false);
				job->m_IsInvalid = (query2.getColumn(JobBean::JOB_FIELD_IS_INVALID.c_str()).getInt() > 0 ? true : false);
				job->m_YearBelong = end.tm_year + 1900;
				EnterCriticalSection(&m_JobCs);
				m_JobBaens.push_back(job);
				LeaveCriticalSection(&m_JobCs);
			}
		}
		catch (SQLite::Exception& e)
		{
			g_log->TraceInfo(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
	}
}



void LogDao::GetLayerStatusTable(LogAssist& la, bool isRemote)
{
	if (m_CurrentShowJob == NULL)
		return;

	if (m_DBMap.find(m_CurrentShowJob->m_YearBelong) == m_DBMap.end())
		return;

	SQLite::Database* db = m_DBMap[m_CurrentShowJob->m_YearBelong];

	char sql[1024];
	EnterCriticalSection(&m_StatusCs);
	for (size_t i = 0; i < m_LayerStatus.size(); ++i) {
		delete m_LayerStatus[i];
		m_LayerStatus[i] = NULL;
	}
	m_LayerStatus.clear();
	LeaveCriticalSection(&m_StatusCs);

	sprintf_s(sql, sizeof(sql), "SELECT * FROM %s WHERE %s = %d ORDER BY %s",
		LayerStatus::STATUS_TABLE_NAME.c_str(), LayerStatus::STATUS_FIELD_JOB_ID.c_str(), m_CurrentShowJob->m_Id, LayerStatus::STATUS_FIELD_INSERT_TIME.c_str());
	
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*db, sql);
		while (query.executeStep()) {
			LayerStatus* ls = new LayerStatus();
			ls->m_Id = query.getColumn(LayerStatus::STATUS_FIELD_ID.c_str()).getInt();
			ls->m_InsertTitme = query.getColumn(LayerStatus::STATUS_FIELD_INSERT_TIME.c_str()).getInt64();
			ls->m_JobId = query.getColumn(LayerStatus::STATUS_FIELD_JOB_ID.c_str()).getInt();
			ls->m_LayerIndex = query.getColumn(LayerStatus::STATUS_FIELD_LAYER_INDEX.c_str()).getUInt();
			ls->m_SpendSecond = query.getColumn(LayerStatus::STATUS_FIELD_SPEND_SECOND.c_str()).getUInt();
			ls->m_MoldMainPos = query.getColumn(LayerStatus::STATUS_FIELD_MOLD_MAIN_POS.c_str()).getDouble();
			ls->m_MoldSlavePos = query.getColumn(LayerStatus::STATUS_FIELD_MOLD_SLAVE_POS.c_str()).getDouble();
			ls->m_PrintOxygen1 = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_OXYGEN1.c_str()).getDouble();
			ls->m_PrintOxygen2 = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_OXYGEN2.c_str()).getDouble();
			//ls->m_OutsideOxygen = (float)query.getColumn(LayerStatus::STATUS_FIELD_OUTSIDE_OXYGEN.c_str()).getDouble();
			ls->m_PrintTemp = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_TEMP.c_str()).getDouble();
			//ls->m_PrintTemp2 = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_TEMP2.c_str()).getDouble();
			ls->m_PrintHumidity = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_HUMIDITY.c_str()).getDouble();
			//ls->m_PrintHumidity2 = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_HUMIDITY2.c_str()).getDouble();
			ls->m_PrintPressure = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_PRESSURE.c_str()).getDouble();
			ls->m_FanFrequency = (float)query.getColumn(LayerStatus::STATUS_FIELD_FAN_FREQUENCY.c_str()).getDouble();
			ls->m_PlateTemp = (float)query.getColumn(LayerStatus::STATUS_FIELD_PLATE_TEMP.c_str()).getDouble();
			ls->m_WindRate = (float)query.getColumn(LayerStatus::STATUS_FIELD_WIND_RATE.c_str()).getDouble();
			ls->m_WaterTemp = (float)query.getColumn(LayerStatus::STATUS_FIELD_WATER_TEMP.c_str()).getDouble();

			EnterCriticalSection(&m_StatusCs);
			m_LayerStatus.push_back(ls);
			LeaveCriticalSection(&m_StatusCs);
		}
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceInfo(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::GetLayerStatusByTime(LogAssist& la, bool isRemote)
{
	if (m_CurrentShowJob == NULL)
		return;

	if (m_DBMap.find(m_CurrentShowJob->m_YearBelong) == m_DBMap.end())
		return;

	SQLite::Database* db = m_DBMap[m_CurrentShowJob->m_YearBelong];

	char sql[1024];
	EnterCriticalSection(&m_StatusCs);
	for (size_t i = 0; i < m_LayerStatus.size(); ++i) {
		delete m_LayerStatus[i];
		m_LayerStatus[i] = NULL;
	}
	m_LayerStatus.clear();
	LeaveCriticalSection(&m_StatusCs);
	for (int i = 0; i < LogAssist::PARAM_LENGTH; ++i) {
		la.paramValue[i].clear();
		la.paramIndex.clear();
		la.minValue[i] = FLT_MAX;
		la.maxValue[i] = -FLT_MAX;
	}
	unsigned int lastSpendSecond = 0;

	sprintf_s(sql, sizeof(sql), "SELECT * FROM %s WHERE %s = %d ORDER BY %s",
		LayerStatus::STATUS_TABLE_NAME.c_str(), LayerStatus::STATUS_FIELD_JOB_ID.c_str(), m_CurrentShowJob->m_Id, LayerStatus::STATUS_FIELD_INSERT_TIME.c_str());
	
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*db, sql);
		int lastLayerIndex = 0;
		unsigned int lastSpendSecondFlag = 0;
		while (query.executeStep()) {
			LayerStatus* ls = new LayerStatus();
			ls->m_Id = query.getColumn(LayerStatus::STATUS_FIELD_ID.c_str()).getInt();
			ls->m_InsertTitme = query.getColumn(LayerStatus::STATUS_FIELD_INSERT_TIME.c_str()).getInt64();
			ls->m_JobId = query.getColumn(LayerStatus::STATUS_FIELD_JOB_ID.c_str()).getInt();
			ls->m_LayerIndex = query.getColumn(LayerStatus::STATUS_FIELD_LAYER_INDEX.c_str()).getUInt();
			ls->m_SpendSecond = query.getColumn(LayerStatus::STATUS_FIELD_SPEND_SECOND.c_str()).getUInt();
			ls->m_MoldMainPos = query.getColumn(LayerStatus::STATUS_FIELD_MOLD_MAIN_POS.c_str()).getDouble();
			ls->m_MoldSlavePos = query.getColumn(LayerStatus::STATUS_FIELD_MOLD_SLAVE_POS.c_str()).getDouble();
			ls->m_PrintOxygen1 = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_OXYGEN1.c_str()).getDouble();
			ls->m_PrintOxygen2 = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_OXYGEN2.c_str()).getDouble();
		
			ls->m_PrintTemp = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_TEMP.c_str()).getDouble();
		
			ls->m_PrintHumidity = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_HUMIDITY.c_str()).getDouble();
			ls->m_PrintPressure = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_PRESSURE.c_str()).getDouble();
			ls->m_FanFrequency = (float)query.getColumn(LayerStatus::STATUS_FIELD_FAN_FREQUENCY.c_str()).getDouble();
			ls->m_PlateTemp = (float)query.getColumn(LayerStatus::STATUS_FIELD_PLATE_TEMP.c_str()).getDouble();
			ls->m_WindRate = (float)query.getColumn(LayerStatus::STATUS_FIELD_WIND_RATE.c_str()).getDouble();
			ls->m_WaterTemp = (float)query.getColumn(LayerStatus::STATUS_FIELD_WATER_TEMP.c_str()).getDouble();
			if (ls->m_LayerIndex < lastLayerIndex) {
				delete ls;
				ls = NULL;
				continue;
			}
			if (ls->m_SpendSecond < lastSpendSecondFlag) {
				delete ls;
				ls = NULL;
				continue;
			}
			else {
				lastSpendSecondFlag = ls->m_SpendSecond;
			}
			lastLayerIndex = ls->m_LayerIndex;

			if (ls->m_PrintOxygen1 < la.minValue[0])la.minValue[0] = ls->m_PrintOxygen1;
			if (ls->m_PrintOxygen1 > la.maxValue[0])la.maxValue[0] = ls->m_PrintOxygen1;
			if (ls->m_PrintOxygen2 < la.minValue[1])la.minValue[1] = ls->m_PrintOxygen2;
			if (ls->m_PrintOxygen2 > la.maxValue[1])la.maxValue[1] = ls->m_PrintOxygen2;
			//if (ls->m_OutsideOxygen < la.minValue[2])la.minValue[2] = ls->m_OutsideOxygen;
			//if (ls->m_OutsideOxygen > la.maxValue[2])la.maxValue[2] = ls->m_OutsideOxygen;
			if (ls->m_PrintTemp < la.minValue[2])la.minValue[2] = ls->m_PrintTemp;
			if (ls->m_PrintTemp > la.maxValue[2])la.maxValue[2] = ls->m_PrintTemp;
			//if (ls->m_PrintTemp2 < la.minValue[4])la.minValue[4] = ls->m_PrintTemp2;
			//if (ls->m_PrintTemp2 > la.maxValue[4])la.maxValue[4] = ls->m_PrintTemp2;
			if (ls->m_PrintHumidity < la.minValue[3])la.minValue[3] = ls->m_PrintHumidity;
			if (ls->m_PrintHumidity > la.maxValue[3])la.maxValue[3] = ls->m_PrintHumidity;
		//	if (ls->m_PrintHumidity2 < la.minValue[6])la.minValue[6] = ls->m_PrintHumidity2;
			//if (ls->m_PrintHumidity2 > la.maxValue[6])la.maxValue[6] = ls->m_PrintHumidity2;
			if (ls->m_PrintPressure < la.minValue[4])la.minValue[4] = ls->m_PrintPressure;
			if (ls->m_PrintPressure > la.maxValue[4])la.maxValue[4] = ls->m_PrintPressure;
			if (ls->m_FanFrequency < la.minValue[5])la.minValue[5] = ls->m_FanFrequency;
			if (ls->m_FanFrequency > la.maxValue[5])la.maxValue[5] = ls->m_FanFrequency;
			if (ls->m_PlateTemp < la.minValue[6])la.minValue[6] = ls->m_PlateTemp;
			if (ls->m_PlateTemp > la.maxValue[6])la.maxValue[6] = ls->m_PlateTemp;
			if (ls->m_WindRate < la.minValue[7])la.minValue[7] = ls->m_WindRate;
			if (ls->m_WindRate > la.maxValue[7])la.maxValue[7] = ls->m_WindRate;
			if (ls->m_WaterTemp < la.minValue[8])la.minValue[8] = ls->m_WaterTemp;
			if (ls->m_WaterTemp > la.maxValue[8])la.maxValue[8] = ls->m_WaterTemp;


			la.paramValue[0].push_back(ls->m_PrintOxygen1);
			la.paramValue[1].push_back(ls->m_PrintOxygen2);
			//la.paramValue[2].push_back(ls->m_OutsideOxygen);
			la.paramValue[2].push_back(ls->m_PrintTemp);
			//la.paramValue[4].push_back(ls->m_PrintTemp2);
			la.paramValue[3].push_back(ls->m_PrintHumidity);
			//la.paramValue[6].push_back(ls->m_PrintHumidity2);
			la.paramValue[4].push_back(ls->m_PrintPressure);
			la.paramValue[5].push_back(ls->m_FanFrequency);
			la.paramValue[6].push_back(ls->m_PlateTemp);
			la.paramValue[7].push_back(ls->m_WindRate);
			la.paramValue[8].push_back(ls->m_WaterTemp);
			if (ls->m_SpendSecond < lastSpendSecond) {
				ls->m_SpendSecond = lastSpendSecond;
			}
			la.paramIndex.push_back(ls->m_InsertTitme);
			lastSpendSecond = ls->m_SpendSecond;

			EnterCriticalSection(&m_StatusCs);
			m_LayerStatus.push_back(ls);
			LeaveCriticalSection(&m_StatusCs);
		}
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceInfo(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::GetLayerStatusByLayer(LogAssist& la, bool isRemote)
{
	if (m_CurrentShowJob == NULL)
		return;
	if (m_DBMap.find(m_CurrentShowJob->m_YearBelong) == m_DBMap.end())
		return;

	SQLite::Database* db = m_DBMap[m_CurrentShowJob->m_YearBelong];
	
	char sql[1024];
	EnterCriticalSection(&m_StatusCs);
	for (size_t i = 0; i < m_LayerStatus.size(); ++i) {
		delete m_LayerStatus[i];
		m_LayerStatus[i] = NULL;
	}
	m_LayerStatus.clear();
	LeaveCriticalSection(&m_StatusCs);

	for (int i = 0; i < LogAssist::PARAM_LENGTH; ++i) {
		la.paramValue[i].clear();
		la.paramIndex.clear();
		la.minValue[i] = FLT_MAX;
		la.maxValue[i] = -FLT_MAX;
	}

	sprintf_s(sql, sizeof(sql), "SELECT %s,min(%s) %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s FROM %s WHERE %s = %d GROUP BY %s ORDER BY %s",
		LayerStatus::STATUS_FIELD_ID.c_str(), LayerStatus::STATUS_FIELD_INSERT_TIME.c_str(), LayerStatus::STATUS_FIELD_INSERT_TIME.c_str(),
		LayerStatus::STATUS_FIELD_JOB_ID.c_str(),
		LayerStatus::STATUS_FIELD_LAYER_INDEX.c_str(),
		LayerStatus::STATUS_FIELD_SPEND_SECOND.c_str(),
		LayerStatus::STATUS_FIELD_MOLD_MAIN_POS.c_str(),
		LayerStatus::STATUS_FIELD_MOLD_SLAVE_POS.c_str(),
		LayerStatus::STATUS_FIELD_PRINT_OXYGEN1.c_str(),
		LayerStatus::STATUS_FIELD_PRINT_OXYGEN2.c_str(),

		LayerStatus::STATUS_FIELD_PRINT_TEMP.c_str(),
		LayerStatus::STATUS_FIELD_PRINT_HUMIDITY.c_str(),
		LayerStatus::STATUS_FIELD_PRINT_PRESSURE.c_str(),
		LayerStatus::STATUS_FIELD_FAN_FREQUENCY.c_str(),
		LayerStatus::STATUS_FIELD_PLATE_TEMP.c_str(),
		LayerStatus::STATUS_FIELD_WIND_RATE.c_str(),
		LayerStatus::STATUS_FIELD_WATER_TEMP.c_str(),
		LayerStatus::STATUS_TABLE_NAME.c_str(), LayerStatus::STATUS_FIELD_JOB_ID.c_str(), m_CurrentShowJob->m_Id,
		LayerStatus::STATUS_FIELD_LAYER_INDEX.c_str(), LayerStatus::STATUS_FIELD_INSERT_TIME.c_str());
	
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*db, sql);
		int lastLayerIndex = 0;
		while (query.executeStep()) {
			LayerStatus* ls = new LayerStatus();
			ls->m_Id = query.getColumn(LayerStatus::STATUS_FIELD_ID.c_str()).getInt();
			ls->m_InsertTitme = query.getColumn(LayerStatus::STATUS_FIELD_INSERT_TIME.c_str()).getInt64();
			ls->m_JobId = query.getColumn(LayerStatus::STATUS_FIELD_JOB_ID.c_str()).getInt();
			ls->m_LayerIndex = query.getColumn(LayerStatus::STATUS_FIELD_LAYER_INDEX.c_str()).getUInt();
			ls->m_SpendSecond = query.getColumn(LayerStatus::STATUS_FIELD_SPEND_SECOND.c_str()).getUInt();
			ls->m_MoldMainPos = query.getColumn(LayerStatus::STATUS_FIELD_MOLD_MAIN_POS.c_str()).getDouble();
			ls->m_MoldSlavePos = query.getColumn(LayerStatus::STATUS_FIELD_MOLD_SLAVE_POS.c_str()).getDouble();
			ls->m_PrintOxygen1 = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_OXYGEN1.c_str()).getDouble();
			ls->m_PrintOxygen2 = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_OXYGEN2.c_str()).getDouble();
		
			ls->m_PrintTemp = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_TEMP.c_str()).getDouble();
		
			ls->m_PrintHumidity = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_HUMIDITY.c_str()).getDouble();
		
			ls->m_PrintPressure = (float)query.getColumn(LayerStatus::STATUS_FIELD_PRINT_PRESSURE.c_str()).getDouble();
			ls->m_FanFrequency = (float)query.getColumn(LayerStatus::STATUS_FIELD_FAN_FREQUENCY.c_str()).getDouble();
			ls->m_PlateTemp = (float)query.getColumn(LayerStatus::STATUS_FIELD_PLATE_TEMP.c_str()).getDouble();
			ls->m_WindRate = (float)query.getColumn(LayerStatus::STATUS_FIELD_WIND_RATE.c_str()).getDouble();
			ls->m_WaterTemp = (float)query.getColumn(LayerStatus::STATUS_FIELD_WATER_TEMP.c_str()).getDouble();
			if (ls->m_LayerIndex < lastLayerIndex) {
				delete ls;
				ls = NULL;

				continue;
			}
			lastLayerIndex = ls->m_LayerIndex;

			if (ls->m_PrintOxygen1 < la.minValue[0])la.minValue[0] = ls->m_PrintOxygen1;
			if (ls->m_PrintOxygen1 > la.maxValue[0])la.maxValue[0] = ls->m_PrintOxygen1;
			if (ls->m_PrintOxygen2 < la.minValue[1])la.minValue[1] = ls->m_PrintOxygen2;
			if (ls->m_PrintOxygen2 > la.maxValue[1])la.maxValue[1] = ls->m_PrintOxygen2;
			//if (ls->m_OutsideOxygen < la.minValue[2])la.minValue[2] = ls->m_OutsideOxygen;
			//if (ls->m_OutsideOxygen > la.maxValue[2])la.maxValue[2] = ls->m_OutsideOxygen;
			if (ls->m_PrintTemp < la.minValue[2])la.minValue[2] = ls->m_PrintTemp;
			if (ls->m_PrintTemp > la.maxValue[2])la.maxValue[2] = ls->m_PrintTemp;
			//if (ls->m_PrintTemp2 < la.minValue[4])la.minValue[4] = ls->m_PrintTemp2;
			//if (ls->m_PrintTemp2 > la.maxValue[4])la.maxValue[4] = ls->m_PrintTemp2;
			if (ls->m_PrintHumidity < la.minValue[3])la.minValue[3] = ls->m_PrintHumidity;
			if (ls->m_PrintHumidity > la.maxValue[3])la.maxValue[3] = ls->m_PrintHumidity;
			//if (ls->m_PrintHumidity2 < la.minValue[6])la.minValue[6] = ls->m_PrintHumidity2;
			//if (ls->m_PrintHumidity2 > la.maxValue[6])la.maxValue[6] = ls->m_PrintHumidity2;
			if (ls->m_PrintPressure < la.minValue[4])la.minValue[4] = ls->m_PrintPressure;
			if (ls->m_PrintPressure > la.maxValue[4])la.maxValue[4] = ls->m_PrintPressure;
			if (ls->m_FanFrequency < la.minValue[5])la.minValue[5] = ls->m_FanFrequency;
			if (ls->m_FanFrequency > la.maxValue[5])la.maxValue[5] = ls->m_FanFrequency;
			if (ls->m_PlateTemp < la.minValue[6])la.minValue[6] = ls->m_PlateTemp;
			if (ls->m_PlateTemp > la.maxValue[6])la.maxValue[6] = ls->m_PlateTemp;
			if (ls->m_WindRate < la.minValue[7])la.minValue[7] = ls->m_WindRate;
			if (ls->m_WindRate > la.maxValue[7])la.maxValue[7] = ls->m_WindRate;
			if (ls->m_WaterTemp < la.minValue[8])la.minValue[8] = ls->m_WaterTemp;
			if (ls->m_WaterTemp > la.maxValue[8])la.maxValue[8] = ls->m_WaterTemp;


			la.paramValue[0].push_back(ls->m_PrintOxygen1);
			la.paramValue[1].push_back(ls->m_PrintOxygen2);
			//la.paramValue[2].push_back(ls->m_OutsideOxygen);
			la.paramValue[2].push_back(ls->m_PrintTemp);
			//la.paramValue[4].push_back(ls->m_PrintTemp2);
			la.paramValue[3].push_back(ls->m_PrintHumidity);
			//la.paramValue[6].push_back(ls->m_PrintHumidity2);
			la.paramValue[4].push_back(ls->m_PrintPressure);
			la.paramValue[5].push_back(ls->m_FanFrequency);
			la.paramValue[6].push_back(ls->m_PlateTemp);
			la.paramValue[7].push_back(ls->m_WindRate);
			la.paramValue[8].push_back(ls->m_WaterTemp);
			la.paramIndex.push_back((float)(ls->m_LayerIndex + 1));
			EnterCriticalSection(&m_StatusCs);
			m_LayerStatus.push_back(ls);
			LeaveCriticalSection(&m_StatusCs);
		}
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceInfo(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::LogLayerStatus(LayerStatus& status)
{
	char sqlbuf[1024];
	sprintf_s(sqlbuf, sizeof(sqlbuf), "INSERT INTO %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) VALUES(%lld,%d,%u,%d,%lf,%.2f, %.2f, %.2f,%.2f,%.2f,%.2f, %.2f, %.2f,%.2f, %.2f)",
		LayerStatus::STATUS_TABLE_NAME.c_str(),
		LayerStatus::STATUS_FIELD_INSERT_TIME.c_str(),
		LayerStatus::STATUS_FIELD_JOB_ID.c_str(),
		LayerStatus::STATUS_FIELD_LAYER_INDEX.c_str(),
		LayerStatus::STATUS_FIELD_SPEND_SECOND.c_str(),
		LayerStatus::STATUS_FIELD_MOLD_MAIN_POS.c_str(),
		LayerStatus::STATUS_FIELD_MOLD_SLAVE_POS.c_str(),
		LayerStatus::STATUS_FIELD_PRINT_OXYGEN1.c_str(),
		LayerStatus::STATUS_FIELD_PRINT_OXYGEN2.c_str(),
		LayerStatus::STATUS_FIELD_PRINT_TEMP.c_str(),
		LayerStatus::STATUS_FIELD_PRINT_HUMIDITY.c_str(),
		LayerStatus::STATUS_FIELD_PRINT_PRESSURE.c_str(),
		LayerStatus::STATUS_FIELD_FAN_FREQUENCY.c_str(),
		LayerStatus::STATUS_FIELD_PLATE_TEMP.c_str(),
		LayerStatus::STATUS_FIELD_WIND_RATE.c_str(),
		LayerStatus::STATUS_FIELD_WATER_TEMP.c_str(),
		status.m_InsertTitme,
		status.m_JobId,
		status.m_LayerIndex,
		status.m_SpendSecond,
		status.m_MoldMainPos,
		status.m_MoldSlavePos,
		status.m_PrintOxygen1,
		status.m_PrintOxygen2,
		status.m_PrintTemp,
		status.m_PrintHumidity,
		status.m_PrintPressure,
		status.m_FanFrequency,
		status.m_PlateTemp,
		status.m_WindRate,
		status.m_WaterTemp
	);

	EnterCriticalSection(&m_DbCs);
	try {
		m_pDB->exec(sqlbuf);
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::GetAlarms(struct tm &begin, struct tm &end, bool isRemote)
{
	begin.tm_hour = 0;
	begin.tm_min = 0;
	begin.tm_sec = 0;
	end.tm_hour = 23;
	end.tm_min = 59;
	end.tm_sec = 59;
	time_t tbegin = mktime(&begin);
	time_t tend = mktime(&end);
	if (tend < tbegin) {
		g_Toast->AddToast(new ToastBean(g_LngManager->Toast_CheckDate->ShowText(), 3000));
		return;
	}
	else if ((tend - tbegin) > 60 * 60 * 24 * 90) {
		g_Toast->AddToast(new ToastBean(g_LngManager->Toast_CheckDateRange90->ShowText(), 3000));
		return;
	}


	EnterCriticalSection(&m_AlarmCs);
	for (size_t i = 0; i < m_Alarms.size(); ++i) {
		delete m_Alarms[i];
		m_Alarms[i] = NULL;
	}
	m_Alarms.clear();
	LeaveCriticalSection(&m_AlarmCs);
	char buffer[1024];
	if (begin.tm_year == end.tm_year)
	{
		if (m_DBMap.find(begin.tm_year + 1900) == m_DBMap.end())return;
		
		sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s,%s,%s FROM %s WHERE %s BETWEEN %lld AND %lld ORDER BY %s",
			HistoryAlarm::FIELD_INSERT_TIME.c_str(),
			HistoryAlarm::FIELD_JOB_NAME.c_str(),
			HistoryAlarm::FIELD_TYPE.c_str(),
			HistoryAlarm::FIELD_ALARM_CONTENT.c_str(),
			HistoryAlarm::TABLE_NAME.c_str(),
			HistoryAlarm::FIELD_INSERT_TIME.c_str(), tbegin, tend, HistoryAlarm::FIELD_INSERT_TIME.c_str());
		
		EnterCriticalSection(&m_DbCs);
		try {
			SQLite::Statement query(*m_DBMap[begin.tm_year + 1900], buffer);
			while (query.executeStep()) {
				HistoryAlarm* alarm = new HistoryAlarm();
				alarm->m_InsertTime = query.getColumn(HistoryAlarm::FIELD_INSERT_TIME.c_str()).getInt64();
				alarm->m_JobName = query.getColumn(HistoryAlarm::FIELD_JOB_NAME.c_str()).getString();
				alarm->m_Type = query.getColumn(HistoryAlarm::FIELD_TYPE.c_str()).getInt();
				alarm->m_AlarmContent = query.getColumn(HistoryAlarm::FIELD_ALARM_CONTENT.c_str()).getString();
				EnterCriticalSection(&m_AlarmCs);
				m_Alarms.push_back(alarm);
				LeaveCriticalSection(&m_AlarmCs);
			}
		}
		catch (SQLite::Exception &e)
		{
			g_log->TraceError(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
	}
	else {
		if (m_DBMap.find(begin.tm_year + 1900) == m_DBMap.end())return;
		sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s,%s,%s FROM %s WHERE %s BETWEEN %lld AND %lld ORDER BY %s",
			HistoryAlarm::FIELD_INSERT_TIME.c_str(),
			HistoryAlarm::FIELD_JOB_NAME.c_str(),
			HistoryAlarm::FIELD_TYPE.c_str(),
			HistoryAlarm::FIELD_ALARM_CONTENT.c_str(),
			HistoryAlarm::TABLE_NAME.c_str(),
			HistoryAlarm::FIELD_INSERT_TIME.c_str(), tbegin, tend, HistoryAlarm::FIELD_INSERT_TIME.c_str());
		
		EnterCriticalSection(&m_DbCs);
		try {
			SQLite::Statement query(*m_DBMap[begin.tm_year + 1900], buffer);
			while (query.executeStep()) {
				HistoryAlarm* alarm = new HistoryAlarm();
				alarm->m_InsertTime = query.getColumn(HistoryAlarm::FIELD_INSERT_TIME.c_str()).getInt64();
				alarm->m_JobName = query.getColumn(HistoryAlarm::FIELD_JOB_NAME.c_str()).getString();
				alarm->m_Type = query.getColumn(HistoryAlarm::FIELD_TYPE.c_str()).getInt();
				alarm->m_AlarmContent = query.getColumn(HistoryAlarm::FIELD_ALARM_CONTENT.c_str()).getString();
				EnterCriticalSection(&m_AlarmCs);
				m_Alarms.push_back(alarm);
				LeaveCriticalSection(&m_AlarmCs);
			}
		}
		catch (SQLite::Exception &e)
		{
			g_log->TraceError(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
		if (m_DBMap.find(end.tm_year + 1900) == m_DBMap.end())return;
		
		EnterCriticalSection(&m_DbCs);
		try {
			SQLite::Statement query2(*m_DBMap[end.tm_year + 1900], buffer);
			while (query2.executeStep()) {
				HistoryAlarm* alarm = new HistoryAlarm();
				alarm->m_InsertTime = query2.getColumn(HistoryAlarm::FIELD_INSERT_TIME.c_str()).getInt64();
				alarm->m_JobName = query2.getColumn(HistoryAlarm::FIELD_JOB_NAME.c_str()).getString();
				alarm->m_Type = query2.getColumn(HistoryAlarm::FIELD_TYPE.c_str()).getInt();
				alarm->m_AlarmContent = query2.getColumn(HistoryAlarm::FIELD_ALARM_CONTENT.c_str()).getString();
				EnterCriticalSection(&m_AlarmCs);
				m_Alarms.push_back(alarm);
				LeaveCriticalSection(&m_AlarmCs);
			}
		}
		catch (SQLite::Exception &e)
		{
			g_log->TraceError(e.getErrorStr());
		}
		LeaveCriticalSection(&m_DbCs);
	}
}


void LogDao::AddHistoryAlarm(string jobname, int type, string code)
{
	time_t tnow;
	time(&tnow);
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s,%s,%s) VALUES(%lld,'%s',%d,'%s')",
		HistoryAlarm::TABLE_NAME.c_str(), HistoryAlarm::FIELD_INSERT_TIME.c_str(),
		HistoryAlarm::FIELD_JOB_NAME.c_str(),
		HistoryAlarm::FIELD_TYPE.c_str(), HistoryAlarm::FIELD_ALARM_CONTENT.c_str(),
		tnow, jobname.c_str(), type, code.c_str());
	EnterCriticalSection(&m_DbCs);
	try {
		m_pDB->exec(buffer);
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}


DWORD WINAPI LogDao::DeleteImageProc(LogDao* _this) {
	if (_this) {
		_this->DeleteImageRun();
	}
	return 0;
}

void LogDao::DeleteImageRun()
{
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s,%s FROM %s ORDER BY %s DESC",
		ImageInfo::FIELD_ID.c_str(),
		ImageInfo::FIELD_INSERT_TIME.c_str(),
		ImageInfo::FIELD_JOB_ID.c_str(),
		ImageInfo::TABLE_NAME.c_str(),
		ImageInfo::FIELD_JOB_ID.c_str());
	EnterCriticalSection(&m_ImgDbCs);
	try {
		SQLite::Statement query(*m_pImgDB, buffer);
		vector<int> ids;
		vector<int> des;
		unsigned int count = 0;
		while (query.executeStep()) {
			int id = query.getColumn(ImageInfo::FIELD_JOB_ID.c_str()).getInt();
			if (count < ImageInfo::MAX_JOB_SIZE) {
				ids.push_back(id);
			}
			else {
				des.push_back(id);
			}
			count++;
		}

		SQLite::Transaction transaction(*m_pImgDB);
		for (size_t i = 0; i < des.size(); ++i) {
			sprintf_s(buffer, sizeof(buffer), "DELETE FROM %s WHERE %s=%d",
				ImageInfo::TABLE_NAME.c_str(),
				ImageInfo::FIELD_JOB_ID.c_str(), des[i]);
			m_pImgDB->exec(buffer);
			sprintf_s(buffer, sizeof(buffer), "DELETE FROM %s WHERE %s=%d",
				LogImage::IMAGE_TABLE_NAME.c_str(),
				LogImage::IMAGE_FIELD_JOB_ID.c_str(), des[i]);
			m_pImgDB->exec(buffer);
		}
		transaction.commit();
		m_ImageFlag = false;
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_ImgDbCs);

}


void LogDao::LogImageBeforePrint(int jobid, bool iscontinue)
{
	char buffer[1024];
	EnterCriticalSection(&m_ImgDbCs);
	sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s=%d", ImageInfo::TABLE_NAME.c_str(), ImageInfo::FIELD_JOB_ID.c_str(), jobid);
	try {
		SQLite::Statement query(*m_pImgDB, buffer);
		if (!query.executeStep()) {
			sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s) VALUES(%lld,%d)",
				ImageInfo::TABLE_NAME.c_str(),
				ImageInfo::FIELD_INSERT_TIME.c_str(),
				ImageInfo::FIELD_JOB_ID.c_str(),
				time(0), jobid);
			m_pImgDB->exec(buffer);
		}
		else {
			if (!iscontinue) {
				sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s) VALUES(%lld,%d)",
					ImageInfo::TABLE_NAME.c_str(),
					ImageInfo::FIELD_INSERT_TIME.c_str(),
					ImageInfo::FIELD_JOB_ID.c_str(),
					time(0), jobid);
				m_pImgDB->exec(buffer);
			}
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}

	LeaveCriticalSection(&m_ImgDbCs);
}

void LogDao::DeleteImageAfterPrint()
{
	if (m_ImageFlag)return;
	m_ImageFlag = true;
	m_ImageThread = AtlCreateThread(DeleteImageProc, this);
	CloseHandle(m_ImageThread);
}

void LogDao::AddImage(LogImage& image)
{
	if (image.m_Image == NULL || image.m_ImageLength == 0)return;
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s,%s,%s,%s) VALUES(%lld,%d,%d,%u,?)",
		LogImage::IMAGE_TABLE_NAME.c_str(),
		LogImage::IMAGE_FIELD_INSERT_TIME.c_str(),
		LogImage::IMAGE_FIELD_JOB_ID.c_str(),
		LogImage::IMAGE_FIELD_IMAGE_TYPE.c_str(),
		LogImage::IMAGE_FIELD_LAYER_INDEX.c_str(),
		LogImage::IMAGE_FIELD_IMAGE.c_str(),
		image.m_InsertTime, image.m_JobId, image.m_Type, image.m_LayerIndex);
	EnterCriticalSection(&m_ImgDbCs);
	try
	{
		SQLite::Statement query(*m_pImgDB, buffer);
		query.bind(1, image.m_Image, image.m_ImageLength);
		query.exec();
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_ImgDbCs);
}

void LogDao::FindImageInfo(bool isRemote)
{
	if (m_CurrentShowJob == NULL)return;
	if (m_ImgDBMap.find(m_CurrentShowJob->m_YearBelong) == m_ImgDBMap.end())return;

	SQLite::Database* db = m_ImgDBMap[m_CurrentShowJob->m_YearBelong];

	EnterCriticalSection(&m_LogImageCs);
	for (size_t i = 0; i < m_LogImages.size(); i++)
	{
		delete m_LogImages[i];
		m_LogImages[i] = NULL;
	}
	m_LogImages.clear();
	LeaveCriticalSection(&m_LogImageCs);
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s,%s,%s,%s FROM %s WHERE %s=%d ",
		LogImage::IMAGE_FIELD_ID.c_str(),
		LogImage::IMAGE_FIELD_INSERT_TIME.c_str(),
		LogImage::IMAGE_FIELD_JOB_ID.c_str(),
		LogImage::IMAGE_FIELD_IMAGE_TYPE.c_str(),
		LogImage::IMAGE_FIELD_LAYER_INDEX.c_str(),
		LogImage::IMAGE_TABLE_NAME.c_str(),
		LogImage::IMAGE_FIELD_JOB_ID.c_str(), m_CurrentShowJob->m_Id);
	EnterCriticalSection(&m_ImgDbCs);
	try
	{
		SQLite::Statement query(*db, buffer);
		while (query.executeStep()) {
			LogImage* image = new LogImage();
			image->m_Id = query.getColumn(LogImage::IMAGE_FIELD_ID.c_str()).getInt();
			image->m_InsertTime = query.getColumn(LogImage::IMAGE_FIELD_INSERT_TIME.c_str()).getInt64();
			image->m_JobId = query.getColumn(LogImage::IMAGE_FIELD_JOB_ID.c_str()).getInt();
			image->m_Type = LogImage::ImageType(query.getColumn(LogImage::IMAGE_FIELD_IMAGE_TYPE.c_str()).getInt());
			image->m_LayerIndex = query.getColumn(LogImage::IMAGE_FIELD_LAYER_INDEX.c_str()).getUInt();
			EnterCriticalSection(&m_LogImageCs);
			m_LogImages.push_back(image);
			LeaveCriticalSection(&m_LogImageCs);
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}

	LeaveCriticalSection(&m_ImgDbCs);
}

bool LogDao::FindImage(long id, unsigned char** image, unsigned long* imagesize, bool isRemote)
{
	if (m_CurrentShowJob == NULL)return false;
	if (m_ImgDBMap.find(m_CurrentShowJob->m_YearBelong) == m_ImgDBMap.end())return false;

	SQLite::Database* db = m_ImgDBMap[m_CurrentShowJob->m_YearBelong];
	bool rel = false;
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT %s FROM %s WHERE %s=%d",
		LogImage::IMAGE_FIELD_IMAGE.c_str(),
		LogImage::IMAGE_TABLE_NAME.c_str(),
		LogImage::IMAGE_FIELD_ID.c_str(), id);
	EnterCriticalSection(&m_ImgDbCs);
	try
	{
		SQLite::Statement query(*db, buffer);
		if (query.executeStep()) {
			SQLite::Column colBlob = query.getColumn(LogImage::IMAGE_FIELD_IMAGE.c_str());
			int blobsize = colBlob.getBytes();
			if (blobsize > 0) {
				unsigned char* pdata = (unsigned char*)colBlob.getBlob();
				*image = new unsigned char[blobsize];
				memcpy_s(*image, blobsize, pdata, blobsize);
				*imagesize = blobsize;
				rel = true;
			}
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_ImgDbCs);
	return rel;
}

void LogDao::AddIFImage(IFImage* image)
{
	if (image->m_Image == NULL || image->m_ImageLength == 0 || image->m_IFData==NULL || image->m_ImageCols==0 || image->m_ImageRows==0)return;
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s,%s,%s,%s,%s,%s,%s,%s) VALUES(%lld,%d,%d,%u,%u,%u,%u,?,?)",
		IFImage::IFIMAGE_TABLE_NAME.c_str(),
		IFImage::IFIMAGE_FIELD_INSERT_TIME.c_str(),
		IFImage::IFIMAGE_FIELD_JOB_ID.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_TYPE.c_str(),
		IFImage::IFIMAGE_FIELD_LAYER_INDEX.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_COLS.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_ROWS.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_LENGTH.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE.c_str(),
		IFImage::IFIMAGE_FIELD_IFDATA.c_str(),
		image->m_InsertTime, image->m_JobId, image->m_Type, image->m_LayerIndex,image->m_ImageCols,image->m_ImageRows,image->m_ImageLength);
	EnterCriticalSection(&m_ImgDbCs);
	try
	{
		SQLite::Statement query(*m_pImgDB, buffer);
		query.bind(1, image->m_Image, image->m_ImageLength);
		query.bind(2, (unsigned char*)image->m_IFData, image->m_ImageCols* image->m_ImageRows*sizeof(float));
		query.exec();
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_ImgDbCs);
}

void LogDao::FindIFImageInfo()
{
	if (m_CurrentShowJob == NULL)return;
	if (m_ImgDBMap.find(m_CurrentShowJob->m_YearBelong) == m_ImgDBMap.end())return;

	SQLite::Database* db = m_ImgDBMap[m_CurrentShowJob->m_YearBelong];

	EnterCriticalSection(&m_LogImageCs);
	for (size_t i = 0; i < m_IFImages.size(); i++)
	{
		delete m_IFImages[i];
		m_IFImages[i] = NULL;
	}
	m_IFImages.clear();
	LeaveCriticalSection(&m_LogImageCs);
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s,%s,%s,%s,%s,%s,%s FROM %s WHERE %s=%d ",
		IFImage::IFIMAGE_FIELD_ID.c_str(),
		IFImage::IFIMAGE_FIELD_INSERT_TIME.c_str(),
		IFImage::IFIMAGE_FIELD_JOB_ID.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_TYPE.c_str(),
		IFImage::IFIMAGE_FIELD_LAYER_INDEX.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_COLS.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_ROWS.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_LENGTH.c_str(),
		IFImage::IFIMAGE_TABLE_NAME.c_str(),
		IFImage::IFIMAGE_FIELD_JOB_ID.c_str(), m_CurrentShowJob->m_Id);

	/*sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s,%s,%s,%s,%s,%s,%s FROM %s",
		IFImage::IFIMAGE_FIELD_ID.c_str(),
		IFImage::IFIMAGE_FIELD_INSERT_TIME.c_str(),
		IFImage::IFIMAGE_FIELD_JOB_ID.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_TYPE.c_str(),
		IFImage::IFIMAGE_FIELD_LAYER_INDEX.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_COLS.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_ROWS.c_str(),
		IFImage::IFIMAGE_FIELD_IMAGE_LENGTH.c_str(),
		IFImage::IFIMAGE_TABLE_NAME.c_str());*/

	EnterCriticalSection(&m_ImgDbCs);
	try
	{
		SQLite::Statement query(*db, buffer);
		while (query.executeStep()) {
			IFImage* image = new IFImage();
			image->m_Id = query.getColumn(IFImage::IFIMAGE_FIELD_ID.c_str()).getInt();
			image->m_InsertTime = query.getColumn(IFImage::IFIMAGE_FIELD_INSERT_TIME.c_str()).getInt64();
			image->m_JobId = query.getColumn(IFImage::IFIMAGE_FIELD_JOB_ID.c_str()).getInt();
			image->m_Type = IFImage::ImageType(query.getColumn(IFImage::IFIMAGE_FIELD_IMAGE_TYPE.c_str()).getInt());
			image->m_LayerIndex = query.getColumn(IFImage::IFIMAGE_FIELD_LAYER_INDEX.c_str()).getUInt();
			image->m_ImageCols = query.getColumn(IFImage::IFIMAGE_FIELD_IMAGE_COLS.c_str()).getUInt();
			image->m_ImageRows = query.getColumn(IFImage::IFIMAGE_FIELD_IMAGE_ROWS.c_str()).getUInt();
			image->m_ImageLength = query.getColumn(IFImage::IFIMAGE_FIELD_IMAGE_LENGTH.c_str()).getUInt();
			EnterCriticalSection(&m_LogImageCs);
			m_IFImages.push_back(image);
			LeaveCriticalSection(&m_LogImageCs);
		}
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}

	LeaveCriticalSection(&m_ImgDbCs);
}

bool LogDao::FindIFImage(long id, unsigned char** image, unsigned long* imagesize, float** tdata, unsigned long* datasize)
{
	if (m_CurrentShowJob == NULL)return false;
	if (m_ImgDBMap.find(m_CurrentShowJob->m_YearBelong) == m_ImgDBMap.end())return false;

	SQLite::Database* db = m_ImgDBMap[m_CurrentShowJob->m_YearBelong];
	bool rel = false;
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s FROM %s WHERE %s=%d",
		IFImage::IFIMAGE_FIELD_IMAGE.c_str(),
		IFImage::IFIMAGE_FIELD_IFDATA.c_str(),
		IFImage::IFIMAGE_TABLE_NAME.c_str(),
		IFImage::IFIMAGE_FIELD_ID.c_str(), id);
	EnterCriticalSection(&m_ImgDbCs);
	try
	{
		SQLite::Statement query(*db, buffer);
		if (query.executeStep()) {
			SQLite::Column colBlob = query.getColumn(IFImage::IFIMAGE_FIELD_IMAGE.c_str());
			int blobsize = colBlob.getBytes();
			SQLite::Column colBlob2 = query.getColumn(IFImage::IFIMAGE_FIELD_IFDATA.c_str());
			int blobsize2 = colBlob2.getBytes();
			if (blobsize > 0) {
				unsigned char* pdata = (unsigned char*)colBlob.getBlob();
				*image = new unsigned char[blobsize];
				memcpy_s(*image, blobsize, pdata, blobsize);
				*imagesize = blobsize;
				rel = true;
			}
			

			
			if (blobsize2 > 0) {
				float* pdata = (float*)colBlob2.getBlob();
				int ds = blobsize2 / 4;
				if (ds > 0) {
					*tdata = new float[ds];
					for (int i = 0; i < ds;i++) {
						(*tdata)[i] = pdata[i];
					}
					*datasize = ds;
					rel = true;
				}
				else {
					*datasize = 0;
				}
				
			}
		}
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_ImgDbCs);
	return rel;
}

void LogDao::AddPartAddition(PartAddition& pa)
{
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s,%s,%s,%s,%s) VALUES('%s',%d,%d,%.2f,%.2f,%.2f)",
		PartAddition::PART_TABLE_NAME.c_str(),
		PartAddition::FIELD_JOB_ID.c_str(),
		PartAddition::FIELD_SOURCE_PART.c_str(),
		PartAddition::FIELD_NEW_PART.c_str(),
		PartAddition::FIELD_X_OFFSET.c_str(),
		PartAddition::FIELD_Y_OFFSET.c_str(),
		PartAddition::FIELD_ROTATE.c_str(),
		pa.m_JobId.c_str(), pa.m_SourcePart, pa.m_NewPart, pa.m_XOffset, pa.m_YOffset, pa.m_Rotate);
	EnterCriticalSection(&m_DbCs);
	try {
		m_pDB->exec(buffer);
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::DeletePartAddition(string jid, int partid) {
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "DELETE FROM %s WHERE %s='%s' AND %s=%d",
		PartAddition::PART_TABLE_NAME.c_str(),
		PartAddition::FIELD_JOB_ID.c_str(), jid.c_str(),
		PartAddition::FIELD_NEW_PART.c_str(), partid);
	EnterCriticalSection(&m_DbCs);
	try {
		m_pDB->exec(buffer);
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::UpdatePartAdditionOffset(string jid, int partid, float x, float y, float rotate)
{
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "UPDATE %s SET %s=%.2f,%s=%.2f,%s=%.2f WHERE %s='%s' AND %s=%d",
		PartAddition::PART_TABLE_NAME.c_str(),
		PartAddition::FIELD_X_OFFSET.c_str(), x,
		PartAddition::FIELD_Y_OFFSET.c_str(), y,
		PartAddition::FIELD_ROTATE.c_str(), rotate,
		PartAddition::FIELD_JOB_ID.c_str(), jid.c_str(),
		PartAddition::FIELD_NEW_PART.c_str(), partid);
	EnterCriticalSection(&m_DbCs);
	try {
		m_pDB->exec(buffer);
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::FindPartAddition(string jid, vector<PartAddition*>& vec)
{
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s='%s'",
		PartAddition::PART_TABLE_NAME.c_str(),
		PartAddition::FIELD_JOB_ID.c_str(), jid.c_str());
	EnterCriticalSection(&m_DbCs);
	try
	{
		SQLite::Statement query(*m_pDB, buffer);
		while (query.executeStep()) {
			PartAddition* pa = new PartAddition();
			pa->m_Id = query.getColumn(PartAddition::FIELD_ID.c_str()).getInt();
			pa->m_JobId = query.getColumn(PartAddition::FIELD_JOB_ID.c_str()).getString();
			pa->m_SourcePart = query.getColumn(PartAddition::FIELD_SOURCE_PART.c_str()).getInt();
			pa->m_NewPart = query.getColumn(PartAddition::FIELD_NEW_PART.c_str()).getInt();
			pa->m_XOffset = (float)(query.getColumn(PartAddition::FIELD_X_OFFSET.c_str()).getDouble());
			pa->m_YOffset = (float)(query.getColumn(PartAddition::FIELD_Y_OFFSET.c_str()).getDouble());
			pa->m_Rotate = (float)(query.getColumn(PartAddition::FIELD_ROTATE.c_str()).getDouble());
			vec.push_back(pa);
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::AddAxisLog(AxisLog* axisLog)
{
	if (!axisLog)return;
//	if (axisLog->m_MoldDataCount == 0 && axisLog->m_PowderDataCount == 0 && axisLog->m_ArmDataCount == 0 && axisLog->m_SupplyDataCount == 0)return;
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) VALUES(%lld,%u,%d,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%u,%u,%u,%u,?,?,?,?)",
		AxisLog::AL_TABLE_NAME.c_str(),
		AxisLog::AL_FIELD_JOB_ID.c_str(),
		AxisLog::AL_FIELD_LAYER_INDEX.c_str(),
		AxisLog::AL_FIELD_COVER_TYPE.c_str(),
		AxisLog::AL_FIELD_PRE_MOLD_POS.c_str(),
		AxisLog::AL_FIELD_PRE_LINEAR_ENCODER_POS.c_str(),
		AxisLog::AL_FIELD_PRE_LOAD_POS.c_str(),
		AxisLog::AL_FIELD_PRE_ARM_POS.c_str(),
		AxisLog::AL_FIELD_PRE_SUPPLY_POS.c_str(),
		AxisLog::AL_FIELD_AFT_MOLD_POS.c_str(),
		AxisLog::AL_FIELD_AFT_LINEAR_ENCODER_POS.c_str(),
		AxisLog::AL_FIELD_AFT_LOAD_POS.c_str(),
		AxisLog::AL_FIELD_AFT_ARM_POS.c_str(),
		AxisLog::AL_FIELD_AFT_SUPPLY_POS.c_str(),
		AxisLog::AL_FIELD_MOLD_DATA_COUNT.c_str(),
		AxisLog::AL_FIELD_LOAD_DATA_COUNT.c_str(),
		AxisLog::AL_FIELD_ARM_DATA_COUNT.c_str(),
		AxisLog::AL_FIELD_SUPPLY_DATA_COUNT.c_str(),
		AxisLog::AL_FIELD_MOLD_DATA.c_str(),
		AxisLog::AL_FIELD_LOAD_DATA.c_str(),
		AxisLog::AL_FIELD_ARM_DATA.c_str(),
		AxisLog::AL_FIELD_SUPPLY_DATA.c_str(),
		axisLog->m_JobId, axisLog->m_LayerIndex, axisLog->m_CoverType, 
		axisLog->m_PreMoldPos, axisLog->m_PreLinearEncoderPos,axisLog->m_PreLoadPos, axisLog->m_PreArmPos, axisLog->m_PreSupplyPos,
		axisLog->m_AftMoldPos, axisLog->m_AftLinearEncoderPos, axisLog->m_AftLoadPos, axisLog->m_AftArmPos, axisLog->m_AftSupplyPos,
		axisLog->m_MoldDataCount, axisLog->m_LoadDataCount, axisLog->m_ArmDataCount, axisLog->m_SupplyDataCount);


	EnterCriticalSection(&m_DbCs);
	try
	{
		SQLite::Statement query(*m_pDB, buffer);
		if (axisLog->m_MoldDataCount > 0)query.bind(1, axisLog->m_MoldData, axisLog->m_MoldDataCount * sizeof(float));
		else query.bind(1);
		if (axisLog->m_LoadDataCount > 0)query.bind(2, axisLog->m_LoadData, axisLog->m_LoadDataCount * sizeof(float));
		else query.bind(2);
		if (axisLog->m_ArmDataCount > 0) query.bind(3, axisLog->m_ArmData, axisLog->m_ArmDataCount * sizeof(float));
		else query.bind(3);
		if (axisLog->m_SupplyDataCount > 0) query.bind(4, axisLog->m_SupplyData, axisLog->m_SupplyDataCount * sizeof(float));
		else query.bind(4);
		query.exec();
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::FindAxisLogInfo(bool isRemote)
{
	if (m_CurrentShowJob == NULL)return;
	if (m_DBMap.find(m_CurrentShowJob->m_YearBelong) == m_DBMap.end())return;

	SQLite::Database* db = m_DBMap[m_CurrentShowJob->m_YearBelong];
	EnterCriticalSection(&m_AxisLogCs);
	for (size_t i = 0; i < m_AxisLogs.size(); i++)
	{
		delete m_AxisLogs[i];
		m_AxisLogs[i] = NULL;
	}
	m_AxisLogs.clear();
	LeaveCriticalSection(&m_AxisLogCs);
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s FROM %s WHERE %s=%d ",
		AxisLog::AL_FIELD_ID.c_str(),
		AxisLog::AL_FIELD_JOB_ID.c_str(),
		AxisLog::AL_FIELD_LAYER_INDEX.c_str(),
		AxisLog::AL_FIELD_COVER_TYPE.c_str(),
		AxisLog::AL_FIELD_PRE_MOLD_POS.c_str(),
		AxisLog::AL_FIELD_PRE_LINEAR_ENCODER_POS.c_str(),
		AxisLog::AL_FIELD_PRE_LOAD_POS.c_str(),
		AxisLog::AL_FIELD_PRE_ARM_POS.c_str(),
		AxisLog::AL_FIELD_PRE_SUPPLY_POS.c_str(),
		AxisLog::AL_FIELD_AFT_MOLD_POS.c_str(),
		AxisLog::AL_FIELD_AFT_LINEAR_ENCODER_POS.c_str(),
		AxisLog::AL_FIELD_AFT_LOAD_POS.c_str(),
		AxisLog::AL_FIELD_AFT_ARM_POS.c_str(),
		AxisLog::AL_FIELD_AFT_SUPPLY_POS.c_str(),
		AxisLog::AL_FIELD_MOLD_DATA_COUNT.c_str(),
		AxisLog::AL_FIELD_LOAD_DATA_COUNT.c_str(),
		AxisLog::AL_FIELD_ARM_DATA_COUNT.c_str(),
		AxisLog::AL_FIELD_SUPPLY_DATA_COUNT.c_str(),
		AxisLog::AL_TABLE_NAME.c_str(),
		AxisLog::AL_FIELD_JOB_ID.c_str(), m_CurrentShowJob->m_Id);
	EnterCriticalSection(&m_DbCs);
	try
	{
		SQLite::Statement query(*db, buffer);
		while (query.executeStep()) {
			AxisLog* lc = new AxisLog();
			lc->m_Id = query.getColumn(AxisLog::AL_FIELD_ID.c_str()).getInt64();
			lc->m_JobId = query.getColumn(AxisLog::AL_FIELD_JOB_ID.c_str()).getInt64();
			lc->m_LayerIndex = query.getColumn(AxisLog::AL_FIELD_LAYER_INDEX.c_str()).getUInt();
			lc->m_CoverType = query.getColumn(AxisLog::AL_FIELD_COVER_TYPE.c_str()).getInt();
			lc->m_PreMoldPos = query.getColumn(AxisLog::AL_FIELD_PRE_MOLD_POS.c_str()).getDouble();
			lc->m_PreLinearEncoderPos = query.getColumn(AxisLog::AL_FIELD_PRE_LINEAR_ENCODER_POS.c_str()).getDouble();
			lc->m_PreLoadPos = query.getColumn(AxisLog::AL_FIELD_PRE_LOAD_POS.c_str()).getDouble();
			lc->m_PreArmPos = query.getColumn(AxisLog::AL_FIELD_PRE_ARM_POS.c_str()).getDouble();
			lc->m_PreSupplyPos = query.getColumn(AxisLog::AL_FIELD_PRE_SUPPLY_POS.c_str()).getDouble();
			lc->m_AftMoldPos = query.getColumn(AxisLog::AL_FIELD_AFT_MOLD_POS.c_str()).getDouble();
			lc->m_AftLinearEncoderPos = query.getColumn(AxisLog::AL_FIELD_AFT_LINEAR_ENCODER_POS.c_str()).getDouble();
			lc->m_AftLoadPos = query.getColumn(AxisLog::AL_FIELD_AFT_LOAD_POS.c_str()).getDouble();
			lc->m_AftArmPos = query.getColumn(AxisLog::AL_FIELD_AFT_ARM_POS.c_str()).getDouble();
			lc->m_AftSupplyPos = query.getColumn(AxisLog::AL_FIELD_AFT_SUPPLY_POS.c_str()).getDouble();
			lc->m_MoldDataCount = query.getColumn(AxisLog::AL_FIELD_MOLD_DATA_COUNT.c_str()).getUInt();
			lc->m_LoadDataCount = query.getColumn(AxisLog::AL_FIELD_LOAD_DATA_COUNT.c_str()).getUInt();
			lc->m_ArmDataCount = query.getColumn(AxisLog::AL_FIELD_ARM_DATA_COUNT.c_str()).getUInt();
			lc->m_SupplyDataCount = query.getColumn(AxisLog::AL_FIELD_SUPPLY_DATA_COUNT.c_str()).getUInt();
			EnterCriticalSection(&m_AxisLogCs);
			m_AxisLogs.push_back(lc);
			LeaveCriticalSection(&m_AxisLogCs);
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::FindAxisLogData(AxisLog* axisLog, bool isRemote)
{
	if (!axisLog)return;
	if (m_CurrentShowJob == NULL)return;
	if (m_DBMap.find(m_CurrentShowJob->m_YearBelong) == m_DBMap.end())return;

	SQLite::Database* db = m_DBMap[m_CurrentShowJob->m_YearBelong];
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s,%s,%s FROM %s WHERE %s=%lld ",
		AxisLog::AL_FIELD_MOLD_DATA.c_str(),
		AxisLog::AL_FIELD_LOAD_DATA.c_str(),
		AxisLog::AL_FIELD_ARM_DATA.c_str(),
		AxisLog::AL_FIELD_SUPPLY_DATA.c_str(),
		AxisLog::AL_TABLE_NAME.c_str(),
		AxisLog::AL_FIELD_ID.c_str(), axisLog->m_Id);
	
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*db, buffer);
		if (query.executeStep()) {
			int moldBytes = query.getColumn(AxisLog::AL_FIELD_MOLD_DATA.c_str()).getBytes();
			int loadBytes = query.getColumn(AxisLog::AL_FIELD_LOAD_DATA.c_str()).getBytes();
			int armBytes = query.getColumn(AxisLog::AL_FIELD_ARM_DATA.c_str()).getBytes();
			int supplyBytes = query.getColumn(AxisLog::AL_FIELD_SUPPLY_DATA.c_str()).getBytes();
			if (moldBytes >= sizeof(float)) {
				float* pdata = (float*)query.getColumn(AxisLog::AL_FIELD_MOLD_DATA.c_str()).getBlob();
				int datasize = moldBytes / 4;
				axisLog->m_MoldDataCount = datasize;

				if (axisLog->m_MoldData) {
					delete[] axisLog->m_MoldData;
					axisLog->m_MoldData = NULL;
				}
				axisLog->m_MoldData = new float[datasize];
				for (int j = 0; j < datasize; j++) {
					axisLog->m_MoldData[j] = pdata[j];
				}
			}
			else {
				if (axisLog->m_MoldData) {
					delete[]axisLog->m_MoldData;
					axisLog->m_MoldData = NULL;
				}
				axisLog->m_MoldDataCount = 0;
			}

			if (loadBytes >= sizeof(float)) {
				float* pdata = (float*)query.getColumn(AxisLog::AL_FIELD_LOAD_DATA.c_str()).getBlob();
				int datasize = loadBytes / 4;
				axisLog->m_LoadDataCount = datasize;

				if (axisLog->m_LoadData) {
					delete[] axisLog->m_LoadData;
					axisLog->m_LoadData = NULL;
				}
				axisLog->m_LoadData = new float[datasize];
				for (int j = 0; j < datasize; j++) {
					axisLog->m_LoadData[j] = pdata[j];
				}
			}
			else {
				if (axisLog->m_LoadData) {
					delete[]axisLog->m_LoadData;
					axisLog->m_LoadData = NULL;
				}
				axisLog->m_LoadDataCount = 0;
			}

			if (armBytes >= sizeof(float)) {
				float* pdata = (float*)query.getColumn(AxisLog::AL_FIELD_ARM_DATA.c_str()).getBlob();
				int datasize = armBytes / 4;
				axisLog->m_ArmDataCount = datasize;

				if (axisLog->m_ArmData) {
					delete[] axisLog->m_ArmData;
					axisLog->m_ArmData = NULL;
				}
				axisLog->m_ArmData = new float[datasize];
				for (int j = 0; j < datasize; j++) {
					axisLog->m_ArmData[j] = pdata[j];
				}
			}
			else {
				if (axisLog->m_ArmData) {
					delete[]axisLog->m_ArmData;
					axisLog->m_ArmData = NULL;
				}
				axisLog->m_ArmDataCount = 0;
			}

			if (supplyBytes >= sizeof(float)) {
				float* pdata = (float*)query.getColumn(AxisLog::AL_FIELD_SUPPLY_DATA.c_str()).getBlob();
				int datasize = supplyBytes / 4;
				axisLog->m_SupplyDataCount = datasize;

				if (axisLog->m_SupplyData) {
					delete[] axisLog->m_SupplyData;
					axisLog->m_SupplyData = NULL;
				}
				axisLog->m_SupplyData = new float[datasize];
				for (int j = 0; j < datasize; j++) {
					axisLog->m_SupplyData[j] = pdata[j];
				}
			}
			else {
				if (axisLog->m_SupplyData) {
					delete[]axisLog->m_SupplyData;
					axisLog->m_SupplyData = NULL;
				}
				axisLog->m_SupplyDataCount = 0;
			}
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}
void LogDao::StartExport(string path, LogAssist& assist)
{
	if (m_ExportThread != INVALID_HANDLE_VALUE)return;
	m_ExportPath = path;
	m_ExportFlag = true;
	m_IsExportData = assist.isExportData;
	m_IsExportAxisData = assist.isExportAxisData;
	m_IsExportImage = assist.isExportImage;
	m_IsExportScanData = assist.isExportScanData;
	m_ExportThread = AtlCreateThread(ExportProc, this);
}

void LogDao::StopExport()
{
	m_ExportFlag = false;
	if (m_ExportThread != INVALID_HANDLE_VALUE) {
		if (WaitForSingleObject(m_ExportThread, 1000) == WAIT_TIMEOUT) {
			TerminateThread(m_ExportThread, 1);
		}
		CloseHandle(m_ExportThread);
		m_ExportThread = INVALID_HANDLE_VALUE;
	}
}

bool LogDao::IsExportFinished()
{
	return !m_ExportFlag;
}

DWORD WINAPI LogDao::ExportProc(LogDao* _this)
{
	if (_this) {
		_this->ExportRun();
		_this->m_ExportFlag = false;
		CloseHandle(_this->m_ExportThread);
		_this->m_ExportThread = INVALID_HANDLE_VALUE;
	}
	return 0;
}

void LogDao::ExportRun()
{
	m_ExportInfo = g_LngManager->SLog_ExportProgressCreatePath->ShowText();
	if (0 != _access(m_ExportPath.c_str(), 0)) {
		_mkdir(m_ExportPath.c_str());
	}
	string imagePath = m_ExportPath + "/images";
	_mkdir(imagePath.c_str());
	char buffer[2048];
	if (m_IsExportData) {
		m_ExportProgress = 0;
		m_ExportInfo = g_LngManager->SLog_ExportProgressData->ShowText();
		string file = m_ExportPath + "/envdata.csv";
		ofstream ofs(file, ios::trunc);
		if (ofs.is_open()) {
			ofs << "日期时间,耗时(s),层位置,氧含量1(PPM),氧含量2(PPM),舱内温度(℃),湿度(%%),舱内压力(kPa),风机频率(Hz),基板温度(℃),风量,水温(℃)\n";
			
		
			EnterCriticalSection(&m_StatusCs);
			for (size_t i = 0; i < m_LayerStatus.size(); ++i) {
				if (!m_ExportFlag)break;
				LayerStatus* ls = m_LayerStatus[i];
				sprintf_s(buffer, sizeof(buffer), "%s,%u,%d,%.3f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f\n",
					TimeHelper::Time2Str(ls->m_InsertTitme).c_str(),
					ls->m_SpendSecond,
					ls->m_LayerIndex + 1, ls->m_PrintOxygen1, ls->m_PrintOxygen2,ls->m_PrintTemp,
					ls->m_PrintHumidity,ls->m_PrintPressure,ls->m_FanFrequency,ls->m_PlateTemp,ls->m_WindRate,ls->m_WaterTemp);
				ofs << buffer;
				m_ExportProgress = (float)(i + 1) / m_LayerStatus.size();
			}
			LeaveCriticalSection(&m_StatusCs);
			ofs.flush();
		}
		ofs.close();
	}
	if (m_IsExportAxisData) {
		m_ExportProgress = 0;
		m_ExportInfo = g_LngManager->SLog_ExportProgressData->ShowText();
		string file = m_ExportPath + "/axisdata.csv";
		ofstream ofs(file, ios::trunc);
		if (ofs.is_open()) {
			string strhead = "层位置,铺粉方式,铺前成型缸位置（mm）,铺后成型缸位置（mm）,铺前层光栅位置（mm）,铺后层光栅位置（mm）,铺前铺粉臂位置（mm）,铺后铺粉臂位置（mm）, 铺前供粉位置（mm）,铺后供粉位置（mm） \n";
			//sprintf_s(buffer, sizeof(buffer), g_LngManager->SLog_ExportAxisDataContentHeader->ShowText());
			ofs << strhead.c_str();
			EnterCriticalSection(&m_AxisLogCs);
			for (size_t i = 0; i < m_AxisLogs.size(); ++i) {
				if (!m_ExportFlag)break;
				AxisLog* ls = m_AxisLogs[i];
				string coverType = "未知";
				if (ls->m_CoverType == CoverCfg::TWO_WAY1) {
					coverType="双向铺粉1";
				}
				else if (ls->m_CoverType == CoverCfg::ONE_WAY) {
					coverType = "单向铺粉";
				}
				else if (ls->m_CoverType == CoverCfg::NO_COVER) {
					coverType = "不铺粉";
				}
				else if (ls->m_CoverType == CoverCfg::TWO_WAY2) {
					coverType = "双向铺粉2";
				}
				else if (ls->m_CoverType == CoverCfg::ONE_WAY2) {
					coverType = "单向铺粉2";
				}
				
				sprintf_s(buffer, sizeof(buffer), "%u,%s,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n",
					ls->m_LayerIndex + 1, coverType.c_str(), ls->m_PreMoldPos, ls->m_AftMoldPos, 
					ls->m_PreLinearEncoderPos,ls->m_AftLinearEncoderPos, ls->m_PreArmPos, ls->m_AftArmPos, ls->m_PreSupplyPos, ls->m_AftSupplyPos);
				ofs << buffer;
				m_ExportProgress = (float)(i + 1) / m_AxisLogs.size();
			}
			LeaveCriticalSection(&m_AxisLogCs);
			ofs.flush();
		}
		ofs.close();
	}
	if (m_IsExportScanData) {
		m_ExportProgress = 0;
		m_ExportInfo = g_LngManager->SLog_ExportProgressData->ShowText();
		string file = m_ExportPath + "/scannerdata.csv";
		ofstream ofs(file, ios::trunc);
		if (ofs.is_open()) {
			sprintf_s(buffer, sizeof(buffer), g_LngManager->SLog_ExportScannerDataContentHeader->ShowText());
			ofs << buffer;
			EnterCriticalSection(&m_ScannerStatusCS);
			for (size_t i = 0; i < m_ScannerStatus.size(); ++i) {
				if (!m_ExportFlag)break;
				ScannerStatus* ls = m_ScannerStatus[i];
				bool IsPositionErrorNormalRangeX = (ls->m_LowStateX & 0x10000) ? true : false;
				bool IsPositionErrorNormalRangeY = (ls->m_LowStateY & 0x10000) ? true : false;
				bool IsCriticalErrorX = (ls->m_LowStateX & 0x2000) ? false : true;
				bool IsCriticalErrorY = (ls->m_LowStateY & 0x2000) ? false : true;
				bool IsScanSystemTempOverLimitX = (ls->m_LowStateX & 0x800) ? false : true;
				bool IsScanSystemTempOverLimitY = (ls->m_LowStateY & 0x800) ? false : true;
				bool IsScannerReachedCriticalEdgePosX = (ls->m_LowStateX & 0x200) ? false : true;
				bool IsScannerReachedCriticalEdgePosY = (ls->m_LowStateY & 0x200) ? false : true;
				bool IsServoBoradOperationTempNormalX = (ls->m_HighStateX & 0x4000) ? true : false;
				bool IsServoBoradOperationTempNormalY = (ls->m_HighStateY & 0x4000) ? true : false;
				bool IsGalvanometerScannerOperationTempNormalX = (ls->m_HighStateX & 0x2000) ? true : false;
				bool IsGalvanometerScannerOperationTempNormalY = (ls->m_HighStateY & 0x2000) ? true : false;
				sprintf_s(buffer, sizeof(buffer), "%s,%d,%d,%.3f,%.3f,%.3f,%.3f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s\n",
					TimeHelper::Time2Str(ls->m_InsertTime).c_str(), ls->m_LayerIndex + 1, ls->m_ScanId, ls->m_ScanTempX, ls->m_ScanTempY, ls->m_ScanServoTempX, ls->m_ScanServoTempY,
					ls->m_ActualPositionX, ls->m_SetPositionX, ls->m_PositionErrorX, ls->m_ActualPositionY, ls->m_SetPositionY, ls->m_PositionErrorY, IsPositionErrorNormalRangeX ? "是" : "否",
					IsPositionErrorNormalRangeY ? "是" : "否", IsCriticalErrorX ? "是" : "否", IsCriticalErrorY ? "是" : "否", IsScanSystemTempOverLimitX ? "是" : "否",
					IsScanSystemTempOverLimitY ? "是" : "否", IsScannerReachedCriticalEdgePosX ? "是" : "否", IsScannerReachedCriticalEdgePosY ? "是" : "否", IsServoBoradOperationTempNormalX ? "是" : "否",
					IsServoBoradOperationTempNormalY ? "是" : "否", IsGalvanometerScannerOperationTempNormalX ? "是" : "否", IsGalvanometerScannerOperationTempNormalY ? "是" : "否");
				ofs << buffer;
				m_ExportProgress = (float)(i + 1) / m_ScannerStatus.size();
			}
			LeaveCriticalSection(&m_ScannerStatusCS);
			ofs.flush();
		}
		ofs.close();
	}

	if (m_IsExportImage) {
		m_ExportProgress = 0;
		m_ExportInfo = g_LngManager->SLog_ExportProgressImage->ShowText();
		tjhandle tjinstance = tjInitTransform();
		//Gdiplus::GdiplusStartupInput gdiplusStartupInput;
		//ULONG_PTR pGdiToken;
		//Gdiplus::GdiplusStartup(&pGdiToken, &gdiplusStartupInput, NULL);
		EnterCriticalSection(&m_LogImageCs);
		for (size_t i = 0; i < m_LogImages.size(); ++i) {
			if (!m_ExportFlag)break;
			LogImage* logImage = m_LogImages[i];
			unsigned char *image = NULL;
			unsigned long image_size = 0;
			//int width, height;
			if (g_log->m_LogDao->FindImage(logImage->m_Id, &image, &image_size)) {

				unsigned long change_size = 0;
				unsigned char *changeImage = NULL;
				tjtransform transform;
				memset(&transform, 0, sizeof(tjtransform));
				transform.op = TJXOP_VFLIP;
				transform.options |= TJXOPT_TRIM;

				int rel = tjTransform(tjinstance, image, image_size, 1, &changeImage, &change_size, &transform, 0);
				if (rel == 0) {
					sprintf_s(buffer, sizeof(buffer), "%s/%d_%d.jpeg", imagePath.c_str(), logImage->m_LayerIndex + 1, logImage->m_Type);
					FILE* jpegFile = fopen(buffer, "wb");
					if (jpegFile != NULL) {
						fwrite(changeImage, change_size, 1, jpegFile);
					}
					fclose(jpegFile);
				}
				tjFree(changeImage);
				m_ExportProgress = (float)(i + 1) / m_LogImages.size();
			}
			if (image != NULL)delete[] image;
		}
		LeaveCriticalSection(&m_LogImageCs);
	}

}

void LogDao::LogScannerStatus(vector<ScannerStatus*>& scannerStatus)
{
	char buffer[1024];
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Transaction transaction(*m_pDB);
		for (size_t i = 0; i < scannerStatus.size(); i++) {
			ScannerStatus* ss = scannerStatus[i];
			sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) VALUES(%d,%lld,%d,%u,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%d,%d,%d,%d);",
				ScannerStatus::SCAN_TABLE_NAME.c_str(),
				ScannerStatus::SCAN_FIELD_SCAN_ID.c_str(),
				ScannerStatus::SCAN_FIELD_INSERT_TIME.c_str(),
				ScannerStatus::SCAN_FIELD_JOB_ID.c_str(),
				ScannerStatus::SCAN_FIELD_LAYER_INDEX.c_str(),
				ScannerStatus::SCAN_FIELD_SCAN_TEMP_X.c_str(),
				ScannerStatus::SCAN_FIELD_SCAN_TEMP_Y.c_str(),
				ScannerStatus::SCAN_FIELD_SERVO_TEMP_X.c_str(),
				ScannerStatus::SCAN_FIELD_SERVO_TEMP_Y.c_str(),
				ScannerStatus::SCAN_FIELD_ACTUAL_POSITION_X.c_str(),
				ScannerStatus::SCAN_FIELD_SET_POSITION_X.c_str(),
				ScannerStatus::SCAN_FIELD_POSITION_ERROR_X.c_str(),
				ScannerStatus::SCAN_FIELD_ACTUAL_POSITION_Y.c_str(),
				ScannerStatus::SCAN_FIELD_SET_POSITION_Y.c_str(),
				ScannerStatus::SCAN_FIELD_POSITION_ERROR_Y.c_str(),
				ScannerStatus::SCAN_FIELD_LOW_STATE_X.c_str(),
				ScannerStatus::SCAN_FIELD_LOW_STATE_Y.c_str(),
				ScannerStatus::SCAN_FIELD_HIGH_STATE_X.c_str(),
				ScannerStatus::SCAN_FIELD_HIGH_STATE_Y.c_str(),
				ss->m_ScanId, ss->m_InsertTime, ss->m_JobId, ss->m_LayerIndex, ss->m_ScanTempX, ss->m_ScanTempY, ss->m_ScanServoTempX, ss->m_ScanServoTempY,
				ss->m_ActualPositionX, ss->m_SetPositionX, ss->m_PositionErrorX, ss->m_ActualPositionY, ss->m_SetPositionY, ss->m_PositionErrorY,
				ss->m_LowStateX, ss->m_LowStateY, ss->m_HighStateX, ss->m_HighStateY);
			m_pDB->exec(buffer);
			//OutputDebugString(buffer);
			//OutputDebugString("\n");
		}
		transaction.commit();
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::FindScanState()
{
	if (m_CurrentShowJob == NULL)
		return;

	if (m_DBMap.find(m_CurrentShowJob->m_YearBelong) == m_DBMap.end())
		return;

	SQLite::Database* db = m_DBMap[m_CurrentShowJob->m_YearBelong];

	//	char sql[1024];
	EnterCriticalSection(&m_ScannerStatusCS);
	for (size_t i = 0; i < m_ScannerStatus.size(); ++i) {
		delete m_ScannerStatus[i];
		m_ScannerStatus[i] = NULL;
	}
	m_ScannerStatus.clear();
	LeaveCriticalSection(&m_ScannerStatusCS);

	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s=%d ",
		ScannerStatus::SCAN_TABLE_NAME.c_str(),
		ScannerStatus::SCAN_FIELD_JOB_ID.c_str(), m_CurrentShowJob->m_Id);
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*db, buffer);
		while (query.executeStep()) {
			ScannerStatus* ss = new ScannerStatus();
			ss->m_ScanId = query.getColumn(ScannerStatus::SCAN_FIELD_SCAN_ID.c_str()).getInt();
			ss->m_InsertTime = query.getColumn(ScannerStatus::SCAN_FIELD_INSERT_TIME.c_str()).getInt64();
			ss->m_JobId = query.getColumn(ScannerStatus::SCAN_FIELD_JOB_ID.c_str()).getInt();
			ss->m_LayerIndex = query.getColumn(ScannerStatus::SCAN_FIELD_LAYER_INDEX.c_str()).getUInt();
			ss->m_ScanTempX = query.getColumn(ScannerStatus::SCAN_FIELD_SCAN_TEMP_X.c_str()).getDouble();
			ss->m_ScanTempY = query.getColumn(ScannerStatus::SCAN_FIELD_SCAN_TEMP_Y.c_str()).getDouble();
			ss->m_ScanServoTempX = query.getColumn(ScannerStatus::SCAN_FIELD_SERVO_TEMP_X.c_str()).getDouble();
			ss->m_ScanServoTempY = query.getColumn(ScannerStatus::SCAN_FIELD_SERVO_TEMP_Y.c_str()).getDouble();

			ss->m_ActualPositionX = query.getColumn(ScannerStatus::SCAN_FIELD_ACTUAL_POSITION_X.c_str()).getDouble();
			ss->m_SetPositionX = query.getColumn(ScannerStatus::SCAN_FIELD_SET_POSITION_X.c_str()).getDouble();
			ss->m_PositionErrorX = query.getColumn(ScannerStatus::SCAN_FIELD_POSITION_ERROR_X.c_str()).getDouble();
			ss->m_ActualPositionY = query.getColumn(ScannerStatus::SCAN_FIELD_ACTUAL_POSITION_Y.c_str()).getDouble();
			ss->m_SetPositionY = query.getColumn(ScannerStatus::SCAN_FIELD_SET_POSITION_Y.c_str()).getDouble();
			ss->m_PositionErrorY = query.getColumn(ScannerStatus::SCAN_FIELD_POSITION_ERROR_Y.c_str()).getDouble();

			ss->m_LowStateX = query.getColumn(ScannerStatus::SCAN_FIELD_LOW_STATE_X.c_str()).getInt();
			ss->m_LowStateY = query.getColumn(ScannerStatus::SCAN_FIELD_LOW_STATE_Y.c_str()).getInt();
			ss->m_HighStateX = query.getColumn(ScannerStatus::SCAN_FIELD_HIGH_STATE_X.c_str()).getInt();
			ss->m_HighStateY = query.getColumn(ScannerStatus::SCAN_FIELD_HIGH_STATE_Y.c_str()).getInt();
			EnterCriticalSection(&m_ScannerStatusCS);
			m_ScannerStatus.push_back(ss);
			LeaveCriticalSection(&m_ScannerStatusCS);
		}
		
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::LogFocusStatus(vector<FocusStatus*>& focusStatus)
{
	if (focusStatus.empty())return;
	char buffer[2048];
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Transaction transaction(*m_pDB);
		for (size_t i = 0; i < focusStatus.size(); i++) {
			FocusStatus* ss = focusStatus[i];
			sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) VALUES(%d,%lld,%d,%u,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%d,%d,%d);",
				FocusStatus::TABLE_NAME.c_str(),
				FocusStatus::FIELD_SCAN_ID.c_str(),
				FocusStatus::FIELD_INSERT_TIME.c_str(),
				FocusStatus::FIELD_JOB_ID.c_str(),
				FocusStatus::FIELD_LAYER_INDEX.c_str(),
				FocusStatus::FIELD_SCAN_SERVO_TEMP.c_str(),
				FocusStatus::FIELD_PD_SUPPLY_VOLTAGE.c_str(),
				FocusStatus::FIELD_DSP_CORE_SUPPLY_VOLTAGE.c_str(),
				FocusStatus::FIELD_DSP_IO_VOLTAGE.c_str(),
				FocusStatus::FIELD_ANALOG_SECTION_VOLTAGE.c_str(),
				FocusStatus::FIELD_AD_CONVERTER_SUPPLY_VOLTAGE.c_str(),
				FocusStatus::FIELD_PD_SUPPLY_CURRENT.c_str(),
				FocusStatus::FIELD_LOW_STATE.c_str(),
				FocusStatus::FIELD_HIGH_STATE.c_str(),
				FocusStatus::FIELD_STOP_ENEN.c_str(),
				ss->m_ScanId, ss->m_InsertTime, ss->m_JobId, ss->m_LayerIndex, ss->m_ScanServoTemp, ss->m_PDSupplyVoltage,
				ss->m_DSPCoreSupplyVoltage, ss->m_DSPIOVoltage, ss->m_AnalogSectionVoltage, ss->m_ADConverterSupplyVoltage,
				ss->m_PDSupplyCurrent, ss->m_LowState, ss->m_HighState, ss->m_StopEven);
			m_pDB->exec(buffer);
		}
		transaction.commit();
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::FindFocusState()
{
	if (m_CurrentShowJob == NULL)
		return;

	if (m_DBMap.find(m_CurrentShowJob->m_YearBelong) == m_DBMap.end())
		return;

	SQLite::Database* db = m_DBMap[m_CurrentShowJob->m_YearBelong];

	//	char sql[1024];
	EnterCriticalSection(&m_FocusStatusCS);
	for (size_t i = 0; i < m_FocusStatus.size(); ++i) {
		delete m_FocusStatus[i];
		m_FocusStatus[i] = NULL;
	}
	m_FocusStatus.clear();
	LeaveCriticalSection(&m_FocusStatusCS);

	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s=%d ",
		FocusStatus::TABLE_NAME.c_str(),
		FocusStatus::FIELD_JOB_ID.c_str(), m_CurrentShowJob->m_Id);

	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*db, buffer);
		while (query.executeStep()) {
			FocusStatus* ss = new FocusStatus();
			ss->m_ScanId = query.getColumn(FocusStatus::FIELD_SCAN_ID.c_str()).getInt();
			ss->m_InsertTime = query.getColumn(FocusStatus::FIELD_INSERT_TIME.c_str()).getInt64();
			ss->m_JobId = query.getColumn(FocusStatus::FIELD_JOB_ID.c_str()).getInt();
			ss->m_LayerIndex = query.getColumn(FocusStatus::FIELD_LAYER_INDEX.c_str()).getUInt();
			ss->m_ScanServoTemp = query.getColumn(FocusStatus::FIELD_SCAN_SERVO_TEMP.c_str()).getDouble();
			ss->m_PDSupplyVoltage = query.getColumn(FocusStatus::FIELD_PD_SUPPLY_VOLTAGE.c_str()).getDouble();
			ss->m_DSPCoreSupplyVoltage = query.getColumn(FocusStatus::FIELD_DSP_CORE_SUPPLY_VOLTAGE.c_str()).getDouble();
			ss->m_DSPIOVoltage = query.getColumn(FocusStatus::FIELD_DSP_IO_VOLTAGE.c_str()).getDouble();

			ss->m_AnalogSectionVoltage = query.getColumn(FocusStatus::FIELD_ANALOG_SECTION_VOLTAGE.c_str()).getDouble();
			ss->m_ADConverterSupplyVoltage = query.getColumn(FocusStatus::FIELD_AD_CONVERTER_SUPPLY_VOLTAGE.c_str()).getDouble();
			ss->m_PDSupplyCurrent = query.getColumn(FocusStatus::FIELD_PD_SUPPLY_CURRENT.c_str()).getDouble();

			ss->m_LowState = query.getColumn(FocusStatus::FIELD_LOW_STATE.c_str()).getInt();
			ss->m_HighState = query.getColumn(FocusStatus::FIELD_HIGH_STATE.c_str()).getInt();
			ss->m_StopEven = query.getColumn(FocusStatus::FIELD_STOP_ENEN.c_str()).getInt();
			EnterCriticalSection(&m_FocusStatusCS);
			m_FocusStatus.push_back(ss);
			LeaveCriticalSection(&m_FocusStatusCS);
		}
		
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::SaveScannerPower(ScannerPowerLog* log)
{
	if (!log)return;
	if (log->m_CurrentDatas.empty() || log->m_VoltageDatas.empty())return;
	char buffer[512];
	string strsql = "INSERT INTO %s(%s,%s,%s,%s,%s) VALUES(%lld,%d,%d,?,?)";
	sprintf_s(buffer, sizeof(buffer), strsql.c_str(), ScannerPowerLog::TABLE_NAME.c_str(), ScannerPowerLog::FIELD_INSERT_TIME.c_str(),
		ScannerPowerLog::FIELD_JOB_ID.c_str(), ScannerPowerLog::FIELD_SNO.c_str(),
		ScannerPowerLog::FIELD_VOLTAGE_DATA.c_str(), ScannerPowerLog::FIELD_CURRENT_DATA.c_str(), log->m_InsertTime, log->m_JobId, log->m_Sno);
	float* vdata = NULL;
	float* cdata = NULL;
	EnterCriticalSection(&m_DbCs);
	try {

		SQLite::Statement query(*m_pDB, buffer);
		int vsize = log->m_VoltageDatas.size();
		int csize = log->m_CurrentDatas.size();
		vdata = new float[vsize];
		cdata = new float[csize];
		for (int i = 0; i < vsize; i++) {
			vdata[i] = log->m_VoltageDatas[i];
		}
		for (int i = 0; i < csize; i++) {
			cdata[i] = log->m_CurrentDatas[i];
		}
		query.bind(1, vdata, vsize * sizeof(float));
		query.bind(2, cdata, csize * sizeof(float));
		query.exec();
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}


	LeaveCriticalSection(&m_DbCs);
	if (vdata) {
		delete[]vdata;
		vdata = NULL;
	}
	if (cdata) {
		delete[]cdata;
		cdata = NULL;
	}
}

void LogDao::FindScannerPowerInfo()
{
	if (!m_CurrentShowJob)return;
	for (size_t i = 0; i < m_ScannerPower.size(); ++i) {
		delete m_ScannerPower[i];
		m_ScannerPower[i] = NULL;
	}
	m_ScannerPower.clear();
	if (m_DBMap.find(m_CurrentShowJob->m_YearBelong) == m_DBMap.end()) {
		return;
	}
	SQLite::Database* db = m_DBMap[m_CurrentShowJob->m_YearBelong];
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s,%s,%s FROM %s WHERE %s=%d ",
		ScannerPowerLog::FIELD_ID.c_str(),
		ScannerPowerLog::FIELD_INSERT_TIME.c_str(),
		ScannerPowerLog::FIELD_JOB_ID.c_str(),
		ScannerPowerLog::FIELD_SNO.c_str(),
		ScannerPowerLog::TABLE_NAME.c_str(),
		ScannerPowerLog::FIELD_JOB_ID.c_str(),
		m_CurrentShowJob->m_Id);
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*db, buffer);
		while (query.executeStep()) {
			ScannerPowerLog* log = new ScannerPowerLog();
			log->m_Id = query.getColumn(ScannerPowerLog::FIELD_ID.c_str()).getInt();
			log->m_InsertTime = query.getColumn(ScannerPowerLog::FIELD_INSERT_TIME.c_str()).getInt64();
			log->m_JobId = query.getColumn(ScannerPowerLog::FIELD_JOB_ID.c_str()).getInt();
			log->m_Sno = query.getColumn(ScannerPowerLog::FIELD_SNO.c_str()).getInt();
			m_ScannerPower.push_back(log);
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::FindScannerPowerData(ScannerPowerLog* spl)
{
	if (!spl)return;
	if (!m_CurrentShowJob)return;

	if (m_DBMap.find(m_CurrentShowJob->m_YearBelong) == m_DBMap.end()) {
		return;
	}
	SQLite::Database* db = m_DBMap[m_CurrentShowJob->m_YearBelong];

	spl->m_VoltageDatas.clear();
	spl->m_CurrentDatas.clear();
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT %s,%s FROM %s WHERE %s=%d ",
		ScannerPowerLog::FIELD_VOLTAGE_DATA.c_str(),
		ScannerPowerLog::FIELD_CURRENT_DATA.c_str(),
		ScannerPowerLog::TABLE_NAME.c_str(),
		ScannerPowerLog::FIELD_ID.c_str(), spl->m_Id);
	
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*db, buffer);
		if (query.executeStep()) {
			int vdsize = query.getColumn(ScannerPowerLog::FIELD_VOLTAGE_DATA.c_str()).getBytes() / 4;
			float* vdata = (float*)query.getColumn(ScannerPowerLog::FIELD_VOLTAGE_DATA.c_str()).getBlob();
			for (int i = 0; i < vdsize; i++) {
				spl->m_VoltageDatas.push_back(vdata[i]);
			}

			int cdsize = query.getColumn(ScannerPowerLog::FIELD_CURRENT_DATA.c_str()).getBytes() / 4;
			float* cdata = (float*)query.getColumn(ScannerPowerLog::FIELD_CURRENT_DATA.c_str()).getBlob();
			for (int i = 0; i < cdsize; i++) {
				spl->m_CurrentDatas.push_back(cdata[i]);
			}
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::FindInfraredTempLog()
{
	JobBean* job = m_CurrentShowJob;
	if (job == NULL)return;
	tm tmtemp;
	localtime_s(&tmtemp, &job->m_InsertTime);
	if (m_DBMap.find(m_CurrentShowJob->m_YearBelong) == m_DBMap.end())return;

	SQLite::Database* db = m_DBMap[m_CurrentShowJob->m_YearBelong];

	EnterCriticalSection(&m_InfraredTempCS);

	for (size_t i = 0; i < m_InfraredTempLogs.size(); i++) {
		delete m_InfraredTempLogs[i];
		m_InfraredTempLogs[i] = NULL;
	}
	m_InfraredTempLogs.clear();
	LeaveCriticalSection(&m_InfraredTempCS);

	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s=%d ",
		InfraredTempLog::IT_TABLE_NAME.c_str(),
		InfraredTempLog::IT_FIELD_JOB_ID.c_str(),
		job->m_Id);
	EnterCriticalSection(&m_DbCs);
	try {
		SQLite::Statement query(*db, buffer);
		while (query.executeStep()) {
			InfraredTempLog* log = new InfraredTempLog();
			log->m_Id = query.getColumn(InfraredTempLog::IT_FIELD_ID.c_str()).getInt();
			log->m_PreInsertTime = query.getColumn(InfraredTempLog::IT_FIELD_PRE_INSERT_TIME.c_str()).getInt64();
			log->m_AftInserTime = query.getColumn(InfraredTempLog::IT_FIELD_AFT_INSERT_TIME.c_str()).getInt64();
			log->m_FinishedTime = query.getColumn(InfraredTempLog::IT_FIELD_FINISHED_TIME.c_str()).getInt64();
			log->m_JobId = query.getColumn(InfraredTempLog::IT_FIELD_JOB_ID.c_str()).getInt();
			log->m_LayerIndex = query.getColumn(InfraredTempLog::IT_FIELD_LAYER_INDEX.c_str()).getUInt();
			log->m_PartCount = query.getColumn(InfraredTempLog::IT_FIELD_PART_COUNT.c_str()).getInt();
			SQLite::Column colBlob = query.getColumn(InfraredTempLog::IT_FIELD_TEMP_DATA.c_str());
			int blobsize = colBlob.getBytes();
			if (blobsize > 0) {
				float* pdata = (float*)colBlob.getBlob();
				int count = 0;
				for (int i = 0; i < log->m_PartCount; i++) {
					InfraredTempLog::ITPair itPair;
					//itPair.Pid = pdata[count++];
					itPair.PreCover = pdata[count++];
					itPair.AftCover = pdata[count++];
					itPair.WaitMax = pdata[count++];
					itPair.PrintMax = pdata[count++];
					itPair.m_DifTemp = pdata[count++];
					itPair.m_PowerAdjustValue = pdata[count++];
					log->m_Temps.push_back(itPair);
				}
			}
			EnterCriticalSection(&m_InfraredTempCS);
			m_InfraredTempLogs.push_back(log);
			LeaveCriticalSection(&m_InfraredTempCS);
		}
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);

}

void LogDao::AddInfraredTempLog(InfraredTempLog& log)
{
	if (log.m_PartCount == 0 || log.m_Temps.size() == 0)return;
	if (log.m_PartCount != log.m_Temps.size())return;
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s,%s,%s,%s,%s,%s) VALUES(%lld,%lld,%lld,%lld,%u,%d,?)",
		InfraredTempLog::IT_TABLE_NAME.c_str(),
		InfraredTempLog::IT_FIELD_PRE_INSERT_TIME.c_str(),
		InfraredTempLog::IT_FIELD_AFT_INSERT_TIME.c_str(),
		InfraredTempLog::IT_FIELD_FINISHED_TIME.c_str(),
		InfraredTempLog::IT_FIELD_JOB_ID.c_str(),
		InfraredTempLog::IT_FIELD_LAYER_INDEX.c_str(),
		InfraredTempLog::IT_FIELD_PART_COUNT.c_str(),
		InfraredTempLog::IT_FIELD_TEMP_DATA.c_str(),
		log.m_PreInsertTime, log.m_AftInserTime, log.m_FinishedTime, log.m_JobId, log.m_LayerIndex, log.m_PartCount);
	EnterCriticalSection(&m_DbCs);
	try
	{
		vector<float> datas;
		SQLite::Statement query(*m_pDB, buffer);
		for (size_t i = 0; i < log.m_Temps.size(); i++) {
			//datas.push_back(log.m_Temps[i].Pid);
			datas.push_back(log.m_Temps[i].PreCover);
			datas.push_back(log.m_Temps[i].AftCover);
			datas.push_back(log.m_Temps[i].WaitMax);
			datas.push_back(log.m_Temps[i].PrintMax);
			datas.push_back(log.m_Temps[i].m_DifTemp);
			datas.push_back(log.m_Temps[i].m_PowerAdjustValue);
		}
		if (datas.size() > 0)query.bind(1, &datas[0], datas.size() * sizeof(float));
		else query.bind(1);

		query.exec();
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::AddPartPos(string jid, vector<int>& pids)
{

	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT %s FROM %s WHERE %s='%s'",
		PartPosBean::FIELD_PART_ID.c_str(),
		PartPosBean::CONFIG_NAME.c_str(),
		PartPosBean::FIELD_JOB_ID.c_str(), jid.c_str());
	string selsql(buffer);

	vector<int> hasPart;
	EnterCriticalSection(&m_DbCs);
	try
	{
		SQLite::Statement query(*m_pDB, selsql);
		while (query.executeStep()) {
			int pid = query.getColumn(PartPosBean::FIELD_PART_ID.c_str()).getInt();
			hasPart.push_back(pid);
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	map<int, bool> pidmap;
	for (size_t i = 0; i < hasPart.size(); i++) {
		pidmap[hasPart[i]] = true;
	}
	vector<string> ins;
	for (size_t i = 0; i < pids.size(); i++) {
		if (pidmap.find(pids[i]) == pidmap.end())
		{
			sprintf_s(buffer, sizeof(buffer), "INSERT INTO %s(%s,%s,%s,%s,%s) VALUES('%s',%d,%.6f,%.6f,%.6f) ",
				PartPosBean::CONFIG_NAME.c_str(),
				PartPosBean::FIELD_JOB_ID.c_str(),
				PartPosBean::FIELD_PART_ID.c_str(),
				PartPosBean::FIELD_X_OFFSET.c_str(),
				PartPosBean::FIELD_Y_OFFSET.c_str(),
				PartPosBean::FIELD_ROTATE_ANGLE.c_str(),
				jid.c_str(), pids[i], 0.0f, 0.0f, 0.0f);
			ins.push_back(buffer);
		}
	}
	if (!ins.empty())
	{
		try {
			SQLite::Transaction transaction(*m_pDB);
			for (size_t i = 0; i < ins.size(); ++i) {
				m_pDB->exec(ins[i]);
			}
			transaction.commit();
		}
		catch (SQLite::Exception &e)
		{
			g_log->TraceError(e.getErrorStr());
		}
	}

	LeaveCriticalSection(&m_DbCs);
}

void LogDao::FindPartPos(string jid, vector<PartPosBean*>& partPos)
{
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "SELECT * FROM %s WHERE %s='%s'",
		PartPosBean::CONFIG_NAME.c_str(),
		PartPosBean::FIELD_JOB_ID.c_str(), jid.c_str());
	EnterCriticalSection(&m_DbCs);
	try
	{
		SQLite::Statement query(*m_pDB, buffer);
		while (query.executeStep()) {
			PartPosBean* pa = new PartPosBean();
			pa->m_JobId = query.getColumn(PartPosBean::FIELD_JOB_ID.c_str()).getString();
			pa->m_PartId = query.getColumn(PartPosBean::FIELD_PART_ID.c_str()).getInt();
			pa->m_XOffset = (float)(query.getColumn(PartPosBean::FIELD_X_OFFSET.c_str()).getDouble());
			pa->m_YOffset = (float)(query.getColumn(PartPosBean::FIELD_Y_OFFSET.c_str()).getDouble());
			pa->m_RotateAngle = (float)(query.getColumn(PartPosBean::FIELD_ROTATE_ANGLE.c_str()).getDouble());
			partPos.push_back(pa);
		}
	}
	catch (SQLite::Exception &e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::UpdatePartPos(string jid, int partid, float x, float y, float rotate)
{
	char buffer[1024];
	sprintf_s(buffer, sizeof(buffer), "UPDATE %s SET %s=%.6f,%s=%.6f,%s=%.6f WHERE %s='%s' AND %s=%d",
		PartPosBean::CONFIG_NAME.c_str(),
		PartPosBean::FIELD_X_OFFSET.c_str(), x,
		PartPosBean::FIELD_Y_OFFSET.c_str(), y,
		PartPosBean::FIELD_ROTATE_ANGLE.c_str(), rotate,
		PartPosBean::FIELD_JOB_ID.c_str(), jid.c_str(),
		PartPosBean::FIELD_PART_ID.c_str(), partid);
	EnterCriticalSection(&m_DbCs);
	try {
		m_pDB->exec(buffer);
	}
	catch (SQLite::Exception& e)
	{
		g_log->TraceError(e.getErrorStr());
	}
	LeaveCriticalSection(&m_DbCs);
}

void LogDao::FindRecordByJob()
{
	if (IsFindingRecord())return;
	SetIsFindingRecord(true);
	HANDLE thread = AtlCreateThread(FindRecordProc, this);
}

DWORD WINAPI LogDao::FindRecordProc(LogDao* _this)
{
	if (_this)
	{
		_this->FindRecordRun();
		_this->SetIsFindingRecord(false);
	}
	return 0;
}

void LogDao::FindRecordRun()
{
	FindImageInfo();
	FindAxisLogInfo();
	FindScanState();
	FindScannerPowerInfo();
	FindInfraredTempLog();
	FindFocusState();
	FindIFImageInfo();
	m_LogAssist.yTitle = "PPM";
	if (m_LogAssist.layer_selected_style == 1) {
		GetLayerStatusTable(m_LogAssist);
	}
	else {
		if (m_LogAssist.layer_selected_base == 0) {
			GetLayerStatusByTime(m_LogAssist);
		}
		else {
			GetLayerStatusByLayer(m_LogAssist);
		}
	}
	m_LogAssist.m_SelectedServoLogRow = -1;
	m_ShowAxisLog = NULL;

	m_LogAssist.selected_sp_id = -1;
	m_ShowScannerPower = NULL;

	m_LogAssist.selected_if_id = -1;
	m_ShowInfraredTemp = NULL;
}