2022-12-08 09:40:43 +00:00
|
|
|
|
#include "HGPdtToolDbImpl.hpp"
|
|
|
|
|
#include "HGPdtToolDb.h"
|
|
|
|
|
#include "base/HGInc.h"
|
2022-12-15 11:52:15 +00:00
|
|
|
|
#include "base/HGInfo.h"
|
2022-12-22 06:41:47 +00:00
|
|
|
|
#include "base/HGUtility.h"
|
2022-12-08 09:40:43 +00:00
|
|
|
|
#include "HGString.h"
|
2023-01-03 10:11:21 +00:00
|
|
|
|
#include <vector>
|
2022-12-08 09:40:43 +00:00
|
|
|
|
|
|
|
|
|
HGPdtToolDbUserMgrImpl::HGPdtToolDbUserMgrImpl()
|
|
|
|
|
{
|
|
|
|
|
m_sql = NULL;
|
2022-12-09 09:39:01 +00:00
|
|
|
|
m_userName.clear();
|
2022-12-15 07:13:21 +00:00
|
|
|
|
m_connectId = -1;
|
2022-12-08 09:40:43 +00:00
|
|
|
|
m_deviceList.clear();
|
2022-12-22 06:41:47 +00:00
|
|
|
|
|
|
|
|
|
curl_global_init(CURL_GLOBAL_ALL);
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGPdtToolDbUserMgrImpl::~HGPdtToolDbUserMgrImpl()
|
|
|
|
|
{
|
2022-12-22 06:41:47 +00:00
|
|
|
|
curl_global_cleanup();
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 02:07:16 +00:00
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::Create(const HGChar* host, HGUShort port, const HGChar* userName, const HGChar* pwd)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
if (NULL != m_sql)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-12 09:05:43 +00:00
|
|
|
|
if (NULL == userName || 0 == *userName || NULL == pwd || 0 == *pwd)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
MYSQL* sql = mysql_init(NULL);
|
|
|
|
|
if (NULL == sql)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-26 06:33:14 +00:00
|
|
|
|
unsigned int timeout = 2;
|
2022-12-27 01:55:42 +00:00
|
|
|
|
mysql_options(sql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout);
|
2022-12-26 06:33:14 +00:00
|
|
|
|
|
2022-12-12 09:05:43 +00:00
|
|
|
|
if (NULL == mysql_real_connect(sql, host, "huago", "huago", "huago_production_tool", port, NULL, 0))
|
2022-12-09 10:17:18 +00:00
|
|
|
|
{
|
2022-12-12 09:05:43 +00:00
|
|
|
|
// 连接错误
|
2022-12-09 10:17:18 +00:00
|
|
|
|
mysql_close(sql);
|
2022-12-12 09:49:04 +00:00
|
|
|
|
return HGPDTTOOLDB_ERR_CONNECT;
|
2022-12-09 10:17:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-12-12 09:05:43 +00:00
|
|
|
|
std::string password = GetPassword(sql, userName);
|
|
|
|
|
if (password.empty())
|
2022-12-09 10:17:18 +00:00
|
|
|
|
{
|
2022-12-12 09:05:43 +00:00
|
|
|
|
// 用户不存在
|
2022-12-09 10:17:18 +00:00
|
|
|
|
mysql_close(sql);
|
2022-12-12 09:49:04 +00:00
|
|
|
|
return HGPDTTOOLDB_ERR_INVALID_USER;
|
2022-12-09 10:17:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-12-12 09:05:43 +00:00
|
|
|
|
std::string authString = GetAuthString(sql, pwd);
|
|
|
|
|
if (password != authString)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
2022-12-12 09:05:43 +00:00
|
|
|
|
// 密码不正确
|
2022-12-08 09:40:43 +00:00
|
|
|
|
mysql_close(sql);
|
2022-12-12 09:49:04 +00:00
|
|
|
|
return HGPDTTOOLDB_ERR_WRONG_PASSWORD;
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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"))
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
mysql_close(sql);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-15 07:13:21 +00:00
|
|
|
|
int connectId = GetConnectId(sql);
|
|
|
|
|
if (-1 == connectId)
|
|
|
|
|
{
|
|
|
|
|
mysql_close(sql);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-15 10:21:28 +00:00
|
|
|
|
if (0 != SetUserLoginInfo(sql, userName, connectId, userName))
|
2022-12-15 07:13:21 +00:00
|
|
|
|
{
|
|
|
|
|
mysql_close(sql);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
m_sql = sql;
|
2022-12-09 09:39:01 +00:00
|
|
|
|
m_userName = userName;
|
2022-12-15 07:13:21 +00:00
|
|
|
|
m_connectId = connectId;
|
2022-12-08 09:40:43 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::Destroy()
|
|
|
|
|
{
|
2022-12-22 01:28:15 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 02:07:16 +00:00
|
|
|
|
while (!m_deviceList.empty())
|
2022-12-22 01:28:15 +00:00
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
delete (*m_deviceList.begin());
|
2022-12-22 01:28:15 +00:00
|
|
|
|
}
|
2022-12-15 07:13:21 +00:00
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
mysql_close(m_sql);
|
|
|
|
|
m_sql = NULL;
|
2022-12-09 09:39:01 +00:00
|
|
|
|
m_userName.clear();
|
2022-12-15 07:13:21 +00:00
|
|
|
|
m_connectId = -1;
|
2022-12-22 02:07:16 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-09 09:39:01 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-15 07:13:21 +00:00
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::RefuseUser(HGChar* userName)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-15 07:13:21 +00:00
|
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-15 10:21:28 +00:00
|
|
|
|
if (0 != SetUserLoginInfo(m_sql, userName, m_connectId, m_userName))
|
2022-12-15 07:13:21 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-09 09:39:01 +00:00
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::GetUserList(HGChar** userNameList, HGUInt maxLen, HGUInt* count)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-09 09:39:01 +00:00
|
|
|
|
{
|
|
|
|
|
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};
|
2022-12-12 09:05:43 +00:00
|
|
|
|
sprintf(sqlCmd, "select user from user_list;");
|
2022-12-09 09:39:01 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-12 09:49:04 +00:00
|
|
|
|
assert(NULL != row[0]);
|
2022-12-12 09:05:43 +00:00
|
|
|
|
userNameList[*count] = (HGChar*)malloc(strlen(row[0]) + 1);
|
|
|
|
|
assert(NULL != userNameList[*count]);
|
|
|
|
|
strcpy(userNameList[*count], row[0]);
|
|
|
|
|
++(*count);
|
2022-12-09 09:39:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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]);
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-09 09:39:01 +00:00
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::CreateUser(const HGChar* userName, const HGChar* defPwd)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-09 09:39:01 +00:00
|
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-13 02:27:22 +00:00
|
|
|
|
// 事务开始
|
|
|
|
|
int ret = mysql_query(m_sql, "begin;");
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-09 09:39:01 +00:00
|
|
|
|
char sqlCmd[1024] = {0};
|
2022-12-12 09:05:43 +00:00
|
|
|
|
sprintf(sqlCmd, "insert into user_list (user, password) values ('%s', password('%s'));", userName, defPwd);
|
2022-12-13 02:27:22 +00:00
|
|
|
|
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;
|
2022-12-09 09:39:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::DestroyUser(const HGChar* userName)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-09 09:39:01 +00:00
|
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-13 02:27:22 +00:00
|
|
|
|
// 事务开始
|
|
|
|
|
int ret = mysql_query(m_sql, "begin;");
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-09 09:39:01 +00:00
|
|
|
|
char sqlCmd[1024] = { 0 };
|
2022-12-13 02:27:22 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-12 03:41:26 +00:00
|
|
|
|
sprintf(sqlCmd, "drop table %s_config;", userName);
|
2022-12-13 02:27:22 +00:00
|
|
|
|
ret = mysql_query(m_sql, sqlCmd);
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
mysql_query(m_sql, "rollback;");
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
2022-12-12 03:41:26 +00:00
|
|
|
|
|
2022-12-13 02:27:22 +00:00
|
|
|
|
// 事务结束
|
|
|
|
|
ret = mysql_query(m_sql, "commit;");
|
|
|
|
|
assert(0 == ret);
|
|
|
|
|
return HGBASE_ERR_OK;
|
2022-12-09 09:39:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::SetPassword(const HGChar* userName, const HGChar* pwd)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-09 09:39:01 +00:00
|
|
|
|
{
|
|
|
|
|
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 };
|
2022-12-12 09:05:43 +00:00
|
|
|
|
sprintf(sqlCmd, "update user_list set password = password('%s') where user = '%s';", pwd, userName);
|
2022-12-09 09:39:01 +00:00
|
|
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
|
|
|
return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-12 02:32:01 +00:00
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::ModifyPassword(const HGChar* oldPwd, const HGChar* newPwd)
|
2022-12-09 09:39:01 +00:00
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-09 09:39:01 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-12 02:32:01 +00:00
|
|
|
|
if (NULL == oldPwd || 0 == *oldPwd || NULL == newPwd || 0 == *newPwd)
|
2022-12-09 09:39:01 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-12 09:05:43 +00:00
|
|
|
|
std::string password = GetPassword(m_sql, m_userName.c_str());
|
|
|
|
|
assert(!password.empty());
|
2022-12-12 02:32:01 +00:00
|
|
|
|
|
2022-12-12 09:05:43 +00:00
|
|
|
|
std::string authString = GetAuthString(m_sql, oldPwd);
|
|
|
|
|
if (password != authString)
|
2022-12-12 02:32:01 +00:00
|
|
|
|
{
|
2022-12-12 09:05:43 +00:00
|
|
|
|
// 旧密码错误
|
2022-12-12 09:49:04 +00:00
|
|
|
|
return HGPDTTOOLDB_ERR_WRONG_PASSWORD;
|
2022-12-12 02:32:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-12-12 09:05:43 +00:00
|
|
|
|
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);
|
2022-12-09 09:39:01 +00:00
|
|
|
|
return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-14 09:32:48 +00:00
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::UploadFile(const HGChar* tag, const HGChar* fileName)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-14 09:32:48 +00:00
|
|
|
|
{
|
|
|
|
|
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);
|
2022-12-15 07:25:13 +00:00
|
|
|
|
int ret = mysql_stmt_prepare(stmt, sqlCmd, (unsigned long)strlen(sqlCmd));
|
2022-12-14 09:32:48 +00:00
|
|
|
|
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);
|
2022-12-15 07:25:13 +00:00
|
|
|
|
ret = mysql_stmt_prepare(stmt, sqlCmd, (unsigned long)strlen(sqlCmd));
|
2022-12-14 09:32:48 +00:00
|
|
|
|
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)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-14 09:32:48 +00:00
|
|
|
|
{
|
|
|
|
|
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);
|
2022-12-15 07:25:13 +00:00
|
|
|
|
int ret = mysql_stmt_prepare(stmt, sqlCmd, (unsigned long)strlen(sqlCmd));
|
2022-12-14 09:32:48 +00:00
|
|
|
|
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))
|
|
|
|
|
{
|
2022-12-22 01:28:15 +00:00
|
|
|
|
res = HGBASE_ERR_OK;
|
2022-12-14 09:32:48 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fclose(file);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
res = HGBASE_ERR_ACCESSDENIED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
free(bnd.buffer);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
res = HGBASE_ERR_OUTOFMEMORY;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mysql_stmt_close(stmt);
|
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::Export(const HGChar* xlsPath)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
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";
|
2022-12-23 06:17:36 +00:00
|
|
|
|
cmd += ", main_test.device_name";
|
|
|
|
|
cmd += ", main_test.device_type";
|
|
|
|
|
cmd += ", main_test.device_version";
|
2022-12-08 09:40:43 +00:00
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cmd += " from main_test";
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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";
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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);
|
2022-12-26 06:33:14 +00:00
|
|
|
|
return HGBASE_ERR_ACCESSDENIED;
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
for (std::vector<std::pair<std::string, int>>::const_iterator titleIter = titleInfo.begin();
|
|
|
|
|
titleIter != titleInfo.end(); ++titleIter)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
2023-01-03 10:11:21 +00:00
|
|
|
|
std::string t = titleIter->first + "\t";
|
|
|
|
|
fwrite(t.c_str(), 1, t.size(), file);
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
2022-12-23 06:17:36 +00:00
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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;
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
if (1 == titleInfo[i].second)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
2022-12-23 06:17:36 +00:00
|
|
|
|
if (NULL != row[i])
|
|
|
|
|
{
|
|
|
|
|
value = Utf8ToStdString(row[i]);
|
|
|
|
|
}
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2023-01-03 10:11:21 +00:00
|
|
|
|
assert(NULL != row[i]);
|
|
|
|
|
const HGChar* ENTRY_STATUS_CN[] = { "未测试", "不通过", "不支持", "通过" };
|
|
|
|
|
value = ENTRY_STATUS_CN[(HGUInt)atoll(row[i])];
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
value += "\t";
|
|
|
|
|
fwrite(value.c_str(), 1, value.size(), file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fwrite("\n", 1, strlen("\n"), file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fclose(file);
|
|
|
|
|
mysql_free_result(sqlRes);
|
2023-01-03 10:11:21 +00:00
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::GetConfig(const HGChar* key, HGChar* value, HGUInt maxLen)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL == key || 0 == *key || NULL == value || 0 == maxLen)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
2022-12-09 09:39:01 +00:00
|
|
|
|
sprintf(sqlCmd, "select config_value from %s_config where config_key = '%s';", m_userName.c_str(), key);
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL == key || 0 == *key)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = {0};
|
2022-12-12 03:41:26 +00:00
|
|
|
|
sprintf(sqlCmd, "insert into %s_config (config_key, config_value) values ('%s', '%s');",
|
2022-12-09 09:39:01 +00:00
|
|
|
|
m_userName.c_str(), key, (NULL != value) ? value : "");
|
2022-12-08 09:40:43 +00:00
|
|
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
|
|
|
if (0 == ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (1062 == mysql_errno(m_sql))
|
|
|
|
|
{
|
2022-12-12 03:41:26 +00:00
|
|
|
|
sprintf(sqlCmd, "update %s_config set config_value = '%s' where config_key = '%s';",
|
2022-12-09 09:39:01 +00:00
|
|
|
|
m_userName.c_str(), (NULL != value) ? value : "", key);
|
2022-12-08 09:40:43 +00:00
|
|
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
|
|
|
return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::OpenDevice(const HGChar* sn, class HGPdtToolDbDeviceImpl** deviceImpl)
|
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_sql)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-29 02:28:09 +00:00
|
|
|
|
if (0 != InitMainTestItem(sn)
|
2023-01-03 10:11:21 +00:00
|
|
|
|
|| 0 != InitInspectionItem("inspection_test", sn)
|
|
|
|
|
|| 0 != InitInspectionItem("inspection_desc", sn)
|
|
|
|
|
|| 0 != InitInspectionItem("inspection_image", sn))
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-12 09:05:43 +00:00
|
|
|
|
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);
|
2022-12-12 09:13:51 +00:00
|
|
|
|
if (NULL != row && NULL != row[0])
|
|
|
|
|
password = row[0];
|
2022-12-12 09:05:43 +00:00
|
|
|
|
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);
|
2022-12-12 09:13:51 +00:00
|
|
|
|
if (NULL != row && NULL != row[0])
|
|
|
|
|
authString = row[0];
|
2022-12-12 09:05:43 +00:00
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return authString;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-15 07:13:21 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-15 10:21:28 +00:00
|
|
|
|
int HGPdtToolDbUserMgrImpl::SetUserLoginInfo(MYSQL* sql, const HGChar* userName, int connectId, const std::string& takeUserName)
|
2022-12-15 07:13:21 +00:00
|
|
|
|
{
|
|
|
|
|
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);
|
2022-12-15 10:21:28 +00:00
|
|
|
|
return mysql_query(sql, sqlCmd);
|
2022-12-15 07:13:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-12-15 09:46:35 +00:00
|
|
|
|
int HGPdtToolDbUserMgrImpl::GetUserLoginInfo(MYSQL* sql, const HGChar* userName, int& connectId, std::string& takeUserName)
|
2022-12-15 07:13:21 +00:00
|
|
|
|
{
|
|
|
|
|
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)
|
|
|
|
|
{
|
2022-12-15 09:46:35 +00:00
|
|
|
|
return ret;
|
2022-12-15 07:13:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-15 09:46:35 +00:00
|
|
|
|
return 0;
|
2022-12-15 07:13:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
HGUInt HGPdtToolDbUserMgrImpl::GetCols(MYSQL* sql, const HGChar* tableName, std::list<std::string>& cols)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
2023-01-03 10:11:21 +00:00
|
|
|
|
assert(NULL != tableName && 0 != *tableName);
|
|
|
|
|
cols.clear();
|
2022-12-08 09:40:43 +00:00
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
2023-01-03 10:11:21 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
2022-12-29 02:28:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
MYSQL_RES* sqlRes = mysql_use_result(sql);
|
|
|
|
|
if (NULL == sqlRes)
|
2022-12-29 02:28:09 +00:00
|
|
|
|
{
|
2023-01-03 10:11:21 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
MYSQL_ROW row = NULL;
|
|
|
|
|
while ((row = mysql_fetch_row(sqlRes)) != NULL)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
2023-01-03 10:11:21 +00:00
|
|
|
|
assert(NULL != row[0]);
|
|
|
|
|
if (0 != strcmp("sn", row[0]))
|
|
|
|
|
cols.push_back(row[0]);
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_OK;
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateFileTable(MYSQL* sql)
|
2022-12-29 02:28:09 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
std::string cmd = "create table if not exists file_list (tag varchar(20) not null primary key";
|
|
|
|
|
cmd += ", file_data blob";
|
2022-12-29 02:28:09 +00:00
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateEntryNameCnStrTable(MYSQL* sql)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
std::string cmd = "create table if not exists entry_name_cn (name varchar(20) not null primary key";
|
|
|
|
|
cmd += ", value text";
|
2022-12-08 09:40:43 +00:00
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateMainTestTable(MYSQL* sql)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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";
|
2022-12-08 09:40:43 +00:00
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateInspectionTable(MYSQL* sql, const HGChar* tableName)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
2023-01-03 10:11:21 +00:00
|
|
|
|
assert(NULL != tableName && 0 != *tableName);
|
2022-12-22 06:41:47 +00:00
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
char sqlCmd[1024];
|
|
|
|
|
sprintf(sqlCmd, "create table if not exists %s (sn varchar(20) not null primary key);", tableName);
|
|
|
|
|
return mysql_query(sql, sqlCmd);
|
2022-12-22 06:41:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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)";
|
2022-12-09 09:39:01 +00:00
|
|
|
|
std::string value = "('" + (std::string)sn + "', now(), '" + m_userName + "', now(), '" + m_userName + "')";
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
int HGPdtToolDbUserMgrImpl::InitInspectionItem(const HGChar* tableName, const HGChar* sn)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-23 06:17:36 +00:00
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::GetEntryStatus(const HGChar* entryName, HGUInt* entryStatus)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_userMgr->m_sql)
|
2022-12-15 07:13:21 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
if (NULL == entryName || 0 == *entryName || NULL == entryStatus)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
2023-01-03 10:11:21 +00:00
|
|
|
|
sprintf(sqlCmd, "select %s from inspection_test where sn = '%s';", entryName, m_sn.c_str());
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::SetEntryStatus(const HGChar* entryName, HGUInt entryStatus)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_userMgr->m_sql)
|
2022-12-15 07:13:21 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
if (NULL == entryName || 0 == *entryName || entryStatus > HGPDTTOOLDB_ENTRYSTATUS_PASS)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
|
|
|
|
|
|
// 事务开始
|
|
|
|
|
int ret = mysql_query(m_userMgr->m_sql, "begin;");
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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());
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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';",
|
2022-12-09 09:39:01 +00:00
|
|
|
|
m_userMgr->m_userName.c_str(), m_sn.c_str());
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::GetEntryExcepDesc(const HGChar* entryName, HGChar* excepDesc, HGUInt maxLen)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_userMgr->m_sql)
|
2022-12-15 07:13:21 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
if (NULL == entryName || 0 == *entryName || NULL == excepDesc || 0 == maxLen)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
2023-01-03 10:11:21 +00:00
|
|
|
|
sprintf(sqlCmd, "select %s from inspection_desc where sn = '%s';", entryName, m_sn.c_str());
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::SetEntryExcepDesc(const HGChar* entryName, const HGChar* excepDesc)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
2022-12-22 02:07:16 +00:00
|
|
|
|
if (NULL == m_userMgr->m_sql)
|
2022-12-15 07:13:21 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
if (NULL == entryName || 0 == *entryName)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
|
|
|
|
|
|
// 事务开始
|
|
|
|
|
int ret = mysql_query(m_userMgr->m_sql, "begin;");
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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());
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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';",
|
2022-12-09 09:39:01 +00:00
|
|
|
|
m_userMgr->m_userName.c_str(), m_sn.c_str());
|
2022-12-08 09:40:43 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::DownloadEntryImage(const HGChar* entryName, const HGChar* ftpHost, HGUShort ftpPort, HGUInt index, const HGChar* fileName)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
{
|
|
|
|
|
if (NULL == m_userMgr->m_sql)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
if (NULL == entryName || 0 == *entryName)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 06:41:47 +00:00
|
|
|
|
if (NULL == ftpHost || 0 == *ftpHost || NULL == fileName || 0 == *fileName)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
HGUInt count = 0;
|
|
|
|
|
GetEntryImageCount(entryName, &count);
|
|
|
|
|
if (index >= count)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
{
|
2023-01-03 10:11:21 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
2022-12-22 06:41:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
if (NULL == entryName || 0 == *entryName || NULL == count)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
{
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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);
|
2022-12-22 06:41:47 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
assert(NULL != row[0]);
|
|
|
|
|
*count = (HGUInt)atoll(row[0]);
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_OK;
|
2022-12-22 06:41:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::ClearEntryImage(const HGChar* entryName)
|
2022-12-28 11:53:28 +00:00
|
|
|
|
{
|
|
|
|
|
if (NULL == m_userMgr->m_sql)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
if (NULL == entryName || 0 == *entryName)
|
2022-12-28 11:53:28 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
|
|
|
|
|
|
// 事务开始
|
|
|
|
|
int ret = mysql_query(m_userMgr->m_sql, "begin;");
|
|
|
|
|
if (0 != ret)
|
2022-12-28 11:53:28 +00:00
|
|
|
|
{
|
2023-01-03 10:11:21 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
2022-12-28 11:53:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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)
|
2022-12-28 11:53:28 +00:00
|
|
|
|
{
|
2023-01-03 10:11:21 +00:00
|
|
|
|
mysql_query(m_userMgr->m_sql, "rollback;");
|
2022-12-28 11:53:28 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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);
|
2022-12-28 11:53:28 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::UploadEntryImage(const HGChar* entryName, const HGChar* ftpHost, HGUShort ftpPort, const HGChar* fileName)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
{
|
|
|
|
|
if (NULL == m_userMgr->m_sql)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
if (NULL == entryName || 0 == *entryName)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
if (NULL == ftpHost || 0 == *ftpHost || NULL == fileName || 0 == *fileName)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
HGUInt count = 0;
|
|
|
|
|
GetEntryImageCount(entryName, &count);
|
2022-12-22 06:41:47 +00:00
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
char remotePath[256];
|
|
|
|
|
sprintf(remotePath, "/upload/%s/%s/%u.jpg", m_sn.c_str(), entryName, count);
|
|
|
|
|
HGResult res = UploadFile(ftpHost, ftpPort, fileName, remotePath);
|
2022-12-22 06:41:47 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-03 10:11:21 +00:00
|
|
|
|
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());
|
2022-12-22 06:41:47 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-23 06:17:36 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 06:41:47 +00:00
|
|
|
|
static size_t read_callback(char* ptr, size_t size, size_t nmemb, void* stream)
|
|
|
|
|
{
|
2022-12-26 02:16:59 +00:00
|
|
|
|
return fread(ptr, size, nmemb, (FILE*)stream);
|
2022-12-22 06:41:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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);
|
2022-12-26 02:16:59 +00:00
|
|
|
|
long fSize = ftell(file);
|
2022-12-22 06:41:47 +00:00
|
|
|
|
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. */
|
2022-12-26 02:16:59 +00:00
|
|
|
|
curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fSize);
|
2022-12-22 06:41:47 +00:00
|
|
|
|
|
|
|
|
|
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)
|
2022-12-27 08:30:54 +00:00
|
|
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
|
2022-12-22 06:41:47 +00:00
|
|
|
|
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)
|
|
|
|
|
{
|
2022-12-22 06:57:52 +00:00
|
|
|
|
return HGBASE_ERR_ACCESSDENIED;
|
2022-12-22 06:41:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
2022-12-08 09:40:43 +00:00
|
|
|
|
}
|