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"
|
|
|
|
|
|
|
|
|
|
const HGChar* INITTIAL_INSPECTION[] =
|
|
|
|
|
{
|
|
|
|
|
"dial_switch",
|
|
|
|
|
"rocker_switch",
|
|
|
|
|
"boot_status",
|
|
|
|
|
"lcd_display",
|
|
|
|
|
"clear_paper_path",
|
|
|
|
|
"key_function",
|
|
|
|
|
"counting_mode",
|
|
|
|
|
"skew_detection",
|
|
|
|
|
"separater_motor",
|
|
|
|
|
"cis_original_image",
|
|
|
|
|
"host_fan",
|
|
|
|
|
"ultrasonic_module",
|
|
|
|
|
"led_light",
|
|
|
|
|
"reset",
|
|
|
|
|
"paper_feed",
|
|
|
|
|
"cover_sensor",
|
|
|
|
|
"scanning_sensor"
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const HGChar* INITTIAL_INSPECTION_CN[] =
|
|
|
|
|
{
|
|
|
|
|
"拨码开关校验",
|
|
|
|
|
"检查船型开关功能",
|
|
|
|
|
"设备上电并观察开机状态",
|
|
|
|
|
"检查液晶显示",
|
|
|
|
|
"清理纸道功能确认",
|
|
|
|
|
"按键功能检测",
|
|
|
|
|
"计数模式检测",
|
|
|
|
|
"歪斜检测",
|
|
|
|
|
"分纸电机检测",
|
|
|
|
|
"CIS原图初检",
|
|
|
|
|
"主机风扇功能检测",
|
|
|
|
|
"超声波模块检验",
|
|
|
|
|
"LED灯状态检查",
|
|
|
|
|
"复位检查",
|
|
|
|
|
"走纸检查",
|
|
|
|
|
"开盖传感器检查",
|
|
|
|
|
"扫描传感器检查"
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const HGChar* IMAGE_INSPECTION[] =
|
|
|
|
|
{
|
|
|
|
|
"configure_speed_mode",
|
|
|
|
|
"place_correction_paper",
|
|
|
|
|
"auto_flat_field",
|
|
|
|
|
"reboot_device",
|
|
|
|
|
"image_quality",
|
|
|
|
|
"colorcard_imaging_quality",
|
|
|
|
|
"colorcard_bias_imaging_quality",
|
|
|
|
|
"clarity_quality",
|
|
|
|
|
"distortion",
|
|
|
|
|
"dormancy",
|
|
|
|
|
"skew_gear",
|
|
|
|
|
"paper_separater_strengch",
|
|
|
|
|
"mech_paper_feeding_inclination"
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const HGChar* IMAGE_INSPECTION_CN[] =
|
|
|
|
|
{
|
|
|
|
|
"配置速度模式",
|
|
|
|
|
"放置校正纸",
|
|
|
|
|
"自动平场校正",
|
|
|
|
|
"重启设备",
|
|
|
|
|
"扫描图像质量确认",
|
|
|
|
|
"色卡纸成像质量评估",
|
|
|
|
|
"色卡纸偏色成像质量评估",
|
|
|
|
|
"清晰度质量评估",
|
|
|
|
|
"畸变修正",
|
|
|
|
|
"设置休眠",
|
|
|
|
|
"歪斜挡位检测",
|
|
|
|
|
"分纸强度检测",
|
|
|
|
|
"机械走纸倾斜检测"
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const HGChar* PRESSURE_INSPECTION[] =
|
|
|
|
|
{
|
|
|
|
|
"single_page_test_1",
|
|
|
|
|
"single_page_test_2",
|
|
|
|
|
"single_page_test_3",
|
|
|
|
|
"pressure_test",
|
|
|
|
|
"clear_roller_count"
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const HGChar* PRESSURE_INSPECTION_CN[] =
|
|
|
|
|
{
|
|
|
|
|
"单张测试1",
|
|
|
|
|
"单张测试2",
|
|
|
|
|
"单张测试3",
|
|
|
|
|
"压力测试2轮",
|
|
|
|
|
"清除滚轴计数"
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
HGPdtToolDbUserMgrImpl::HGPdtToolDbUserMgrImpl()
|
|
|
|
|
{
|
|
|
|
|
m_sql = NULL;
|
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-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
|
|
|
|
}
|
|
|
|
|
|
2022-12-14 09:32:48 +00:00
|
|
|
|
if (0 != CreateFileTable(sql) || 0 != CreateMainTestTable(sql)
|
|
|
|
|
|| 0 != CreateInitInspTestTable(sql) || 0 != CreateInitInspDescTable(sql)
|
2022-12-08 09:40:43 +00:00
|
|
|
|
|| 0 != CreateImgInspTestTable(sql) || 0 != CreateImgInspDescTable(sql)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
|| 0 != CreatePreInspTestTable(sql) || 0 != CreatePreInspDescTable(sql)
|
|
|
|
|
|| 0 != CreateInspImageTable(sql))
|
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";
|
|
|
|
|
cmd += ", main_test.current_entry";
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*); ++i)
|
|
|
|
|
{
|
|
|
|
|
cmd += ", initial_inspection_test.";
|
|
|
|
|
cmd += INITTIAL_INSPECTION[i];
|
|
|
|
|
cmd += ", initial_inspection_desc.";
|
|
|
|
|
cmd += INITTIAL_INSPECTION[i];
|
|
|
|
|
}
|
|
|
|
|
for (int i = 0; i < sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*); ++i)
|
|
|
|
|
{
|
|
|
|
|
cmd += ", image_inspection_test.";
|
|
|
|
|
cmd += IMAGE_INSPECTION[i];
|
|
|
|
|
cmd += ", image_inspection_desc.";
|
|
|
|
|
cmd += IMAGE_INSPECTION[i];
|
|
|
|
|
}
|
|
|
|
|
for (int i = 0; i < sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*); ++i)
|
|
|
|
|
{
|
|
|
|
|
cmd += ", pressure_inspection_test.";
|
|
|
|
|
cmd += PRESSURE_INSPECTION[i];
|
|
|
|
|
cmd += ", pressure_inspection_desc.";
|
|
|
|
|
cmd += PRESSURE_INSPECTION[i];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cmd += " from main_test";
|
|
|
|
|
cmd += " inner join initial_inspection_test on main_test.sn = initial_inspection_test.sn";
|
|
|
|
|
cmd += " inner join initial_inspection_desc on main_test.sn = initial_inspection_desc.sn";
|
|
|
|
|
cmd += " inner join image_inspection_test on main_test.sn = image_inspection_test.sn";
|
|
|
|
|
cmd += " inner join image_inspection_desc on main_test.sn = image_inspection_desc.sn";
|
|
|
|
|
cmd += " inner join pressure_inspection_test on main_test.sn = pressure_inspection_test.sn";
|
|
|
|
|
cmd += " inner join pressure_inspection_desc on main_test.sn = pressure_inspection_desc.sn";
|
|
|
|
|
cmd += ";";
|
|
|
|
|
|
|
|
|
|
int ret = mysql_query(m_sql, cmd.c_str());
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MYSQL_RES* sqlRes = mysql_use_result(m_sql);
|
|
|
|
|
if (NULL == sqlRes)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
FILE* file = fopen(xlsPath, "wb");
|
|
|
|
|
if (NULL == file)
|
|
|
|
|
{
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const HGChar* MAIN_TEST_CN[] = {"序列号", "创建时间", "创建用户", "最后修改时间", "最后修改用户", "当前测试项"};
|
|
|
|
|
for (int i = 0; i < sizeof(MAIN_TEST_CN) / sizeof(const HGChar*); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string title = (std::string)MAIN_TEST_CN[i] + "\t";
|
|
|
|
|
fwrite(title.c_str(), 1, title.size(), file);
|
|
|
|
|
}
|
|
|
|
|
for (int i = 0; i < sizeof(INITTIAL_INSPECTION_CN) / sizeof(const HGChar*); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string title = (std::string)INITTIAL_INSPECTION_CN[i] + "\t";
|
|
|
|
|
fwrite(title.c_str(), 1, title.size(), file);
|
|
|
|
|
std::string descTitle = (std::string)INITTIAL_INSPECTION_CN[i] + "异常说明" + "\t";
|
|
|
|
|
fwrite(descTitle.c_str(), 1, descTitle.size(), file);
|
|
|
|
|
}
|
|
|
|
|
for (int i = 0; i < sizeof(IMAGE_INSPECTION_CN) / sizeof(const HGChar*); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string title = (std::string)IMAGE_INSPECTION_CN[i] + "\t";
|
|
|
|
|
fwrite(title.c_str(), 1, title.size(), file);
|
|
|
|
|
std::string descTitle = (std::string)IMAGE_INSPECTION_CN[i] + "异常说明" + "\t";
|
|
|
|
|
fwrite(descTitle.c_str(), 1, descTitle.size(), file);
|
|
|
|
|
}
|
|
|
|
|
for (int i = 0; i < sizeof(PRESSURE_INSPECTION_CN) / sizeof(const HGChar*); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string title = (std::string)PRESSURE_INSPECTION_CN[i] + "\t";
|
|
|
|
|
fwrite(title.c_str(), 1, title.size(), file);
|
|
|
|
|
std::string descTitle = (std::string)PRESSURE_INSPECTION_CN[i] + "异常说明" + "\t";
|
|
|
|
|
fwrite(descTitle.c_str(), 1, descTitle.size(), file);
|
|
|
|
|
}
|
|
|
|
|
fwrite("\n", 1, strlen("\n"), file);
|
|
|
|
|
|
|
|
|
|
MYSQL_ROW row = NULL;
|
|
|
|
|
while ((row = mysql_fetch_row(sqlRes)) != NULL)
|
|
|
|
|
{
|
|
|
|
|
unsigned int cols = mysql_num_fields(sqlRes);
|
|
|
|
|
for (unsigned int i = 0; i < cols; ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string value;
|
|
|
|
|
|
|
|
|
|
if (i < 5)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != row[i]);
|
|
|
|
|
value = row[i];
|
|
|
|
|
}
|
|
|
|
|
else if (i == 5)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != row[i]);
|
|
|
|
|
value = GetEntryNameCnStr((HGUInt)atoll(row[i]));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (0 == (i - 6) % 2)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != row[i]);
|
|
|
|
|
const HGChar* ENTRY_STATUS_CN[] = { "未测试", "不通过", "不支持", "通过" };
|
|
|
|
|
value = ENTRY_STATUS_CN[(HGUInt)atoll(row[i])];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (NULL != row[i])
|
|
|
|
|
{
|
|
|
|
|
value = Utf8ToStdString(row[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
value += "\t";
|
|
|
|
|
fwrite(value.c_str(), 1, value.size(), file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fwrite("\n", 1, strlen("\n"), file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fclose(file);
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::GetConfig(const HGChar* key, HGChar* value, HGUInt maxLen)
|
|
|
|
|
{
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (0 != InitMainTestItem(sn) || 0 != InitInspTestItem("initial_inspection_test", sn)
|
|
|
|
|
|| 0 != InitInspTestItem("initial_inspection_desc", sn) || 0 != InitInspTestItem("image_inspection_test", sn)
|
|
|
|
|
|| 0 != InitInspTestItem("image_inspection_desc", sn) || 0 != InitInspTestItem("pressure_inspection_test", sn)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
|| 0 != InitInspTestItem("pressure_inspection_desc", sn) || 0 != InitInspTestItem("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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const HGChar* HGPdtToolDbUserMgrImpl::GetEntryNameCnStr(HGUInt entryName)
|
|
|
|
|
{
|
|
|
|
|
if (0 == entryName)
|
|
|
|
|
return "未开始测试";
|
|
|
|
|
else if (0xFFFFFFFF == entryName)
|
|
|
|
|
return "已完成测试";
|
|
|
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
|
|
|
|
|
return INITTIAL_INSPECTION_CN[entryName - HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH];
|
|
|
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
|
|
|
|
|
return IMAGE_INSPECTION_CN[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
|
|
|
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
|
|
|
|
|
return PRESSURE_INSPECTION_CN[entryName - HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1];
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
2022-12-14 09:32:48 +00:00
|
|
|
|
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());
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateMainTestTable(MYSQL* sql)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
|
|
|
|
std::string cmd = "create table if not exists main_test (sn varchar(20) not null primary key";
|
|
|
|
|
cmd += ", create_time datetime";
|
|
|
|
|
cmd += ", create_user text not null";
|
|
|
|
|
cmd += ", last_modify_time datetime";
|
|
|
|
|
cmd += ", last_modify_user text not null";
|
|
|
|
|
cmd += ", current_entry int unsigned default 0";
|
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateInitInspTestTable(MYSQL* sql)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
|
|
|
|
std::string cmd = "create table if not exists initial_inspection_test (sn varchar(20) not null primary key";
|
|
|
|
|
int size = sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*);
|
|
|
|
|
for (int i = 0; i < size; ++i)
|
|
|
|
|
{
|
|
|
|
|
cmd += ", ";
|
|
|
|
|
cmd += INITTIAL_INSPECTION[i];
|
|
|
|
|
cmd += " tinyint unsigned default 0";
|
|
|
|
|
}
|
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateInitInspDescTable(MYSQL* sql)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
|
|
|
|
std::string cmd = "create table if not exists initial_inspection_desc (sn varchar(20) not null primary key";
|
|
|
|
|
int size = sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*);
|
|
|
|
|
for (int i = 0; i < size; ++i)
|
|
|
|
|
{
|
|
|
|
|
cmd += ", ";
|
|
|
|
|
cmd += INITTIAL_INSPECTION[i];
|
|
|
|
|
cmd += " text";
|
|
|
|
|
}
|
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateImgInspTestTable(MYSQL* sql)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
|
|
|
|
std::string cmd = "create table if not exists image_inspection_test (sn varchar(20) not null primary key";
|
|
|
|
|
int size = sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*);
|
|
|
|
|
for (int i = 0; i < size; ++i)
|
|
|
|
|
{
|
|
|
|
|
cmd += ", ";
|
|
|
|
|
cmd += IMAGE_INSPECTION[i];
|
|
|
|
|
cmd += " tinyint unsigned default 0";
|
|
|
|
|
}
|
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateImgInspDescTable(MYSQL* sql)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
|
|
|
|
std::string cmd = "create table if not exists image_inspection_desc (sn varchar(20) not null primary key";
|
|
|
|
|
int size = sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*);
|
|
|
|
|
for (int i = 0; i < size; ++i)
|
|
|
|
|
{
|
|
|
|
|
cmd += ", ";
|
|
|
|
|
cmd += IMAGE_INSPECTION[i];
|
|
|
|
|
cmd += " text";
|
|
|
|
|
}
|
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreatePreInspTestTable(MYSQL* sql)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
|
|
|
|
std::string cmd = "create table if not exists pressure_inspection_test (sn varchar(20) not null primary key";
|
|
|
|
|
int size = sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*);
|
|
|
|
|
for (int i = 0; i < size; ++i)
|
|
|
|
|
{
|
|
|
|
|
cmd += ", ";
|
|
|
|
|
cmd += PRESSURE_INSPECTION[i];
|
|
|
|
|
cmd += " tinyint unsigned default 0";
|
|
|
|
|
}
|
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreatePreInspDescTable(MYSQL* sql)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
|
|
|
|
std::string cmd = "create table if not exists pressure_inspection_desc (sn varchar(20) not null primary key";
|
|
|
|
|
int size = sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*);
|
|
|
|
|
for (int i = 0; i < size; ++i)
|
|
|
|
|
{
|
|
|
|
|
cmd += ", ";
|
|
|
|
|
cmd += PRESSURE_INSPECTION[i];
|
|
|
|
|
cmd += " text";
|
|
|
|
|
}
|
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 06:41:47 +00:00
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateInspImageTable(MYSQL* sql)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != sql);
|
|
|
|
|
|
|
|
|
|
std::string cmd = "create table if not exists inspection_image (sn varchar(20) not null primary key";
|
|
|
|
|
int size = sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*);
|
|
|
|
|
for (int i = 0; i < size; ++i)
|
|
|
|
|
{
|
|
|
|
|
cmd += ", ";
|
|
|
|
|
cmd += IMAGE_INSPECTION[i];
|
|
|
|
|
cmd += " text";
|
|
|
|
|
}
|
|
|
|
|
cmd += ");";
|
|
|
|
|
return mysql_query(sql, cmd.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int HGPdtToolDbUserMgrImpl::InitInspTestItem(const HGChar* tableName, const HGChar* sn)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != tableName && 0 != *tableName);
|
|
|
|
|
assert(NULL != sn && 0 != *sn && NULL != m_sql);
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024];
|
|
|
|
|
sprintf(sqlCmd, "insert into %s (sn) values ('%s');", tableName, sn);
|
|
|
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
|
|
|
return (1062 == mysql_errno(m_sql)) ? 0 : ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
HGPdtToolDbDeviceImpl::HGPdtToolDbDeviceImpl(class HGPdtToolDbUserMgrImpl* userMgr, const HGChar* sn)
|
|
|
|
|
{
|
|
|
|
|
m_userMgr = userMgr;
|
|
|
|
|
m_sn = sn;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGPdtToolDbDeviceImpl::~HGPdtToolDbDeviceImpl()
|
|
|
|
|
{
|
|
|
|
|
m_userMgr->RemoveDevice(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::GetCurrEntry(HGUInt* entryName)
|
|
|
|
|
{
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
if (NULL == entryName)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
|
sprintf(sqlCmd, "select current_entry from main_test where sn = '%s';", m_sn.c_str());
|
|
|
|
|
int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MYSQL_RES* sqlRes = mysql_use_result(m_userMgr->m_sql);
|
|
|
|
|
if (NULL == sqlRes)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MYSQL_ROW row = mysql_fetch_row(sqlRes);
|
|
|
|
|
if (NULL == row)
|
|
|
|
|
{
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
assert(NULL != row[0]);
|
|
|
|
|
*entryName = (HGUInt)atoll(row[0]);
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::SetCurrEntry(HGUInt entryName)
|
|
|
|
|
{
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
if (0 != entryName && 0xFFFFFFFF != entryName)
|
|
|
|
|
{
|
|
|
|
|
const HGChar* entryNameStr = GetEntryNameStr(entryName);
|
|
|
|
|
if (NULL == entryNameStr)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
|
sprintf(sqlCmd, "update main_test set current_entry = %u, last_modify_time = now(), last_modify_user = '%s' where sn = '%s';",
|
2022-12-09 09:39:01 +00:00
|
|
|
|
entryName, m_userMgr->m_userName.c_str(), m_sn.c_str());
|
2022-12-08 09:40:43 +00:00
|
|
|
|
int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
|
|
|
return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::GetEntryStatus(HGUInt entryName, HGUInt* entryStatus)
|
|
|
|
|
{
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
if (NULL == entryStatus)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const HGChar* entryNameStr = GetEntryNameStr(entryName);
|
|
|
|
|
const HGChar* tableName = GetTestTableName(entryName);
|
|
|
|
|
if (NULL == entryNameStr || NULL == tableName)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
|
sprintf(sqlCmd, "select %s from %s where sn = '%s';", entryNameStr, tableName, m_sn.c_str());
|
|
|
|
|
int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MYSQL_RES *sqlRes = mysql_use_result(m_userMgr->m_sql);
|
|
|
|
|
if (NULL == sqlRes)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MYSQL_ROW row = mysql_fetch_row(sqlRes);
|
|
|
|
|
if (NULL == row)
|
|
|
|
|
{
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
assert(NULL != row[0]);
|
|
|
|
|
*entryStatus = (HGUInt)atoll(row[0]);
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::SetEntryStatus(HGUInt entryName, HGUInt entryStatus)
|
|
|
|
|
{
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
if (entryStatus > HGPDTTOOLDB_ENTRYSTATUS_PASS)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const HGChar* entryNameStr = GetEntryNameStr(entryName);
|
|
|
|
|
const HGChar* tableName = GetTestTableName(entryName);
|
|
|
|
|
if (NULL == entryNameStr || NULL == tableName)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
|
|
|
|
|
|
// 事务开始
|
|
|
|
|
int ret = mysql_query(m_userMgr->m_sql, "begin;");
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sprintf(sqlCmd, "update %s set %s = %u where sn = '%s';", tableName, entryNameStr, entryStatus, m_sn.c_str());
|
|
|
|
|
ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
mysql_query(m_userMgr->m_sql, "rollback;");
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sprintf(sqlCmd, "update main_test set last_modify_time = now(), last_modify_user = '%s' where sn = '%s';",
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::GetEntryExcepDesc(HGUInt entryName, HGChar* excepDesc, HGUInt maxLen)
|
|
|
|
|
{
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
if (NULL == excepDesc || 0 == maxLen)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const HGChar* entryNameStr = GetEntryNameStr(entryName);
|
|
|
|
|
const HGChar* tableName = GetDescTableName(entryName);
|
|
|
|
|
if (NULL == entryNameStr || NULL == tableName)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
|
sprintf(sqlCmd, "select %s from %s where sn = '%s';", entryNameStr, tableName, m_sn.c_str());
|
|
|
|
|
int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MYSQL_RES* sqlRes = mysql_use_result(m_userMgr->m_sql);
|
|
|
|
|
if (NULL == sqlRes)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MYSQL_ROW row = mysql_fetch_row(sqlRes);
|
|
|
|
|
if (NULL == row)
|
|
|
|
|
{
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL == row[0])
|
|
|
|
|
{
|
|
|
|
|
*excepDesc = '\0';
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (maxLen < strlen(row[0]) + 1)
|
|
|
|
|
{
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
strcpy(excepDesc, row[0]);
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::SetEntryExcepDesc(HGUInt entryName, const HGChar* excepDesc)
|
|
|
|
|
{
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-08 09:40:43 +00:00
|
|
|
|
const HGChar* entryNameStr = GetEntryNameStr(entryName);
|
|
|
|
|
const HGChar* tableName = GetDescTableName(entryName);
|
|
|
|
|
if (NULL == entryNameStr || NULL == tableName)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
|
|
|
|
|
|
// 事务开始
|
|
|
|
|
int ret = mysql_query(m_userMgr->m_sql, "begin;");
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sprintf(sqlCmd, "update %s set %s = '%s' where sn = '%s';",
|
|
|
|
|
tableName, entryNameStr, (NULL != excepDesc) ? excepDesc : "", m_sn.c_str());
|
|
|
|
|
ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
mysql_query(m_userMgr->m_sql, "rollback;");
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sprintf(sqlCmd, "update main_test set last_modify_time = now(), last_modify_user = '%s' where sn = '%s';",
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 06:41:47 +00:00
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::DownloadEntryImage(HGUInt entryName, const HGChar* ftpHost, HGUShort ftpPort, const HGChar* fileName)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == m_userMgr->m_sql)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL == ftpHost || 0 == *ftpHost || NULL == fileName || 0 == *fileName)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const HGChar* entryNameStr = NULL;
|
|
|
|
|
if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
|
|
|
|
|
entryNameStr = IMAGE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
|
|
|
|
|
if (NULL == entryNameStr)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 09:28:50 +00:00
|
|
|
|
std::string remotePath;
|
|
|
|
|
HGResult res = GetEntryImageRemotePath(entryNameStr, remotePath);
|
|
|
|
|
if (HGBASE_ERR_OK != res)
|
2022-12-22 06:41:47 +00:00
|
|
|
|
{
|
2022-12-22 09:28:50 +00:00
|
|
|
|
return res;
|
2022-12-22 06:41:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 09:28:50 +00:00
|
|
|
|
if (remotePath.empty())
|
2022-12-22 06:41:47 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 09:28:50 +00:00
|
|
|
|
return DownloadFile(ftpHost, ftpPort, remotePath.c_str(), fileName);
|
2022-12-22 06:41:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::UploadEntryImage(HGUInt entryName, const HGChar* ftpHost, HGUShort ftpPort, const HGChar* fileName)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == m_userMgr->m_sql)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL == ftpHost || 0 == *ftpHost || NULL == fileName || 0 == *fileName)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const HGChar* entryNameStr = NULL;
|
|
|
|
|
if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
|
|
|
|
|
entryNameStr = IMAGE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
|
|
|
|
|
if (NULL == entryNameStr)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 09:28:50 +00:00
|
|
|
|
std::string remotePath;
|
|
|
|
|
HGResult res = GetEntryImageRemotePath(entryNameStr, remotePath);
|
|
|
|
|
if (HGBASE_ERR_OK != res)
|
|
|
|
|
{
|
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (remotePath.empty())
|
|
|
|
|
{
|
|
|
|
|
HGChar uuid[256];
|
|
|
|
|
HGBase_GetUuid(uuid, 256);
|
|
|
|
|
remotePath = std::string("/upload/") + uuid + ".jpg";
|
|
|
|
|
}
|
2022-12-22 06:41:47 +00:00
|
|
|
|
|
2022-12-22 09:28:50 +00:00
|
|
|
|
res = UploadFile(ftpHost, ftpPort, fileName, remotePath.c_str());
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sprintf(sqlCmd, "update inspection_image set %s = '%s' where sn = '%s';",
|
2022-12-22 09:28:50 +00:00
|
|
|
|
entryNameStr, remotePath.c_str(), 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-08 09:40:43 +00:00
|
|
|
|
const HGChar* HGPdtToolDbDeviceImpl::GetEntryNameStr(HGUInt entryName)
|
|
|
|
|
{
|
|
|
|
|
if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
|
|
|
|
|
return INITTIAL_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH];
|
|
|
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
|
|
|
|
|
return IMAGE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
|
|
|
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
|
|
|
|
|
return PRESSURE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1];
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const HGChar* HGPdtToolDbDeviceImpl::GetTestTableName(HGUInt entryName)
|
|
|
|
|
{
|
|
|
|
|
if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
|
|
|
|
|
return "initial_inspection_test";
|
|
|
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
|
|
|
|
|
return "image_inspection_test";
|
|
|
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
|
|
|
|
|
return "pressure_inspection_test";
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const HGChar* HGPdtToolDbDeviceImpl::GetDescTableName(HGUInt entryName)
|
|
|
|
|
{
|
|
|
|
|
if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
|
|
|
|
|
return "initial_inspection_desc";
|
|
|
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
|
|
|
|
|
return "image_inspection_desc";
|
|
|
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
|
|
|
|
|
return "pressure_inspection_desc";
|
|
|
|
|
return NULL;
|
2022-12-22 06:41:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 09:28:50 +00:00
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::GetEntryImageRemotePath(const HGChar* entryNameStr, std::string& remotePath)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != m_userMgr->m_sql);
|
|
|
|
|
assert(NULL != entryNameStr);
|
|
|
|
|
remotePath.clear();
|
|
|
|
|
|
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
|
sprintf(sqlCmd, "select %s from inspection_image where sn = '%s';", entryNameStr, m_sn.c_str());
|
|
|
|
|
int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MYSQL_RES* sqlRes = mysql_use_result(m_userMgr->m_sql);
|
|
|
|
|
if (NULL == sqlRes)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MYSQL_ROW row = mysql_fetch_row(sqlRes);
|
|
|
|
|
if (NULL == row)
|
|
|
|
|
{
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL != row[0])
|
|
|
|
|
remotePath = row[0];
|
|
|
|
|
mysql_free_result(sqlRes);
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-22 06:41:47 +00:00
|
|
|
|
static size_t read_callback(char* ptr, size_t size, size_t nmemb, void* stream)
|
|
|
|
|
{
|
|
|
|
|
unsigned long nread;
|
|
|
|
|
/* in real-world cases, this would probably get this data differently
|
|
|
|
|
as this fread() stuff is exactly what the library already would do
|
|
|
|
|
by default internally */
|
|
|
|
|
size_t retcode = fread(ptr, size, nmemb, (FILE*)stream);
|
|
|
|
|
|
|
|
|
|
if (retcode > 0)
|
|
|
|
|
{
|
|
|
|
|
nread = (unsigned long)retcode;
|
|
|
|
|
//fprintf(stderr, "*** We read %lu bytes from file\n", nread);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return retcode;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int read_xferinfo(void* p, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
|
|
|
|
|
{
|
|
|
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "ulnow=%lld, ultotal=%lld", ulnow, ultotal);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::UploadFile(const HGChar* host, HGUShort port, const HGChar* localPath, const HGChar* remotePath)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != host && 0 != *host);
|
|
|
|
|
assert(NULL != localPath && 0 != *localPath);
|
|
|
|
|
assert(NULL != remotePath && 0 != *remotePath);
|
|
|
|
|
|
|
|
|
|
FILE* file = fopen(localPath, "rb");
|
|
|
|
|
if (NULL == file)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FILENOTEXIST;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult ret = HGBASE_ERR_FAIL;
|
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
|
|
|
long fsize = ftell(file);
|
|
|
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
|
|
|
|
|
|
/* get a curl handle */
|
|
|
|
|
CURL* curl = curl_easy_init();
|
|
|
|
|
if (NULL != curl)
|
|
|
|
|
{
|
|
|
|
|
/* we want to use our own read function */
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
|
|
|
|
|
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
|
|
|
|
|
|
|
|
|
|
char url[512];
|
|
|
|
|
sprintf(url, "ftp://%s:%d%s", host, port, remotePath);
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_URL, url);
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_FTP_CREATE_MISSING_DIRS, 1);
|
|
|
|
|
|
|
|
|
|
/* now specify which file to upload */
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_READDATA, file);
|
|
|
|
|
|
|
|
|
|
/* Set the size of the file to upload (optional). If you give a *_LARGE
|
|
|
|
|
option you MUST make sure that the type of the passed-in argument is a
|
|
|
|
|
curl_off_t. If you use CURLOPT_INFILESIZE (without _LARGE) you must
|
|
|
|
|
make sure that to pass in a type 'long' argument. */
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fsize);
|
|
|
|
|
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, read_xferinfo);
|
|
|
|
|
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
|
|
|
|
|
|
|
|
|
|
/* Now run off and do what you have been told! */
|
|
|
|
|
CURLcode res = curl_easy_perform(curl);
|
|
|
|
|
/* Check for errors */
|
|
|
|
|
if (res != CURLE_OK)
|
|
|
|
|
fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
|
|
|
|
|
else
|
|
|
|
|
ret = HGBASE_ERR_OK;
|
|
|
|
|
|
|
|
|
|
/* always cleanup */
|
|
|
|
|
curl_easy_cleanup(curl);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fclose(file); /* close the local file */
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static size_t write_callback(void* ptr, size_t size, size_t nmemb, void* stream)
|
|
|
|
|
{
|
|
|
|
|
return fwrite(ptr, size, nmemb, (FILE*)stream);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int write_xferinfo(void* p, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
|
|
|
|
|
{
|
|
|
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "ulnow=%lld, ultotal=%lld", ulnow, ultotal);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::DownloadFile(const HGChar* host, HGUShort port, const HGChar* remotePath, const HGChar* localPath)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != host && 0 != *host);
|
|
|
|
|
assert(NULL != remotePath && 0 != *remotePath);
|
|
|
|
|
assert(NULL != localPath && 0 != *localPath);
|
|
|
|
|
|
|
|
|
|
FILE* file = fopen(localPath, "wb");
|
|
|
|
|
if (NULL == file)
|
|
|
|
|
{
|
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
|
|
|
|
}
|