#include <jdbc/mysql_driver.h>
#include <mysql/jdbc.h>
#include <vector>
//部门任务
struct Dept {
std::string id;
std::string sample_name;
std::string sample_model;
std::string help_instruction;
std::string manufacture_no;
std::string manufacturer;
std::string customer_name;
std::string FULL_NAME;
std::string require_over_time;
std::string is_urgent;
};
// 我的任务
struct MyTasks
{
std::string id;
std::string sample_name;
std::string sample_model;
std::string help_instruction;
std::string manufacture_no;
std::string manufacturer;
std::string customer_name;
std::string FULL_NAME;
std::string require_over_time;
std::string is_urgent;
};
//创建任务单列表
struct CreateTaskList
{
std::string id;
std::string order_no;
std::string customer_name;
std::string DEPT_FULL_NAME;
std::string require_over_time;
std::string deliverer;
std::string is_urgent;
};
//查看任务单
struct CatTask
{
std::string id;
std::string order_no;
std::string customer_name;
std::string DEPT_FULL_NAME;
std::string require_over_time;
std::string deliverer;
std::string deliverer_tel;
std::string undertaker_name;
std::string undertake_time;
std::string is_urgent;
std::string receive_illustrate;
};
//查看任务单-任务单列表
struct CatTaskList
{
std::string id;
std::string sample_name;
std::string sample_model;
std::string manufacture_no;
std::string manufacturer;
std::string appendix_descn;
std::string special_require;
std::string measure_complete_time;
std::string conclusion;
std::string limit_instruction;
};
//标准设备管理
struct BizDeviceManage
{
std::string id;
std::string equipment_name;
std::string model;
std::string manufacture_no;
std::string manufacturer;
};
//标准设备管理-查看设备信息
struct CatDeviceInfor
{
std::string equipment_name;
std::string model;
std::string manufacture_no;
std::string measure_valid_date;
std::string product_country;
std::string manufacturer;
std::string produce_date;
std::string purchase_date;
std::string unit_price;
std::string usage_status;
std::string quality_status;
std::string dept_name;
std::string director_name;
std::string supplier_name;
std::string location;
std::string type;
std::string standard_type;
std::string category;
std::string level;
std::string measure_cycle;
std::string unpack_record_name;
std::string remark;
};
//标准设备管理-核查项目及核查点-直流稳压电源检定装置
struct CheckDCPower
{
std::string id;
std::string params;
std::string check_point;
std::string unit;
std::string resolution;
std::string urel;
std::string check_type;
std::string datum_point;
std::string cycle_number;
std::string resistance_value;
std::string resistance_value_unit;
std::string remark;
};
//被检设备管理-
struct TestedDevice
{
std::string id;
std::string equipment_name;
std::string model;
std::string help_instruction;
std::string manufacture_no;
std::string manufacturer;
std::string FULL_NAME;
std::string meter_identify;
std::string check_cycle;
std::string certificate_valid;
};
//被检设备管理-查看设备
struct TestedCatDevice
{
std::string equipment_name;
std::string model;
std::string help_instruction;
std::string manufacture_no;
std::string product_country;
std::string manufacturer;
std::string product_date;
std::string purchase_date;
std::string unit_price;
std::string usage_status;
std::string quality_condition;
std::string FULL_NAME;
std::string category;
std::string check_cycle;
std::string level;
std::string remark;
};
//被检设备管理-检定项目及检定点-检定项多功能校准源
struct VerificationMultifunctionalCalibration
{
std::string id;
std::string params;
std::string capacity;
std::string unit;
std::string frequency;
std::string range_range;
std::string standard_value;
std::string resolution;
std::string maximum_error;
std::string error_param_a;
std::string error_param_b;
};
//判断装置表
struct JudgeCalibrationTable
{
std::string item_category_id;
std::string belong_standard_equipment;
};
//检定数据管理
struct VerificationDataManagement
{
std::string id;
std::string sample_name;
std::string model;
std::string help_instruction;
std::string manufacture_no;
std::string manufacturer;
std::string customer_name;
std::string FULL_NAME;
std::string NAME;
std::string trace_date;
std::string measure_valid_date;
std::string meter_identify;
std::string restriction_instruction;
};
//检定数据管理-检定基本信息
struct VerificationBasicDataDetails
{
std::string sample_name;
std::string model;
std::string help_instruction;
std::string manufacture_no;
std::string manufacturer;
std::string customer_name;
std::string based_documents;
std::string trace_date;
std::string temperature;
std::string humidity;
std::string measure_address;
std::string measure_valid_date;
std::string NAME;
std::string conclusion;
std::string restriction_instruction;
};
//检定数据管理-检定结果信息
struct VerificationResultData
{
std::string id;
std::string params;
std::string capacity;
std::string unit;
std::string frequency;
std::string range_range;
std::string standard_value;
std::string resolution;
std::string maximum_error;
std::string error_param_a;
std::string error_param_b;
std::string other_outcome;
};
//核查数据管理
struct CheckDataManage
{
std::string id;
std::string equipment_name;
std::string model;
std::string manufacture_no;
std::string meter_standard_name;
std::string meter_standard_id;
std::string create_user_name;
std::string check_date;
std::string dept_name;
};
//核查数据管理-核查基本信息
struct CheckDataManageBasicInfo
{
std::string equipment_name;
std::string model;
std::string manufacture_no;
std::string manufacturer;
std::string temperature;
std::string humidity;
std::string check_date;
std::string check_address;
std::string create_user_name;
std::string conclusion;
};
//核查数据管理-核查结果信息-核查项多功能校准源数据
struct CheckDataManageResultManage
{
std::string id;
std::string check_type;
std::string params;
std::string unit;
std::string frequency;
std::string check_point;
std::string check_date;
std::string urel;
std::string tfer;
std::string dccp;
std::string flit;
};
class MySQLConnector {
private:
sql::mysql::MySQL_Driver* driver;
sql::Connection* con;
public:
MySQLConnector(const std::string& host, const std::string& port,const std::string& user, const std::string& password, const std::string& database) {
driver = sql::mysql::get_mysql_driver_instance();
con = driver->connect("tcp://" + host + ":"+ port, user, password);
con->setSchema(database);
con->setClientOption("character_set_results", "utf8mb4");
con->setClientOption("character_set_connection", "utf8mb4");
}
~MySQLConnector() {
delete con;
}
std::vector<Dept> getAllData() {
std::vector<Dept> result;
try {
sql::Statement* stmt = con->createStatement();
sql::ResultSet* res = stmt->executeQuery("SELECT bi.id ,br.sample_name , br.sample_model ,ei.help_instruction ,ei.manufacture_no ,ei.manufacturer ,bi.customer_name ,dept.FULL_NAME,bi.require_over_time ,bi.is_urgent FROM biz_business_order_info bi LEft JOIN biz_business_order_sample_relation br ON bi.id = br.order_id LEft JOIN eqpt_equipment_info ei ON br.sample_no = ei.equipment_no LEft JOIN sys_dept dept ON ei.dept_id = dept.ID LEft JOIN sys_user user ON user.ID = bi.create_user_id");
while (res->next()) {
Dept Dept;
Dept.id = res->getString("id");
Dept.sample_name = res->getString("sample_name");
Dept.sample_model = res->getString("sample_model");
Dept.help_instruction = res->getString("help_instruction");
Dept.manufacture_no = res->getString("manufacture_no");
Dept.manufacturer = res->getString("manufacturer");
Dept.customer_name = res->getString("customer_name");
Dept.FULL_NAME = res->getString("FULL_NAME");
Dept.require_over_time = res->getString("require_over_time");
Dept.is_urgent = res->getString("is_urgent");
result.push_back(Dept);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
std::vector<MyTasks> getMyTasks() {
std::vector<MyTasks> result;
try {
sql::Statement* stmt = con->createStatement();
sql::ResultSet* res = stmt->executeQuery("SELECT "
"bi.id, br.sample_name, br.sample_model, ei.help_instruction, ei.manufacture_no,"
"ei.manufacturer, bi.customer_name,"
"dept.FULL_NAME, bi.require_over_time,"
"bi.is_urgent FROM biz_business_order_info bi"
" LEfT JOIN biz_business_order_sample_relation br ON bi.id = br.order_id"
" LEfT JOIN eqpt_equipment_info ei ON br.sample_no = ei.equipment_no LEfT JOIN "
"sys_dept dept ON ei.dept_id = dept.ID WHERE bi.create_user_id = '1640229293790650370'");
while (res->next()) {
MyTasks MyTasks;
MyTasks.id = res->getString("id");
MyTasks.sample_name = res->getString("sample_name");
MyTasks.sample_model = res->getString("sample_model");
MyTasks.help_instruction = res->getString("help_instruction");
MyTasks.manufacture_no = res->getString("manufacture_no");
MyTasks.manufacturer = res->getString("manufacturer");
MyTasks.customer_name = res->getString("customer_name");
MyTasks.FULL_NAME = res->getString("FULL_NAME");
MyTasks.require_over_time = res->getString("require_over_time");
MyTasks.is_urgent = res->getString("is_urgent");
result.push_back(MyTasks);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
std::vector<CreateTaskList> getCreateTaskList() {
std::vector<CreateTaskList> result;
try {
sql::Statement* stmt = con->createStatement();
sql::ResultSet* res = stmt->executeQuery("SELECT bi.id,bi.order_no ,bi.customer_name ,dept.FULL_NAME ,"
"bi.require_over_time , bi.deliverer ,bi.is_urgent FROM biz_business_order_info bi,sys_dept dept WHERE bi.customer_id = dept.ID");
while (res->next()) {
CreateTaskList CreateTaskList;
CreateTaskList.id = res->getString("id");
CreateTaskList.order_no = res->getString("order_no");
CreateTaskList.customer_name = res->getString("customer_name");
CreateTaskList.DEPT_FULL_NAME = res->getString("FULL_NAME");
CreateTaskList.require_over_time = res->getString("require_over_time");
CreateTaskList.deliverer = res->getString("deliverer");
CreateTaskList.is_urgent = res->getString("is_urgent");
result.push_back(CreateTaskList);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
std::vector<CatTask> getCatTask(std::string orderNo) {
std::vector<CatTask> result;
try {
sql::Statement* stmt = con->createStatement();
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT bi.id, bi.order_no, bi.customer_name, dept.FULL_NAME, bi.require_over_time,"
"bi.deliverer, bi.deliverer_tel, bi.undertaker_name, bi.undertake_time, bi.is_urgent,"
"bi.receive_illustrate FROM biz_business_order_info bi LEFT JOIN sys_dept dept ON bi.customer_id = dept.ID"
" WHERE bi.order_no = ?");
// 绑定参数
prepStmt->setString(1, orderNo);
sql::ResultSet* res = prepStmt->executeQuery();
while (res->next()) {
CatTask CatTask;
CatTask.id = res->getString("id");
CatTask.order_no = res->getString("order_no");
CatTask.customer_name = res->getString("customer_name");
CatTask.DEPT_FULL_NAME = res->getString("FULL_NAME");
CatTask.require_over_time = res->getString("require_over_time");
CatTask.deliverer = res->getString("deliverer");
CatTask.deliverer_tel = res->getString("deliverer_tel");
CatTask.undertaker_name = res->getString("undertaker_name");
CatTask.undertake_time = res->getString("undertake_time");
CatTask.is_urgent = res->getString("is_urgent");
CatTask.receive_illustrate = res->getString("receive_illustrate");
result.push_back(CatTask);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
std::vector<CatTaskList> getCatTaskList(std::string orderId) {
std::vector<CatTaskList> result;
try {
sql::Statement* stmt = con->createStatement();
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT br.id , br.sample_name ,br.sample_model ,ei.manufacture_no,ei.manufacturer ,br.appendix_descn ,"
"br.special_require ,br.measure_complete_time ,bbdmi.conclusion ,ei.limit_instruction FROM biz_business_order_sample_relation br"
" Left JOIN eqpt_equipment_info ei ON br.sample_no = ei.equipment_no "
"Left JOIN biz_business_device_measure_info bbdmi ON br.order_id = bbdmi.order_id "
"WHERE br.order_id = ?;");
// 绑定参数
prepStmt->setString(1, orderId);
sql::ResultSet* res = prepStmt->executeQuery();
while (res->next()) {
CatTaskList CatTaskList;
CatTaskList.id = res->getString("id");
CatTaskList.sample_name = res->getString("sample_name");
CatTaskList.sample_model = res->getString("sample_model");
CatTaskList.manufacture_no = res->getString("manufacture_no");
CatTaskList.manufacturer = res->getString("manufacturer");
CatTaskList.appendix_descn = res->getString("appendix_descn");
CatTaskList.special_require = res->getString("special_require");
CatTaskList.measure_complete_time = res->getString("measure_complete_time");
CatTaskList.conclusion = res->getString("conclusion");
CatTaskList.limit_instruction = res->getString("limit_instruction");
result.push_back(CatTaskList);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
std::vector<BizDeviceManage> getBizDeviceManage() {
std::vector<BizDeviceManage> result;
try {
sql::Statement* stmt = con->createStatement();
sql::ResultSet* res = stmt->executeQuery("SELECT bei.id ,bei.equipment_name ,bei.model ,bei.manufacture_no ,bei.manufacturer FROM biz_equipment_info bei");
while (res->next()) {
BizDeviceManage BizDeviceManage;
BizDeviceManage.id = res->getString("id");
BizDeviceManage.equipment_name = res->getString("equipment_name");
BizDeviceManage.model = res->getString("model");
BizDeviceManage.manufacture_no = res->getString("manufacture_no");
BizDeviceManage.manufacturer = res->getString("manufacturer");
result.push_back(BizDeviceManage);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
std::vector<CatDeviceInfor> getCatDeviceInfor(std::string id) {
std::vector<CatDeviceInfor> result;
try {
sql::Statement* stmt = con->createStatement();
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT bei.equipment_name ,bei.model ,bei.manufacture_no ,bei.measure_valid_date ,"
"bei.product_country , bei.manufacturer , bei.produce_date, bei.purchase_date ,bei.unit_price , bei.usage_status , bei.quality_status , "
"bei.dept_name , bei.director_name , bei.supplier_name , bei.location , bei.type , bei.standard_type , bei.category , bei.level , "
"bei.measure_cycle , bei.unpack_record_name , bei.remark FROM biz_equipment_info bei WHERE bei.id = ?");
// 绑定参数
prepStmt->setString(1, id);
sql::ResultSet* res = prepStmt->executeQuery();
while (res->next()) {
CatDeviceInfor CatDeviceInfor;
//CatTaskList.id = res->getString("id");
CatDeviceInfor.equipment_name = res->getString("equipment_name");
CatDeviceInfor.model = res->getString("model");
CatDeviceInfor.manufacture_no = res->getString("manufacture_no");
CatDeviceInfor.measure_valid_date = res->getString("measure_valid_date");
CatDeviceInfor.product_country = res->getString("product_country");
CatDeviceInfor.manufacturer = res->getString("manufacturer");
CatDeviceInfor.produce_date = res->getString("produce_date");
CatDeviceInfor.purchase_date = res->getString("purchase_date");
CatDeviceInfor.unit_price = res->getString("unit_price");
CatDeviceInfor.usage_status = res->getString("usage_status");
CatDeviceInfor.quality_status = res->getString("quality_status");
CatDeviceInfor.dept_name = res->getString("dept_name");
CatDeviceInfor.director_name = res->getString("director_name");
CatDeviceInfor.supplier_name = res->getString("supplier_name");
CatDeviceInfor.location = res->getString("location");
CatDeviceInfor.type = res->getString("type");
CatDeviceInfor.location = res->getString("location");
CatDeviceInfor.standard_type = res->getString("standard_type");
CatDeviceInfor.category = res->getString("category");
CatDeviceInfor.level = res->getString("level");
CatDeviceInfor.measure_cycle = res->getString("measure_cycle");
CatDeviceInfor.unpack_record_name = res->getString("unpack_record_name");
CatDeviceInfor.remark = res->getString("remark");
result.push_back(CatDeviceInfor);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
//根据id获取装置名称
std::string getApparatus(std::string id) {
std::string result;
try {
// 使用预编译的PreparedStatement以防止SQL注入
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT besi.standard_name FROM biz_equipment_standard_info besi WHERE besi.id = ( "
"SELECT bei.meter_standard_id FROM biz_equipment_info bei WHERE bei.id = ? )"
);
// 设置参数
prepStmt->setString(1, id);
// 执行查询并获取结果集
sql::ResultSet* res = prepStmt->executeQuery();
// 检查是否获取到数据
if (res->next()) {
// 获取standard_name字段的值
result = res->getString("standard_name");
}
else {
// 如果没有找到对应记录，可以设置一个默认值或者抛出异常
result = "Not Found";
}
// 释放资源
delete res;
delete prepStmt; // 注意这里应该是删除PreparedStatement而不是Statement
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
// 可能需要在catch块中处理更详细的错误情况，比如重试、回滚事务等
}
return result;
}
//直流稳压电源检定装置
std::vector<CheckDCPower> getCheckDCPower(std::string item_category_id) {
std::vector<CheckDCPower> result;
try {
sql::Statement* stmt = con->createStatement();
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT besciddp.id ,besciddp.params,besciddp.unit,resolution,besciddp.urel,besciddp.check_type,datum_point,cycle_number"
", datum_point, resistance_value, resistance_value_unit, remark FROM biz_equipment_standard_check_item_data_dc_power besciddp WHERE item_category_id = (SELECT bescic.id FROM biz_equipment_standard_check_item_category bescic WHERE bescic.belong_standard_equipment_name = ?)");
// 绑定参数
prepStmt->setString(1, item_category_id);
sql::ResultSet* res = prepStmt->executeQuery();
while (res->next()) {
CheckDCPower CheckDCPower;
//CatTaskList.id = res->getString("id");
CheckDCPower.id = res->getString("id");
CheckDCPower.params = res->getString("params");
CheckDCPower.check_point = res->getString("check_point");
CheckDCPower.unit = res->getString("unit");
CheckDCPower.resolution = res->getString("resolution");
CheckDCPower.urel = res->getString("urel");
CheckDCPower.check_type = res->getString("check_type");
CheckDCPower.datum_point = res->getString("datum_point");
CheckDCPower.cycle_number = res->getString("cycle_number");
CheckDCPower.datum_point = res->getString("datum_point");
CheckDCPower.resistance_value = res->getString("resistance_value");
CheckDCPower.resistance_value_unit = res->getString("resistance_value_unit");
CheckDCPower.remark = res->getString("remark");
result.push_back(CheckDCPower);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
// 被检设备管理
std::vector<TestedDevice> getTestedDevice() {
std::vector<TestedDevice> result;
try {
sql::Statement* stmt = con->createStatement();
sql::ResultSet* res = stmt->executeQuery("SELECT eei.id ,eei.equipment_name ,eei.model ,eei.help_instruction ,eei.manufacture_no ,eei.manufacturer ,sys_dept.FULL_NAME ,eei.meter_identify ,eei.check_cycle ,eei.certificate_valid from eqpt_equipment_info eei LEFT JOIN sys_dept ON sys_dept.ID = eei.dept_id");
while (res->next()) {
TestedDevice TestedDevice;
TestedDevice.id = res->getString("id");
TestedDevice.equipment_name = res->getString("equipment_name");
TestedDevice.model = res->getString("model");
TestedDevice.help_instruction = res->getString("help_instruction");
TestedDevice.manufacture_no = res->getString("manufacture_no");
TestedDevice.manufacturer = res->getString("manufacturer");
TestedDevice.FULL_NAME = res->getString("FULL_NAME");
TestedDevice.meter_identify = res->getString("meter_identify");
TestedDevice.check_cycle = res->getString("check_cycle");
TestedDevice.certificate_valid = res->getString("certificate_valid");
result.push_back(TestedDevice);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
// 被检设备管理查看设备信息
std::vector<TestedCatDevice>getTestedCatDevice(std::string id) {
std::vector<TestedCatDevice> result;
try {
sql::Statement* stmt = con->createStatement();
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT eei.equipment_name ,eei.model ,eei.help_instruction ,eei.manufacture_no ,eei.product_country ,eei.manufacturer ,eei.product_date ,eei.purchase_date ,eei.unit_price ,eei.usage_status ,eei.quality_condition ,sys_dept.FULL_NAME ,"
"eei.category , eei.check_cycle ,eei.level , eei.remark from eqpt_equipment_info eei LEFT JOIN sys_dept ON sys_dept.ID = eei.dept_id WHERE eei.id = ?");
// 绑定参数
prepStmt->setString(1, id);
sql::ResultSet* res = prepStmt->executeQuery();
while (res->next()) {
TestedCatDevice TestedCatDevice;
//CatTaskList.id = res->getString("id");
TestedCatDevice.equipment_name = res->getString("equipment_name");
TestedCatDevice.model = res->getString("model");
TestedCatDevice.help_instruction = res->getString("help_instruction");
TestedCatDevice.manufacture_no = res->getString("manufacture_no");
TestedCatDevice.product_country = res->getString("product_country");
TestedCatDevice.manufacturer = res->getString("manufacturer");
TestedCatDevice.product_date = res->getString("product_date");
TestedCatDevice.purchase_date = res->getString("purchase_date");
TestedCatDevice.unit_price = res->getString("unit_price");
TestedCatDevice.usage_status = res->getString("usage_status");
TestedCatDevice.quality_condition = res->getString("quality_condition");
TestedCatDevice.FULL_NAME = res->getString("FULL_NAME");
TestedCatDevice.category = res->getString("category");
TestedCatDevice.check_cycle = res->getString("check_cycle");
TestedCatDevice.level = res->getString("level");
TestedCatDevice.remark = res->getString("remark");
result.push_back(TestedCatDevice);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
//判断检定装置是哪张表 参数：设备id
std::vector<JudgeCalibrationTable> getJudgeCalibrationTable(std::string id)
{
std::vector<JudgeCalibrationTable> result;
try {
// 使用预编译的PreparedStatement以防止SQL注入
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT item_category_id,belong_standard_equipment FROM biz_business_device_measure_item_info bbdmii WHERE bbdmii.device_model_id =(SELECT eei.model_id from eqpt_equipment_info eei WHERE eei.id = ?)"
);
// 设置参数 1716997603953311746
prepStmt->setString(1, id);
// 执行查询并获取结果集
sql::ResultSet* res = prepStmt->executeQuery();
while (res->next()) {
JudgeCalibrationTable JudgeCalibrationTable;
//CatTaskList.id = res->getString("id");
JudgeCalibrationTable.item_category_id = res->getString("item_category_id");
JudgeCalibrationTable.belong_standard_equipment = res->getString("belong_standard_equipment");
result.push_back(JudgeCalibrationTable);
}
// 释放资源
delete res;
delete prepStmt; // 注意这里应该是删除PreparedStatement而不是Statement
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
// 可能需要在catch块中处理更详细的错误情况，比如重试、回滚事务等
}
return result;
}
//被检设备管理-检定项目及检定点-多功能校准源
std::vector<VerificationMultifunctionalCalibration> getVerificationMultifunctionalCalibration(std::string itemId)
{
std::vector<VerificationMultifunctionalCalibration> result;
try {
sql::Statement* stmt = con->createStatement();
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT bbdmidc.id ,bbdmidc.params ,bbdmidc.capacity ,bbdmidc.unit ,bbdmidc.frequency , bbdmidc.range_range , bbdmidc.standard_value , bbdmidc.resolution , bbdmidc.maximum_error , bbdmidc.error_param_a , bbdmidc.error_param_b "
" FROM biz_business_device_measure_item_data_calibrator bbdmidc WHERE item_id = ?");
// 绑定参数 '1717086652508487681'
prepStmt->setString(1, itemId);
sql::ResultSet* res = prepStmt->executeQuery();
while (res->next()) {
VerificationMultifunctionalCalibration VerificationMultifunctionalCalibration;
VerificationMultifunctionalCalibration.id = res->getString("id");
VerificationMultifunctionalCalibration.params = res->getString("params");
VerificationMultifunctionalCalibration.capacity = res->getString("capacity");
VerificationMultifunctionalCalibration.unit = res->getString("unit");
VerificationMultifunctionalCalibration.frequency = res->getString("frequency");
VerificationMultifunctionalCalibration.range_range = res->getString("range_range");
VerificationMultifunctionalCalibration.standard_value = res->getString("standard_value");
VerificationMultifunctionalCalibration.resolution = res->getString("resolution");
VerificationMultifunctionalCalibration.maximum_error = res->getString("maximum_error");
VerificationMultifunctionalCalibration.error_param_a = res->getString("error_param_a");
VerificationMultifunctionalCalibration.error_param_b = res->getString("error_param_b");
result.push_back(VerificationMultifunctionalCalibration);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
//检定数据管理
std::vector<VerificationDataManagement> getVerificationDataManagement()
{
std::vector<VerificationDataManagement> result;
try {
sql::Statement* stmt = con->createStatement();
sql::ResultSet* res = stmt->executeQuery("SELECT bbdmi.id , bbdmi.sample_name ,bbdmi.model ,eei.help_instruction ,bbdmi.manufacture_no ,"
"bbdmi.manufacturer , bboi.customer_name , dept.FULL_NAME , _user.NAME , bbdmi.trace_date ,"
"bbdmi.measure_valid_date , eei.meter_identify , bbdmi.restriction_instruction "
"FROM biz_business_device_measure_info bbdmi LEFT JOIN eqpt_equipment_info eei ON bbdmi.sample_id = eei.id "
" LEFT JOIN biz_business_order_info bboi ON bbdmi.order_id = bboi.id LEFT JOIN sys_dept dept ON eei.dept_id = dept.ID "
" LEFT JOIN sys_user _user ON bbdmi.create_user_id = _user.id");
while (res->next()) {
VerificationDataManagement VerificationDataManagement;
VerificationDataManagement.id = res->getString("id");
VerificationDataManagement.sample_name = res->getString("sample_name");
VerificationDataManagement.model = res->getString("model");
VerificationDataManagement.help_instruction = res->getString("help_instruction");
VerificationDataManagement.manufacture_no = res->getString("manufacture_no");
VerificationDataManagement.manufacturer = res->getString("manufacturer");
VerificationDataManagement.FULL_NAME = res->getString("FULL_NAME");
VerificationDataManagement.NAME = res->getString("NAME");
VerificationDataManagement.trace_date = res->getString("trace_date");
VerificationDataManagement.measure_valid_date = res->getString("measure_valid_date");
VerificationDataManagement.meter_identify = res->getString("meter_identify");
VerificationDataManagement.restriction_instruction = res->getString("restriction_instruction");
result.push_back(VerificationDataManagement);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
//检定数据管理-检定基本信息
std::vector<VerificationBasicDataDetails> getVerificationBasicDataDetails(std::string id)
{
std::vector<VerificationBasicDataDetails> result;
try {
sql::Statement* stmt = con->createStatement();
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT bbdmi.sample_name ,bbdmi.model ,eei.help_instruction ,bbdmi.manufacture_no ,bbdmi.manufacturer ,"
" bboi.customer_name, eemtte.based_documents, bbdmi.trace_date , bbdmi.temperature , bbdmi.humidity ,"
"bbdmi.measure_address , bbdmi.measure_valid_date , _user.NAME , bbdmi.conclusion , bbdmi.restriction_instruction "
"FROM biz_business_device_measure_info bbdmi LEFT JOIN eqpt_equipment_info eei ON bbdmi.sample_id = eei.id "
" LEFT JOIN biz_business_order_info bboi ON bbdmi.order_id = bboi.id "
" LEFT JOIN biz_business_device_measure_item_info bbdmii ON bbdmi.item_id = bbdmii.id "
" LEFT JOIN eqpt_equipment_model_technical_target eemtte ON bbdmii.device_model_id = eemtte.model_id "
" LEFT JOIN sys_user _user ON bbdmi.create_user_id = _user.id WHERE bbdmi.id = ?");
prepStmt->setString(1, id);
//'1708657907573821442'
sql::ResultSet* res = prepStmt->executeQuery();
while (res->next()) {
VerificationBasicDataDetails VerificationBasicDataDetails;
VerificationBasicDataDetails.sample_name = res->getString("sample_name");
VerificationBasicDataDetails.model = res->getString("model");
VerificationBasicDataDetails.help_instruction = res->getString("help_instruction");
VerificationBasicDataDetails.manufacture_no = res->getString("manufacture_no");
VerificationBasicDataDetails.manufacturer = res->getString("manufacturer");
VerificationBasicDataDetails.customer_name = res->getString("customer_name");
VerificationBasicDataDetails.trace_date = res->getString("trace_date");
VerificationBasicDataDetails.temperature = res->getString("temperature");
VerificationBasicDataDetails.humidity = res->getString("humidity");
VerificationBasicDataDetails.measure_address = res->getString("measure_address");
VerificationBasicDataDetails.measure_valid_date = res->getString("measure_valid_date");
VerificationBasicDataDetails.based_documents = res->getString("based_documents");
VerificationBasicDataDetails.NAME = res->getString("NAME");
VerificationBasicDataDetails.conclusion = res->getString("conclusion");
VerificationBasicDataDetails.restriction_instruction = res->getString("restriction_instruction");
result.push_back(VerificationBasicDataDetails);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
//检定数据管理-检定结果信息
std::vector<VerificationResultData>getVerificationResultData(std::string sampleId)
{
std::vector<VerificationResultData> result;
try {
sql::Statement* stmt = con->createStatement();
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT bbdmidc.id ,bbdmidc.params ,bbdmidc.capacity ,bbdmidc.unit ,"
" bbdmidc.frequency , bbdmidc.range_range , bbdmidc.standard_value , bbdmidc.resolution , bbdmidc.maximum_error , "
" bbdmidc.error_param_a , bbdmidc.error_param_b ,bbdmi.other_outcome "
" FROM biz_business_device_measure_item_data_calibrator bbdmidc "
" LEFT JOIN biz_business_device_measure_info bbdmi ON bbdmi.item_id = bbdmidc.item_id "
"WHERE bbdmidc.item_id = (SELECT CONVERT(item_id USING utf8mb4) COLLATE utf8mb4_0900_ai_ci FROM biz_business_device_measure_info bbdmi "
" WHERE sample_id = ? )");
prepStmt->setString(1, sampleId);
//prepStmt->setString(2, otherOutcome);
//'1708657907573821442'
sql::ResultSet* res = prepStmt->executeQuery();
while (res->next()) {
VerificationResultData VerificationResultData;
VerificationResultData.id = res->getString("id");
VerificationResultData.params = res->getString("params");
VerificationResultData.capacity = res->getString("capacity");
VerificationResultData.unit = res->getString("unit");
VerificationResultData.frequency = res->getString("frequency");
VerificationResultData.range_range = res->getString("range_range");
VerificationResultData.standard_value = res->getString("standard_value");
VerificationResultData.resolution = res->getString("resolution");
VerificationResultData.maximum_error = res->getString("maximum_error");
VerificationResultData.error_param_a = res->getString("error_param_a");
VerificationResultData.error_param_b = res->getString("error_param_b");
VerificationResultData.other_outcome = res->getString("other_outcome");
result.push_back(VerificationResultData);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
//核查数据管理
std::vector<CheckDataManage> getCheckDataManage()
{
std::vector<CheckDataManage> result;
try {
sql::Statement* stmt = con->createStatement();
sql::ResultSet* res = stmt->executeQuery(
"SELECT bei.id , bei.equipment_name ,bei.model ,bei.manufacture_no ,bei.meter_standard_name ,bei.meter_standard_id ,"
" besci.create_user_name , besci.check_date , bei.dept_name "
" FROM biz_equipment_info bei LEFT JOIN biz_equipment_standard_check_info besci ON besci.equipment_id = bei.id"
);
while (res->next()) {
CheckDataManage CheckDataManage;
CheckDataManage.id = res->getString("id");
CheckDataManage.equipment_name = res->getString("equipment_name");
CheckDataManage.model = res->getString("model");
CheckDataManage.manufacture_no = res->getString("manufacture_no");
CheckDataManage.meter_standard_name = res->getString("meter_standard_name");
CheckDataManage.meter_standard_id = res->getString("meter_standard_id");
CheckDataManage.create_user_name = res->getString("create_user_name");
CheckDataManage.check_date = res->getString("check_date");
CheckDataManage.dept_name = res->getString("dept_name");
result.push_back(CheckDataManage);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
//核查数据管理-核查基本信息
std::vector<CheckDataManageBasicInfo> getCheckDataManageBasicInfo(std::string id) {
std::vector<CheckDataManageBasicInfo> result;
try {
sql::Statement* stmt = con->createStatement();
sql::PreparedStatement* prepStmt = con->prepareStatement(
"SELECT bei.equipment_name ,bei.model ,bei.manufacture_no ,bei.manufacturer ,besci.temperature ,besci.humidity ,besci.check_date ,"
" besci.check_address , besci.create_user_name , besci.conclusion "
"FROM biz_equipment_info bei LEFT JOIN biz_equipment_standard_check_info besci ON besci.equipment_id = bei.id "
" LEFT JOIN biz_equipment_standard_check_info_equipment bescie ON bei.id = bescie.check_equipment_id"
" WHERE bei.id = ? ");
prepStmt->setString(1, id);
//''1692780663553441794''
sql::ResultSet* res = prepStmt->executeQuery();
while (res->next()) {
CheckDataManageBasicInfo CheckDataManageBasicInfo;
CheckDataManageBasicInfo.equipment_name = res->getString("equipment_name");
CheckDataManageBasicInfo.model = res->getString("model");
CheckDataManageBasicInfo.manufacture_no = res->getString("manufacture_no");
CheckDataManageBasicInfo.manufacturer = res->getString("manufacturer");
CheckDataManageBasicInfo.temperature = res->getString("temperature");
CheckDataManageBasicInfo.humidity = res->getString("humidity");
CheckDataManageBasicInfo.check_date = res->getString("check_date");
CheckDataManageBasicInfo.check_address = res->getString("check_address");
CheckDataManageBasicInfo.create_user_name = res->getString("create_user_name");
CheckDataManageBasicInfo.conclusion = res->getString("conclusion");
result.push_back(CheckDataManageBasicInfo);
}
// Clean up
delete res;
delete stmt;
}
catch (sql::SQLException& e) {
std::cerr << "SQL error: " << e.what() << std::endl;
}
return result;
}
//核查数据管理-核查结果信息-核查项多功能校准源数据
std::vector<CheckDataManageResultManage> getCheckDataManageResultManage()
{
}
};
int main() {
MySQLConnector connector("111.198.10.15", "21906", "zdjdcs", "11111111", "casic_metering_xichang");
std::vector<Dept> people = connector.getAllData();
std::setlocale(LC_ALL, "en_US.utf8"); // 设置本地化环境为 UTF-8
std::wcout.imbue(std::locale("en_US.utf8"));
//for (const auto& Dept : people) {
// std::cout << Dept.id << ", " << Dept.sample_name << ", " << Dept.sample_model << ", " << Dept.help_instruction
// << Dept.manufacture_no << "," << Dept.manufacturer << "," << Dept.customer_name << "," << Dept.FULL_NAME
// << "," << Dept.require_over_time << "," << Dept.is_urgent
// << std::endl;
//}
std::vector<MyTasks> myTasks = connector.getMyTasks();
//for (const auto& MyTasks : myTasks)
//{
// std::cout << MyTasks.id << ", " << MyTasks.sample_name << ", " << MyTasks.sample_model << ", " << MyTasks.help_instruction
// << MyTasks.manufacture_no << "," << MyTasks.manufacturer << "," << MyTasks.customer_name << "," << MyTasks.FULL_NAME
// << "," << MyTasks.require_over_time << "," << MyTasks.is_urgent
// << std::endl;
//}
std::vector<CreateTaskList> createTaskList = connector.getCreateTaskList();
//for (const auto& CreateTaskList : createTaskList)
//{
// std::cout << CreateTaskList.id << ", " <<CreateTaskList.order_no << ", " << CreateTaskList.customer_name << ", " << CreateTaskList.DEPT_FULL_NAME << ", " << CreateTaskList.require_over_time
// << CreateTaskList.deliverer << "," << CreateTaskList.is_urgent
// << std::endl;
//}
std::vector<CatTask> catTask = connector.getCatTask("rwd202308220001");
/* for (const auto& CatTask : catTask)
{
std::cout << CatTask.id << "," << CatTask.order_no << ", " << CatTask.customer_name << ", " << CatTask.DEPT_FULL_NAME
<< ", " << CatTask.require_over_time << "," << CatTask.deliverer <<", "<< CatTask.deliverer_tel << ", " << CatTask.undertaker_name << ", " << CatTask.undertake_time << "," << CatTask.is_urgent << "," << CatTask.receive_illustrate
<< std::endl;
}*/
std::vector<CatTaskList> catTaskList = connector.getCatTaskList("1735863426170793985");
//for (const auto& CatTaskList : catTaskList)
//{
// std::cout << CatTaskList.id << "," << CatTaskList.sample_name << ", " << CatTaskList.sample_model << ", " << CatTaskList.manufacture_no
// << ", " << CatTaskList.manufacturer << "," << CatTaskList.appendix_descn << ", " << CatTaskList.special_require << ", " << CatTaskList.measure_complete_time << ", "
// << CatTaskList.conclusion << "," << CatTaskList.limit_instruction
// << std::endl;
//}
std::vector<BizDeviceManage> bizDeviceManage = connector.getBizDeviceManage();
//for (const auto& BizDeviceManage : bizDeviceManage)
//{
// std::cout << BizDeviceManage.id << "," << BizDeviceManage.equipment_name << ", " << BizDeviceManage.model << ", " << BizDeviceManage.manufacture_no
// << ", " << BizDeviceManage.manufacturer
// << std::endl;
//}
std::vector<CatDeviceInfor> catDeviceInfor = connector.getCatDeviceInfor("1692772193007128577");
//for (const auto& CatDeviceInfor : catDeviceInfor)
//{
// std::cout << CatDeviceInfor.equipment_name << "," << CatDeviceInfor.model << ", " << CatDeviceInfor.manufacture_no << ", " << CatDeviceInfor.measure_valid_date
// << ", " << CatDeviceInfor.manufacturer
// << std::endl;
//}
std::string getApparatus = connector.getApparatus("1752157193060225025");
//std::cout << getApparatus << std::endl;
std::vector<TestedDevice> getTestedDevice = connector.getTestedDevice();
/* for (const auto& TestedDevice : getTestedDevice)
{
std::cout << TestedDevice.id << "," << TestedDevice.equipment_name << ", " << TestedDevice.model << ", " << TestedDevice.help_instruction
<< ", " << TestedDevice.manufacture_no
<< std::endl;
}*/
std::vector<TestedCatDevice> getTestedCatDevice = connector.getTestedCatDevice("1697133619962744833");
//for (const auto& TestedCatDevice : getTestedCatDevice)
//{
// std::cout << TestedCatDevice.equipment_name << ", " << TestedCatDevice.model << ", " << TestedCatDevice.help_instruction
// << ", " << TestedCatDevice.manufacture_no << std::endl;
//}
std::vector<JudgeCalibrationTable> getJudgeCalibrationTable = connector.getJudgeCalibrationTable("1716997603953311746");
for (const auto& JudgeCalibrationTable : getJudgeCalibrationTable)
{
std::cout << JudgeCalibrationTable.item_category_id << ", " << JudgeCalibrationTable.belong_standard_equipment << std::endl;
}
std::vector<VerificationMultifunctionalCalibration> getVerificationMultifunctionalCalibration = connector.getVerificationMultifunctionalCalibration("1717086652508487681");
/* for (const auto& VerificationMultifunctionalCalibration : getVerificationMultifunctionalCalibration)
{
std::cout << VerificationMultifunctionalCalibration.id << ", " << VerificationMultifunctionalCalibration.params << ", " << VerificationMultifunctionalCalibration.capacity
<< ", " << VerificationMultifunctionalCalibration.unit << ", " << VerificationMultifunctionalCalibration.frequency << std::endl;
}*/
std::vector< VerificationDataManagement> getVerificationDataManagement = connector.getVerificationDataManagement();
//for (const auto& VerificationDataManagement : getVerificationDataManagement)
//{
// std::cout << VerificationDataManagement.id << ", " << VerificationDataManagement.sample_name
// << ", " << VerificationDataManagement.model
// << ", " << VerificationDataManagement.help_instruction
// << ", " << VerificationDataManagement.manufacture_no
// << ", " << VerificationDataManagement.manufacturer
// << ", " << VerificationDataManagement.FULL_NAME
// << ", " << VerificationDataManagement.NAME
// << std::endl;
//}
std::vector<VerificationBasicDataDetails> getVerificationBasicDataDetails = connector.getVerificationBasicDataDetails("1708657907573821442");
//for (const auto& VerificationBasicDataDetails : getVerificationBasicDataDetails)
//{
// std::cout << VerificationBasicDataDetails.sample_name
// << ", " << VerificationBasicDataDetails.model
// << ", " << VerificationBasicDataDetails.help_instruction
// << ", " << VerificationBasicDataDetails.manufacture_no
// << ", " << VerificationBasicDataDetails.manufacturer
// << ", " << VerificationBasicDataDetails.customer_name
// << ", " << VerificationBasicDataDetails.NAME
// << std::endl;
//}
std::vector<VerificationResultData> getVerificationResultData = connector.getVerificationResultData("1716997603953311746");
//for (const auto& VerificationResultData : getVerificationResultData)
//{
// std::cout << VerificationResultData.id
// << ", " << VerificationResultData.params
// << ", " << VerificationResultData.capacity
// << ", " << VerificationResultData.unit
// << ", " << VerificationResultData.frequency
// << ", " << VerificationResultData.range_range
// << ", " << VerificationResultData.standard_value
// << std::endl;
//}
std::vector<CheckDataManage> getCheckDataManage = connector.getCheckDataManage();
//for (const auto& CheckDataManage : getCheckDataManage)
//{
// std::cout << CheckDataManage.id
// << ", " << CheckDataManage.equipment_name
// << ", " << CheckDataManage.model
// << ", " << CheckDataManage.manufacture_no
// << ", " << CheckDataManage.meter_standard_name
// << ", " << CheckDataManage.meter_standard_id
// << ", " << CheckDataManage.create_user_name
// << ", " << CheckDataManage.create_user_name
// << ", " << CheckDataManage.dept_name
// << std::endl;
//}
std::vector<CheckDataManageBasicInfo> getCheckDataManageBasicInfo = connector.getCheckDataManageBasicInfo("1692780663553441794");
for (const auto& CheckDataManageBasicInfo : getCheckDataManageBasicInfo)
{
std::cout
<< CheckDataManageBasicInfo.equipment_name
<< ", " << CheckDataManageBasicInfo.model
<< ", " << CheckDataManageBasicInfo.manufacture_no
<< ", " << CheckDataManageBasicInfo.temperature
<< ", " << CheckDataManageBasicInfo.humidity
<< ", " << CheckDataManageBasicInfo.create_user_name
<< ", " << CheckDataManageBasicInfo.create_user_name
<< ", " << CheckDataManageBasicInfo.check_date
<< ", " << CheckDataManageBasicInfo.check_address
<< std::endl;
}
return 0;
}
