#include "HGPdtToolDbImpl.hpp"
#include "HGPdtToolDb.h"
#include "base/HGInc.h"
#include "base/HGInfo.h"
#include "base/HGUtility.h"
#include "HGString.h"
#include <vector>

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

	unsigned int timeout = 2;
	mysql_options(sql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout);

	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 != CreateEntryNameCnStrTable(sql) || 0 != CreateMainTestTable(sql)
		|| 0 != CreateInspectionTable(sql, "inspection_test")
		|| 0 != CreateInspectionTable(sql, "inspection_desc")
		|| 0 != CreateInspectionTable(sql, "inspection_image"))
	{
		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.device_name";
	cmd += ", main_test.device_type";
	cmd += ", main_test.device_version";

	std::vector<std::pair<std::string, int>> titleInfo;
	titleInfo.push_back(std::pair<std::string, int>("设备序列号", 1));
	titleInfo.push_back(std::pair<std::string, int>("创建时间", 1));
	titleInfo.push_back(std::pair<std::string, int>("创建用户", 1));
	titleInfo.push_back(std::pair<std::string, int>("最后修改时间", 1));
	titleInfo.push_back(std::pair<std::string, int>("最后修改用户", 1));
	titleInfo.push_back(std::pair<std::string, int>("设备名", 1));
	titleInfo.push_back(std::pair<std::string, int>("设备类型", 1));
	titleInfo.push_back(std::pair<std::string, int>("设备固件版本", 1));

	std::list<std::string> testCols, descCols, imageCols;
	GetCols(m_sql, "inspection_test", testCols);
	GetCols(m_sql, "inspection_desc", descCols);
	GetCols(m_sql, "inspection_image", imageCols);

	for (std::list<std::string>::const_iterator testIter = testCols.begin(); testIter != testCols.end(); ++testIter)
	{
		HGChar entryNameCnStr[256] = {0};
		GetEntryNameCnStr(testIter->c_str(), entryNameCnStr, 256);
		std::string entryNameCn = Utf8ToStdString(entryNameCnStr);
		if (entryNameCn.empty())
			entryNameCn = testIter->c_str();

		cmd += ", inspection_test.";
		cmd += *testIter;
		titleInfo.push_back(std::pair<std::string, int>(entryNameCn, 2));

		for (std::list<std::string>::const_iterator descIter = descCols.begin(); descIter != descCols.end(); ++descIter)
		{
			if (*testIter == *descIter)
			{
				cmd += ", inspection_desc.";
				cmd += *testIter;
				titleInfo.push_back(std::pair<std::string, int>(entryNameCn + "（异常说明）", 1));
				break;
			}
		}

		for (std::list<std::string>::const_iterator imageIter = imageCols.begin(); imageIter != imageCols.end(); ++imageIter)
		{
			if (*testIter == *imageIter)
			{
				cmd += ", inspection_image.";
				cmd += *testIter;
				titleInfo.push_back(std::pair<std::string, int>(entryNameCn + "（图像数量）", 1));
				break;
			}
		}
	}

	cmd += " from main_test";
	cmd += " inner join inspection_test on main_test.sn = inspection_test.sn";
	cmd += " inner join inspection_desc on main_test.sn = inspection_desc.sn";
	cmd += " inner join inspection_image on main_test.sn = inspection_image.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_ACCESSDENIED;
	}

	for (std::vector<std::pair<std::string, int>>::const_iterator titleIter = titleInfo.begin();
		titleIter != titleInfo.end(); ++titleIter)
	{
		std::string t = titleIter->first + "\t";
		fwrite(t.c_str(), 1, t.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 (1 == titleInfo[i].second)
			{
				if (NULL != row[i])
				{
					value = Utf8ToStdString(row[i]);
				}
			}
			else
			{
				assert(NULL != row[i]);
				const HGChar* ENTRY_STATUS_CN[] = { "未测试", "不通过", "不支持", "通过" };
				value = ENTRY_STATUS_CN[(HGUInt)atoll(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::GetEntryNameCnStr(const HGChar* entryName, HGChar* entryNameCnStr, HGUInt maxLen)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

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

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select value from entry_name_cn where name = '%s';", entryName);
	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])
	{
		*entryNameCnStr = '\0';
		mysql_free_result(sqlRes);
		return HGBASE_ERR_OK;
	}

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

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

HGResult HGPdtToolDbUserMgrImpl::SetEntryNameCnStr(const HGChar* entryName, const HGChar* entryNameCnStr)
{
	if (NULL == m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

	char sqlCmd[1024];
	sprintf(sqlCmd, "insert into entry_name_cn (name, value) values ('%s', '%s');", entryName, (NULL != entryNameCnStr) ? entryNameCnStr : "");
	int ret = mysql_query(m_sql, sqlCmd);
	if (0 == ret)
	{
		return HGBASE_ERR_OK;
	}

	if (1062 == mysql_errno(m_sql))
	{
		sprintf(sqlCmd, "update entry_name_cn set value = '%s' where name = '%s';", (NULL != entryNameCnStr) ? entryNameCnStr : "", entryName);
		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 != InitInspectionItem("inspection_test", sn)
		|| 0 != InitInspectionItem("inspection_desc", sn)
		|| 0 != InitInspectionItem("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;
		}
	}
}

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

HGUInt HGPdtToolDbUserMgrImpl::GetCols(MYSQL* sql, const HGChar* tableName, std::list<std::string>& cols)
{
	assert(NULL != sql);
	assert(NULL != tableName && 0 != *tableName);
	cols.clear();

	char sqlCmd[1024];
	sprintf(sqlCmd, "select COLUMN_NAME from information_schema.COLUMNS where table_name = '%s';", tableName);
	int ret = mysql_query(sql, sqlCmd);
	if (0 != ret)
	{
		return HGBASE_ERR_FAIL;
	}

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

	MYSQL_ROW row = NULL;
	while ((row = mysql_fetch_row(sqlRes)) != NULL)
	{
		assert(NULL != row[0]);
		if (0 != strcmp("sn", row[0]))
			cols.push_back(row[0]);
	}

	mysql_free_result(sqlRes);
	return HGBASE_ERR_OK;
}

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::CreateEntryNameCnStrTable(MYSQL* sql)
{
	assert(NULL != sql);

	std::string cmd = "create table if not exists entry_name_cn (name varchar(20) not null primary key";
	cmd += ", value text";
	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 += ", device_name text";
	cmd += ", device_type text";
	cmd += ", device_version text";
	cmd += ");";
	return mysql_query(sql, cmd.c_str());
}

int HGPdtToolDbUserMgrImpl::CreateInspectionTable(MYSQL* sql, const HGChar* tableName)
{
	assert(NULL != sql);
	assert(NULL != tableName && 0 != *tableName);

	char sqlCmd[1024];
	sprintf(sqlCmd, "create table if not exists %s (sn varchar(20) not null primary key);", tableName);
	return mysql_query(sql, sqlCmd);
}

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::InitInspectionItem(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::GetName(HGChar* name, HGUInt maxLen)
{
	return GetProperty("device_name", name, maxLen);
}

HGResult HGPdtToolDbDeviceImpl::SetName(const HGChar* name)
{
	return SetProperty("device_name", name);
}

HGResult HGPdtToolDbDeviceImpl::GetType(HGChar* type, HGUInt maxLen)
{
	return GetProperty("device_type", type, maxLen);
}

HGResult HGPdtToolDbDeviceImpl::SetType(const HGChar* type)
{
	return SetProperty("device_type", type);
}

HGResult HGPdtToolDbDeviceImpl::GetVersion(HGChar* version, HGUInt maxLen)
{
	return GetProperty("device_version", version, maxLen);
}

HGResult HGPdtToolDbDeviceImpl::SetVersion(const HGChar* version)
{
	return SetProperty("device_version", version);
}

HGResult HGPdtToolDbDeviceImpl::GetEntryStatus(const HGChar* entryName, HGUInt* entryStatus)
{
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select %s from inspection_test where sn = '%s';", entryName, 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(const HGChar* entryName, HGUInt entryStatus)
{
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == entryName || 0 == *entryName || entryStatus > HGPDTTOOLDB_ENTRYSTATUS_PASS)
	{
		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, "alter table inspection_test add column %s tinyint unsigned default 0;", entryName);
	mysql_query(m_userMgr->m_sql, sqlCmd);

	sprintf(sqlCmd, "update inspection_test set %s = %u where sn = '%s';", entryName, 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(const HGChar* entryName, HGChar* excepDesc, HGUInt maxLen)
{
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select %s from inspection_desc where sn = '%s';", entryName, 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(const HGChar* entryName, const HGChar* excepDesc)
{
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == entryName || 0 == *entryName)
	{
		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, "alter table inspection_desc add column %s text;", entryName);
	mysql_query(m_userMgr->m_sql, sqlCmd);

	sprintf(sqlCmd, "update inspection_desc set %s = '%s' where sn = '%s';", 
		entryName, (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(const HGChar* entryName, const HGChar* ftpHost, HGUShort ftpPort, HGUInt index, const HGChar* fileName)
{
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

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

	HGUInt count = 0;
	GetEntryImageCount(entryName, &count);
	if (index >= count)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	char remotePath[256];
	sprintf(remotePath, "/upload/%s/%s/%u.jpg", m_sn.c_str(), entryName, index);
	return DownloadFile(ftpHost, ftpPort, remotePath, fileName);
}

HGResult HGPdtToolDbDeviceImpl::GetEntryImageCount(const HGChar* entryName, HGUInt* count)
{
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

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

HGResult HGPdtToolDbDeviceImpl::ClearEntryImage(const HGChar* entryName)
{
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

	if (NULL == entryName || 0 == *entryName)
	{
		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, "alter table inspection_image add column %s int unsigned default 0;", entryName);
	mysql_query(m_userMgr->m_sql, sqlCmd);

	sprintf(sqlCmd, "update inspection_image set %s = 0 where sn = '%s';", entryName, 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::UploadEntryImage(const HGChar* entryName, const HGChar* ftpHost, HGUShort ftpPort, const HGChar* fileName)
{
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

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

	HGUInt count = 0;
	GetEntryImageCount(entryName, &count);

	char remotePath[256];
	sprintf(remotePath, "/upload/%s/%s/%u.jpg", m_sn.c_str(), entryName, count);
	HGResult res = UploadFile(ftpHost, ftpPort, fileName, remotePath);
	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, "alter table inspection_image add column %s int unsigned default 0;", entryName);
	mysql_query(m_userMgr->m_sql, sqlCmd);

	sprintf(sqlCmd, "update inspection_image set %s = %u where sn = '%s';", entryName, count + 1, 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::GetProperty(const HGChar* prop, HGChar* str, HGUInt maxLen)
{
	assert(NULL != prop && 0 != *prop);
	
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "select %s from main_test where sn = '%s';", prop, 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])
	{
		*str = '\0';
		mysql_free_result(sqlRes);
		return HGBASE_ERR_OK;
	}

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

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

HGResult HGPdtToolDbDeviceImpl::SetProperty(const HGChar* prop, const HGChar* str)
{
	assert(NULL != prop && 0 != *prop);
	
	if (NULL == m_userMgr->m_sql)
	{
		return HGBASE_ERR_FAIL;
	}

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

	char sqlCmd[1024] = { 0 };
	sprintf(sqlCmd, "update main_test set %s = '%s', last_modify_time = now(), last_modify_user = '%s' where sn = '%s';",
		prop, str, 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;
}

static size_t read_callback(char* ptr, size_t size, size_t nmemb, void* stream)
{
	return fread(ptr, size, nmemb, (FILE*)stream);
}

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)
			HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", 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;
}