code_production/db/HGPdtToolDb/HGPdtToolDbImpl.cpp

#include "HGPdtToolDbImpl.hpp"
#include "HGPdtToolDb.h"
#include "base/HGInc.h"
#include "base/HGInfo.h"
#include "HGString.h"

const HGChar* INITTIAL_INSPECTION[] =
{
	"dial_switch",
	"rocker_switch",
	"boot_status",
	"lcd_display",
	"clear_paper_path",
	"key_function",
	"counting_mode",
	"skew_detection",
	"separater_motor",
	"cis_original_image",
	"host_fan",
	"ultrasonic_module",
	"led_light",
	"reset",
	"paper_feed",
	"cover_sensor",
	"scanning_sensor"
};

const HGChar* INITTIAL_INSPECTION_CN[] =
{
	"拨码开关校验",
	"检查船型开关功能",
	"设备上电并观察开机状态",
	"检查液晶显示",
	"清理纸道功能确认",
	"按键功能检测",
	"计数模式检测",
	"歪斜检测",
	"分纸电机检测",
	"CIS原图初检",
	"主机风扇功能检测",
	"超声波模块检验",
	"LED灯状态检查",
	"复位检查",
	"走纸检查",
	"开盖传感器检查",
	"扫描传感器检查"
};

const HGChar* IMAGE_INSPECTION[] =
{
	"configure_speed_mode",
	"place_correction_paper",
	"auto_flat_field",
	"reboot_device",
	"image_quality",
	"colorcard_imaging_quality",
	"colorcard_bias_imaging_quality",
	"clarity_quality",
	"distortion",
	"dormancy",
	"skew_gear",
	"paper_separater_strengch",
	"mech_paper_feeding_inclination"
};

const HGChar* IMAGE_INSPECTION_CN[] =
{
	"配置速度模式",
	"放置校正纸",
	"自动平场校正",
	"重启设备",
	"扫描图像质量确认",
	"色卡纸成像质量评估",
	"色卡纸偏色成像质量评估",
	"清晰度质量评估",
	"畸变修正",
	"设置休眠",
	"歪斜挡位检测",
	"分纸强度检测",
	"机械走纸倾斜检测"
};

const HGChar* PRESSURE_INSPECTION[] =
{
	"single_page_test_1",
	"single_page_test_2",
	"single_page_test_3",
	"pressure_test",
	"clear_roller_count"
};

const HGChar* PRESSURE_INSPECTION_CN[] =
{
	"单张测试1",
	"单张测试2",
	"单张测试3",
	"压力测试2轮",
	"清除滚轴计数"
};


HGPdtToolDbUserMgrImpl::HGPdtToolDbUserMgrImpl()
{
	m_sql = NULL;
	m_userName.clear();
	m_connectId = -1;
	m_func = NULL;
	m_param = NULL;
	m_valid = HGFALSE;

	m_lock = NULL;
	m_event = NULL;
	m_stopThread = HGFALSE;
	m_thread = NULL;

	m_deviceList.clear();
}

HGPdtToolDbUserMgrImpl::~HGPdtToolDbUserMgrImpl()
{

}

