#include "HGPdtToolDbImpl.hpp"
#include "HGPdtToolDb.h"
#include "base/HGInc.h"
#include "base/HGInfo.h"
#include "base/HGUtility.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_deviceList.clear();

	curl_global_init(CURL_GLOBAL_ALL);
}

HGPdtToolDbUserMgrImpl::~HGPdtToolDbUserMgrImpl()
{
	curl_global_cleanup();
}

HGResult HGPdtToolDbUserMgrImpl::Create(const HGChar* host, HGUShort port, const HGChar* userName, const HGChar* pwd)
{
	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)
		|| 0 != CreateInspImageTable(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;
	return HGBASE_ERR_OK;
}

HGResult HGPdtToolDbUserMgrImpl::Destroy()
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	while (!m_deviceList.empty())
	{
		delete (*m_deviceList.begin());
	}

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

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

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

	*userStatus = HGPDTTOOLDB_USERSTATUS_OK;
	int connectId = -1;
	std::string takeUserName;
	int ret = GetUserLoginInfo(m_sql, m_userName.c_str(), connectId, takeUserName);
	if (0 != ret)
	{
		*userStatus = HGPDTTOOLDB_USERSTATUS_DBERROR;
	}
	else if (takeUserName == "root" && takeUserName != m_userName)
	{
		*userStatus = HGPDTTOOLDB_USERSTATUS_REFUSE;
	}
	else if (connectId != -1 && connectId != m_connectId)
	{
		*userStatus = HGPDTTOOLDB_USERSTATUS_CONFLICT;
	}

	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)
{
	if (NULL == m_sql)
	{
		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)
{
	if (NULL == m_sql)
	{
		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)
{
	if (NULL == m_sql)
	{
		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)
{
	if (NULL == m_sql)
	{
		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)
{
	if (NULL == m_sql)
	{
		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)
{
	if (NULL == m_sql)
	{
		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)
{
	if (NULL == m_sql)
	{
		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)
{
	if (NULL == m_sql)
	{
		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))
				{
					res = 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)
{
	if (NULL == m_sql)
	{
		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)
{
	if (NULL == m_sql)
	{
		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)
{
	if (NULL == m_sql)
	{
		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)
{
	if (NULL == m_sql)
	{
		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) || 0 != InitInspTestItem("inspection_image", 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 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::CreateInspImageTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists inspection_image (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::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)
{
	if (NULL == m_userMgr->m_sql)
	{
		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)
{
	if (NULL == m_userMgr->m_sql)
	{
		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)
{
	if (NULL == m_userMgr->m_sql)
	{
		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)
{
	if (NULL == m_userMgr->m_sql)
	{
		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)
{
	if (NULL == m_userMgr->m_sql)
	{
		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)
{
	if (NULL == m_userMgr->m_sql)
	{
		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;
}

HGResult HGPdtToolDbDeviceImpl::DownloadEntryImage(HGUInt entryName, const HGChar* ftpHost, HGUShort ftpPort, const HGChar* fileName)
{
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

	const HGChar* entryNameStr = NULL;
	if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
		entryNameStr = IMAGE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
	if (NULL == entryNameStr)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	std::string remotePath;
	HGResult res = GetEntryImageRemotePath(entryNameStr, remotePath);
	if (HGBASE_ERR_OK != res)
	{
		return res;
	}

	if (remotePath.empty())
	{
		return HGBASE_ERR_FAIL;
	}

	return DownloadFile(ftpHost, ftpPort, remotePath.c_str(), fileName);
}

HGResult HGPdtToolDbDeviceImpl::UploadEntryImage(HGUInt entryName, const HGChar* ftpHost, HGUShort ftpPort, const HGChar* fileName)
{
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

	const HGChar* entryNameStr = NULL;
	if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
		entryNameStr = IMAGE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
	if (NULL == entryNameStr)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	std::string remotePath;
	HGResult res = GetEntryImageRemotePath(entryNameStr, remotePath);
	if (HGBASE_ERR_OK != res)
	{
		return res;
	}

	if (remotePath.empty())
	{
		HGChar uuid[256];
		HGBase_GetUuid(uuid, 256);
		remotePath = std::string("/upload/") + uuid + ".jpg";
	}

	res = UploadFile(ftpHost, ftpPort, fileName, remotePath.c_str());
	if (HGBASE_ERR_OK != res)
	{
		return res;
	}

	char sqlCmd[1024] = { 0 };

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

	sprintf(sqlCmd, "update inspection_image set %s = '%s' where sn = '%s';",
		entryNameStr, remotePath.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;
	}

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

HGResult HGPdtToolDbDeviceImpl::GetEntryImageRemotePath(const HGChar* entryNameStr, std::string& remotePath)
{
	assert(NULL != m_userMgr->m_sql);
	assert(NULL != entryNameStr);
	remotePath.clear();

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select %s from inspection_image where sn = '%s';", entryNameStr, 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])
		remotePath = row[0];
	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

static size_t read_callback(char* ptr, size_t size, size_t nmemb, void* stream)
{
	unsigned long nread;
	/* in real-world cases, this would probably get this data differently
	   as this fread() stuff is exactly what the library already would do
	   by default internally */
	size_t retcode = fread(ptr, size, nmemb, (FILE*)stream);

	if (retcode > 0)
	{
		nread = (unsigned long)retcode;
		//fprintf(stderr, "*** We read %lu bytes from file\n", nread);
	}

	return retcode;
}

static int read_xferinfo(void* p, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
{
	HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "ulnow=%lld, ultotal=%lld", ulnow, ultotal);
	return 0;
}

HGResult HGPdtToolDbDeviceImpl::UploadFile(const HGChar* host, HGUShort port, const HGChar* localPath, const HGChar* remotePath)
{
	assert(NULL != host && 0 != *host);
	assert(NULL != localPath && 0 != *localPath);
	assert(NULL != remotePath && 0 != *remotePath);

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

	HGResult ret = HGBASE_ERR_FAIL;
	fseek(file, 0, SEEK_END);
	long fsize = ftell(file);
	fseek(file, 0, SEEK_SET);

	/* get a curl handle */
	CURL* curl = curl_easy_init();
	if (NULL != curl)
	{
		/* we want to use our own read function */
		curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);

		curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);

		char url[512];
		sprintf(url, "ftp://%s:%d%s", host, port, remotePath);
		curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
		curl_easy_setopt(curl, CURLOPT_URL, url);
		curl_easy_setopt(curl, CURLOPT_FTP_CREATE_MISSING_DIRS, 1);

		/* now specify which file to upload */
		curl_easy_setopt(curl, CURLOPT_READDATA, file);

		/* Set the size of the file to upload (optional).  If you give a *_LARGE
		   option you MUST make sure that the type of the passed-in argument is a
		   curl_off_t. If you use CURLOPT_INFILESIZE (without _LARGE) you must
		   make sure that to pass in a type 'long' argument. */
		curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fsize);

		curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, read_xferinfo);
		curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);

		/* Now run off and do what you have been told! */
		CURLcode res = curl_easy_perform(curl);
		/* Check for errors */
		if (res != CURLE_OK)
			fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
		else
			ret = HGBASE_ERR_OK;

		/* always cleanup */
		curl_easy_cleanup(curl);
	}

	fclose(file); /* close the local file */
	return ret;
}

static size_t write_callback(void* ptr, size_t size, size_t nmemb, void* stream)
{
	return fwrite(ptr, size, nmemb, (FILE*)stream);
}

static int write_xferinfo(void* p, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
{
	HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "ulnow=%lld, ultotal=%lld", ulnow, ultotal);
	return 0;
}

HGResult HGPdtToolDbDeviceImpl::DownloadFile(const HGChar* host, HGUShort port, const HGChar* remotePath, const HGChar* localPath)
{
	assert(NULL != host && 0 != *host);
	assert(NULL != remotePath && 0 != *remotePath);
	assert(NULL != localPath && 0 != *localPath);

	FILE* file = fopen(localPath, "wb");
	if (NULL == file)
	{
		return HGBASE_ERR_ACCESSDENIED;
	}

	HGResult ret = HGBASE_ERR_FAIL;

	/* get a curl handle */
	CURL* curl = curl_easy_init();
	if (NULL != curl)
	{
		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);

		char url[512];
		sprintf(url, "ftp://%s:%d%s", host, port, remotePath);
		curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
		curl_easy_setopt(curl, CURLOPT_URL, url);
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, file);

		curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, write_xferinfo);
		curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);

		/* Now run off and do what you have been told! */
		CURLcode res = curl_easy_perform(curl);
		/* Check for errors */
		if (res != CURLE_OK)
			fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
		else
			ret = HGBASE_ERR_OK;

		/* always cleanup */
		curl_easy_cleanup(curl);
	}

	fclose(file); /* close the local file */
	return ret;
}