1115 lines
27 KiB
C++
1115 lines
27 KiB
C++
#include "HGPdtToolDbImpl.hpp"
|
|
#include "HGPdtToolDb.h"
|
|
#include "base/HGInc.h"
|
|
#include "HGString.h"
|
|
|
|
const HGChar* INITTIAL_INSPECTION[] =
|
|
{
|
|
"dial_switch",
|
|
"rocker_switch",
|
|
"boot_status",
|
|
"lcd_display",
|
|
"clear_paper_path",
|
|
"key_function",
|
|
"counting_mode",
|
|
"skew_detection",
|
|
"separater_motor",
|
|
"cis_original_image",
|
|
"host_fan",
|
|
"ultrasonic_module",
|
|
"led_light",
|
|
"reset",
|
|
"paper_feed",
|
|
"cover_sensor",
|
|
"scanning_sensor"
|
|
};
|
|
|
|
const HGChar* INITTIAL_INSPECTION_CN[] =
|
|
{
|
|
"拨码开关校验",
|
|
"检查船型开关功能",
|
|
"设备上电并观察开机状态",
|
|
"检查液晶显示",
|
|
"清理纸道功能确认",
|
|
"按键功能检测",
|
|
"计数模式检测",
|
|
"歪斜检测",
|
|
"分纸电机检测",
|
|
"CIS原图初检",
|
|
"主机风扇功能检测",
|
|
"超声波模块检验",
|
|
"LED灯状态检查",
|
|
"复位检查",
|
|
"走纸检查",
|
|
"开盖传感器检查",
|
|
"扫描传感器检查"
|
|
};
|
|
|
|
const HGChar* IMAGE_INSPECTION[] =
|
|
{
|
|
"configure_speed_mode",
|
|
"place_correction_paper",
|
|
"auto_flat_field",
|
|
"reboot_device",
|
|
"image_quality",
|
|
"colorcard_imaging_quality",
|
|
"colorcard_bias_imaging_quality",
|
|
"clarity_quality",
|
|
"distortion",
|
|
"dormancy",
|
|
"skew_gear",
|
|
"paper_separater_strengch",
|
|
"mech_paper_feeding_inclination"
|
|
};
|
|
|
|
const HGChar* IMAGE_INSPECTION_CN[] =
|
|
{
|
|
"配置速度模式",
|
|
"放置校正纸",
|
|
"自动平场校正",
|
|
"重启设备",
|
|
"扫描图像质量确认",
|
|
"色卡纸成像质量评估",
|
|
"色卡纸偏色成像质量评估",
|
|
"清晰度质量评估",
|
|
"畸变修正",
|
|
"设置休眠",
|
|
"歪斜挡位检测",
|
|
"分纸强度检测",
|
|
"机械走纸倾斜检测"
|
|
};
|
|
|
|
const HGChar* PRESSURE_INSPECTION[] =
|
|
{
|
|
"single_page_test_1",
|
|
"single_page_test_2",
|
|
"single_page_test_3",
|
|
"pressure_test",
|
|
"clear_roller_count"
|
|
};
|
|
|
|
const HGChar* PRESSURE_INSPECTION_CN[] =
|
|
{
|
|
"单张测试1",
|
|
"单张测试2",
|
|
"单张测试3",
|
|
"压力测试2轮",
|
|
"清除滚轴计数"
|
|
};
|
|
|
|
|
|
HGPdtToolDbUserMgrImpl::HGPdtToolDbUserMgrImpl()
|
|
{
|
|
m_sql = NULL;
|
|
m_userName.clear();
|
|
m_deviceList.clear();
|
|
}
|
|
|
|
HGPdtToolDbUserMgrImpl::~HGPdtToolDbUserMgrImpl()
|
|
{
|
|
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::Create(const HGChar* host, HGUShort port, const HGChar* userName, const HGChar* pwd)
|
|
{
|
|
if (NULL != m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
MYSQL* sql = mysql_init(NULL);
|
|
if (NULL == sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == mysql_real_connect(sql, host, userName, pwd, NULL, port, NULL, 0))
|
|
{
|
|
mysql_close(sql);
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
int ret = mysql_query(sql, "create database if not exists huago_production_tool;");
|
|
if (0 != ret)
|
|
{
|
|
mysql_close(sql);
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
ret = mysql_select_db(sql, "huago_production_tool");
|
|
if (0 != ret)
|
|
{
|
|
mysql_close(sql);
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (0 != CreateUserConfigTable(sql, userName) || 0 != CreateMainTestTable(sql)
|
|
|| 0 != CreateInitInspTestTable(sql) || 0 != CreateInitInspDescTable(sql)
|
|
|| 0 != CreateImgInspTestTable(sql) || 0 != CreateImgInspDescTable(sql)
|
|
|| 0 != CreatePreInspTestTable(sql) || 0 != CreatePreInspDescTable(sql))
|
|
{
|
|
mysql_close(sql);
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
m_sql = sql;
|
|
m_userName = userName;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::Destroy()
|
|
{
|
|
if (NULL == m_sql || !m_deviceList.empty())
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
mysql_close(m_sql);
|
|
m_sql = NULL;
|
|
m_userName.clear();
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::GetUserType(HGUInt* userType)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == userType)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
*userType = HGPDTTOOLDB_USERTYPE_NORMAL;
|
|
if (0 == strcmp(m_userName.c_str(), "root"))
|
|
*userType = HGPDTTOOLDB_USERTYPE_ROOT;
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::GetUserName(HGChar* userName, HGUInt maxLen)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == userName || 0 == maxLen)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
if (maxLen < m_userName.size() + 1)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
strcpy(userName, m_userName.c_str());
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::GetUserList(HGChar** userNameList, HGUInt maxLen, HGUInt* count)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == userNameList || 0 == maxLen || NULL == count)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
HGUInt userType = 0;
|
|
GetUserType(&userType);
|
|
if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
|
|
{
|
|
return HGBASE_ERR_ACCESSDENIED;
|
|
}
|
|
|
|
char sqlCmd[1024] = {0};
|
|
sprintf(sqlCmd, "select user, host from mysql.user");
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
if (0 != ret)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
MYSQL_RES* sqlRes = mysql_use_result(m_sql);
|
|
if (NULL == sqlRes)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
*count = 0;
|
|
MYSQL_ROW row = NULL;
|
|
while ((row = mysql_fetch_row(sqlRes)) != NULL)
|
|
{
|
|
if (*count >= maxLen)
|
|
{
|
|
break;
|
|
}
|
|
|
|
assert(NULL != row[0] && NULL != row[1]);
|
|
if (0 == strcmp(row[1], "%"))
|
|
{
|
|
userNameList[*count] = (HGChar*)malloc(strlen(row[0]) + 1);
|
|
assert(NULL != userNameList[*count]);
|
|
strcpy(userNameList[*count], row[0]);
|
|
++(*count);
|
|
}
|
|
}
|
|
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::ReleaseUserList(HGChar** userNameList, HGUInt count)
|
|
{
|
|
if (NULL == userNameList || 0 == count)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
for (HGUInt i = 0; i < count; ++i)
|
|
{
|
|
free(userNameList[i]);
|
|
}
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::CreateUser(const HGChar* userName, const HGChar* defPwd)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == userName || 0 == *userName || NULL == defPwd || 0 == *defPwd)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
HGUInt userType = 0;
|
|
GetUserType(&userType);
|
|
if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
|
|
{
|
|
return HGBASE_ERR_ACCESSDENIED;
|
|
}
|
|
|
|
if (0 == strcmp(userName, "root"))
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
char sqlCmd[1024] = {0};
|
|
sprintf(sqlCmd, "create user '%s'@'%%' identified by '%s';", userName, defPwd);
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
if (0 != ret)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
sprintf(sqlCmd, "grant all privileges on huago_production_tool.* to '%s'@'%%' with grant option;", userName);
|
|
ret = mysql_query(m_sql, sqlCmd);
|
|
assert(0 == ret);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::DestroyUser(const HGChar* userName)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == userName || 0 == *userName)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
HGUInt userType = 0;
|
|
GetUserType(&userType);
|
|
if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
|
|
{
|
|
return HGBASE_ERR_ACCESSDENIED;
|
|
}
|
|
|
|
if (0 == strcmp(userName, "root"))
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
sprintf(sqlCmd, "drop user '%s'@'%%';", userName);
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::SetPassword(const HGChar* userName, const HGChar* pwd)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == userName || 0 == *userName || NULL == pwd || 0 == *pwd)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
HGUInt userType = 0;
|
|
GetUserType(&userType);
|
|
if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
|
|
{
|
|
return HGBASE_ERR_ACCESSDENIED;
|
|
}
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
sprintf(sqlCmd, "set password for '%s'@'%%' = password('%s');", userName, pwd);
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::ModifyPassword(const HGChar* newPwd)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == newPwd || 0 == *newPwd)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
sprintf(sqlCmd, "set password for '%s'@'%%' = password('%s');", m_userName.c_str(), newPwd);
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::Export(const HGChar* xlsPath)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == xlsPath || 0 == *xlsPath)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
HGUInt userType = 0;
|
|
GetUserType(&userType);
|
|
if (HGPDTTOOLDB_USERTYPE_ROOT != userType)
|
|
{
|
|
return HGBASE_ERR_ACCESSDENIED;
|
|
}
|
|
|
|
std::string cmd = "select main_test.sn";
|
|
cmd += ", main_test.create_time";
|
|
cmd += ", main_test.create_user";
|
|
cmd += ", main_test.last_modify_time";
|
|
cmd += ", main_test.last_modify_user";
|
|
cmd += ", main_test.current_entry";
|
|
|
|
for (int i = 0; i < sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*); ++i)
|
|
{
|
|
cmd += ", initial_inspection_test.";
|
|
cmd += INITTIAL_INSPECTION[i];
|
|
cmd += ", initial_inspection_desc.";
|
|
cmd += INITTIAL_INSPECTION[i];
|
|
}
|
|
for (int i = 0; i < sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*); ++i)
|
|
{
|
|
cmd += ", image_inspection_test.";
|
|
cmd += IMAGE_INSPECTION[i];
|
|
cmd += ", image_inspection_desc.";
|
|
cmd += IMAGE_INSPECTION[i];
|
|
}
|
|
for (int i = 0; i < sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*); ++i)
|
|
{
|
|
cmd += ", pressure_inspection_test.";
|
|
cmd += PRESSURE_INSPECTION[i];
|
|
cmd += ", pressure_inspection_desc.";
|
|
cmd += PRESSURE_INSPECTION[i];
|
|
}
|
|
|
|
cmd += " from main_test";
|
|
cmd += " inner join initial_inspection_test on main_test.sn = initial_inspection_test.sn";
|
|
cmd += " inner join initial_inspection_desc on main_test.sn = initial_inspection_desc.sn";
|
|
cmd += " inner join image_inspection_test on main_test.sn = image_inspection_test.sn";
|
|
cmd += " inner join image_inspection_desc on main_test.sn = image_inspection_desc.sn";
|
|
cmd += " inner join pressure_inspection_test on main_test.sn = pressure_inspection_test.sn";
|
|
cmd += " inner join pressure_inspection_desc on main_test.sn = pressure_inspection_desc.sn";
|
|
cmd += ";";
|
|
|
|
int ret = mysql_query(m_sql, cmd.c_str());
|
|
if (0 != ret)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
MYSQL_RES* sqlRes = mysql_use_result(m_sql);
|
|
if (NULL == sqlRes)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
FILE* file = fopen(xlsPath, "wb");
|
|
if (NULL == file)
|
|
{
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
const HGChar* MAIN_TEST_CN[] = {"序列号", "创建时间", "创建用户", "最后修改时间", "最后修改用户", "当前测试项"};
|
|
for (int i = 0; i < sizeof(MAIN_TEST_CN) / sizeof(const HGChar*); ++i)
|
|
{
|
|
std::string title = (std::string)MAIN_TEST_CN[i] + "\t";
|
|
fwrite(title.c_str(), 1, title.size(), file);
|
|
}
|
|
for (int i = 0; i < sizeof(INITTIAL_INSPECTION_CN) / sizeof(const HGChar*); ++i)
|
|
{
|
|
std::string title = (std::string)INITTIAL_INSPECTION_CN[i] + "\t";
|
|
fwrite(title.c_str(), 1, title.size(), file);
|
|
std::string descTitle = (std::string)INITTIAL_INSPECTION_CN[i] + "异常说明" + "\t";
|
|
fwrite(descTitle.c_str(), 1, descTitle.size(), file);
|
|
}
|
|
for (int i = 0; i < sizeof(IMAGE_INSPECTION_CN) / sizeof(const HGChar*); ++i)
|
|
{
|
|
std::string title = (std::string)IMAGE_INSPECTION_CN[i] + "\t";
|
|
fwrite(title.c_str(), 1, title.size(), file);
|
|
std::string descTitle = (std::string)IMAGE_INSPECTION_CN[i] + "异常说明" + "\t";
|
|
fwrite(descTitle.c_str(), 1, descTitle.size(), file);
|
|
}
|
|
for (int i = 0; i < sizeof(PRESSURE_INSPECTION_CN) / sizeof(const HGChar*); ++i)
|
|
{
|
|
std::string title = (std::string)PRESSURE_INSPECTION_CN[i] + "\t";
|
|
fwrite(title.c_str(), 1, title.size(), file);
|
|
std::string descTitle = (std::string)PRESSURE_INSPECTION_CN[i] + "异常说明" + "\t";
|
|
fwrite(descTitle.c_str(), 1, descTitle.size(), file);
|
|
}
|
|
fwrite("\n", 1, strlen("\n"), file);
|
|
|
|
MYSQL_ROW row = NULL;
|
|
while ((row = mysql_fetch_row(sqlRes)) != NULL)
|
|
{
|
|
unsigned int cols = mysql_num_fields(sqlRes);
|
|
for (unsigned int i = 0; i < cols; ++i)
|
|
{
|
|
std::string value;
|
|
|
|
if (i < 5)
|
|
{
|
|
assert(NULL != row[i]);
|
|
value = row[i];
|
|
}
|
|
else if (i == 5)
|
|
{
|
|
assert(NULL != row[i]);
|
|
value = GetEntryNameCnStr((HGUInt)atoll(row[i]));
|
|
}
|
|
else
|
|
{
|
|
if (0 == (i - 6) % 2)
|
|
{
|
|
assert(NULL != row[i]);
|
|
const HGChar* ENTRY_STATUS_CN[] = { "未测试", "不通过", "不支持", "通过" };
|
|
value = ENTRY_STATUS_CN[(HGUInt)atoll(row[i])];
|
|
}
|
|
else
|
|
{
|
|
if (NULL != row[i])
|
|
{
|
|
value = Utf8ToStdString(row[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
value += "\t";
|
|
fwrite(value.c_str(), 1, value.size(), file);
|
|
}
|
|
|
|
fwrite("\n", 1, strlen("\n"), file);
|
|
}
|
|
|
|
fclose(file);
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::GetConfig(const HGChar* key, HGChar* value, HGUInt maxLen)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == key || 0 == *key || NULL == value || 0 == maxLen)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
sprintf(sqlCmd, "select config_value from %s_config where config_key = '%s';", m_userName.c_str(), key);
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
if (0 != ret)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
MYSQL_RES* sqlRes = mysql_use_result(m_sql);
|
|
if (NULL == sqlRes)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
MYSQL_ROW row = mysql_fetch_row(sqlRes);
|
|
if (NULL == row)
|
|
{
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == row[0])
|
|
{
|
|
*value = '\0';
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
if (maxLen < strlen(row[0]) + 1)
|
|
{
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
strcpy(value, row[0]);
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::SetConfig(const HGChar* key, const HGChar* value)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == key || 0 == *key)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
char sqlCmd[1024] = {0};
|
|
sprintf(sqlCmd, "insert into %s_config (config_key, config_value) values ('%s', '%s')",
|
|
m_userName.c_str(), key, (NULL != value) ? value : "");
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
if (0 == ret)
|
|
{
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
if (1062 == mysql_errno(m_sql))
|
|
{
|
|
sprintf(sqlCmd, "update %s_config set config_value = '%s' where config_key = '%s'",
|
|
m_userName.c_str(), (NULL != value) ? value : "", key);
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGResult HGPdtToolDbUserMgrImpl::OpenDevice(const HGChar* sn, class HGPdtToolDbDeviceImpl** deviceImpl)
|
|
{
|
|
if (NULL == m_sql)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (NULL == sn || 0 == *sn || NULL == deviceImpl)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
// 事务开始
|
|
int ret = mysql_query(m_sql, "begin;");
|
|
if (0 != ret)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
if (0 != InitMainTestItem(sn) || 0 != InitInspTestItem("initial_inspection_test", sn)
|
|
|| 0 != InitInspTestItem("initial_inspection_desc", sn) || 0 != InitInspTestItem("image_inspection_test", sn)
|
|
|| 0 != InitInspTestItem("image_inspection_desc", sn) || 0 != InitInspTestItem("pressure_inspection_test", sn)
|
|
|| 0 != InitInspTestItem("pressure_inspection_desc", sn))
|
|
{
|
|
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;
|
|
}
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateUserConfigTable(MYSQL* sql, const HGChar* user)
|
|
{
|
|
assert(NULL != sql);
|
|
assert(NULL != user && 0 != *user);
|
|
|
|
char sqlCmd[1024] = {0};
|
|
sprintf(sqlCmd, "create table if not exists %s_config (config_key varchar(40) not null primary key, config_value text)", user);
|
|
return mysql_query(sql, sqlCmd);
|
|
}
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateMainTestTable(MYSQL* sql)
|
|
{
|
|
assert(NULL != sql);
|
|
|
|
std::string cmd = "create table if not exists main_test (sn varchar(20) not null primary key";
|
|
cmd += ", create_time datetime";
|
|
cmd += ", create_user text not null";
|
|
cmd += ", last_modify_time datetime";
|
|
cmd += ", last_modify_user text not null";
|
|
cmd += ", current_entry int unsigned default 0";
|
|
cmd += ");";
|
|
return mysql_query(sql, cmd.c_str());
|
|
}
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateInitInspTestTable(MYSQL* sql)
|
|
{
|
|
assert(NULL != sql);
|
|
|
|
std::string cmd = "create table if not exists initial_inspection_test (sn varchar(20) not null primary key";
|
|
int size = sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*);
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
cmd += ", ";
|
|
cmd += INITTIAL_INSPECTION[i];
|
|
cmd += " tinyint unsigned default 0";
|
|
}
|
|
cmd += ");";
|
|
return mysql_query(sql, cmd.c_str());
|
|
}
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateInitInspDescTable(MYSQL* sql)
|
|
{
|
|
assert(NULL != sql);
|
|
|
|
std::string cmd = "create table if not exists initial_inspection_desc (sn varchar(20) not null primary key";
|
|
int size = sizeof(INITTIAL_INSPECTION) / sizeof(const HGChar*);
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
cmd += ", ";
|
|
cmd += INITTIAL_INSPECTION[i];
|
|
cmd += " text";
|
|
}
|
|
cmd += ");";
|
|
return mysql_query(sql, cmd.c_str());
|
|
}
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateImgInspTestTable(MYSQL* sql)
|
|
{
|
|
assert(NULL != sql);
|
|
|
|
std::string cmd = "create table if not exists image_inspection_test (sn varchar(20) not null primary key";
|
|
int size = sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*);
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
cmd += ", ";
|
|
cmd += IMAGE_INSPECTION[i];
|
|
cmd += " tinyint unsigned default 0";
|
|
}
|
|
cmd += ");";
|
|
return mysql_query(sql, cmd.c_str());
|
|
}
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreateImgInspDescTable(MYSQL* sql)
|
|
{
|
|
assert(NULL != sql);
|
|
|
|
std::string cmd = "create table if not exists image_inspection_desc (sn varchar(20) not null primary key";
|
|
int size = sizeof(IMAGE_INSPECTION) / sizeof(const HGChar*);
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
cmd += ", ";
|
|
cmd += IMAGE_INSPECTION[i];
|
|
cmd += " text";
|
|
}
|
|
cmd += ");";
|
|
return mysql_query(sql, cmd.c_str());
|
|
}
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreatePreInspTestTable(MYSQL* sql)
|
|
{
|
|
assert(NULL != sql);
|
|
|
|
std::string cmd = "create table if not exists pressure_inspection_test (sn varchar(20) not null primary key";
|
|
int size = sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*);
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
cmd += ", ";
|
|
cmd += PRESSURE_INSPECTION[i];
|
|
cmd += " tinyint unsigned default 0";
|
|
}
|
|
cmd += ");";
|
|
return mysql_query(sql, cmd.c_str());
|
|
}
|
|
|
|
int HGPdtToolDbUserMgrImpl::CreatePreInspDescTable(MYSQL* sql)
|
|
{
|
|
assert(NULL != sql);
|
|
|
|
std::string cmd = "create table if not exists pressure_inspection_desc (sn varchar(20) not null primary key";
|
|
int size = sizeof(PRESSURE_INSPECTION) / sizeof(const HGChar*);
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
cmd += ", ";
|
|
cmd += PRESSURE_INSPECTION[i];
|
|
cmd += " text";
|
|
}
|
|
cmd += ");";
|
|
return mysql_query(sql, cmd.c_str());
|
|
}
|
|
|
|
int HGPdtToolDbUserMgrImpl::InitMainTestItem(const HGChar* sn)
|
|
{
|
|
assert(NULL != sn && 0 != *sn && NULL != m_sql);
|
|
|
|
std::string title = "(sn, create_time, create_user, last_modify_time, last_modify_user)";
|
|
std::string value = "('" + (std::string)sn + "', now(), '" + m_userName + "', now(), '" + m_userName + "')";
|
|
std::string cmd = (std::string)"insert into main_test " + title + " values " + value + ";";
|
|
int ret = mysql_query(m_sql, cmd.c_str());
|
|
return (1062 == mysql_errno(m_sql)) ? 0 : ret;
|
|
}
|
|
|
|
int HGPdtToolDbUserMgrImpl::InitInspTestItem(const HGChar* tableName, const HGChar* sn)
|
|
{
|
|
assert(NULL != tableName && 0 != *tableName);
|
|
assert(NULL != sn && 0 != *sn && NULL != m_sql);
|
|
|
|
char sqlCmd[1024];
|
|
sprintf(sqlCmd, "insert into %s (sn) values ('%s');", tableName, sn);
|
|
int ret = mysql_query(m_sql, sqlCmd);
|
|
return (1062 == mysql_errno(m_sql)) ? 0 : ret;
|
|
}
|
|
|
|
|
|
HGPdtToolDbDeviceImpl::HGPdtToolDbDeviceImpl(class HGPdtToolDbUserMgrImpl* userMgr, const HGChar* sn)
|
|
{
|
|
m_userMgr = userMgr;
|
|
m_sn = sn;
|
|
}
|
|
|
|
HGPdtToolDbDeviceImpl::~HGPdtToolDbDeviceImpl()
|
|
{
|
|
m_userMgr->RemoveDevice(this);
|
|
}
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::GetCurrEntry(HGUInt* entryName)
|
|
{
|
|
if (NULL == entryName)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
sprintf(sqlCmd, "select current_entry from main_test where sn = '%s';", m_sn.c_str());
|
|
int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
if (0 != ret)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
MYSQL_RES* sqlRes = mysql_use_result(m_userMgr->m_sql);
|
|
if (NULL == sqlRes)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
MYSQL_ROW row = mysql_fetch_row(sqlRes);
|
|
if (NULL == row)
|
|
{
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
assert(NULL != row[0]);
|
|
*entryName = (HGUInt)atoll(row[0]);
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::SetCurrEntry(HGUInt entryName)
|
|
{
|
|
if (0 != entryName && 0xFFFFFFFF != entryName)
|
|
{
|
|
const HGChar* entryNameStr = GetEntryNameStr(entryName);
|
|
if (NULL == entryNameStr)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
}
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
sprintf(sqlCmd, "update main_test set current_entry = %u, last_modify_time = now(), last_modify_user = '%s' where sn = '%s';",
|
|
entryName, m_userMgr->m_userName.c_str(), m_sn.c_str());
|
|
int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
return (0 == ret) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::GetEntryStatus(HGUInt entryName, HGUInt* entryStatus)
|
|
{
|
|
if (NULL == entryStatus)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
const HGChar* entryNameStr = GetEntryNameStr(entryName);
|
|
const HGChar* tableName = GetTestTableName(entryName);
|
|
if (NULL == entryNameStr || NULL == tableName)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
sprintf(sqlCmd, "select %s from %s where sn = '%s';", entryNameStr, tableName, m_sn.c_str());
|
|
int ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
if (0 != ret)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
MYSQL_RES *sqlRes = mysql_use_result(m_userMgr->m_sql);
|
|
if (NULL == sqlRes)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
MYSQL_ROW row = mysql_fetch_row(sqlRes);
|
|
if (NULL == row)
|
|
{
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
assert(NULL != row[0]);
|
|
*entryStatus = (HGUInt)atoll(row[0]);
|
|
mysql_free_result(sqlRes);
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::SetEntryStatus(HGUInt entryName, HGUInt entryStatus)
|
|
{
|
|
if (entryStatus > HGPDTTOOLDB_ENTRYSTATUS_PASS)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
const HGChar* entryNameStr = GetEntryNameStr(entryName);
|
|
const HGChar* tableName = GetTestTableName(entryName);
|
|
if (NULL == entryNameStr || NULL == tableName)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
// 事务开始
|
|
int ret = mysql_query(m_userMgr->m_sql, "begin;");
|
|
if (0 != ret)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
sprintf(sqlCmd, "update %s set %s = %u where sn = '%s';", tableName, entryNameStr, entryStatus, m_sn.c_str());
|
|
ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
if (0 != ret)
|
|
{
|
|
mysql_query(m_userMgr->m_sql, "rollback;");
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
sprintf(sqlCmd, "update main_test set last_modify_time = now(), last_modify_user = '%s' where sn = '%s';",
|
|
m_userMgr->m_userName.c_str(), m_sn.c_str());
|
|
ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
if (0 != ret)
|
|
{
|
|
mysql_query(m_userMgr->m_sql, "rollback;");
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
// 事务结束
|
|
ret = mysql_query(m_userMgr->m_sql, "commit;");
|
|
assert(0 == ret);
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
HGResult HGPdtToolDbDeviceImpl::GetEntryExcepDesc(HGUInt entryName, HGChar* excepDesc, HGUInt maxLen)
|
|
{
|
|
if (NULL == 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)
|
|
{
|
|
const HGChar* entryNameStr = GetEntryNameStr(entryName);
|
|
const HGChar* tableName = GetDescTableName(entryName);
|
|
if (NULL == entryNameStr || NULL == tableName)
|
|
{
|
|
return HGBASE_ERR_INVALIDARG;
|
|
}
|
|
|
|
char sqlCmd[1024] = { 0 };
|
|
|
|
// 事务开始
|
|
int ret = mysql_query(m_userMgr->m_sql, "begin;");
|
|
if (0 != ret)
|
|
{
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
sprintf(sqlCmd, "update %s set %s = '%s' where sn = '%s';",
|
|
tableName, entryNameStr, (NULL != excepDesc) ? excepDesc : "", m_sn.c_str());
|
|
ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
if (0 != ret)
|
|
{
|
|
mysql_query(m_userMgr->m_sql, "rollback;");
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
sprintf(sqlCmd, "update main_test set last_modify_time = now(), last_modify_user = '%s' where sn = '%s';",
|
|
m_userMgr->m_userName.c_str(), m_sn.c_str());
|
|
ret = mysql_query(m_userMgr->m_sql, sqlCmd);
|
|
if (0 != ret)
|
|
{
|
|
mysql_query(m_userMgr->m_sql, "rollback;");
|
|
return HGBASE_ERR_FAIL;
|
|
}
|
|
|
|
// 事务结束
|
|
ret = mysql_query(m_userMgr->m_sql, "commit;");
|
|
assert(0 == ret);
|
|
|
|
return HGBASE_ERR_OK;
|
|
}
|
|
|
|
const HGChar* HGPdtToolDbDeviceImpl::GetEntryNameStr(HGUInt entryName)
|
|
{
|
|
if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
|
|
return INITTIAL_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH];
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
|
|
return IMAGE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE];
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
|
|
return PRESSURE_INSPECTION[entryName - HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1];
|
|
return NULL;
|
|
}
|
|
|
|
const HGChar* HGPdtToolDbDeviceImpl::GetTestTableName(HGUInt entryName)
|
|
{
|
|
if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
|
|
return "initial_inspection_test";
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
|
|
return "image_inspection_test";
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
|
|
return "pressure_inspection_test";
|
|
return NULL;
|
|
}
|
|
|
|
const HGChar* HGPdtToolDbDeviceImpl::GetDescTableName(HGUInt entryName)
|
|
{
|
|
if (entryName >= HGPDTTOOLDB_ENTRYNAME_DIAL_SWITCH && entryName <= HGPDTTOOLDB_ENTRYNAME_SCANNING_SENSOR)
|
|
return "initial_inspection_desc";
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_CONFIGURE_SPEED_MODE && entryName <= HGPDTTOOLDB_ENTRYNAME_MECH_PAPER_FEEDING_INCLINATION)
|
|
return "image_inspection_desc";
|
|
else if (entryName >= HGPDTTOOLDB_ENTRYNAME_SINGLE_PAGE_TEST_1 && entryName <= HGPDTTOOLDB_ENTRYNAME_CLEAR_ROLLER_COUNT)
|
|
return "pressure_inspection_desc";
|
|
return NULL;
|
|
} |