HGResult HGPdtToolDbUserMgrImpl::Create(const HGChar* host, HGUShort port, const HGChar* userName, const HGChar* pwd,
	HGPdtToolDbUserEventFunc func, HGPointer param)
{
	if (NULL != m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userName || 0 == *userName || NULL == pwd || 0 == *pwd)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	MYSQL* sql = mysql_init(NULL);
	if (NULL == sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == mysql_real_connect(sql, host, "huago", "huago", "huago_production_tool", port, NULL, 0))
	{
		// 连接错误
		mysql_close(sql);
		return HGPDTTOOLDB_ERR_CONNECT;
	}

	std::string password = GetPassword(sql, userName);
	if (password.empty())
	{
		// 用户不存在
		mysql_close(sql);
		return HGPDTTOOLDB_ERR_INVALID_USER;
	}

	std::string authString = GetAuthString(sql, pwd);
	if (password != authString)
	{
		// 密码不正确
		mysql_close(sql);
		return HGPDTTOOLDB_ERR_WRONG_PASSWORD;
	}

	if (0 != CreateFileTable(sql) || 0 != CreateMainTestTable(sql)
		|| 0 != CreateInitInspTestTable(sql) || 0 != CreateInitInspDescTable(sql)
		|| 0 != CreateImgInspTestTable(sql) || 0 != CreateImgInspDescTable(sql)
		|| 0 != CreatePreInspTestTable(sql) || 0 != CreatePreInspDescTable(sql))
	{
		mysql_close(sql);
		return HGBASE_ERR_FAIL;
	}

	int connectId = GetConnectId(sql);
	if (-1 == connectId)
	{
		mysql_close(sql);
		return HGBASE_ERR_FAIL;
	}

	if (0 != SetUserLoginInfo(sql, userName, connectId, userName))
	{
		mysql_close(sql);
		return HGBASE_ERR_FAIL;
	}

	m_sql = sql;
	m_userName = userName;
	m_connectId = connectId;
	m_func = func;
	m_param = param;
	m_valid = HGTRUE;

	HGBase_CreateLock(&m_lock);
	HGBase_CreateEvent(HGTRUE, HGFALSE, &m_event);
	m_stopThread = HGFALSE;
	HGBase_OpenThread(ThreadFunc, this, &m_thread);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::Destroy()
{
	if (NULL == m_sql || !m_deviceList.empty())
	{
		return HGBASE_ERR_FAIL;
	}

	m_stopThread = HGTRUE;
	HGBase_SetEvent(m_event);
	HGBase_CloseThread(m_thread);
	m_thread = NULL;
	HGBase_DestroyEvent(m_event);
	m_event = NULL;
	HGBase_DestroyLock(m_lock);
	m_lock = NULL;

	mysql_close(m_sql);
	m_sql = NULL;
	m_userName.clear();
	m_connectId = -1;
	m_func = NULL;
	m_param = NULL;
	m_valid = HGFALSE;
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::GetUserType(HGUInt* userType)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userType)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	*userType = HGPDTTOOLDB_USERTYPE_NORMAL;
	if (0 == strcmp(m_userName.c_str(), "root"))
		*userType = HGPDTTOOLDB_USERTYPE_ROOT;
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::GetUserName(HGChar* userName, HGUInt maxLen)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userName || 0 == maxLen)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	if (maxLen < m_userName.size() + 1)
	{
		return HGBASE_ERR_FAIL;
	}

	strcpy(userName, m_userName.c_str());
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::RefuseUser(HGChar* userName)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userName || 0 == *userName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	if (0 == strcmp(userName, "root"))
	{
		return HGBASE_ERR_FAIL;
	}

	if (0 != SetUserLoginInfo(m_sql, userName, m_connectId, m_userName))
	{
		return HGBASE_ERR_FAIL;
	}

	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::GetUserList(HGChar** userNameList, HGUInt maxLen, HGUInt* count)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userNameList || 0 == maxLen || NULL == count)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "select user from user_list;");
	int ret = mysql_query(m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES* sqlRes = mysql_use_result(m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	*count = 0;
	MYSQL_ROW row = NULL;
	while ((row = mysql_fetch_row(sqlRes)) != NULL)
	{
		if (*count >= maxLen)
		{
			break;
		}

		assert(NULL != row[0]);
		userNameList[*count] = (HGChar*)malloc(strlen(row[0]) + 1);
		assert(NULL != userNameList[*count]);
		strcpy(userNameList[*count], row[0]);
		++(*count);
	}

	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::ReleaseUserList(HGChar** userNameList, HGUInt count)
{
	if (NULL == userNameList || 0 == count)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	for (HGUInt i = 0; i < count; ++i)
	{
		free(userNameList[i]);
	}

	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::CreateUser(const HGChar* userName, const HGChar* defPwd)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userName || 0 == *userName || NULL == defPwd || 0 == *defPwd)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	if (0 == strcmp(userName, "root"))
	{
		return HGBASE_ERR_FAIL;
	}

	// 事务开始
	int ret = mysql_query(m_sql, "begin;");
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "insert into user_list (user, password) values ('%s', password('%s'));", userName, defPwd);
	ret = mysql_query(m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	sprintf(sqlCmd, "create table %s_config (config_key varchar(40) not null primary key, config_value text);", userName);
	ret = mysql_query(m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	// 事务结束
	ret = mysql_query(m_sql, "commit;");
	assert(0 == ret);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::DestroyUser(const HGChar* userName)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userName || 0 == *userName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	if (0 == strcmp(userName, "root"))
	{
		return HGBASE_ERR_FAIL;
	}

	// 事务开始
	int ret = mysql_query(m_sql, "begin;");
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "delete from user_list where user = '%s';", userName);
	ret = mysql_query(m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	sprintf(sqlCmd, "drop table %s_config;", userName);
	ret = mysql_query(m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	// 事务结束
	ret = mysql_query(m_sql, "commit;");
	assert(0 == ret);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::SetPassword(const HGChar* userName, const HGChar* pwd)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == userName || 0 == *userName || NULL == pwd || 0 == *pwd)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "update user_list set password = password('%s') where user = '%s';", pwd, userName);
	int ret = mysql_query(m_sql, sqlCmd);
	return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
}

HGResult HGPdtToolDbUserMgrImpl::ModifyPassword(const HGChar* oldPwd, const HGChar* newPwd)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == oldPwd || 0 == *oldPwd || NULL == newPwd || 0 == *newPwd)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	std::string password = GetPassword(m_sql, m_userName.c_str());
	assert(!password.empty());

	std::string authString = GetAuthString(m_sql, oldPwd);
	if (password != authString)
	{
		// 旧密码错误
		return HGPDTTOOLDB_ERR_WRONG_PASSWORD;
	}

	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "update user_list set password = password('%s') where user = '%s';", newPwd, m_userName.c_str());
	int ret = mysql_query(m_sql, sqlCmd);
	return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
}

