2022-05-24 02:01:36 +00:00
|
|
|
|
#include "WSUser.h"
|
2022-05-23 10:29:23 +00:00
|
|
|
|
#include "WSServer.h"
|
|
|
|
|
#include "ManagerV2.h"
|
|
|
|
|
#include "base/HGInfo.h"
|
2022-06-06 10:51:34 +00:00
|
|
|
|
#include "base/HGUtility.h"
|
2022-05-23 10:29:23 +00:00
|
|
|
|
#include "sha1.h"
|
|
|
|
|
#include "base64.h"
|
2022-05-30 11:01:23 +00:00
|
|
|
|
#include "HGString.h"
|
2022-05-23 10:29:23 +00:00
|
|
|
|
|
|
|
|
|
namespace ver_2
|
|
|
|
|
{
|
2022-06-01 10:36:22 +00:00
|
|
|
|
static int GetJsonIntValue(cJSON* json, const std::string& key, bool *find = NULL)
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
int ret = 0;
|
2022-06-01 10:36:22 +00:00
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = false;
|
2022-05-23 10:29:23 +00:00
|
|
|
|
|
|
|
|
|
cJSON* p = json->child;
|
|
|
|
|
while (NULL != p)
|
|
|
|
|
{
|
|
|
|
|
if (0 == strcmp(p->string, key.c_str()))
|
|
|
|
|
{
|
|
|
|
|
if (p->type == cJSON_Number)
|
2022-06-01 10:36:22 +00:00
|
|
|
|
{
|
2022-05-23 10:29:23 +00:00
|
|
|
|
ret = p->valueint;
|
2022-06-01 10:36:22 +00:00
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = true;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-23 10:29:23 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
p = p->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-06 11:34:54 +00:00
|
|
|
|
static double GetJsonDoubleValue(cJSON* json, const std::string& key, bool* find = NULL)
|
|
|
|
|
{
|
|
|
|
|
double ret = 0.0;
|
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = false;
|
|
|
|
|
|
|
|
|
|
cJSON* p = json->child;
|
|
|
|
|
while (NULL != p)
|
|
|
|
|
{
|
|
|
|
|
if (0 == strcmp(p->string, key.c_str()))
|
|
|
|
|
{
|
|
|
|
|
if (p->type == cJSON_Number)
|
|
|
|
|
{
|
|
|
|
|
ret = p->valuedouble;
|
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
p = p->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-01 10:36:22 +00:00
|
|
|
|
static bool GetJsonBoolValue(cJSON* json, const std::string& key, bool* find = NULL)
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
bool ret = false;
|
2022-06-01 10:36:22 +00:00
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = false;
|
2022-05-23 10:29:23 +00:00
|
|
|
|
|
|
|
|
|
cJSON* p = json->child;
|
|
|
|
|
while (NULL != p)
|
|
|
|
|
{
|
|
|
|
|
if (0 == strcmp(p->string, key.c_str()))
|
|
|
|
|
{
|
2022-06-01 10:36:22 +00:00
|
|
|
|
if (p->type == cJSON_True || p->type == cJSON_False)
|
|
|
|
|
{
|
|
|
|
|
ret = (p->type == cJSON_True) ? true : false;
|
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = true;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-23 10:29:23 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
p = p->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-01 10:36:22 +00:00
|
|
|
|
static std::string GetJsonStringValue(cJSON* json, const std::string& key, bool* find = NULL)
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
std::string ret;
|
2022-06-01 10:36:22 +00:00
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = false;
|
|
|
|
|
|
|
|
|
|
cJSON* p = json->child;
|
|
|
|
|
while (NULL != p)
|
|
|
|
|
{
|
|
|
|
|
if (0 == strcmp(p->string, key.c_str()))
|
|
|
|
|
{
|
2022-06-15 11:07:55 +00:00
|
|
|
|
if (p->type == cJSON_String)
|
2022-06-01 10:36:22 +00:00
|
|
|
|
{
|
2022-06-15 11:07:55 +00:00
|
|
|
|
ret = p->valuestring;
|
2022-06-01 10:36:22 +00:00
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
p = p->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static std::vector<std::string> GetJsonStringListValue(cJSON* json, const std::string& key, bool* find = NULL)
|
|
|
|
|
{
|
|
|
|
|
std::vector<std::string> ret;
|
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = false;
|
2022-05-23 10:29:23 +00:00
|
|
|
|
|
|
|
|
|
cJSON* p = json->child;
|
|
|
|
|
while (NULL != p)
|
|
|
|
|
{
|
|
|
|
|
if (0 == strcmp(p->string, key.c_str()))
|
|
|
|
|
{
|
2022-06-01 10:36:22 +00:00
|
|
|
|
if (p->type == cJSON_Array)
|
|
|
|
|
{
|
|
|
|
|
cJSON* pEx = p->child;
|
|
|
|
|
while (NULL != pEx)
|
|
|
|
|
{
|
|
|
|
|
if (pEx->type == cJSON_String)
|
|
|
|
|
ret.push_back(pEx->valuestring);
|
|
|
|
|
|
|
|
|
|
pEx = pEx->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = true;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-23 10:29:23 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
p = p->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-09 09:30:04 +00:00
|
|
|
|
static std::vector<int> GetJsonIntListValue(cJSON* json, const std::string& key, bool* find = NULL)
|
|
|
|
|
{
|
|
|
|
|
std::vector<int> ret;
|
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = false;
|
|
|
|
|
|
|
|
|
|
cJSON* p = json->child;
|
|
|
|
|
while (NULL != p)
|
|
|
|
|
{
|
|
|
|
|
if (0 == strcmp(p->string, key.c_str()))
|
|
|
|
|
{
|
|
|
|
|
if (p->type == cJSON_Array)
|
|
|
|
|
{
|
|
|
|
|
cJSON* pEx = p->child;
|
|
|
|
|
while (NULL != pEx)
|
|
|
|
|
{
|
|
|
|
|
if (pEx->type == cJSON_Number)
|
|
|
|
|
ret.push_back(pEx->valueint);
|
|
|
|
|
|
|
|
|
|
pEx = pEx->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL != find)
|
|
|
|
|
*find = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
p = p->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-23 10:29:23 +00:00
|
|
|
|
#if defined(HG_CMP_MSC)
|
|
|
|
|
WSUser::WSUser(WebServer* server, HGUInt id, const std::string& ip, uint16_t port, SOCKET sockConn)
|
|
|
|
|
#else
|
|
|
|
|
WSUser::WSUser(WebServer* server, HGUInt id, const std::string& ip, uint16_t port, int sockConn)
|
|
|
|
|
#endif
|
|
|
|
|
: WebUser(server, id, ip, port, sockConn)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
m_initDeviceIden.clear();
|
|
|
|
|
m_initDeviceHaveIden = false;
|
|
|
|
|
m_startScanIden.clear();
|
|
|
|
|
m_startScanHaveIden = false;
|
2022-08-01 07:58:12 +00:00
|
|
|
|
m_startScanBlankCheck = false;
|
2022-06-21 10:37:41 +00:00
|
|
|
|
m_startScanIsLocalSave = true;
|
2022-06-09 03:05:24 +00:00
|
|
|
|
m_startScanIsGetBase64 = false;
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2023-05-16 07:37:40 +00:00
|
|
|
|
GetManager()->AddUser(this);
|
2022-05-23 10:29:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
WSUser::~WSUser()
|
|
|
|
|
{
|
2023-05-16 07:37:40 +00:00
|
|
|
|
GetManager()->RemoveUser(this);
|
2022-05-23 10:29:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ManagerV2* WSUser::GetManager()
|
|
|
|
|
{
|
|
|
|
|
return ((WSServer*)m_server)->GetManger();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::HandleCmd(const WSCmdParam* param)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != param && m_id == param->usrId);
|
|
|
|
|
|
|
|
|
|
std::string cmdData((const char*)param->data, param->size);
|
|
|
|
|
cJSON* json = cJSON_Parse(cmdData.c_str());
|
|
|
|
|
if (NULL != json)
|
|
|
|
|
{
|
|
|
|
|
std::string func = GetJsonStringValue(json, "func");
|
2022-05-30 11:01:23 +00:00
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden");
|
|
|
|
|
|
2022-05-23 10:29:23 +00:00
|
|
|
|
if ("set_global_config" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
SetGlobalConfig(json);
|
2022-05-23 10:29:23 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("get_global_config" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
GetGlobalConfig(json);
|
2022-05-23 10:29:23 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("load_local_image" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
LoadLocalImage(json);
|
2022-05-31 09:39:54 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("save_local_image" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
SaveLocalImage(json);
|
2022-05-23 10:29:23 +00:00
|
|
|
|
}
|
2022-06-01 10:36:22 +00:00
|
|
|
|
else if ("delete_local_file" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
DeleteLocalFile(json);
|
2022-06-01 10:36:22 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("clear_global_file_save_path" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
ClearGlobalFileSavePath(json);
|
2022-06-01 10:36:22 +00:00
|
|
|
|
}
|
2022-06-21 10:37:41 +00:00
|
|
|
|
else if ("merge_local_image" == func || "merge_base64_image" == func || "merge_image" == func)
|
2022-06-01 10:36:22 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
MergeImage(json, func);
|
2022-06-01 10:36:22 +00:00
|
|
|
|
}
|
2022-06-21 10:37:41 +00:00
|
|
|
|
else if ("local_make_multi_image" == func || "base64_make_multi_image" == func || "make_multi_image" == func)
|
2022-06-01 10:36:22 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
MakeMultiImage(json, func);
|
2022-06-01 10:36:22 +00:00
|
|
|
|
}
|
2022-06-21 10:37:41 +00:00
|
|
|
|
else if ("split_local_image" == func || "split_base64_image" == func || "split_image" == func)
|
2022-06-01 10:36:22 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
SplitImage(json, func);
|
2022-06-01 10:36:22 +00:00
|
|
|
|
}
|
2022-06-21 10:37:41 +00:00
|
|
|
|
else if ("local_make_zip_file" == func || "base64_make_zip_file" == func || "make_zip_file" == func)
|
2022-06-01 10:36:22 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
MakeZipFile(json, func);
|
2022-06-01 10:36:22 +00:00
|
|
|
|
}
|
2022-06-21 10:37:41 +00:00
|
|
|
|
else if ("local_image_deskew" == func || "base64_image_deskew" == func || "image_deskew" == func)
|
2022-06-01 10:36:22 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
ImageDeskew(json, func);
|
2022-06-01 10:36:22 +00:00
|
|
|
|
}
|
2022-06-21 10:37:41 +00:00
|
|
|
|
else if ("local_image_add_watermark" == func || "base64_image_add_watermark" == func || "image_add_watermark" == func)
|
2022-06-14 10:22:23 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
ImageAddWatermark(json, func);
|
|
|
|
|
}
|
|
|
|
|
else if ("local_image_decontamination" == func || "base64_image_decontamination" == func || "image_decontamination" == func)
|
|
|
|
|
{
|
|
|
|
|
ImageDecontamination(json, func);
|
2022-06-14 10:22:23 +00:00
|
|
|
|
}
|
2022-06-23 03:35:17 +00:00
|
|
|
|
else if ("local_image_direction_correct" == func || "base64_image_direction_correct" == func || "image_direction_correct" == func)
|
|
|
|
|
{
|
|
|
|
|
ImageDirectionCorrect(json, func);
|
|
|
|
|
}
|
2022-07-11 08:40:21 +00:00
|
|
|
|
else if ("local_image_clip" == func || "base64_image_clip" == func || "image_clip" == func)
|
|
|
|
|
{
|
|
|
|
|
ImageClip(json, func);
|
|
|
|
|
}
|
2022-07-27 07:56:10 +00:00
|
|
|
|
else if ("upload_image" == func || "upload_local_file" == func || "upload_image_base64" == func)
|
2022-06-01 10:36:22 +00:00
|
|
|
|
{
|
2022-07-27 07:56:10 +00:00
|
|
|
|
UploadFile(json, func);
|
2022-06-01 10:36:22 +00:00
|
|
|
|
}
|
2022-05-30 11:01:23 +00:00
|
|
|
|
else if ("init_device" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
InitDevice(json);
|
2022-05-30 11:01:23 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("deinit_device" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
DeinitDevice(json);
|
2022-05-30 11:01:23 +00:00
|
|
|
|
}
|
2023-05-17 07:37:04 +00:00
|
|
|
|
else if ("is_device_init" == func)
|
|
|
|
|
{
|
|
|
|
|
IsDeviceInit(json);
|
|
|
|
|
}
|
2022-05-30 11:01:23 +00:00
|
|
|
|
else if ("get_device_name_list" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
GetDeviceNameList(json);
|
2022-05-30 11:01:23 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("open_device" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
OpenDevice(json);
|
2022-05-30 11:01:23 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("close_device" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
CloseDevice(json);
|
2022-06-01 10:36:22 +00:00
|
|
|
|
}
|
2023-09-06 03:11:34 +00:00
|
|
|
|
else if ("get_device_sn" == func)
|
|
|
|
|
{
|
|
|
|
|
GetDeviceSN(json);
|
|
|
|
|
}
|
2022-06-01 10:36:22 +00:00
|
|
|
|
else if ("set_device_param" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
SetDeviceParam(json);
|
2022-06-01 10:36:22 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("get_device_param" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
GetDeviceParam(json);
|
2022-05-30 11:01:23 +00:00
|
|
|
|
}
|
2022-06-16 06:20:52 +00:00
|
|
|
|
else if ("reset_device_param" == func)
|
|
|
|
|
{
|
|
|
|
|
ResetDeviceParam(json);
|
|
|
|
|
}
|
2022-05-30 11:01:23 +00:00
|
|
|
|
else if ("get_curr_device_name" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
GetCurrDeviceName(json);
|
2022-05-30 11:01:23 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("start_scan" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
StartScan(json);
|
2022-05-30 11:01:23 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("stop_scan" == func)
|
|
|
|
|
{
|
2022-06-06 10:51:34 +00:00
|
|
|
|
StopScan(json);
|
2022-05-30 11:01:23 +00:00
|
|
|
|
}
|
2023-05-17 07:37:04 +00:00
|
|
|
|
else if ("is_device_scanning" == func)
|
|
|
|
|
{
|
|
|
|
|
IsDeviceScanning(json);
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
else if ("get_batch_id_list" == func)
|
|
|
|
|
{
|
|
|
|
|
GetBatchIdList(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("open_batch" == func)
|
|
|
|
|
{
|
|
|
|
|
OpenBatch(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("delete_batch" == func)
|
|
|
|
|
{
|
|
|
|
|
DeleteBatch(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("new_batch" == func)
|
|
|
|
|
{
|
|
|
|
|
NewBatch(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("get_curr_batch_id" == func)
|
|
|
|
|
{
|
|
|
|
|
GetCurrBatchId(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("modify_batch_id" == func)
|
|
|
|
|
{
|
|
|
|
|
ModifyBatchId(json);
|
|
|
|
|
}
|
2022-06-11 06:18:33 +00:00
|
|
|
|
else if ("bind_folder" == func)
|
|
|
|
|
{
|
|
|
|
|
BindFolder(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("stop_bind_folder" == func)
|
|
|
|
|
{
|
|
|
|
|
StopBindFolder(json);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
else if ("get_image_thumbnail_list" == func)
|
|
|
|
|
{
|
|
|
|
|
GetImageThumbnailList(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("get_image_count" == func)
|
|
|
|
|
{
|
|
|
|
|
GetImageCount(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("load_image" == func)
|
|
|
|
|
{
|
|
|
|
|
LoadImage(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("save_image" == func)
|
|
|
|
|
{
|
|
|
|
|
SaveImage(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("insert_local_image" == func)
|
|
|
|
|
{
|
|
|
|
|
InsertLocalImage(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("insert_image" == func)
|
|
|
|
|
{
|
|
|
|
|
InsertImage(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("modify_image_tag" == func)
|
|
|
|
|
{
|
|
|
|
|
ModifyImageTag(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("delete_image" == func)
|
|
|
|
|
{
|
|
|
|
|
DeleteImage(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("clear_image_list" == func)
|
|
|
|
|
{
|
|
|
|
|
ClearImageList(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("modify_image" == func)
|
|
|
|
|
{
|
|
|
|
|
ModifyImage(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("modify_image_by_local" == func)
|
|
|
|
|
{
|
|
|
|
|
ModifyImageByLocal(json);
|
|
|
|
|
}
|
|
|
|
|
else if ("move_image" == func)
|
|
|
|
|
{
|
|
|
|
|
MoveImage(json);
|
|
|
|
|
}
|
2022-06-11 06:18:33 +00:00
|
|
|
|
else if ("exchange_image" == func)
|
|
|
|
|
{
|
|
|
|
|
ExchangeImage(json);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
else if ("image_book_sort" == func)
|
|
|
|
|
{
|
|
|
|
|
ImageBookSort(json);
|
|
|
|
|
}
|
2022-05-23 10:29:23 +00:00
|
|
|
|
|
|
|
|
|
cJSON_Delete(json);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::HandleEvent(const WSEvtParam* param)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != param && m_id == param->usrId);
|
|
|
|
|
|
|
|
|
|
SendResponse(param->data, param->size, HGTRUE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::PostCmdMsg(const HGByte* data, HGUInt dataSize)
|
|
|
|
|
{
|
|
|
|
|
WSCmdParam* param = new WSCmdParam;
|
|
|
|
|
param->svr = (WSServer*)m_server;
|
|
|
|
|
param->usrId = m_id;
|
|
|
|
|
param->data = new HGByte[dataSize];
|
|
|
|
|
param->size = dataSize;
|
|
|
|
|
memcpy(param->data, data, dataSize);
|
|
|
|
|
|
|
|
|
|
HGMsg msg;
|
|
|
|
|
msg.id = MSGID_WS_COMMAND;
|
|
|
|
|
msg.data = param;
|
|
|
|
|
if (HGBASE_ERR_OK != HGBase_PostPumpMessage(m_server->GetMsgPump(), &msg))
|
|
|
|
|
{
|
|
|
|
|
delete[] param->data;
|
|
|
|
|
param->size = 0;
|
|
|
|
|
delete param;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::PostEventMsg(const HGByte* data, HGUInt dataSize)
|
|
|
|
|
{
|
|
|
|
|
WSEvtParam* param = new WSEvtParam;
|
|
|
|
|
param->svr = (WSServer*)m_server;
|
|
|
|
|
param->usrId = m_id;
|
|
|
|
|
param->data = new HGByte[dataSize];
|
|
|
|
|
param->size = dataSize;
|
|
|
|
|
memcpy(param->data, data, dataSize);
|
|
|
|
|
|
|
|
|
|
HGMsg msg;
|
|
|
|
|
msg.id = MSGID_WS_EVENT;
|
|
|
|
|
msg.data = param;
|
|
|
|
|
if (HGBASE_ERR_OK != HGBase_PostPumpMessage(m_server->GetMsgPump(), &msg))
|
|
|
|
|
{
|
|
|
|
|
delete[] param->data;
|
|
|
|
|
param->size = 0;
|
|
|
|
|
delete param;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::ThreadFunc()
|
|
|
|
|
{
|
|
|
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "WSUser::ThreadFunc");
|
|
|
|
|
|
|
|
|
|
char chBuffer[2048];
|
|
|
|
|
const char* pBuffer = chBuffer;
|
|
|
|
|
int nBufferSize = 0;
|
|
|
|
|
bool bConnect = false;
|
|
|
|
|
|
|
|
|
|
unsigned char connectDataTail[4] = { '\r', '\n', '\r', '\n' };
|
|
|
|
|
unsigned int connectDataTailLen = 0;
|
|
|
|
|
std::string connectData;
|
|
|
|
|
|
|
|
|
|
uint8_t* pData = NULL;
|
|
|
|
|
int nDataSize = 0;
|
|
|
|
|
uint8_t* pDataEx = NULL;
|
|
|
|
|
int nRemainSize = 0;
|
|
|
|
|
uint8_t headData[20];
|
|
|
|
|
uint32_t nHeadDataLen = 0;
|
|
|
|
|
uint8_t vMask[4];
|
|
|
|
|
uint32_t nMaskCount = 0;
|
|
|
|
|
bool bHandle = false;
|
|
|
|
|
std::vector<uint8_t> vAllData;
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
if (0 == nBufferSize)
|
|
|
|
|
{
|
|
|
|
|
int len = recv(m_sockConn, chBuffer, 2048, 0);
|
|
|
|
|
if (len <= 0)
|
|
|
|
|
{
|
2022-05-24 02:01:36 +00:00
|
|
|
|
// 这里跳出,可能是服务器关闭了socketConn,或者客户端关闭了socket,或者网络断开
|
2022-05-23 10:29:23 +00:00
|
|
|
|
PostDisConnectMsg();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
pBuffer = chBuffer;
|
|
|
|
|
nBufferSize = len;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
assert(nBufferSize > 0);
|
|
|
|
|
|
|
|
|
|
if (!bConnect)
|
|
|
|
|
{
|
|
|
|
|
unsigned char b = *pBuffer;
|
|
|
|
|
++pBuffer;
|
|
|
|
|
--nBufferSize;
|
|
|
|
|
|
|
|
|
|
connectData.push_back(b);
|
|
|
|
|
if (b == connectDataTail[connectDataTailLen])
|
|
|
|
|
{
|
|
|
|
|
++connectDataTailLen;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
connectDataTailLen = 0;
|
|
|
|
|
if (b == connectDataTail[connectDataTailLen])
|
|
|
|
|
{
|
|
|
|
|
++connectDataTailLen;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (4 == connectDataTailLen)
|
|
|
|
|
{
|
|
|
|
|
connectDataTailLen = 0;
|
|
|
|
|
bool shakeRet = ShakeHand(connectData);
|
|
|
|
|
connectData.clear();
|
|
|
|
|
|
|
|
|
|
if (!shakeRet)
|
|
|
|
|
{
|
|
|
|
|
PostDisConnectMsg();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bConnect = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (NULL == pData)
|
|
|
|
|
{
|
|
|
|
|
assert(0 == nDataSize);
|
|
|
|
|
|
|
|
|
|
uint8_t b = *pBuffer;
|
|
|
|
|
++pBuffer;
|
|
|
|
|
--nBufferSize;
|
|
|
|
|
headData[nHeadDataLen] = b;
|
|
|
|
|
++nHeadDataLen;
|
|
|
|
|
|
|
|
|
|
if (1 == nHeadDataLen)
|
|
|
|
|
{
|
2022-05-24 02:01:36 +00:00
|
|
|
|
if ((0x80 | 0x08) == headData[0]) // 断开连接
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
PostDisConnectMsg();
|
|
|
|
|
break;
|
|
|
|
|
}
|
2022-05-24 02:01:36 +00:00
|
|
|
|
else if ((0x80 | 0x09) == headData[0]) // PING帧
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
//
|
|
|
|
|
}
|
2022-05-24 02:01:36 +00:00
|
|
|
|
else if ((0x80 | 0x0A) == headData[0]) // PONG帧
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
//
|
|
|
|
|
}
|
|
|
|
|
else if ((0x00 | 0x01) == headData[0] || (0x00 | 0x02) == headData[0] || (0x00 | 0x00) == headData[0] || (0x80 | 0x00) == headData[0]
|
2022-05-24 02:01:36 +00:00
|
|
|
|
|| (0x80 | 0x01) == headData[0] || (0x80 | 0x02) == headData[0]) // 数据帧
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
if ((0x80 | 0x00) == headData[0] || (0x80 | 0x01) == headData[0] || (0x80 | 0x02) == headData[0])
|
|
|
|
|
{
|
2022-05-24 02:01:36 +00:00
|
|
|
|
// 分片结束
|
2022-05-23 10:29:23 +00:00
|
|
|
|
bHandle = true;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2022-05-24 02:01:36 +00:00
|
|
|
|
// 分片帧
|
2022-05-23 10:29:23 +00:00
|
|
|
|
bHandle = false;
|
|
|
|
|
}
|
|
|
|
|
}
|
2022-05-24 02:01:36 +00:00
|
|
|
|
else // 帧错误,断开连接
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
PostDisConnectMsg();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (2 == nHeadDataLen)
|
|
|
|
|
{
|
2022-05-24 02:01:36 +00:00
|
|
|
|
if (0 == (headData[1] & 0x80)) // 必须经过掩码处理
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
PostDisConnectMsg();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-24 02:01:36 +00:00
|
|
|
|
if ((0x80 | 0x09) == headData[0]) // PING帧
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
if (0x80 != headData[1])
|
|
|
|
|
{
|
|
|
|
|
PostDisConnectMsg();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2022-05-24 02:01:36 +00:00
|
|
|
|
else if ((0x80 | 0x0A) == headData[0]) // PONG帧
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
if (0x80 != headData[1])
|
|
|
|
|
{
|
|
|
|
|
PostDisConnectMsg();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if ((headData[1] & 0x7F) <= 125)
|
|
|
|
|
{
|
|
|
|
|
uint32_t nCmdSize = (headData[1] & 0x7F);
|
|
|
|
|
nHeadDataLen = 0;
|
|
|
|
|
|
|
|
|
|
if (0 == nCmdSize)
|
|
|
|
|
{
|
|
|
|
|
PostDisConnectMsg();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nDataSize = nCmdSize;
|
|
|
|
|
nRemainSize = nCmdSize;
|
|
|
|
|
pData = new uint8_t[nDataSize];
|
|
|
|
|
pDataEx = pData;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (4 == nHeadDataLen)
|
|
|
|
|
{
|
2022-05-24 02:01:36 +00:00
|
|
|
|
if ((0x80 | 0x09) == headData[0]) // PING帧
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
//
|
|
|
|
|
}
|
2022-05-24 02:01:36 +00:00
|
|
|
|
else if ((0x80 | 0x0A) == headData[0]) // PONG帧
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
//
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if ((headData[1] & 0x7F) == 126)
|
|
|
|
|
{
|
|
|
|
|
uint32_t nCmdSize = ntohs(*(uint16_t*)&headData[2]);
|
|
|
|
|
nHeadDataLen = 0;
|
|
|
|
|
|
|
|
|
|
if (0 == nCmdSize)
|
|
|
|
|
{
|
|
|
|
|
PostDisConnectMsg();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nDataSize = nCmdSize;
|
|
|
|
|
nRemainSize = nCmdSize;
|
|
|
|
|
pData = new uint8_t[nDataSize];
|
|
|
|
|
pDataEx = pData;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (6 == nHeadDataLen)
|
|
|
|
|
{
|
2022-05-24 02:01:36 +00:00
|
|
|
|
if ((0x80 | 0x09) == headData[0]) // PING帧
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
nHeadDataLen = 0;
|
|
|
|
|
|
|
|
|
|
Pong();
|
|
|
|
|
}
|
2022-05-24 02:01:36 +00:00
|
|
|
|
else if ((0x80 | 0x0A) == headData[0]) // PONG帧
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
nHeadDataLen = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (10 == nHeadDataLen)
|
|
|
|
|
{
|
2022-05-24 02:01:36 +00:00
|
|
|
|
if ((headData[1] & 0x7F) == 127) // 这里一定会等于127
|
2022-05-23 10:29:23 +00:00
|
|
|
|
{
|
|
|
|
|
uint32_t nCmdSizeHigh = ntohl(*(uint32_t*)&headData[2]);
|
|
|
|
|
uint32_t nCmdSize = ntohl(*(uint32_t*)&headData[6]);
|
|
|
|
|
nHeadDataLen = 0;
|
|
|
|
|
|
|
|
|
|
if ((0 != nCmdSizeHigh) || (0 == nCmdSize))
|
|
|
|
|
{
|
|
|
|
|
PostDisConnectMsg();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nDataSize = nCmdSize;
|
|
|
|
|
nRemainSize = nCmdSize;
|
|
|
|
|
pData = new uint8_t[nDataSize];
|
|
|
|
|
pDataEx = pData;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (4 != nMaskCount)
|
|
|
|
|
{
|
|
|
|
|
uint8_t b = *pBuffer;
|
|
|
|
|
++pBuffer;
|
|
|
|
|
--nBufferSize;
|
|
|
|
|
vMask[nMaskCount] = b;
|
|
|
|
|
++nMaskCount;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int nWriteSize = HGMIN(nBufferSize, nRemainSize);
|
|
|
|
|
memcpy(pDataEx, pBuffer, nWriteSize);
|
|
|
|
|
pBuffer += nWriteSize;
|
|
|
|
|
nBufferSize -= nWriteSize;
|
|
|
|
|
pDataEx += nWriteSize;
|
|
|
|
|
nRemainSize -= nWriteSize;
|
|
|
|
|
|
|
|
|
|
if (0 == nRemainSize)
|
|
|
|
|
{
|
|
|
|
|
assert(pDataEx == pData + nDataSize);
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < nDataSize; ++i)
|
|
|
|
|
{
|
|
|
|
|
int j = i % 4;
|
|
|
|
|
pData[i] = pData[i] ^ vMask[j];
|
|
|
|
|
vAllData.push_back(pData[i]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
delete[] pData;
|
|
|
|
|
pData = NULL;
|
|
|
|
|
nDataSize = 0;
|
|
|
|
|
nMaskCount = 0;
|
|
|
|
|
|
|
|
|
|
if (bHandle)
|
|
|
|
|
{
|
2022-05-24 02:01:36 +00:00
|
|
|
|
PostCmdMsg(&vAllData[0], (HGUInt)vAllData.size());
|
2022-05-23 10:29:23 +00:00
|
|
|
|
|
|
|
|
|
bHandle = false;
|
|
|
|
|
vAllData.clear();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL != pData)
|
|
|
|
|
{
|
|
|
|
|
delete[] pData;
|
|
|
|
|
pData = NULL;
|
|
|
|
|
nDataSize = 0;
|
|
|
|
|
nMaskCount = 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-16 07:37:40 +00:00
|
|
|
|
void WSUser::SaneEvent(int code, const char* str, bool err, void* param)
|
2022-05-31 09:39:54 +00:00
|
|
|
|
{
|
|
|
|
|
WSUser* p = (WSUser*)param;
|
|
|
|
|
|
|
|
|
|
if (code == SANEEVENT_ARRIVE)
|
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("device_arrive"));
|
|
|
|
|
if (p->m_initDeviceHaveIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(p->m_initDeviceIden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "device_name", cJSON_CreateString(str));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
p->PostEventMsg((const HGByte*)resp, (HGUInt)strlen(resp));
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-05-31 09:39:54 +00:00
|
|
|
|
}
|
|
|
|
|
else if (code == SANEEVENT_REMOVE)
|
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("device_remove"));
|
|
|
|
|
if (p->m_initDeviceHaveIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(p->m_initDeviceIden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "device_name", cJSON_CreateString(str));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
p->PostEventMsg((const HGByte*)resp, (HGUInt)strlen(resp));
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-05-31 09:39:54 +00:00
|
|
|
|
}
|
|
|
|
|
else if (code == SANEEVENT_WORKING)
|
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("scan_begin"));
|
|
|
|
|
if (p->m_startScanHaveIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(p->m_startScanIden.c_str()));
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
p->PostEventMsg((const HGByte*)resp, (HGUInt)strlen(resp));
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("scan_info"));
|
|
|
|
|
if (p->m_startScanHaveIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(p->m_startScanIden.c_str()));
|
|
|
|
|
if (err)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "is_error", cJSON_CreateTrue());
|
|
|
|
|
else
|
|
|
|
|
cJSON_AddItemToObject(retJson, "is_error", cJSON_CreateFalse());
|
|
|
|
|
cJSON_AddItemToObject(retJson, "info", cJSON_CreateString(str));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
p->PostEventMsg((const HGByte*)resp, (HGUInt)strlen(resp));
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-05-31 09:39:54 +00:00
|
|
|
|
}
|
|
|
|
|
else if (code == SANEEVENT_FINISH)
|
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON *retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("scan_info"));
|
|
|
|
|
if (p->m_startScanHaveIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(p->m_startScanIden.c_str()));
|
|
|
|
|
if (err)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "is_error", cJSON_CreateTrue());
|
|
|
|
|
else
|
|
|
|
|
cJSON_AddItemToObject(retJson, "is_error", cJSON_CreateFalse());
|
|
|
|
|
cJSON_AddItemToObject(retJson, "info", cJSON_CreateString(str));
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
p->PostEventMsg((const HGByte*)resp, (HGUInt)strlen(resp));
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("scan_end"));
|
|
|
|
|
if (p->m_startScanHaveIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(p->m_startScanIden.c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
p->PostEventMsg((const HGByte*)resp, (HGUInt)strlen(resp));
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-05-31 09:39:54 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-16 07:37:40 +00:00
|
|
|
|
void WSUser::SaneImageCallback(const char* path, bool blank, void* param)
|
2022-05-31 09:39:54 +00:00
|
|
|
|
{
|
|
|
|
|
WSUser* p = (WSUser*)param;
|
|
|
|
|
|
2022-06-09 03:05:24 +00:00
|
|
|
|
std::string base64;
|
|
|
|
|
if (p->m_startScanIsGetBase64)
|
|
|
|
|
{
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
p->GetManager()->LoadLocalImage(path, base64, errInfo);
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON *retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 03:05:24 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("scan_image"));
|
|
|
|
|
if (p->m_startScanHaveIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(p->m_startScanIden.c_str()));
|
2022-06-21 10:37:41 +00:00
|
|
|
|
|
2022-08-01 07:58:12 +00:00
|
|
|
|
if (p->m_startScanBlankCheck)
|
|
|
|
|
{
|
|
|
|
|
if (blank)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "is_blank", cJSON_CreateTrue());
|
|
|
|
|
else
|
|
|
|
|
cJSON_AddItemToObject(retJson, "is_blank", cJSON_CreateFalse());
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if (p->m_startScanIsLocalSave)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path", cJSON_CreateString(StdStringToUtf8(path).c_str()));
|
|
|
|
|
else
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(path);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
|
2022-06-09 03:05:24 +00:00
|
|
|
|
if (p->m_startScanIsGetBase64)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64", cJSON_CreateString(base64.c_str()));
|
2022-06-09 03:05:24 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
2022-05-30 11:01:23 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
p->PostEventMsg((const HGByte*)resp, (HGUInt)strlen(resp));
|
|
|
|
|
free(resp);
|
2022-05-30 11:01:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-05-30 11:01:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-23 10:29:23 +00:00
|
|
|
|
bool WSUser::ShakeHand(const std::string& head)
|
|
|
|
|
{
|
|
|
|
|
std::string requestMethod;
|
|
|
|
|
std::string requestURIPath;
|
|
|
|
|
HttpPairs requestURIQueryInfos;
|
|
|
|
|
std::string requestURIFragment;
|
|
|
|
|
std::string httpVersion;
|
|
|
|
|
HttpPairs headInfos;
|
|
|
|
|
HttpHead::AnalysisHead(head, requestMethod, requestURIPath, requestURIQueryInfos,
|
|
|
|
|
requestURIFragment, httpVersion, headInfos);
|
|
|
|
|
|
2022-08-05 08:46:07 +00:00
|
|
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, head.c_str());
|
|
|
|
|
|
|
|
|
|
//if (std::string::npos == HttpHead::GetValue(headInfos, "Connection").find("Upgrade"))
|
|
|
|
|
// return false;
|
|
|
|
|
//if ("websocket" != HttpHead::GetValue(headInfos, "Upgrade"))
|
|
|
|
|
// return false;
|
2022-05-23 10:29:23 +00:00
|
|
|
|
|
|
|
|
|
std::string key = HttpHead::GetValue(headInfos, "Sec-WebSocket-Key");
|
|
|
|
|
if (key.empty())
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
key += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
|
|
|
|
|
|
|
|
|
|
unsigned int message_digest[5];
|
|
|
|
|
SHA1 sha;
|
|
|
|
|
sha.Reset();
|
|
|
|
|
sha << key.c_str();
|
|
|
|
|
sha.Result(message_digest);
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 5; ++i)
|
|
|
|
|
message_digest[i] = htonl(message_digest[i]);
|
|
|
|
|
std::string serverKey = base64_encode((const unsigned char*)message_digest, 20);
|
|
|
|
|
|
|
|
|
|
std::string handShakeResp = "HTTP/1.1 101 Switching Protocols\r\n";
|
|
|
|
|
handShakeResp += "Upgrade: websocket\r\n";
|
|
|
|
|
handShakeResp += "Connection: Upgrade\r\n";
|
|
|
|
|
handShakeResp += "Sec-WebSocket-Accept:";
|
|
|
|
|
handShakeResp += serverKey;
|
|
|
|
|
handShakeResp += "\r\n\r\n";
|
|
|
|
|
send(m_sockConn, handShakeResp.c_str(), (int)handShakeResp.length(), 0);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::Pong()
|
|
|
|
|
{
|
|
|
|
|
uint8_t vHead[2];
|
|
|
|
|
vHead[0] = 0x80 | 0x0A;
|
|
|
|
|
vHead[1] = 0;
|
|
|
|
|
|
|
|
|
|
HGBase_EnterLock(m_cs);
|
|
|
|
|
send(m_sockConn, (const char*)vHead, 2, 0);
|
|
|
|
|
HGBase_LeaveLock(m_cs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool WSUser::SendResponse(const HGByte* data, HGUInt size, HGBool text)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == data || 0 == size)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint32_t nHeadLen = 0;
|
|
|
|
|
|
|
|
|
|
uint8_t vHead[20] = { 0 };
|
|
|
|
|
vHead[0] = text ? (0x80 | 0x01) : (0x80 | 0x02);
|
|
|
|
|
if (size <= 125)
|
|
|
|
|
{
|
|
|
|
|
vHead[1] = (uint8_t)size;
|
|
|
|
|
nHeadLen = 2;
|
|
|
|
|
}
|
|
|
|
|
else if (size <= 0xFFFF)
|
|
|
|
|
{
|
|
|
|
|
vHead[1] = 126;
|
|
|
|
|
uint16_t payloadLength16b = htons((uint16_t)size);
|
|
|
|
|
memcpy(&vHead[2], &payloadLength16b, 2);
|
|
|
|
|
nHeadLen = 4;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
vHead[1] = 127;
|
|
|
|
|
vHead[2] = 0;
|
|
|
|
|
vHead[3] = 0;
|
|
|
|
|
vHead[4] = 0;
|
|
|
|
|
vHead[5] = 0;
|
|
|
|
|
uint32_t payloadLength32b = htonl(size);
|
|
|
|
|
memcpy(&vHead[6], &payloadLength32b, 4);
|
|
|
|
|
nHeadLen = 10;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_EnterLock(m_cs);
|
|
|
|
|
send(m_sockConn, (const char*)vHead, nHeadLen, 0);
|
|
|
|
|
send(m_sockConn, (const char*)data, size, 0);
|
|
|
|
|
HGBase_LeaveLock(m_cs);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
void WSUser::SetGlobalConfig(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
GlobalConfig cfg;
|
|
|
|
|
HGUInt mask = 0;
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
cfg.fileSavePath = Utf8ToStdString(GetJsonStringValue(json, "file_save_path", &find));
|
|
|
|
|
if (find)
|
|
|
|
|
mask |= GlobalConfig::fileSavePathMask;
|
|
|
|
|
|
|
|
|
|
cfg.fileNamePrefix = Utf8ToStdString(GetJsonStringValue(json, "file_name_prefix", &find));
|
|
|
|
|
if (find)
|
|
|
|
|
mask |= GlobalConfig::fileNamePrefixMask;
|
|
|
|
|
|
|
|
|
|
cfg.fileNameMode = GetJsonStringValue(json, "file_name_mode", &find);
|
|
|
|
|
if (find)
|
|
|
|
|
mask |= GlobalConfig::fileNameModeMask;
|
|
|
|
|
|
|
|
|
|
cfg.imageFormat = GetJsonStringValue(json, "image_format", &find);
|
|
|
|
|
if (find)
|
|
|
|
|
mask |= GlobalConfig::imageFormatMask;
|
|
|
|
|
|
|
|
|
|
cfg.imageJpegQuality = GetJsonIntValue(json, "image_jpeg_quality", &find);
|
|
|
|
|
if (find)
|
|
|
|
|
mask |= GlobalConfig::imageJpegQualityMask;
|
|
|
|
|
|
|
|
|
|
cfg.imageTiffCompression = GetJsonStringValue(json, "image_tiff_compression", &find);
|
|
|
|
|
if (find)
|
|
|
|
|
mask |= GlobalConfig::imageTiffCompressionMask;
|
|
|
|
|
|
|
|
|
|
cfg.imageTiffJpegQuality = GetJsonIntValue(json, "image_tiff_jpeg_quality", &find);
|
|
|
|
|
if (find)
|
|
|
|
|
mask |= GlobalConfig::imageTiffJpegQualityMask;
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->SetGlobalConfig(cfg, mask, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("set_global_config"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::GetGlobalConfig(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
GlobalConfig cfg;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->GetGlobalConfig(cfg, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("get_global_config"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
else
|
2022-06-21 05:42:22 +00:00
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "file_save_path", cJSON_CreateString(StdStringToUtf8(cfg.fileSavePath).c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "file_name_prefix", cJSON_CreateString(StdStringToUtf8(cfg.fileNamePrefix).c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "file_name_mode", cJSON_CreateString(cfg.fileNameMode.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_format", cJSON_CreateString(cfg.imageFormat.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_jpeg_quality", cJSON_CreateNumber(cfg.imageJpegQuality));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_tiff_compression", cJSON_CreateString(cfg.imageTiffCompression.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_tiff_jpeg_quality", cJSON_CreateNumber(cfg.imageTiffJpegQuality));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::LoadLocalImage(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string imagePath = Utf8ToStdString(GetJsonStringValue(json, "image_path"));
|
|
|
|
|
|
|
|
|
|
std::string imageBase64;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->LoadLocalImage(imagePath, imageBase64, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("load_local_image"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
else
|
2022-06-21 05:42:22 +00:00
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64", cJSON_CreateString(imageBase64.c_str()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::SaveLocalImage(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string imageBase64 = GetJsonStringValue(json, "image_base64");
|
|
|
|
|
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
std::string errInfo;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
int ret = GetManager()->SaveLocalImage(imageBase64, false, imagePath, errInfo);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("save_local_image"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
else
|
2022-06-21 05:42:22 +00:00
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path", cJSON_CreateString(StdStringToUtf8(imagePath).c_str()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::DeleteLocalFile(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string filePath = Utf8ToStdString(GetJsonStringValue(json, "file_path"));
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->DeleteLocalFile(filePath, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("delete_local_file"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::ClearGlobalFileSavePath(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->ClearGlobalFileSavePath(errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("clear_global_file_save_path"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-07-27 07:56:10 +00:00
|
|
|
|
void WSUser::UploadFile(cJSON* json, const std::string& func)
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
2022-07-27 07:56:10 +00:00
|
|
|
|
std::string filePath;
|
|
|
|
|
if ("upload_image" == func)
|
|
|
|
|
{
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->SaveImage(imageIndex, true, filePath, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
else if ("upload_local_file" == func)
|
|
|
|
|
{
|
|
|
|
|
filePath = Utf8ToStdString(GetJsonStringValue(json, "file_path"));
|
|
|
|
|
}
|
|
|
|
|
else if ("upload_image_base64" == func)
|
|
|
|
|
{
|
|
|
|
|
std::string imageBase64 = GetJsonStringValue(json, "image_base64");
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->SaveLocalImage(imageBase64, true, filePath, errInfo2);
|
|
|
|
|
}
|
2022-06-21 10:37:41 +00:00
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
std::string remoteFilePath = Utf8ToStdString(GetJsonStringValue(json, "remote_file_path", &find));
|
|
|
|
|
if (!find)
|
|
|
|
|
{
|
|
|
|
|
HGChar fileName[256];
|
|
|
|
|
HGBase_GetFileName(filePath.c_str(), fileName, 256);
|
|
|
|
|
remoteFilePath.clear();
|
|
|
|
|
remoteFilePath += "/";
|
|
|
|
|
remoteFilePath += fileName;
|
|
|
|
|
}
|
|
|
|
|
std::string uploadMode = GetJsonStringValue(json, "upload_mode", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
uploadMode = "http";
|
|
|
|
|
std::string httpHost = GetJsonStringValue(json, "http_host", &find);
|
|
|
|
|
int httpPort = GetJsonIntValue(json, "http_port", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
httpPort = 80;
|
|
|
|
|
std::string httpPath = GetJsonStringValue(json, "http_path", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
httpPath = "/upload.cgi";
|
|
|
|
|
std::string ftpUser = GetJsonStringValue(json, "ftp_user", &find);
|
|
|
|
|
std::string ftpPassword = GetJsonStringValue(json, "ftp_password", &find);
|
|
|
|
|
std::string ftpHost = GetJsonStringValue(json, "ftp_host", &find);
|
|
|
|
|
int ftpPort = GetJsonIntValue(json, "ftp_port", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
ftpPort = 21;
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->UploadLocalFile(filePath, remoteFilePath, uploadMode, httpHost, httpPort, httpPath,
|
|
|
|
|
ftpUser, ftpPassword, ftpHost, ftpPort, errInfo);
|
|
|
|
|
|
2022-07-27 07:56:10 +00:00
|
|
|
|
if ("upload_image" == func || "upload_image_base64" == func)
|
|
|
|
|
{
|
|
|
|
|
HGBase_DeleteFile(filePath.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
2022-07-27 07:56:10 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString(func.c_str()));
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::MergeImage(cJSON* json, const std::string& func)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
std::string mode = GetJsonStringValue(json, "mode", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
mode = "horz";
|
|
|
|
|
std::string align = GetJsonStringValue(json, "align", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
align = "center";
|
|
|
|
|
int interval = GetJsonIntValue(json, "interval", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
interval = 0;
|
2022-06-21 10:37:41 +00:00
|
|
|
|
bool localSave = GetJsonBoolValue(json, "local_save", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
localSave = true;
|
|
|
|
|
|
|
|
|
|
std::vector<std::string> imagePathList;
|
|
|
|
|
if ("merge_image" == func)
|
|
|
|
|
{
|
|
|
|
|
std::vector<int> imageIndexList = GetJsonIntListValue(json, "image_index_list");
|
|
|
|
|
for (int i = 0; i < (int)imageIndexList.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveImage(imageIndexList[i], true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
imagePathList.push_back(imagePath);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if ("merge_local_image" == func)
|
|
|
|
|
{
|
|
|
|
|
imagePathList = GetJsonStringListValue(json, "image_path_list");
|
|
|
|
|
for (int i = 0; i < (int)imagePathList.size(); ++i)
|
|
|
|
|
imagePathList[i] = Utf8ToStdString(imagePathList[i]);
|
|
|
|
|
}
|
|
|
|
|
else if ("merge_base64_image" == func)
|
|
|
|
|
{
|
|
|
|
|
std::vector<std::string> imageBase64List = GetJsonStringListValue(json, "image_base64_list");
|
|
|
|
|
for (int i = 0; i < (int)imageBase64List.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveLocalImage(imageBase64List[i], true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
imagePathList.push_back(imagePath);
|
|
|
|
|
}
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
std::string outImagePath;
|
|
|
|
|
std::string errInfo;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
int ret = GetManager()->MergeLocalImage(imagePathList, mode, align, interval, !localSave, outImagePath, errInfo);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if ("merge_image" == func || "merge_base64_image" == func)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < (int)imagePathList.size(); ++i)
|
|
|
|
|
{
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(imagePathList[i].c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-09 03:05:24 +00:00
|
|
|
|
std::string outImageBase64;
|
|
|
|
|
bool getBase64 = GetJsonBoolValue(json, "get_base64");
|
|
|
|
|
if (0 == ret && getBase64)
|
|
|
|
|
{
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->LoadLocalImage(outImagePath, outImageBase64, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-06 10:51:34 +00:00
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
2022-06-21 05:42:22 +00:00
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString(func.c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
else
|
2022-06-09 03:05:24 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if (localSave)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path", cJSON_CreateString(StdStringToUtf8(outImagePath).c_str()));
|
|
|
|
|
else
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(outImagePath.c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
|
2022-06-09 03:05:24 +00:00
|
|
|
|
if (getBase64)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64", cJSON_CreateString(outImageBase64.c_str()));
|
2022-06-09 03:05:24 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
2022-06-21 05:42:22 +00:00
|
|
|
|
if (NULL != resp)
|
2022-06-09 03:05:24 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
2022-06-09 03:05:24 +00:00
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
void WSUser::MakeMultiImage(cJSON* json, const std::string& func)
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
std::string format = GetJsonStringValue(json, "format", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
format = "tif";
|
|
|
|
|
std::string tiffCompression = GetJsonStringValue(json, "tiff_compression", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
tiffCompression = "lzw";
|
|
|
|
|
int tiffJpegQuality = GetJsonIntValue(json, "tiff_jpeg_quality", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
tiffJpegQuality = 80;
|
2022-06-21 10:37:41 +00:00
|
|
|
|
bool localSave = GetJsonBoolValue(json, "local_save", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
localSave = true;
|
|
|
|
|
|
|
|
|
|
std::vector<std::string> imagePathList;
|
|
|
|
|
if ("make_multi_image" == func)
|
|
|
|
|
{
|
|
|
|
|
std::vector<int> imageIndexList = GetJsonIntListValue(json, "image_index_list");
|
|
|
|
|
for (int i = 0; i < (int)imageIndexList.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveImage(imageIndexList[i], true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
imagePathList.push_back(imagePath);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if ("local_make_multi_image" == func)
|
|
|
|
|
{
|
|
|
|
|
imagePathList = GetJsonStringListValue(json, "image_path_list");
|
|
|
|
|
for (int i = 0; i < (int)imagePathList.size(); ++i)
|
|
|
|
|
imagePathList[i] = Utf8ToStdString(imagePathList[i]);
|
|
|
|
|
}
|
|
|
|
|
else if ("base64_make_multi_image" == func)
|
|
|
|
|
{
|
|
|
|
|
std::vector<std::string> imageBase64List = GetJsonStringListValue(json, "image_base64_list");
|
|
|
|
|
for (int i = 0; i < (int)imageBase64List.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveLocalImage(imageBase64List[i], true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
imagePathList.push_back(imagePath);
|
|
|
|
|
}
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
std::string outImagePath;
|
|
|
|
|
std::string errInfo;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
int ret = GetManager()->LocalMakeMultiImage(imagePathList, format, tiffCompression, tiffJpegQuality, !localSave, outImagePath, errInfo);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if ("make_multi_image" == func || "base64_make_multi_image" == func)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < (int)imagePathList.size(); ++i)
|
|
|
|
|
{
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(imagePathList[i].c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-09 03:05:24 +00:00
|
|
|
|
std::string outImageBase64;
|
|
|
|
|
bool getBase64 = GetJsonBoolValue(json, "get_base64");
|
|
|
|
|
if (0 == ret && getBase64)
|
|
|
|
|
{
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->LoadLocalImage(outImagePath, outImageBase64, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-06 10:51:34 +00:00
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString(func.c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
else
|
2022-06-09 03:05:24 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if (localSave)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path", cJSON_CreateString(StdStringToUtf8(outImagePath).c_str()));
|
|
|
|
|
else
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(outImagePath.c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
|
2022-06-09 03:05:24 +00:00
|
|
|
|
if (getBase64)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64", cJSON_CreateString(outImageBase64.c_str()));
|
2022-06-09 03:05:24 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
2022-06-09 03:05:24 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
2022-06-09 03:05:24 +00:00
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
void WSUser::SplitImage(cJSON* json, const std::string& func)
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
std::string mode = GetJsonStringValue(json, "mode", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
mode = "horz";
|
|
|
|
|
int location = GetJsonIntValue(json, "location", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
location = 0;
|
2022-06-21 10:37:41 +00:00
|
|
|
|
bool localSave = GetJsonBoolValue(json, "local_save", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
localSave = true;
|
|
|
|
|
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
if ("split_image" == func)
|
|
|
|
|
{
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveImage(imageIndex, true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("split_local_image" == func)
|
|
|
|
|
{
|
|
|
|
|
imagePath = Utf8ToStdString(GetJsonStringValue(json, "image_path"));
|
|
|
|
|
}
|
|
|
|
|
else if ("split_base64_image" == func)
|
|
|
|
|
{
|
|
|
|
|
std::string imageBase64 = GetJsonStringValue(json, "image_base64");
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveLocalImage(imageBase64, true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
std::vector<std::string> outImagePathList;
|
|
|
|
|
std::string errInfo;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
int ret = GetManager()->SplitLocalImage(imagePath, mode, location, !localSave, outImagePathList, errInfo);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if ("split_image" == func || "split_base64_image" == func)
|
|
|
|
|
{
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(imagePath.c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-09 03:05:24 +00:00
|
|
|
|
std::vector<std::string> outImageBase64List;
|
|
|
|
|
bool getBase64 = GetJsonBoolValue(json, "get_base64");
|
|
|
|
|
if (0 == ret && getBase64)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < (int)outImagePathList.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string outImageBase64;
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->LoadLocalImage(outImagePathList[i], outImageBase64, errInfo2);
|
|
|
|
|
outImageBase64List.push_back(outImageBase64);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-06 10:51:34 +00:00
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString(func.c_str()));
|
2022-06-21 05:42:22 +00:00
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-09 03:05:24 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if (localSave)
|
|
|
|
|
{
|
|
|
|
|
cJSON* imgPathList = cJSON_CreateArray();
|
|
|
|
|
for (int i = 0; i < (int)outImagePathList.size(); ++i)
|
|
|
|
|
cJSON_AddItemToArray(imgPathList, cJSON_CreateString(StdStringToUtf8(outImagePathList[i]).c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path_list", imgPathList);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < (int)outImagePathList.size(); ++i)
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(outImagePathList[i].c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
if (getBase64)
|
|
|
|
|
{
|
|
|
|
|
cJSON* imgBase64List = cJSON_CreateArray();
|
|
|
|
|
for (int i = 0; i < (int)outImageBase64List.size(); ++i)
|
|
|
|
|
cJSON_AddItemToArray(imgBase64List, cJSON_CreateString(outImageBase64List[i].c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64_list", imgBase64List);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
2022-06-09 03:05:24 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
2022-06-09 03:05:24 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
2022-06-09 03:05:24 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
void WSUser::MakeZipFile(cJSON* json, const std::string& func)
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
bool find = false;
|
|
|
|
|
bool localSave = GetJsonBoolValue(json, "local_save", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
localSave = true;
|
|
|
|
|
|
|
|
|
|
std::vector<std::string> filePathList;
|
2022-06-11 09:54:04 +00:00
|
|
|
|
std::vector<std::string> nameList;
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if ("make_zip_file" == func)
|
|
|
|
|
{
|
|
|
|
|
std::vector<int> imageIndexList = GetJsonIntListValue(json, "image_index_list");
|
|
|
|
|
for (int i = 0; i < (int)imageIndexList.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveImage(imageIndexList[i], true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
filePathList.push_back(imagePath);
|
|
|
|
|
|
|
|
|
|
HGChar suffix[256];
|
|
|
|
|
HGBase_GetFileSuffix(imagePath.c_str(), suffix, 256);
|
|
|
|
|
char name[256];
|
|
|
|
|
sprintf(name, "%d.%s", imageIndexList[i], suffix);
|
|
|
|
|
nameList.push_back(name);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if ("local_make_zip_file" == func)
|
|
|
|
|
{
|
|
|
|
|
filePathList = GetJsonStringListValue(json, "file_path_list");
|
|
|
|
|
for (int i = 0; i < (int)filePathList.size(); ++i)
|
|
|
|
|
filePathList[i] = Utf8ToStdString(filePathList[i]);
|
|
|
|
|
}
|
|
|
|
|
else if ("base64_make_zip_file" == func)
|
|
|
|
|
{
|
|
|
|
|
std::vector<std::string> imageBase64List = GetJsonStringListValue(json, "image_base64_list");
|
|
|
|
|
for (int i = 0; i < (int)imageBase64List.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveLocalImage(imageBase64List[i], true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
filePathList.push_back(imagePath);
|
|
|
|
|
|
|
|
|
|
HGChar suffix[256];
|
|
|
|
|
HGBase_GetFileSuffix(imagePath.c_str(), suffix, 256);
|
|
|
|
|
char name[256];
|
|
|
|
|
sprintf(name, "%d.%s", i, suffix);
|
|
|
|
|
nameList.push_back(name);
|
|
|
|
|
}
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2023-10-23 08:22:47 +00:00
|
|
|
|
std::string zipPath = GetJsonStringValue(json, "zip_path");
|
|
|
|
|
|
2022-06-06 10:51:34 +00:00
|
|
|
|
std::string outZipPath;
|
|
|
|
|
std::string errInfo;
|
2023-10-23 08:22:47 +00:00
|
|
|
|
int ret = GetManager()->LocalMakeZipFile(filePathList, nameList, zipPath, !localSave, outZipPath, errInfo);
|
2022-06-11 09:54:04 +00:00
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if ("make_zip_file" == func || "base64_make_zip_file" == func)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < (int)filePathList.size(); ++i)
|
|
|
|
|
{
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(filePathList[i].c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-11 09:54:04 +00:00
|
|
|
|
std::string outZipBase64;
|
|
|
|
|
bool getBase64 = GetJsonBoolValue(json, "get_base64");
|
|
|
|
|
if (0 == ret && getBase64)
|
|
|
|
|
{
|
|
|
|
|
GetManager()->LoadBase64(outZipPath, outZipBase64);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString(func.c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
else
|
2022-06-11 09:54:04 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if (localSave)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "zip_path", cJSON_CreateString(StdStringToUtf8(outZipPath).c_str()));
|
|
|
|
|
else
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(outZipPath.c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
|
2022-06-11 09:54:04 +00:00
|
|
|
|
if (getBase64)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "zip_base64", cJSON_CreateString(outZipBase64.c_str()));
|
2022-06-11 09:54:04 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
2022-06-11 09:54:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
2022-06-11 09:54:04 +00:00
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
void WSUser::ImageDeskew(cJSON* json, const std::string& func)
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
bool find = false;
|
|
|
|
|
bool localSave = GetJsonBoolValue(json, "local_save", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
localSave = true;
|
|
|
|
|
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
if ("image_deskew" == func)
|
|
|
|
|
{
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveImage(imageIndex, true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("local_image_deskew" == func)
|
|
|
|
|
{
|
|
|
|
|
imagePath = Utf8ToStdString(GetJsonStringValue(json, "image_path"));
|
|
|
|
|
}
|
|
|
|
|
else if ("base64_image_deskew" == func)
|
|
|
|
|
{
|
|
|
|
|
std::string imageBase64 = GetJsonStringValue(json, "image_base64");
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveLocalImage(imageBase64, true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
std::string outImagePath;
|
|
|
|
|
std::string errInfo;
|
2022-06-23 03:35:17 +00:00
|
|
|
|
int ret = GetManager()->LocalImageDeskew(imagePath, true, true, true, 0, 0, !localSave, outImagePath, errInfo);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if ("image_deskew" == func || "base64_image_deskew" == func)
|
|
|
|
|
{
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(imagePath.c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-09 03:05:24 +00:00
|
|
|
|
std::string outImageBase64;
|
|
|
|
|
bool getBase64 = GetJsonBoolValue(json, "get_base64");
|
|
|
|
|
if (0 == ret && getBase64)
|
|
|
|
|
{
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->LoadLocalImage(outImagePath, outImageBase64, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-06 10:51:34 +00:00
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString(func.c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
else
|
2022-06-09 03:05:24 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if (localSave)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path", cJSON_CreateString(StdStringToUtf8(outImagePath).c_str()));
|
|
|
|
|
else
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(outImagePath.c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
|
2022-06-09 03:05:24 +00:00
|
|
|
|
if (getBase64)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64", cJSON_CreateString(outImageBase64.c_str()));
|
2022-06-09 03:05:24 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
2022-06-09 03:05:24 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
2022-06-09 03:05:24 +00:00
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
void WSUser::ImageAddWatermark(cJSON* json, const std::string& func)
|
2022-06-14 10:22:23 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
2022-06-15 01:50:21 +00:00
|
|
|
|
std::string text = Utf8ToStdString(GetJsonStringValue(json, "text"));
|
2022-06-14 10:22:23 +00:00
|
|
|
|
|
|
|
|
|
bool find;
|
|
|
|
|
std::string textColor = GetJsonStringValue(json, "text_color", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
textColor = "#000000";
|
|
|
|
|
int textOpacity = GetJsonIntValue(json, "text_opacity", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
textOpacity = 255;
|
|
|
|
|
std::string textPos = GetJsonStringValue(json, "text_pos", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
textPos = "location";
|
|
|
|
|
int marginLeft = GetJsonIntValue(json, "margin_left", &find);
|
|
|
|
|
int marginTop = GetJsonIntValue(json, "margin_top", &find);
|
|
|
|
|
int marginRight = GetJsonIntValue(json, "margin_right", &find);
|
|
|
|
|
int marginBottom = GetJsonIntValue(json, "margin_bottom", &find);
|
|
|
|
|
int locationX = GetJsonIntValue(json, "location_x", &find);
|
|
|
|
|
int locationY = GetJsonIntValue(json, "location_y", &find);
|
|
|
|
|
|
|
|
|
|
std::string fontName = Utf8ToStdString(GetJsonStringValue(json, "font_name", &find));
|
|
|
|
|
if (!find)
|
|
|
|
|
fontName = "宋体";
|
|
|
|
|
int fontSize = GetJsonIntValue(json, "font_size", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
fontSize = 20;
|
|
|
|
|
bool fontBold = GetJsonBoolValue(json, "font_bold");
|
|
|
|
|
bool fontUnderline = GetJsonBoolValue(json, "font_underline");
|
|
|
|
|
bool fontItalic = GetJsonBoolValue(json, "font_italic");
|
|
|
|
|
bool fontStrikeout = GetJsonBoolValue(json, "font_strikeout");
|
2022-06-21 10:37:41 +00:00
|
|
|
|
bool localSave = GetJsonBoolValue(json, "local_save", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
localSave = true;
|
|
|
|
|
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
if ("image_add_watermark" == func)
|
|
|
|
|
{
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveImage(imageIndex, true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("local_image_add_watermark" == func)
|
|
|
|
|
{
|
|
|
|
|
imagePath = Utf8ToStdString(GetJsonStringValue(json, "image_path"));
|
|
|
|
|
}
|
|
|
|
|
else if ("base64_image_add_watermark" == func)
|
|
|
|
|
{
|
|
|
|
|
std::string imageBase64 = GetJsonStringValue(json, "image_base64");
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveLocalImage(imageBase64, true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
2022-06-14 10:22:23 +00:00
|
|
|
|
|
|
|
|
|
std::string outImagePath;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->LocalImageAddWatermark(imagePath, text, textColor, textOpacity, textPos,
|
|
|
|
|
marginLeft, marginTop, marginRight, marginBottom, locationX, locationY, fontName, fontSize,
|
2022-06-22 07:41:59 +00:00
|
|
|
|
fontBold, fontUnderline, fontItalic, fontStrikeout, !localSave, outImagePath, errInfo);
|
2022-06-14 10:22:23 +00:00
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if ("image_add_watermark" == func || "base64_image_add_watermark" == func)
|
|
|
|
|
{
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(imagePath.c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-14 10:22:23 +00:00
|
|
|
|
std::string outImageBase64;
|
|
|
|
|
bool getBase64 = GetJsonBoolValue(json, "get_base64");
|
|
|
|
|
if (0 == ret && getBase64)
|
|
|
|
|
{
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->LoadLocalImage(outImagePath, outImageBase64, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-14 10:22:23 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString(func.c_str()));
|
2022-06-14 10:22:23 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-14 10:22:23 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
if (localSave)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path", cJSON_CreateString(StdStringToUtf8(outImagePath).c_str()));
|
|
|
|
|
else
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(outImagePath.c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
|
2022-06-14 10:22:23 +00:00
|
|
|
|
if (getBase64)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64", cJSON_CreateString(outImageBase64.c_str()));
|
2022-06-14 10:22:23 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
2022-06-14 10:22:23 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
2022-06-14 10:22:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-14 10:22:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
void WSUser::ImageDecontamination(cJSON* json, const std::string& func)
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
2022-06-21 10:37:41 +00:00
|
|
|
|
std::string mode = GetJsonStringValue(json, "mode", &find);
|
2022-06-13 11:56:43 +00:00
|
|
|
|
if (!find)
|
2022-06-21 10:37:41 +00:00
|
|
|
|
mode = "inside";
|
|
|
|
|
std::string color = GetJsonStringValue(json, "color", &find);
|
|
|
|
|
int x = GetJsonIntValue(json, "x");
|
|
|
|
|
int y = GetJsonIntValue(json, "y");
|
|
|
|
|
int width = GetJsonIntValue(json, "width");
|
|
|
|
|
int height = GetJsonIntValue(json, "height");
|
|
|
|
|
bool localSave = GetJsonBoolValue(json, "local_save", &find);
|
2022-06-13 11:56:43 +00:00
|
|
|
|
if (!find)
|
2022-06-21 10:37:41 +00:00
|
|
|
|
localSave = true;
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-21 10:37:41 +00:00
|
|
|
|
std::string imagePath;
|
|
|
|
|
if ("image_decontamination" == func)
|
|
|
|
|
{
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveImage(imageIndex, true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
else if ("local_image_decontamination" == func)
|
|
|
|
|
{
|
|
|
|
|
imagePath = Utf8ToStdString(GetJsonStringValue(json, "image_path"));
|
|
|
|
|
}
|
|
|
|
|
else if ("base64_image_decontamination" == func)
|
|
|
|
|
{
|
|
|
|
|
std::string imageBase64 = GetJsonStringValue(json, "image_base64");
|
|
|
|
|
std::string errInfo2;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
GetManager()->SaveLocalImage(imageBase64, true, imagePath, errInfo2);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string outImagePath;
|
|
|
|
|
std::string errInfo;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
int ret = GetManager()->LocalImageDecontamination(imagePath, mode, color, x, y, width, height, !localSave, outImagePath, errInfo);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
|
|
|
|
|
if ("image_decontamination" == func || "base64_image_decontamination" == func)
|
|
|
|
|
{
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(imagePath.c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string outImageBase64;
|
|
|
|
|
bool getBase64 = GetJsonBoolValue(json, "get_base64");
|
|
|
|
|
if (0 == ret && getBase64)
|
|
|
|
|
{
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->LoadLocalImage(outImagePath, outImageBase64, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-23 03:35:17 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString(func.c_str()));
|
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (localSave)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path", cJSON_CreateString(StdStringToUtf8(outImagePath).c_str()));
|
|
|
|
|
else
|
|
|
|
|
HGBase_DeleteFile(outImagePath.c_str());
|
|
|
|
|
|
|
|
|
|
if (getBase64)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64", cJSON_CreateString(outImageBase64.c_str()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::ImageDirectionCorrect(cJSON* json, const std::string& func)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
bool localSave = GetJsonBoolValue(json, "local_save", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
localSave = true;
|
|
|
|
|
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
if ("image_direction_correct" == func)
|
|
|
|
|
{
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->SaveImage(imageIndex, true, imagePath, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
else if ("local_image_direction_correct" == func)
|
|
|
|
|
{
|
|
|
|
|
imagePath = Utf8ToStdString(GetJsonStringValue(json, "image_path"));
|
|
|
|
|
}
|
|
|
|
|
else if ("base64_image_direction_correct" == func)
|
|
|
|
|
{
|
|
|
|
|
std::string imageBase64 = GetJsonStringValue(json, "image_base64");
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->SaveLocalImage(imageBase64, true, imagePath, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string outImagePath;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->LocalImageDirectionCorrect(imagePath, !localSave, outImagePath, errInfo);
|
|
|
|
|
|
|
|
|
|
if ("image_direction_correct" == func || "base64_image_direction_correct" == func)
|
|
|
|
|
{
|
|
|
|
|
HGBase_DeleteFile(imagePath.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string outImageBase64;
|
|
|
|
|
bool getBase64 = GetJsonBoolValue(json, "get_base64");
|
|
|
|
|
if (0 == ret && getBase64)
|
|
|
|
|
{
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->LoadLocalImage(outImagePath, outImageBase64, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-07-11 08:40:21 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString(func.c_str()));
|
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (localSave)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path", cJSON_CreateString(StdStringToUtf8(outImagePath).c_str()));
|
|
|
|
|
else
|
|
|
|
|
HGBase_DeleteFile(outImagePath.c_str());
|
|
|
|
|
|
|
|
|
|
if (getBase64)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64", cJSON_CreateString(outImageBase64.c_str()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::ImageClip(cJSON* json, const std::string& func)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
int x = GetJsonIntValue(json, "x");
|
|
|
|
|
int y = GetJsonIntValue(json, "y");
|
|
|
|
|
int width = GetJsonIntValue(json, "width");
|
|
|
|
|
int height = GetJsonIntValue(json, "height");
|
|
|
|
|
bool find = false;
|
|
|
|
|
bool localSave = GetJsonBoolValue(json, "local_save", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
localSave = true;
|
|
|
|
|
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
if ("image_clip" == func)
|
|
|
|
|
{
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->SaveImage(imageIndex, true, imagePath, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
else if ("local_image_clip" == func)
|
|
|
|
|
{
|
|
|
|
|
imagePath = Utf8ToStdString(GetJsonStringValue(json, "image_path"));
|
|
|
|
|
}
|
|
|
|
|
else if ("base64_image_clip" == func)
|
|
|
|
|
{
|
|
|
|
|
std::string imageBase64 = GetJsonStringValue(json, "image_base64");
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->SaveLocalImage(imageBase64, true, imagePath, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string outImagePath;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->LocalImageClip(imagePath, x, y, width, height, !localSave, outImagePath, errInfo);
|
|
|
|
|
|
|
|
|
|
if ("image_clip" == func || "base64_image_clip" == func)
|
|
|
|
|
{
|
|
|
|
|
HGBase_DeleteFile(imagePath.c_str());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string outImageBase64;
|
|
|
|
|
bool getBase64 = GetJsonBoolValue(json, "get_base64");
|
|
|
|
|
if (0 == ret && getBase64)
|
|
|
|
|
{
|
|
|
|
|
std::string errInfo2;
|
|
|
|
|
GetManager()->LoadLocalImage(outImagePath, outImageBase64, errInfo2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 10:37:41 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString(func.c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-21 10:37:41 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (localSave)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path", cJSON_CreateString(StdStringToUtf8(outImagePath).c_str()));
|
|
|
|
|
else
|
2022-06-22 07:41:59 +00:00
|
|
|
|
HGBase_DeleteFile(outImagePath.c_str());
|
2022-06-21 10:37:41 +00:00
|
|
|
|
|
|
|
|
|
if (getBase64)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64", cJSON_CreateString(outImageBase64.c_str()));
|
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::InitDevice(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (!GetManager()->IsDeviceInit())
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
|
|
|
|
m_initDeviceIden = iden;
|
|
|
|
|
m_initDeviceHaveIden = findIden;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-07 03:18:55 +00:00
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->InitDevice(errInfo);
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
{
|
|
|
|
|
m_initDeviceIden.clear();
|
|
|
|
|
m_initDeviceHaveIden = false;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("init_device"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::DeinitDevice(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->DeinitDevice(errInfo);
|
|
|
|
|
|
|
|
|
|
m_initDeviceIden.clear();
|
|
|
|
|
m_initDeviceHaveIden = false;
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("deinit_device"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-05-17 07:37:04 +00:00
|
|
|
|
void WSUser::IsDeviceInit(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->IsDeviceInit() ? 0 : -1;
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("is_device_init"));
|
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-06 10:51:34 +00:00
|
|
|
|
void WSUser::GetDeviceNameList(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::vector<std::string> devNameList;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->GetDeviceNameList(devNameList, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("get_device_name_list"));
|
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
cJSON* deviceNameList = cJSON_CreateArray();
|
|
|
|
|
for (int i = 0; i < (int)devNameList.size(); ++i)
|
|
|
|
|
cJSON_AddItemToArray(deviceNameList, cJSON_CreateString(devNameList[i].c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "device_name_list", deviceNameList);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
2022-06-07 03:18:55 +00:00
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::OpenDevice(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
std::string devName = GetJsonStringValue(json, "device_name", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
{
|
|
|
|
|
std::vector<std::string> devNameList;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
GetManager()->GetDeviceNameList(devNameList, errInfo);
|
|
|
|
|
if (!devNameList.empty())
|
|
|
|
|
devName = devNameList[0];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->OpenDevice(devName, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("open_device"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::CloseDevice(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->CloseDevice(errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("close_device"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-09-06 03:11:34 +00:00
|
|
|
|
void WSUser::GetDeviceSN(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string sn;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->GetDeviceSN(sn, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("get_device_sn"));
|
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
else
|
|
|
|
|
cJSON_AddItemToObject(retJson, "sn", cJSON_CreateString(StdStringToUtf8(sn).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-06 10:51:34 +00:00
|
|
|
|
void WSUser::SetDeviceParam(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
2022-06-15 11:07:55 +00:00
|
|
|
|
std::vector<DeviceParam> devParams;
|
|
|
|
|
|
|
|
|
|
cJSON* p = json->child;
|
|
|
|
|
while (NULL != p)
|
|
|
|
|
{
|
|
|
|
|
if (0 != strcmp(p->string, "device_param"))
|
|
|
|
|
{
|
|
|
|
|
p = p->next;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-15 11:07:55 +00:00
|
|
|
|
if (p->type != cJSON_Array)
|
|
|
|
|
{
|
|
|
|
|
break;
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-15 11:07:55 +00:00
|
|
|
|
cJSON* pEx = p->child;
|
|
|
|
|
while (NULL != pEx)
|
|
|
|
|
{
|
|
|
|
|
if (pEx->type != cJSON_Object)
|
|
|
|
|
{
|
|
|
|
|
pEx = pEx->next;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-15 11:07:55 +00:00
|
|
|
|
DeviceParam devParam;
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-15 11:07:55 +00:00
|
|
|
|
cJSON* pEx2 = pEx->child;
|
|
|
|
|
while (NULL != pEx2)
|
|
|
|
|
{
|
|
|
|
|
if (0 == strcmp(pEx2->string, "name") && pEx2->type == cJSON_String)
|
|
|
|
|
{
|
|
|
|
|
devParam.title = pEx2->valuestring;
|
|
|
|
|
}
|
|
|
|
|
else if (0 == strcmp(pEx2->string, "value"))
|
|
|
|
|
{
|
|
|
|
|
if (pEx2->type == cJSON_String)
|
|
|
|
|
devParam.stringValue = pEx2->valuestring;
|
|
|
|
|
else if (pEx2->type == cJSON_Number)
|
|
|
|
|
{
|
|
|
|
|
devParam.intValue = pEx2->valueint;
|
|
|
|
|
devParam.doubleValue = pEx2->valuedouble;
|
|
|
|
|
}
|
|
|
|
|
else if (pEx2->type == cJSON_True)
|
|
|
|
|
devParam.boolValue = true;
|
|
|
|
|
else if (pEx2->type == cJSON_False)
|
|
|
|
|
devParam.boolValue = false;
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-15 11:07:55 +00:00
|
|
|
|
pEx2 = pEx2->next;
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-15 11:07:55 +00:00
|
|
|
|
devParams.push_back(devParam);
|
|
|
|
|
pEx = pEx->next;
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-15 11:07:55 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
2022-06-15 11:07:55 +00:00
|
|
|
|
int ret = GetManager()->SetDeviceParam(devParams, errInfo);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("set_device_param"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::GetDeviceParam(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
2022-06-16 06:20:52 +00:00
|
|
|
|
std::vector<DeviceParamsGroup> devParams;
|
2022-06-06 10:51:34 +00:00
|
|
|
|
std::string errInfo;
|
2022-06-15 11:07:55 +00:00
|
|
|
|
int ret = GetManager()->GetDeviceParam(devParams, errInfo);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("get_device_param"));
|
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
else
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* deviceParams = cJSON_CreateArray();
|
|
|
|
|
for (int k = 0; k < (int)devParams.size(); ++k)
|
2022-06-15 11:07:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* groupParams = cJSON_CreateObject();
|
2022-10-08 03:36:49 +00:00
|
|
|
|
cJSON_AddItemToObject(groupParams, "group_name", cJSON_CreateString(devParams[k].groupTitle.c_str()));
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* groupParam = cJSON_CreateArray();
|
|
|
|
|
for (int i = 0; i < (int)devParams[k].devParams.size(); ++i)
|
2022-06-15 11:07:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* param = cJSON_CreateObject();
|
|
|
|
|
cJSON_AddItemToObject(param, "name", cJSON_CreateString(devParams[k].devParams[i].title.c_str()));
|
2022-06-15 11:07:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
if (1 == devParams[k].devParams[i].valueType)
|
2022-06-15 11:07:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
assert(1 == devParams[k].devParams[i].rangeType);
|
|
|
|
|
cJSON_AddItemToObject(param, "value_type", cJSON_CreateString("string"));
|
|
|
|
|
cJSON_AddItemToObject(param, "value", cJSON_CreateString(devParams[k].devParams[i].stringValue.c_str()));
|
|
|
|
|
|
|
|
|
|
cJSON* valueList = cJSON_CreateArray();
|
|
|
|
|
for (int j = 0; j < (int)devParams[k].devParams[i].stringValueList.size(); ++j)
|
|
|
|
|
cJSON_AddItemToArray(valueList, cJSON_CreateString(devParams[k].devParams[i].stringValueList[j].c_str()));
|
|
|
|
|
cJSON_AddItemToObject(param, "range_type", cJSON_CreateString("list"));
|
|
|
|
|
cJSON_AddItemToObject(param, "value_list", valueList);
|
2022-06-15 11:07:55 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
else if (2 == devParams[k].devParams[i].valueType)
|
2022-06-16 06:20:52 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(param, "value_type", cJSON_CreateString("int"));
|
|
|
|
|
cJSON_AddItemToObject(param, "value", cJSON_CreateNumber(devParams[k].devParams[i].intValue));
|
2022-06-16 06:20:52 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
if (2 == devParams[k].devParams[i].rangeType)
|
2022-06-16 06:20:52 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* valueList = cJSON_CreateArray();
|
|
|
|
|
for (int j = 0; j < (int)devParams[k].devParams[i].intValueList.size(); ++j)
|
|
|
|
|
cJSON_AddItemToArray(valueList, cJSON_CreateNumber(devParams[k].devParams[i].intValueList[j]));
|
|
|
|
|
cJSON_AddItemToObject(param, "range_type", cJSON_CreateString("list"));
|
|
|
|
|
cJSON_AddItemToObject(param, "value_list", valueList);
|
2022-06-16 06:20:52 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
else if (4 == devParams[k].devParams[i].rangeType)
|
2022-06-16 06:20:52 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(param, "range_type", cJSON_CreateString("min_max"));
|
|
|
|
|
cJSON_AddItemToObject(param, "value_min", cJSON_CreateNumber(devParams[k].devParams[i].intValueMin));
|
|
|
|
|
cJSON_AddItemToObject(param, "value_max", cJSON_CreateNumber(devParams[k].devParams[i].intValueMax));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(0 == devParams[k].devParams[i].rangeType);
|
2022-06-16 06:20:52 +00:00
|
|
|
|
}
|
2022-06-15 11:07:55 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
else if (3 == devParams[k].devParams[i].valueType)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(param, "value_type", cJSON_CreateString("double"));
|
|
|
|
|
cJSON_AddItemToObject(param, "value", cJSON_CreateNumber(devParams[k].devParams[i].doubleValue));
|
2022-06-16 06:20:52 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
if (3 == devParams[k].devParams[i].rangeType)
|
|
|
|
|
{
|
|
|
|
|
cJSON* valueList = cJSON_CreateArray();
|
|
|
|
|
for (int j = 0; j < (int)devParams[k].devParams[i].doubleValueList.size(); ++j)
|
|
|
|
|
cJSON_AddItemToArray(valueList, cJSON_CreateNumber(devParams[k].devParams[i].doubleValueList[j]));
|
|
|
|
|
cJSON_AddItemToObject(param, "range_type", cJSON_CreateString("list"));
|
|
|
|
|
cJSON_AddItemToObject(param, "value_list", valueList);
|
|
|
|
|
}
|
|
|
|
|
else if (5 == devParams[k].devParams[i].rangeType)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(param, "range_type", cJSON_CreateString("min_max"));
|
|
|
|
|
cJSON_AddItemToObject(param, "value_min", cJSON_CreateNumber(devParams[k].devParams[i].doubleValueMin));
|
|
|
|
|
cJSON_AddItemToObject(param, "value_max", cJSON_CreateNumber(devParams[k].devParams[i].doubleValueMax));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(0 == devParams[k].devParams[i].rangeType);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(4 == devParams[k].devParams[i].valueType);
|
|
|
|
|
assert(0 == devParams[k].devParams[i].rangeType);
|
2022-06-15 11:07:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(param, "value_type", cJSON_CreateString("bool"));
|
|
|
|
|
if (devParams[k].devParams[i].boolValue)
|
|
|
|
|
cJSON_AddItemToObject(param, "value", cJSON_CreateTrue());
|
|
|
|
|
else
|
|
|
|
|
cJSON_AddItemToObject(param, "value", cJSON_CreateFalse());
|
|
|
|
|
}
|
2022-06-15 11:07:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToArray(groupParam, param);
|
|
|
|
|
}
|
|
|
|
|
cJSON_AddItemToObject(groupParams, "group_param", groupParam);
|
2022-06-15 11:07:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToArray(deviceParams, groupParams);
|
2022-06-16 06:20:52 +00:00
|
|
|
|
}
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "device_param", deviceParams);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
2022-06-07 03:18:55 +00:00
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-16 06:20:52 +00:00
|
|
|
|
void WSUser::ResetDeviceParam(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->ResetDeviceParam(errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-16 06:20:52 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("reset_device_param"));
|
2022-06-16 06:20:52 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-16 06:20:52 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-16 06:20:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-06 10:51:34 +00:00
|
|
|
|
void WSUser::GetCurrDeviceName(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string devName;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->GetCurrDeviceName(devName, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("get_curr_device_name"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
else
|
2022-06-21 05:42:22 +00:00
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "device_name", cJSON_CreateString(devName.c_str()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::StartScan(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
2022-06-21 10:37:41 +00:00
|
|
|
|
bool find = false;
|
2022-08-01 07:58:12 +00:00
|
|
|
|
bool blankCheck = GetJsonBoolValue(json, "blank_check", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
blankCheck = false;
|
2022-06-21 10:37:41 +00:00
|
|
|
|
bool localSave = GetJsonBoolValue(json, "local_save", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
localSave = true;
|
|
|
|
|
bool getBase64 = GetJsonBoolValue(json, "get_base64", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
getBase64 = false;
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (!GetManager()->IsScanning())
|
|
|
|
|
{
|
|
|
|
|
m_startScanIden = iden;
|
|
|
|
|
m_startScanHaveIden = findIden;
|
2022-08-01 07:58:12 +00:00
|
|
|
|
m_startScanBlankCheck = blankCheck;
|
2022-06-21 10:37:41 +00:00
|
|
|
|
m_startScanIsLocalSave = localSave;
|
2022-06-09 03:05:24 +00:00
|
|
|
|
m_startScanIsGetBase64 = getBase64;
|
2022-06-07 03:18:55 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-06 10:51:34 +00:00
|
|
|
|
std::string errInfo;
|
2022-08-01 07:58:12 +00:00
|
|
|
|
int ret = GetManager()->StartScan(blankCheck, !localSave, errInfo);
|
2022-06-09 03:05:24 +00:00
|
|
|
|
if (0 != ret)
|
2022-06-06 10:51:34 +00:00
|
|
|
|
{
|
2022-06-07 03:18:55 +00:00
|
|
|
|
m_startScanIden.clear();
|
|
|
|
|
m_startScanHaveIden = false;
|
2022-08-01 07:58:12 +00:00
|
|
|
|
m_startScanBlankCheck = false;
|
2022-06-21 10:37:41 +00:00
|
|
|
|
m_startScanIsLocalSave = true;
|
2022-06-09 03:05:24 +00:00
|
|
|
|
m_startScanIsGetBase64 = false;
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("start_scan"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::StopScan(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->StopScan(errInfo);
|
|
|
|
|
|
|
|
|
|
m_startScanIden.clear();
|
|
|
|
|
m_startScanHaveIden = false;
|
2022-08-01 07:58:12 +00:00
|
|
|
|
m_startScanBlankCheck = false;
|
2022-06-21 10:37:41 +00:00
|
|
|
|
m_startScanIsLocalSave = true;
|
2022-06-09 03:05:24 +00:00
|
|
|
|
m_startScanIsGetBase64 = false;
|
2022-06-06 10:51:34 +00:00
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 03:18:55 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("stop_scan"));
|
2022-06-07 03:18:55 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 03:18:55 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-06 10:51:34 +00:00
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
|
2023-05-17 07:37:04 +00:00
|
|
|
|
void WSUser::IsDeviceScanning(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->IsScanning() ? 0 : -1;
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("is_device_scanning"));
|
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-07 10:22:27 +00:00
|
|
|
|
void WSUser::GetBatchIdList(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::vector<std::string> batchIdList;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->GetBatchIdList(batchIdList, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 10:22:27 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("get_batch_id_list"));
|
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
cJSON* idList = cJSON_CreateArray();
|
|
|
|
|
for (int i = 0; i < (int)batchIdList.size(); ++i)
|
|
|
|
|
cJSON_AddItemToArray(idList, cJSON_CreateString(batchIdList[i].c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "batch_id_list", idList);
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
2022-06-07 10:22:27 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
2022-06-07 10:22:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
2022-06-07 10:22:27 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::OpenBatch(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
std::string batchId = GetJsonStringValue(json, "batch_id", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
{
|
|
|
|
|
std::vector<std::string> batchIdList;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
GetManager()->GetBatchIdList(batchIdList, errInfo);
|
|
|
|
|
|
|
|
|
|
if (!batchIdList.empty())
|
|
|
|
|
batchId = batchIdList[batchIdList.size() - 1];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->OpenBatch(batchId, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 10:22:27 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("open_batch"));
|
2022-06-07 10:22:27 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::DeleteBatch(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string batchId = GetJsonStringValue(json, "batch_id");
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->DeleteBatch(batchId, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 10:22:27 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("delete_batch"));
|
2022-06-07 10:22:27 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::NewBatch(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
int ret;
|
|
|
|
|
std::string newBatchId;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
std::string batchId = GetJsonStringValue(json, "batch_id", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
{
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
HGChar uuid[256];
|
|
|
|
|
HGBase_GetUuid(uuid, 256);
|
|
|
|
|
batchId = std::string(uuid, 6);
|
|
|
|
|
|
|
|
|
|
ret = GetManager()->NewBatch(batchId, errInfo);
|
|
|
|
|
if (0 == ret)
|
|
|
|
|
{
|
|
|
|
|
newBatchId = batchId;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
ret = GetManager()->NewBatch(batchId, errInfo);
|
|
|
|
|
if (0 == ret)
|
|
|
|
|
newBatchId = batchId;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 10:22:27 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("new_batch"));
|
2022-06-07 10:22:27 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 10:22:27 +00:00
|
|
|
|
else
|
2022-06-21 05:42:22 +00:00
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "batch_id", cJSON_CreateString(newBatchId.c_str()));
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::GetCurrBatchId(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string batchId;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->GetCurrBatchId(batchId, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 10:22:27 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("get_curr_batch_id"));
|
2022-06-07 10:22:27 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 10:22:27 +00:00
|
|
|
|
else
|
2022-06-21 05:42:22 +00:00
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "batch_id", cJSON_CreateString(batchId.c_str()));
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::ModifyBatchId(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
std::string batchId = GetJsonStringValue(json, "batch_id", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
{
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
GetManager()->GetCurrBatchId(batchId, errInfo);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string newBatchId = GetJsonStringValue(json, "new_batch_id");
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->ModifyBatchId(batchId, newBatchId, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-07 10:22:27 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("modify_batch_id"));
|
2022-06-07 10:22:27 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-07 10:22:27 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-07 10:22:27 +00:00
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-11 06:18:33 +00:00
|
|
|
|
void WSUser::BindFolder(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string folder = Utf8ToStdString(GetJsonStringValue(json, "folder"));
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
std::string nameMode = GetJsonStringValue(json, "name_mode");
|
|
|
|
|
if (!find)
|
2022-06-13 04:02:51 +00:00
|
|
|
|
nameMode = "order";
|
|
|
|
|
|
|
|
|
|
int nameWidth = GetJsonIntValue(json, "name_width", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
nameWidth = 1;
|
|
|
|
|
|
|
|
|
|
int nameBase = GetJsonIntValue(json, "name_base", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
nameBase = 0;
|
2022-06-11 06:18:33 +00:00
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
2022-06-13 04:02:51 +00:00
|
|
|
|
int ret = GetManager()->BindFolder(folder, nameMode, nameWidth, nameBase, errInfo);
|
2022-06-11 06:18:33 +00:00
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-11 06:18:33 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("bind_folder"));
|
2022-06-11 06:18:33 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-11 06:18:33 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-11 06:18:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::StopBindFolder(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->StopBindFolder(errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-11 06:18:33 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("stop_bind_folder"));
|
2022-06-11 06:18:33 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-11 06:18:33 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-11 06:18:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-09 09:30:04 +00:00
|
|
|
|
void WSUser::GetImageThumbnailList(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::vector<ImageThumbInfo> imageThumbList;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->GetImageThumbnailList(imageThumbList, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("get_image_thumbnail_list"));
|
|
|
|
|
if (findIden)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
cJSON* thumbList = cJSON_CreateArray();
|
|
|
|
|
for (int i = 0; i < (int)imageThumbList.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
cJSON* thumb = cJSON_CreateObject();
|
|
|
|
|
cJSON_AddItemToObject(thumb, "image_tag", cJSON_CreateString(imageThumbList[i].tag.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(thumb, "image_base64", cJSON_CreateString(imageThumbList[i].thumbBase64.c_str()));
|
|
|
|
|
cJSON_AddItemToArray(thumbList, thumb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_thumbnail_list", thumbList);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::GetImageCount(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
int imageCount = 0;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->GetImageCount(imageCount, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("get_image_count"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
else
|
2022-06-21 05:42:22 +00:00
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_count", cJSON_CreateNumber(imageCount));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::LoadImage(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
|
|
|
|
|
std::string imageTag, imageBase64;
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->LoadImage(imageIndex, imageTag, imageBase64, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("load_image"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
else
|
2022-06-21 05:42:22 +00:00
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_tag", cJSON_CreateString(imageTag.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_base64", cJSON_CreateString(imageBase64.c_str()));
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::SaveImage(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
|
|
|
|
|
std::string imagePath;
|
|
|
|
|
std::string errInfo;
|
2022-06-22 07:41:59 +00:00
|
|
|
|
int ret = GetManager()->SaveImage(imageIndex, false, imagePath, errInfo);
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("save_image"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
else
|
2022-06-21 05:42:22 +00:00
|
|
|
|
{
|
|
|
|
|
cJSON_AddItemToObject(retJson, "image_path", cJSON_CreateString(StdStringToUtf8(imagePath).c_str()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::InsertLocalImage(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string imagePath = Utf8ToStdString(GetJsonStringValue(json, "image_path"));
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
int insertPos = GetJsonIntValue(json, "insert_pos", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
insertPos = -1;
|
|
|
|
|
|
|
|
|
|
std::string imageTag = GetJsonStringValue(json, "image_tag");
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->InsertLocalImage(imagePath, insertPos, imageTag, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("insert_local_image"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::InsertImage(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string imageBase64 = GetJsonStringValue(json, "image_base64");
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
int insertPos = GetJsonIntValue(json, "insert_pos", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
insertPos = -1;
|
|
|
|
|
|
|
|
|
|
std::string imageTag = GetJsonStringValue(json, "image_tag");
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->InsertImage(imageBase64, insertPos, imageTag, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("insert_image"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::ModifyImageTag(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::vector<int> imageIndexList = GetJsonIntListValue(json, "image_index_list");
|
|
|
|
|
std::vector<std::string> imageTagList = GetJsonStringListValue(json, "image_tag_list");
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->ModifyImageTag(imageIndexList, imageTagList, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("modify_image_tag"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::DeleteImage(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::vector<int> imageIndexList = GetJsonIntListValue(json, "image_index_list");
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->DeleteImage(imageIndexList, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("delete_image"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::ClearImageList(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->ClearImageList(errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("clear_image_list"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::ModifyImage(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
std::string imageBase64 = GetJsonStringValue(json, "image_base64");
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->ModifyImage(imageIndex, imageBase64, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("modify_image"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::ModifyImageByLocal(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
int imageIndex = GetJsonIntValue(json, "image_index");
|
|
|
|
|
std::string imagePath = Utf8ToStdString(GetJsonStringValue(json, "image_path"));
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->ModifyImageByLocal(imageIndex, imagePath, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("modify_image_by_local"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void WSUser::MoveImage(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::vector<int> imageIndexList = GetJsonIntListValue(json, "image_index_list");
|
|
|
|
|
|
|
|
|
|
bool find = false;
|
|
|
|
|
std::string mode = GetJsonStringValue(json, "mode", &find);
|
|
|
|
|
if (!find)
|
|
|
|
|
mode = "index";
|
|
|
|
|
|
|
|
|
|
int target = GetJsonIntValue(json, "target");
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->MoveImage(imageIndexList, mode, target, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("move_image"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-11 06:18:33 +00:00
|
|
|
|
void WSUser::ExchangeImage(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
int imageIndex1 = GetJsonIntValue(json, "image_index_1");
|
|
|
|
|
int imageIndex2 = GetJsonIntValue(json, "image_index_2");
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->ExchangeImage(imageIndex1, imageIndex2, errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-11 06:18:33 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("exchange_image"));
|
2022-06-11 06:18:33 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-11 06:18:33 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-11 06:18:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-09 09:30:04 +00:00
|
|
|
|
void WSUser::ImageBookSort(cJSON* json)
|
|
|
|
|
{
|
|
|
|
|
assert(NULL != json);
|
|
|
|
|
|
|
|
|
|
std::string errInfo;
|
|
|
|
|
int ret = GetManager()->ImageBookSort(errInfo);
|
|
|
|
|
|
|
|
|
|
bool findIden = false;
|
|
|
|
|
std::string iden = GetJsonStringValue(json, "iden", &findIden);
|
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON* retJson = cJSON_CreateObject();
|
|
|
|
|
if (NULL != retJson)
|
2022-06-09 09:30:04 +00:00
|
|
|
|
{
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "func", cJSON_CreateString("image_book_sort"));
|
2022-06-09 09:30:04 +00:00
|
|
|
|
if (findIden)
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_AddItemToObject(retJson, "iden", cJSON_CreateString(iden.c_str()));
|
|
|
|
|
cJSON_AddItemToObject(retJson, "ret", cJSON_CreateNumber(ret));
|
|
|
|
|
if (0 != ret)
|
|
|
|
|
cJSON_AddItemToObject(retJson, "err_info", cJSON_CreateString(StdStringToUtf8(errInfo).c_str()));
|
|
|
|
|
|
|
|
|
|
char* resp = cJSON_Print(retJson);
|
|
|
|
|
if (NULL != resp)
|
|
|
|
|
{
|
|
|
|
|
SendResponse((const HGByte*)resp, (HGUInt)strlen(resp), HGTRUE);
|
|
|
|
|
free(resp);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
|
2022-06-21 05:42:22 +00:00
|
|
|
|
cJSON_Delete(retJson);
|
|
|
|
|
}
|
2022-06-09 09:30:04 +00:00
|
|
|
|
}
|
2023-05-16 07:37:40 +00:00
|
|
|
|
}
|