HGResult HGPdtToolDbUserMgrImpl::UploadFile(const HGChar* tag, const HGChar* fileName)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == tag || 0 == *tag || NULL == fileName || 0 == *fileName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGUInt userType = 0;
	GetUserType(&userType);
	if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	FILE* file = fopen(fileName, "rb");
	if (NULL == file)
	{
		return HGBASE_ERR_FILENOTEXIST;
	}

	fseek(file, 0, SEEK_END);
	unsigned long fileSize = ftell(file);
	fseek(file, 0, SEEK_SET);
	if (fileSize <= 0)
	{
		fclose(file);
		return HGBASE_ERR_FILEERROR;
	}

	void* fileData = malloc(fileSize);
	if (NULL == fileData)
	{
		fclose(file);
		return HGBASE_ERR_OUTOFMEMORY;
	}

	if (fileSize != fread(fileData, 1, fileSize, file))
	{
		free(fileData);
		fclose(file);
		return HGBASE_ERR_FAIL;
	}

	HGResult res = HGBASE_ERR_FAIL;
	MYSQL_STMT *stmt = mysql_stmt_init(m_sql);
	assert(NULL != stmt);

	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "insert into file_list (tag, file_data) values ('%s', ?);", tag);
	int ret = mysql_stmt_prepare(stmt, sqlCmd, (unsigned long)strlen(sqlCmd));
	assert(0 == ret);

	MYSQL_BIND bnd = {0};
	bnd.buffer_type = MYSQL_TYPE_BLOB;
	bnd.buffer = fileData;
	bnd.buffer_length = fileSize;
	ret = mysql_stmt_bind_param(stmt, &bnd);
	assert(0 == ret);

	ret = mysql_stmt_execute(stmt);
	if (0 == ret)
	{
		res = HGBASE_ERR_OK;
	}
	else
	{
		if (1062 == mysql_stmt_errno(stmt))
		{
			sprintf(sqlCmd, "update file_list set file_data = ? where tag = '%s';", tag);
			ret = mysql_stmt_prepare(stmt, sqlCmd, (unsigned long)strlen(sqlCmd));
			assert(0 == ret);

			MYSQL_BIND bnd = {0};
			bnd.buffer_type = MYSQL_TYPE_BLOB;
			bnd.buffer = fileData;
			bnd.buffer_length = fileSize;
			ret = mysql_stmt_bind_param(stmt, &bnd);
			assert(0 == ret);

			ret = mysql_stmt_execute(stmt);
			if (0 == ret)
			{
				res = HGBASE_ERR_OK;
			}
		}
	}

	mysql_stmt_close(stmt);
	free(fileData);
	fclose(file);
	return res;
}

HGResult HGPdtToolDbUserMgrImpl::DownloadFile(const HGChar* tag, const HGChar* fileName)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == tag || 0 == *tag || NULL == fileName || 0 == *fileName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGResult res = HGBASE_ERR_FAIL;
	MYSQL_STMT* stmt = mysql_stmt_init(m_sql);
	assert(NULL != stmt);

	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "select file_data from file_list where tag = '%s';", tag);
	int ret = mysql_stmt_prepare(stmt, sqlCmd, (unsigned long)strlen(sqlCmd));
	assert(0 == ret);

	unsigned long readLength = 0;
	MYSQL_BIND bnd = {0};
	bnd.buffer_type = MYSQL_TYPE_BLOB;
	bnd.length = &readLength;
	ret = mysql_stmt_bind_result(stmt, &bnd);
	assert(0 == ret);

	ret = mysql_stmt_execute(stmt);
	assert(0 == ret);
	mysql_stmt_fetch(stmt);

	if (readLength > 0)
	{
		bnd.buffer = malloc(readLength);
		if (NULL != bnd.buffer)
		{
			bnd.buffer_length = readLength;
			ret = mysql_stmt_fetch_column(stmt, &bnd, 0, 0);
			assert(0 == ret);

			FILE* file = fopen(fileName, "wb");
			if (NULL != file)
			{
				if (readLength == fwrite(bnd.buffer, 1, bnd.buffer_length, file))
				{
					ret = HGBASE_ERR_OK;
				}

				fclose(file);
			}
			else
			{
				res = HGBASE_ERR_ACCESSDENIED;
			}

			free(bnd.buffer);
		}
		else
		{
			res = HGBASE_ERR_OUTOFMEMORY;
		}
	}
	
	mysql_stmt_close(stmt);
	return res;
}

HGResult HGPdtToolDbUserMgrImpl::Export(const HGChar* xlsPath)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == xlsPath || 0 == *xlsPath)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	std::string cmd = "select main_test.sn";
	cmd += ", main_test.create_time";
	cmd += ", main_test.create_user";
	cmd += ", main_test.last_modify_time";
	cmd += ", main_test.last_modify_user";
	cmd += ", main_test.current_entry";

	for (int i = 0; i < sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*); ++i)
	{
		cmd += ", initial_inspection_test.";
		cmd += INITTIAL_INSPECTION[i];
		cmd += ", initial_inspection_desc.";
		cmd += INITTIAL_INSPECTION[i];
	}
	for (int i = 0; i < sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*); ++i)
	{
		cmd += ", image_inspection_test.";
		cmd += IMAGE_INSPECTION[i];
		cmd += ", image_inspection_desc.";
		cmd += IMAGE_INSPECTION[i];
	}
	for (int i = 0; i < sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*); ++i)
	{
		cmd += ", pressure_inspection_test.";
		cmd += PRESSURE_INSPECTION[i];
		cmd += ", pressure_inspection_desc.";
		cmd += PRESSURE_INSPECTION[i];
	}

	cmd += " from main_test";
	cmd += " inner join initial_inspection_test on main_test.sn = initial_inspection_test.sn";
	cmd += " inner join initial_inspection_desc on main_test.sn = initial_inspection_desc.sn";
	cmd += " inner join image_inspection_test on main_test.sn = image_inspection_test.sn";
	cmd += " inner join image_inspection_desc on main_test.sn = image_inspection_desc.sn";
	cmd += " inner join pressure_inspection_test on main_test.sn = pressure_inspection_test.sn";
	cmd += " inner join pressure_inspection_desc on main_test.sn = pressure_inspection_desc.sn";
	cmd += ";";

	int ret = mysql_query(m_sql, cmd.c_str());
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES* sqlRes = mysql_use_result(m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	FILE* file = fopen(xlsPath, "wb");
	if (NULL == file)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	const HGChar* MAIN_TEST_CN[] = {"序列号", "创建时间", "创建用户", "最后修改时间", "最后修改用户", "当前测试项"};
	for (int i = 0; i < sizeof(MAIN_TEST_CN) / sizeof(const HGChar*); ++i)
	{
		std::string title = (std::string)MAIN_TEST_CN[i] + "\t";
		fwrite(title.c_str(), 1, title.size(), file);
	}
	for (int i = 0; i < sizeof(INITTIAL_INSPECTION_CN) / sizeof(const HGChar*); ++i)
	{
		std::string title = (std::string)INITTIAL_INSPECTION_CN[i] + "\t";
		fwrite(title.c_str(), 1, title.size(), file);
		std::string descTitle = (std::string)INITTIAL_INSPECTION_CN[i] + "异常说明" + "\t";
		fwrite(descTitle.c_str(), 1, descTitle.size(), file);
	}
	for (int i = 0; i < sizeof(IMAGE_INSPECTION_CN) / sizeof(const HGChar*); ++i)
	{
		std::string title = (std::string)IMAGE_INSPECTION_CN[i] + "\t";
		fwrite(title.c_str(), 1, title.size(), file);
		std::string descTitle = (std::string)IMAGE_INSPECTION_CN[i] + "异常说明" + "\t";
		fwrite(descTitle.c_str(), 1, descTitle.size(), file);
	}
	for (int i = 0; i < sizeof(PRESSURE_INSPECTION_CN) / sizeof(const HGChar*); ++i)
	{
		std::string title = (std::string)PRESSURE_INSPECTION_CN[i] + "\t";
		fwrite(title.c_str(), 1, title.size(), file);
		std::string descTitle = (std::string)PRESSURE_INSPECTION_CN[i] + "异常说明" + "\t";
		fwrite(descTitle.c_str(), 1, descTitle.size(), file);
	}
	fwrite("\n", 1, strlen("\n"), file);

	MYSQL_ROW row = NULL;
	while ((row = mysql_fetch_row(sqlRes)) != NULL)
	{
		unsigned int cols = mysql_num_fields(sqlRes);
		for (unsigned int i = 0; i < cols; ++i)
		{
			std::string value;

			if (i < 5)
			{
				assert(NULL != row[i]);
				value = row[i];
			}
			else if (i == 5)
			{
				assert(NULL != row[i]);
				value = GetEntryNameCnStr((HGUInt)atoll(row[i]));
			}
			else
			{
				if (0 == (i - 6) % 2)
				{
					assert(NULL != row[i]);
					const HGChar* ENTRY_STATUS_CN[] = { "未测试", "不通过", "不支持", "通过" };
					value = ENTRY_STATUS_CN[(HGUInt)atoll(row[i])];
				}
				else
				{
					if (NULL != row[i])
					{
						value = Utf8ToStdString(row[i]);
					}
				}
			}

			value += "\t";
			fwrite(value.c_str(), 1, value.size(), file);
		}

		fwrite("\n", 1, strlen("\n"), file);
	}

	fclose(file);
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::GetConfig(const HGChar* key, HGChar* value, HGUInt maxLen)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == key || 0 == *key || NULL == value || 0 == maxLen)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select config_value from %s_config where config_key = '%s';", m_userName.c_str(), key);
	int ret = mysql_query(m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES* sqlRes = mysql_use_result(m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_ROW row = mysql_fetch_row(sqlRes);
	if (NULL == row)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	if (NULL == row[0])
	{
		*value = '\0';
		mysql_free_result(sqlRes);
		return HGBASE_ERR_OK;
	}

	if (maxLen < strlen(row[0]) + 1)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	strcpy(value, row[0]);
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::SetConfig(const HGChar* key, const HGChar* value)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == key || 0 == *key)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "insert into %s_config (config_key, config_value) values ('%s', '%s');", 
		m_userName.c_str(), key, (NULL != value) ? value : "");
	int ret = mysql_query(m_sql, sqlCmd);
	if (0 == ret)
	{
		return HGBASE_ERR_OK;
	}

	if (1062 == mysql_errno(m_sql))
	{
		sprintf(sqlCmd, "update %s_config set config_value = '%s' where config_key = '%s';",
			m_userName.c_str(), (NULL != value) ? value : "", key);
		int ret = mysql_query(m_sql, sqlCmd);
		return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
	}

	return HGBASE_ERR_FAIL;
}

HGResult HGPdtToolDbUserMgrImpl::OpenDevice(const HGChar* sn, class HGPdtToolDbDeviceImpl** deviceImpl)
{
	HGBase_EnterLock(m_lock);
	HGBool valid = m_valid;
	HGBase_LeaveLock(m_lock);
	if (NULL == m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == sn || 0 == *sn || NULL == deviceImpl)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	// 事务开始
	int ret = mysql_query(m_sql, "begin;");
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	if (0 != InitMainTestItem(sn) || 0 != InitInspTestItem("initial_inspection_test", sn)
		|| 0 != InitInspTestItem("initial_inspection_desc", sn) || 0 != InitInspTestItem("image_inspection_test", sn)
		|| 0 != InitInspTestItem("image_inspection_desc", sn) || 0 != InitInspTestItem("pressure_inspection_test", sn)
		|| 0 != InitInspTestItem("pressure_inspection_desc", sn))
	{
		mysql_query(m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	// 事务结束
	ret = mysql_query(m_sql, "commit;");
	assert(0 == ret);

	*deviceImpl = new HGPdtToolDbDeviceImpl(this, sn);
	m_deviceList.push_back(*deviceImpl);
	return HGBASE_ERR_OK;
}

void HGAPI HGPdtToolDbUserMgrImpl::ThreadFunc(HGThread thread, HGPointer param)
{
	HGPdtToolDbUserMgrImpl* p = (HGPdtToolDbUserMgrImpl*)param;
	while (!p->m_stopThread)
	{
		HGUInt event = 0;

		int connectId = -1;
		std::string takeUserName;
		int ret = GetUserLoginInfo(p->m_sql, p->m_userName.c_str(), connectId, takeUserName);
		if (0 != ret)
		{
			event = HGPDTTOOLDB_USEREVENT_DBERROR;
		}
		else if (takeUserName == "root" && takeUserName != p->m_userName)
		{
			event = HGPDTTOOLDB_USEREVENT_REFUSE;
		}
		else if (connectId != -1 && connectId != p->m_connectId)
		{
			event = HGPDTTOOLDB_USEREVENT_CONFLICT;
		}

		if (0 != event)
		{
			HGBase_EnterLock(p->m_lock);
			p->m_valid = HGFALSE;
			HGBase_LeaveLock(p->m_lock);

			if (NULL != p->m_func)
				p->m_func((HGPdtToolDbUserMgr)p, event, p->m_param);
			break;
		}

		HGBase_WaitEventTimeout(p->m_event, 1000);
	}
}

void HGPdtToolDbUserMgrImpl::RemoveDevice(class HGPdtToolDbDeviceImpl* deviceImpl)
{
	std::list<class HGPdtToolDbDeviceImpl*>::iterator iter;
	for (iter = m_deviceList.begin(); iter != m_deviceList.end(); ++iter)
	{
		if (deviceImpl == *iter)
		{
			m_deviceList.erase(iter);
			break;
		}
	}
}

const HGChar* HGPdtToolDbUserMgrImpl::GetEntryNameCnStr(HGUInt entryName)
{
	if (0 == entryName)
		return "未开始测试";
	else if (0xFFFFFFFF == entryName)
		return "已完成测试";
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
		return INITTIAL_INSPECTION_CN[entryName - HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH];
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
		return IMAGE_INSPECTION_CN[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
		return PRESSURE_INSPECTION_CN[entryName - HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1];
	return NULL;
}

std::string HGPdtToolDbUserMgrImpl::GetPassword(MYSQL* sql, const HGChar* userName)
{
	assert(NULL != sql);
	assert(NULL != userName && 0 != *userName);

	std::string password;
	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select password from user_list where user = '%s';", userName);
	int ret = mysql_query(sql, sqlCmd);
	if (0 == ret)
	{
		MYSQL_RES* sqlRes = mysql_use_result(sql);
		if (NULL != sqlRes)
		{
			MYSQL_ROW row = mysql_fetch_row(sqlRes);
			if (NULL != row && NULL != row[0])
				password = row[0];
			mysql_free_result(sqlRes);
		}
	}

	return password;
}

std::string HGPdtToolDbUserMgrImpl::GetAuthString(MYSQL* sql, const HGChar* pwd)
{
	assert(NULL != sql);
	assert(NULL != pwd && 0 != *pwd);

	std::string authString;
	char sqlCmd[1024] = {0};
	sprintf(sqlCmd, "select password('%s');", pwd);
	int ret = mysql_query(sql, sqlCmd);
	if (0 == ret)
	{
		MYSQL_RES* sqlRes = mysql_use_result(sql);
		if (NULL != sqlRes)
		{
			MYSQL_ROW row = mysql_fetch_row(sqlRes);
			if (NULL != row && NULL != row[0])
				authString = row[0];
			mysql_free_result(sqlRes);
		}
	}

	return authString;
}

int HGPdtToolDbUserMgrImpl::GetConnectId(MYSQL* sql)
{
	assert(NULL != sql);

	int connId = -1;
	char sqlCmd[1024];
	sprintf(sqlCmd, "select connection_id();");
	int ret = mysql_query(sql, sqlCmd);
	if (0 == ret)
	{
		MYSQL_RES* sqlRes = mysql_use_result(sql);
		if (NULL != sqlRes)
		{
			MYSQL_ROW row = mysql_fetch_row(sqlRes);
			if (NULL != row && NULL != row[0])
				connId = atoi(row[0]);
			mysql_free_result(sqlRes);
		}
	}

	return connId;
}

int HGPdtToolDbUserMgrImpl::SetUserLoginInfo(MYSQL* sql, const HGChar* userName, int connectId, const std::string& takeUserName)
{
	assert(NULL != sql);
	assert(NULL != userName && 0 != *userName);
	assert(-1 != connectId);
	assert(!takeUserName.empty());

	char sqlCmd[1024];
	sprintf(sqlCmd, "update user_list set connect_id = %d, take_user = '%s' where user = '%s';", 
		connectId, takeUserName.c_str(), userName);
	return mysql_query(sql, sqlCmd);
}

int HGPdtToolDbUserMgrImpl::GetUserLoginInfo(MYSQL* sql, const HGChar* userName, int& connectId, std::string& takeUserName)
{
	assert(NULL != sql);
	assert(NULL != userName && 0 != *userName);
	connectId = -1;
	takeUserName.clear();

	char sqlCmd[1024];
	sprintf(sqlCmd, "select connect_id, take_user from user_list where user = '%s';", userName);
	int ret = mysql_query(sql, sqlCmd);
	if (0 != ret)
	{
		return ret;
	}

	MYSQL_RES* sqlRes = mysql_use_result(sql);
	if (NULL != sqlRes)
	{
		MYSQL_ROW row = mysql_fetch_row(sqlRes);
		if (NULL != row)
		{
			assert(NULL != row[0] && NULL != row[1]);
			connectId = atoi(row[0]);
			takeUserName = row[1];
		}
	
		mysql_free_result(sqlRes);
	}

	return 0;
}

int HGPdtToolDbUserMgrImpl::CreateFileTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists file_list (tag varchar(20) not null primary key";
	cmd += ", file_data blob";
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreateMainTestTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists main_test (sn varchar(20) not null primary key";
	cmd += ", create_time datetime";
	cmd += ", create_user text not null";
	cmd += ", last_modify_time datetime";
	cmd += ", last_modify_user text not null";
	cmd += ", current_entry int unsigned default 0";
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreateInitInspTestTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists initial_inspection_test (sn varchar(20) not null primary key";
	int size = sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += INITTIAL_INSPECTION[i];
		cmd += " tinyint unsigned default 0";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreateInitInspDescTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists initial_inspection_desc (sn varchar(20) not null primary key";
	int size = sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += INITTIAL_INSPECTION[i];
		cmd += " text";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreateImgInspTestTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists image_inspection_test (sn varchar(20) not null primary key";
	int size = sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += IMAGE_INSPECTION[i];
		cmd += " tinyint unsigned default 0";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreateImgInspDescTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists image_inspection_desc (sn varchar(20) not null primary key";
	int size = sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += IMAGE_INSPECTION[i];
		cmd += " text";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreatePreInspTestTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists pressure_inspection_test (sn varchar(20) not null primary key";
	int size = sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += PRESSURE_INSPECTION[i];
		cmd += " tinyint unsigned default 0";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreatePreInspDescTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists pressure_inspection_desc (sn varchar(20) not null primary key";
	int size = sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*);
	for (int i = 0; i < size; ++i)
	{
		cmd += ", ";
		cmd += PRESSURE_INSPECTION[i];
		cmd += " text";
	}
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::InitMainTestItem(const HGChar* sn)
{
	assert(NULL != sn && 0 != *sn && NULL != m_sql);

	std::string title = "(sn, create_time, create_user, last_modify_time, last_modify_user)";
	std::string value = "('" + (std::string)sn + "', now(), '" + m_userName + "', now(), '" + m_userName + "')";
	std::string cmd = (std::string)"insert into main_test " + title + " values " + value + ";";
	int ret = mysql_query(m_sql, cmd.c_str());
	return (1062 == mysql_errno(m_sql)) ? 0 : ret;
}

int HGPdtToolDbUserMgrImpl::InitInspTestItem(const HGChar* tableName, const HGChar* sn)
{
	assert(NULL != tableName && 0 != *tableName);
	assert(NULL != sn && 0 != *sn && NULL != m_sql);

	char sqlCmd[1024];
	sprintf(sqlCmd, "insert into %s (sn) values ('%s');", tableName, sn);
	int ret = mysql_query(m_sql, sqlCmd);
	return (1062 == mysql_errno(m_sql)) ? 0 : ret;
}


HGPdtToolDbDeviceImpl::HGPdtToolDbDeviceImpl(class HGPdtToolDbUserMgrImpl* userMgr, const HGChar* sn)
{
	m_userMgr = userMgr;
	m_sn = sn;
}

HGPdtToolDbDeviceImpl::~HGPdtToolDbDeviceImpl()
{
	m_userMgr->RemoveDevice(this);
}

HGResult HGPdtToolDbDeviceImpl::GetCurrEntry(HGUInt* entryName)
{
	HGBase_EnterLock(m_userMgr->m_lock);
	HGBool valid = m_userMgr->m_valid;
	HGBase_LeaveLock(m_userMgr->m_lock);
	if (NULL == m_userMgr->m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == entryName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select current_entry from main_test where sn = '%s';", m_sn.c_str());
	int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES* sqlRes = mysql_use_result(m_userMgr->m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_ROW row = mysql_fetch_row(sqlRes);
	if (NULL == row)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	assert(NULL != row[0]);
	*entryName = (HGUInt)atoll(row[0]);
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbDeviceImpl::SetCurrEntry(HGUInt entryName)
{
	HGBase_EnterLock(m_userMgr->m_lock);
	HGBool valid = m_userMgr->m_valid;
	HGBase_LeaveLock(m_userMgr->m_lock);
	if (NULL == m_userMgr->m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (0 != entryName && 0xFFFFFFFF != entryName)
	{
		const HGChar* entryNameStr = GetEntryNameStr(entryName);
		if (NULL == entryNameStr)
		{
			return HGBASE_ERR_FAIL;
		}
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "update main_test set current_entry = %u, last_modify_time = now(), last_modify_user = '%s' where sn = '%s';", 
		entryName, m_userMgr->m_userName.c_str(), m_sn.c_str());
	int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
}

HGResult HGPdtToolDbDeviceImpl::GetEntryStatus(HGUInt entryName, HGUInt* entryStatus)
{
	HGBase_EnterLock(m_userMgr->m_lock);
	HGBool valid = m_userMgr->m_valid;
	HGBase_LeaveLock(m_userMgr->m_lock);
	if (NULL == m_userMgr->m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == entryStatus)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	const HGChar* entryNameStr = GetEntryNameStr(entryName);
	const HGChar* tableName = GetTestTableName(entryName);
	if (NULL == entryNameStr || NULL == tableName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select %s from %s where sn = '%s';", entryNameStr, tableName, m_sn.c_str());
	int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES *sqlRes = mysql_use_result(m_userMgr->m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_ROW row = mysql_fetch_row(sqlRes);
	if (NULL == row)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	assert(NULL != row[0]);
	*entryStatus = (HGUInt)atoll(row[0]);
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbDeviceImpl::SetEntryStatus(HGUInt entryName, HGUInt entryStatus)
{
	HGBase_EnterLock(m_userMgr->m_lock);
	HGBool valid = m_userMgr->m_valid;
	HGBase_LeaveLock(m_userMgr->m_lock);
	if (NULL == m_userMgr->m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (entryStatus > HGPDTTOOLDB_ENTRYSTATUS_PASS)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	const HGChar* entryNameStr = GetEntryNameStr(entryName);
	const HGChar* tableName = GetTestTableName(entryName);
	if (NULL == entryNameStr || NULL == tableName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };

	// 事务开始
	int ret = mysql_query(m_userMgr->m_sql, "begin;");
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	sprintf(sqlCmd, "update %s set %s = %u where sn = '%s';", tableName, entryNameStr, entryStatus, m_sn.c_str());
	ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_userMgr->m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	sprintf(sqlCmd, "update main_test set last_modify_time = now(), last_modify_user = '%s' where sn = '%s';", 
		m_userMgr->m_userName.c_str(), m_sn.c_str());
	ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_userMgr->m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	// 事务结束
	ret = mysql_query(m_userMgr->m_sql, "commit;");
	assert(0 == ret);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbDeviceImpl::GetEntryExcepDesc(HGUInt entryName, HGChar* excepDesc, HGUInt maxLen)
{
	HGBase_EnterLock(m_userMgr->m_lock);
	HGBool valid = m_userMgr->m_valid;
	HGBase_LeaveLock(m_userMgr->m_lock);
	if (NULL == m_userMgr->m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == excepDesc || 0 == maxLen)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	const HGChar* entryNameStr = GetEntryNameStr(entryName);
	const HGChar* tableName = GetDescTableName(entryName);
	if (NULL == entryNameStr || NULL == tableName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select %s from %s where sn = '%s';", entryNameStr, tableName, m_sn.c_str());
	int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_RES* sqlRes = mysql_use_result(m_userMgr->m_sql);
	if (NULL == sqlRes)
	{
		return HGBASE_ERR_FAIL;
	}

	MYSQL_ROW row = mysql_fetch_row(sqlRes);
	if (NULL == row)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	if (NULL == row[0])
	{
		*excepDesc = '\0';
		mysql_free_result(sqlRes);
		return HGBASE_ERR_OK;
	}

	if (maxLen < strlen(row[0]) + 1)
	{
		mysql_free_result(sqlRes);
		return HGBASE_ERR_FAIL;
	}

	strcpy(excepDesc, row[0]);
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbDeviceImpl::SetEntryExcepDesc(HGUInt entryName, const HGChar* excepDesc)
{
	HGBase_EnterLock(m_userMgr->m_lock);
	HGBool valid = m_userMgr->m_valid;
	HGBase_LeaveLock(m_userMgr->m_lock);
	if (NULL == m_userMgr->m_sql || !valid)
	{
		return HGBASE_ERR_FAIL;
	}

	const HGChar* entryNameStr = GetEntryNameStr(entryName);
	const HGChar* tableName = GetDescTableName(entryName);
	if (NULL == entryNameStr || NULL == tableName)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char sqlCmd[1024] = { 0 };

	// 事务开始
	int ret = mysql_query(m_userMgr->m_sql, "begin;");
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

	sprintf(sqlCmd, "update %s set %s = '%s' where sn = '%s';", 
		tableName, entryNameStr, (NULL != excepDesc) ? excepDesc : "", m_sn.c_str());
	ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_userMgr->m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	sprintf(sqlCmd, "update main_test set last_modify_time = now(), last_modify_user = '%s' where sn = '%s';",
		m_userMgr->m_userName.c_str(), m_sn.c_str());
	ret = mysql_query(m_userMgr->m_sql, sqlCmd);
	if (0 != ret)
	{
		mysql_query(m_userMgr->m_sql, "rollback;");
		return HGBASE_ERR_FAIL;
	}

	// 事务结束
	ret = mysql_query(m_userMgr->m_sql, "commit;");
	assert(0 == ret);
	return HGBASE_ERR_OK;
}

const HGChar* HGPdtToolDbDeviceImpl::GetEntryNameStr(HGUInt entryName)
{
	if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
		return INITTIAL_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH];
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
		return IMAGE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
		return PRESSURE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1];
	return NULL;
}

const HGChar* HGPdtToolDbDeviceImpl::GetTestTableName(HGUInt entryName)
{
	if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
		return "initial_inspection_test";
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
		return "image_inspection_test";
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
		return "pressure_inspection_test";
	return NULL;
}

const HGChar* HGPdtToolDbDeviceImpl::GetDescTableName(HGUInt entryName)
{
	if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
		return "initial_inspection_desc";
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
		return "image_inspection_desc";
	else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
		return "pressure_inspection_desc";
	return NULL;
}