lmh188
/
code_app
mirror of http://192.168.10.5:8099/sane/code_app.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
code_app/sdk/webservice/HttpUser.cpp

903 lines
30 KiB
C++
Raw Normal View History

整理websdk目录，方便V1和V2版本管理
2022-05-23 02:35:42 +00:00
#include "HttpUser.h"
用命名空间ver_1和ver_2来区分1.0和2.0版本
2022-05-23 10:29:23 +00:00
#include "HttpServer.h"
#include "ManagerV1.h"
整理websdk目录，方便V1和V2版本管理
2022-05-23 02:35:42 +00:00
#include "base/HGInfo.h"
#include "cJSON.h"
namespace ver_1
{
static std::string ToJsonPair(const std::string& key, int value, bool sep)
{
char ret[256];
sprintf(ret, "\"%s\":%d", key.c_str(), value);
std::string retStr = ret;
if (sep)
retStr += ", ";
return retStr;
}
static std::string ToJsonPair(const std::string& key, bool value, bool sep)
{
char ret[256];
sprintf(ret, "\"%s\":%s", key.c_str(), value ? "true" : "false");
std::string retStr = ret;
if (sep)
retStr += ", ";
return retStr;
}
static std::string ToJsonPair(const std::string& key, const std::string& value, bool sep)
{
char ret[256];
if (value.empty())
sprintf(ret, "\"%s\":null", key.c_str());
else
sprintf(ret, "\"%s\":\"%s\"", key.c_str(), value.c_str());
std::string retStr = ret;
if (sep)
retStr += ", ";
return retStr;
}
static int GetJsonIntValue(cJSON* json, const std::string& key)
{
int ret = 0;
cJSON* p = json->child;
while (NULL != p)
{
if (0 == strcmp(p->string, key.c_str()))
{
if (p->type == cJSON_Number)
ret = p->valueint;
break;
}
p = p->next;
}
return ret;
}
static bool GetJsonBoolValue(cJSON* json, const std::string& key)
{
bool ret = false;
cJSON* p = json->child;
while (NULL != p)
{
if (0 == strcmp(p->string, key.c_str()))
{
if (p->type == cJSON_True)
ret = true;
break;
}
p = p->next;
}
return ret;
}
static std::string GetJsonStringValue(cJSON* json, const std::string& key)
{
std::string ret;
cJSON* p = json->child;
while (NULL != p)
{
if (0 == strcmp(p->string, key.c_str()))
{
if (p->type == cJSON_String)
ret = p->valuestring;
break;
}
p = p->next;
}
return ret;
}
#if defined(HG_CMP_MSC)
用命名空间ver_1和ver_2来区分1.0和2.0版本
2022-05-23 10:29:23 +00:00
HttpUser::HttpUser(WebServer* server, HGUInt id, const std::string& ip, uint16_t port, SOCKET sockConn)
整理websdk目录，方便V1和V2版本管理
2022-05-23 02:35:42 +00:00
#else
用命名空间ver_1和ver_2来区分1.0和2.0版本
2022-05-23 10:29:23 +00:00
HttpUser::HttpUser(WebServer* server, HGUInt id, const std::string& ip, uint16_t port, int sockConn)
整理websdk目录，方便V1和V2版本管理
2022-05-23 02:35:42 +00:00
#endif
: WebUser(server, id, ip, port, sockConn)
{
}
HttpUser::~HttpUser()
{
}
用命名空间ver_1和ver_2来区分1.0和2.0版本
2022-05-23 10:29:23 +00:00
ManagerV1* HttpUser::GetManager()
{
return ((HttpServer*)m_server)->GetManger();
}
整理websdk目录，方便V1和V2版本管理
2022-05-23 02:35:42 +00:00
void HttpUser::HandleCmd(const HttpCmdParam* param)
{
assert(NULL != param && m_id == param->usrId);
std::string requestMethod = param->head.GetRequestMethod();
std::string requestURIPath = param->head.GetRequestURIPath();
HttpPairs requestURIQueryInfos = param->head.GetRequestURIQueryInfos();
std::string requestHttpVersion = param->head.GetRequestHttpVersion();
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "HttpUser: method=%s, path=%s, httpVersion=%s",
requestMethod.c_str(), requestURIPath.c_str(), requestHttpVersion.c_str());
if (requestMethod == "POST" && requestURIPath == "/WebScan/getVersionInfo")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
}
std::string devId;
GetManager()->GetCurDevId(devId);
char* result = new char[devId.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"%s\"}", 200, devId.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/getDevices")
{
std::vector<std::string> devNameList;
GetManager()->GetDevNames(devNameList);
std::string devNames = "[";
for (int i = 0; i < (int)devNameList.size(); ++i)
{
devNames += "\"";
devNames += devNameList[i];
devNames += "\"";
if (i != (int)devNameList.size() - 1)
devNames += ",";
}
devNames += "]";
char* result = new char[devNames.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":%s}", 200, devNames.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/image/getImageByPid")
{
std::string devId = HttpHead::GetValue(requestURIQueryInfos, "pid");
std::vector<std::string> imgNameList;
std::vector<std::string> imgBase64List;
GetManager()->GetImageByDevId(devId, imgNameList, imgBase64List);
std::string imgInfos = "[";
for (int i = 0; i < (int)imgNameList.size(); ++i)
{
imgInfos += "{\"imageName\":\"";
imgInfos += imgNameList[i];
imgInfos += "\",\"src\":\"";
imgInfos += imgBase64List[i];
imgInfos += "\"}";
if (i != imgNameList.size() - 1)
imgInfos += ",";
}
imgInfos += "]";
char* result = new char[imgInfos.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":%s}", 200, imgInfos.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/getParams")
{
std::string devId = HttpHead::GetValue(requestURIQueryInfos, "pid");
DevParam devParam;
GetManager()->GetDevParam(devId, devParam);
std::string devParamStr = "{";
devParamStr += ToJsonPair("device", devParam.device, true);
devParamStr += ToJsonPair("autofeeder", devParam.autofeeder, true);
devParamStr += ToJsonPair("pixel", devParam.pixel, true);
devParamStr += ToJsonPair("white", devParam.white, true);
devParamStr += ToJsonPair("discardBlankThre", devParam.discardBlankThre, true);
devParamStr += ToJsonPair("single", devParam.single, true);
devParamStr += ToJsonPair("format", devParam.format, true);
devParamStr += ToJsonPair("resolution", devParam.resolution, true);
devParamStr += ToJsonPair("orentation", devParam.orentation, true);
devParamStr += ToJsonPair("paperType", devParam.paperType, true);
devParamStr += ToJsonPair("splitImage", devParam.splitImage, true);
devParamStr += ToJsonPair("noiseDetachEnable", devParam.noiseDetachEnable, true);
devParamStr += ToJsonPair("noiseDetach", devParam.noiseDetach, true);
devParamStr += "\"upload\":{";
devParamStr += ToJsonPair("uploadMode", devParam.uploadMode, true);
devParamStr += ToJsonPair("httpUrl", devParam.httpUrl, true);
devParamStr += ToJsonPair("fileName", devParam.fileName, true);
devParamStr += ToJsonPair("httpMethod", devParam.httpMethod, true);
devParamStr += ToJsonPair("header", devParam.header, true);
devParamStr += ToJsonPair("param", devParam.param, true);
devParamStr += ToJsonPair("ftpUrl", devParam.ftpUrl, true);
devParamStr += ToJsonPair("ftpPath", devParam.ftpPath, true);
devParamStr += ToJsonPair("ftpUser", devParam.ftpUser, true);
devParamStr += ToJsonPair("ftpPassword", devParam.ftpPassword, true);
devParamStr += ToJsonPair("ftpPort", devParam.ftpPort, true);
devParamStr += ToJsonPair("ftpMode", devParam.ftpMode, false);
devParamStr += "}}";
char* result = new char[devParamStr.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":%s}", 200, devParamStr.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/setParams")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string devId = HttpHead::GetValue(uriQueryInfos, "pid");
std::string devParamStr = HttpHead::GetValue(uriQueryInfos, "params");
DevParam devParam;
cJSON* json = cJSON_Parse(devParamStr.c_str());
if (NULL != json)
{
devParam.autofeeder = GetJsonBoolValue(json, "autofeeder");
devParam.pixel = GetJsonIntValue(json, "pixel");
devParam.white = GetJsonBoolValue(json, "white");
devParam.discardBlankThre = GetJsonIntValue(json, "discardBlankThre");
devParam.single = GetJsonBoolValue(json, "single");
devParam.format = GetJsonStringValue(json, "format");
devParam.resolution = GetJsonIntValue(json, "resolution");
if (0 == devParam.resolution)
devParam.resolution = atoi(GetJsonStringValue(json, "resolution").c_str());
devParam.orentation = GetJsonIntValue(json, "orentation");
devParam.paperType = GetJsonStringValue(json, "paperType");
devParam.splitImage = GetJsonIntValue(json, "splitImage");
devParam.noiseDetachEnable = GetJsonBoolValue(json, "noiseDetachEnable");
devParam.noiseDetach = GetJsonIntValue(json, "noiseDetach");
cJSON* p = json->child;
while (NULL != p)
{
if (0 == strcmp(p->string, "upload"))
{
break;
}
p = p->next;
}
if (NULL != p && p->type == cJSON_Object)
{
devParam.uploadMode = GetJsonIntValue(p, "uploadMode");
devParam.httpUrl = GetJsonStringValue(p, "httpUrl");
devParam.fileName = GetJsonStringValue(p, "fileName");
devParam.httpMethod = GetJsonStringValue(p, "httpMethod");
devParam.header = GetJsonStringValue(p, "header");
devParam.param = GetJsonStringValue(p, "param");
devParam.ftpUrl = GetJsonStringValue(p, "ftpUrl");
devParam.ftpPath = GetJsonStringValue(p, "ftpPath");
if (!devParam.ftpPath.empty() && devParam.ftpPath[0] != '/')
devParam.ftpPath.insert(0, "/");
devParam.ftpUser = GetJsonStringValue(p, "ftpUser");
devParam.ftpPassword = GetJsonStringValue(p, "ftpPassword");
devParam.ftpPort = GetJsonIntValue(p, "ftpPort");
if (0 == devParam.ftpPort)
devParam.ftpPort = atoi(GetJsonStringValue(p, "ftpPort").c_str());
devParam.ftpMode = GetJsonIntValue(p, "ftpMode");
}
cJSON_Delete(json);
}
GetManager()->SetDevParam(devId, devParam);
char result[256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"\"}", 200);
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
}
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/majorOfd")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string majorOfdParam = HttpHead::GetValue(uriQueryInfos, "formDataString");
std::string devId;
bool isAuto = false;
cJSON* json = cJSON_Parse(majorOfdParam.c_str());
if (NULL != json)
{
devId = GetJsonStringValue(json, "pid");
isAuto = GetJsonBoolValue(json, "isAuto");
cJSON_Delete(json);
}
std::string imgBase64;
GetManager()->ExportOfd(devId, isAuto, imgBase64);
char* result = new char[imgBase64.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":%s}", 200, imgBase64.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/majorOfdFile")
{
std::string devId = HttpHead::GetValue(requestURIQueryInfos, "pid");
bool isAuto = ("true" == HttpHead::GetValue(requestURIQueryInfos, "isAuto") ? true : false);
HGByte* data = NULL;
HGUInt size = 0;
GetManager()->ExportOfdFile(devId, isAuto, &data, &size);
SendResponse(requestHttpVersion.c_str(), 200, "OK", data, size, "application/zip");
delete[] data;
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/majorPdf")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string majorOfdParam = HttpHead::GetValue(uriQueryInfos, "formDataString");
std::string devId;
cJSON* json = cJSON_Parse(majorOfdParam.c_str());
if (NULL != json)
{
devId = GetJsonStringValue(json, "pid");
cJSON_Delete(json);
}
std::string imgBase64;
GetManager()->ExportPdf(devId, imgBase64);
char* result = new char[imgBase64.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":%s}", 200, imgBase64.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/majorPdfFile")
{
std::string devId = HttpHead::GetValue(requestURIQueryInfos, "pid");
HGByte* data = NULL;
HGUInt size = 0;
GetManager()->ExportPdfFile(devId, &data, &size);
SendResponse(requestHttpVersion.c_str(), 200, "OK", data, size, "application/pdf");
delete[] data;
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/majorTiff")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string devId = HttpHead::GetValue(uriQueryInfos, "pid");
std::string imgBase64;
GetManager()->ExportTiff(devId, imgBase64);
char* result = new char[imgBase64.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":%s}", 200, imgBase64.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/majorTiffFile")
{
std::string devId = HttpHead::GetValue(requestURIQueryInfos, "pid");
HGByte* data = NULL;
HGUInt size = 0;
GetManager()->ExportTiffFile(devId, &data, &size);
SendResponse(requestHttpVersion.c_str(), 200, "OK", data, size, "application/x-tif");
delete[] data;
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/downLoadZip")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string devId = HttpHead::GetValue(uriQueryInfos, "pid");
std::string imgBase64;
GetManager()->ExportZip(devId, imgBase64);
char* result = new char[imgBase64.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":%s}", 200, imgBase64.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/downLoadZipFile")
{
std::string devId = HttpHead::GetValue(requestURIQueryInfos, "pid");
HGByte* data = NULL;
HGUInt size = 0;
GetManager()->ExportZipFile(devId, &data, &size);
SendResponse(requestHttpVersion.c_str(), 200, "OK", data, size, "application/zip");
delete[] data;
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/uploadImage")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string uploadParamStr = HttpHead::GetValue(uriQueryInfos, "formDataString");
UploadParam uploadParam;
cJSON* json = cJSON_Parse(uploadParamStr.c_str());
if (NULL != json)
{
uploadParam.uploadMode = GetJsonIntValue(json, "uploadMode");
uploadParam.httpUrl = GetJsonStringValue(json, "httpUrl");
uploadParam.fileName = GetJsonStringValue(json, "fileName");
uploadParam.httpMethod = GetJsonStringValue(json, "httpMethod");
uploadParam.header = GetJsonStringValue(json, "header");
uploadParam.param = GetJsonStringValue(json, "param");
uploadParam.ftpUrl = GetJsonStringValue(json, "ftpUrl");
uploadParam.ftpPath = GetJsonStringValue(json, "ftpPath");
if (!uploadParam.ftpPath.empty() && uploadParam.ftpPath[0] != '/')
uploadParam.ftpPath.insert(0, "/");
uploadParam.ftpUser = GetJsonStringValue(json, "ftpUser");
uploadParam.ftpPassword = GetJsonStringValue(json, "ftpPassword");
uploadParam.ftpPort = GetJsonIntValue(json, "ftpPort");
if (0 == uploadParam.ftpPort)
uploadParam.ftpPort = atoi(GetJsonStringValue(json, "ftpPort").c_str());
uploadParam.ftpMode = GetJsonIntValue(json, "ftpMode");
uploadParam.format = GetJsonIntValue(json, "format");
cJSON_Delete(json);
}
bool ret = GetManager()->UploadImage(uploadParam);
char result[256];
if (ret)
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"%s\"}", 200, "success");
else
sprintf(result, "{\"code\":%d, \"msg\":\"%s\", \"data\":\"%s\"}", 201, "uploadImage failed", "fail");
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
}
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/image/saveImage")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string devId = HttpHead::GetValue(uriQueryInfos, "pid");
std::string imgName = HttpHead::GetValue(uriQueryInfos, "imageName");
std::string imgBase64 = HttpHead::GetValue(uriQueryInfos, "image");
GetManager()->SaveImage(devId, imgName, imgBase64);
char result[256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"%s\"}", 200, "success");
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
}
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/image/deleteImage")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string devId = HttpHead::GetValue(uriQueryInfos, "pid");
std::string imgName = HttpHead::GetValue(uriQueryInfos, "imageName");
GetManager()->DeleteImage(devId, imgName);
char result[256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"%s\"}", 200, "success");
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
}
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/image/deleteAllImage")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string devId = HttpHead::GetValue(uriQueryInfos, "pid");
GetManager()->DeleteAllImage(devId);
char result[256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"%s\"}", 200, "success");
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
}
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/image/mergeHorizontal")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string devId = HttpHead::GetValue(uriQueryInfos, "pid");
bool isHorizontal = ("false" != HttpHead::GetValue(uriQueryInfos, "isHorizontal")) ? true : false;
std::vector<int> imgIndexs;
for (int i = 0; i < (int)uriQueryInfos.size(); ++i)
{
if ("indexs[]" == uriQueryInfos[i].first)
{
imgIndexs.push_back(atoi(uriQueryInfos[i].second.c_str()));
}
}
std::string imgName, imgBase64;
GetManager()->MergeImage(devId, isHorizontal, imgIndexs, imgName, imgBase64);
char* result = new char[256 + imgName.size() + imgBase64.size()];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":{\"imageName\":\"%s\", \"src\":\"%s\"}}",
200, imgName.c_str(), imgBase64.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/image/bookSort")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string devId = HttpHead::GetValue(uriQueryInfos, "pid");
std::vector<std::string> imgNameList, imgBase64List;
GetManager()->BookSort(devId, imgNameList, imgBase64List);
std::string imgInfos = "[";
for (int i = 0; i < (int)imgNameList.size(); ++i)
{
imgInfos += "{\"imageName\":\"";
imgInfos += imgNameList[i];
imgInfos += "\",\"src\":\"";
imgInfos += imgBase64List[i];
imgInfos += "\"}";
if (i != imgNameList.size() - 1)
imgInfos += ",";
}
imgInfos += "]";
char* result = new char[imgInfos.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":%s}", 200, imgInfos.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/image/exchangeImage")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string devId = HttpHead::GetValue(uriQueryInfos, "pid");
int index1 = -1, index2 = -1;
for (int i = 0; i < (int)uriQueryInfos.size(); ++i)
{
if ("indexs[]" == uriQueryInfos[i].first)
{
if (-1 == index1)
index1 = atoi(uriQueryInfos[i].second.c_str());
else if (-1 == index2)
index2 = atoi(uriQueryInfos[i].second.c_str());
}
}
GetManager()->ExchangeImage(devId, index1, index2);
char result[256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"%s\"}", 200, "success");
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
}
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/getLastBatch")
{
std::string devId;
GetManager()->GetLastBetch(devId);
char* result = new char[devId.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"%s\"}", 200, devId.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/getSerialNumber")
{
std::string devId = HttpHead::GetValue(requestURIQueryInfos, "pid");
std::string devSerialNo;
GetManager()->GetDevSerialNo(devId, devSerialNo);
char* result = new char[devSerialNo.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"%s\"}", 200, devSerialNo.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
else if (requestMethod == "GET" && requestURIPath == "/WebScan/getImageByName")
{
std::string devId = HttpHead::GetValue(requestURIQueryInfos, "pid");
std::string imgName = HttpHead::GetValue(requestURIQueryInfos, "imageName");
std::string imgBase64;
GetManager()->GetImageBase64(devId, imgName, imgBase64);
char* result = new char[imgBase64.size() + 256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"%s\"}", 200, imgBase64.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/image/resetPatchIndex")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
}
GetManager()->ResetPatchIndex();
char result[256];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":\"%s\"}", 200, "success");
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
}
else if (requestMethod == "POST" && requestURIPath == "/WebScan/image/split")
{
if (std::string::npos != param->head.GetContentType().find("application/x-www-form-urlencoded"))
{
std::string query((const char*)param->data, param->size);
HttpPairs uriQueryInfos;
HttpHead::AnalysisURIQuery(query.c_str(), uriQueryInfos);
std::string devId = HttpHead::GetValue(uriQueryInfos, "pid");
std::string imgName = HttpHead::GetValue(uriQueryInfos, "imageName");
bool isHorizontal = ("false" != HttpHead::GetValue(uriQueryInfos, "isHorizontal")) ? true : false;
int x1 = atoi(HttpHead::GetValue(uriQueryInfos, "x1").c_str());
int x2 = atoi(HttpHead::GetValue(uriQueryInfos, "x2").c_str());
int y1 = atoi(HttpHead::GetValue(uriQueryInfos, "y1").c_str());
int y2 = atoi(HttpHead::GetValue(uriQueryInfos, "y2").c_str());
std::string imgName1, imgBase64_1, imgName2, imgBase64_2;
GetManager()->SplitImage(devId, imgName, isHorizontal, x1, y1, x2, y2,
imgName1, imgBase64_1, imgName2, imgBase64_2);
char* result = new char[256 + imgName1.size() + imgBase64_1.size() + imgName2.size() + imgBase64_2.size()];
sprintf(result, "{\"code\":%d, \"msg\":null, \"data\":{\"oneSrc\":\"%s\", \"oneName\":\"%s\", \"twoSrc\":\"%s\", \"twoName\":\"%s\"}}",
200, imgBase64_1.c_str(), imgName1.c_str(), imgBase64_2.c_str(), imgName2.c_str());
SendResponse(requestHttpVersion.c_str(), 200, "OK",
(const HGByte*)result, (HGUInt)strlen(result), "application/json");
delete[] result;
}
}
}
void HttpUser::PostCmdMsg(const HttpHead& headInfo, const HGByte* data, HGUInt dataSize)
{
HttpCmdParam* param = new HttpCmdParam;
param->svr = (HttpServer*)m_server;
param->usrId = m_id;
param->head = headInfo;
param->data = NULL;
param->size = 0;
if (0 != dataSize)
{
param->data = new HGByte[dataSize];
param->size = dataSize;
memcpy(param->data, data, dataSize);
}
HGMsg msg;
msg.id = MSGID_HTTP_COMMAND;
msg.data = param;
if (HGBASE_ERR_OK != HGBase_PostPumpMessage(m_server->GetMsgPump(), &msg))
{
delete[] param->data;
param->size = 0;
delete param;
}
}
void HttpUser::ThreadFunc()
{
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "HttpUser::ThreadFunc");
char chBuffer[2048];
const char* pBuffer = chBuffer;
int nBufferSize = 0;
unsigned char headDataTail[4] = { '\r', '\n', '\r', '\n' };
unsigned int headDataTailLen = 0;
std::string headData;
HttpHead headInfo;
uint8_t* data = NULL;
int dataSize = 0;
bool getData = false;
int getDataSize = 0;
while (1)
{
if (0 == nBufferSize)
{
int len = recv(m_sockConn, chBuffer, 2048, 0);
if (len <= 0)
{
// 这里跳出，可能是服务器关闭了socketConn，或者客户端关闭了socket，或者网络断开
PostDisConnectMsg();
break;
}
else
{
pBuffer = chBuffer;
nBufferSize = len;
}
}
assert(nBufferSize > 0);
unsigned char b = *pBuffer;
++pBuffer;
--nBufferSize;
if (!getData)
{
headData.push_back(b);
if (b == headDataTail[headDataTailLen])
{
++headDataTailLen;
}
else
{
headDataTailLen = 0;
if (b == headDataTail[headDataTailLen])
{
++headDataTailLen;
}
}
if (4 == headDataTailLen)
{
headDataTailLen = 0;
if (!headInfo.Parse(headData.c_str()))
{
PostDisConnectMsg();
break;
}
headData.clear();
int contentLen = headInfo.GetContentLength();
if (contentLen > 0)
{
data = new uint8_t[contentLen];
dataSize = contentLen;
getData = true;
getDataSize = 0;
}
else
{
PostCmdMsg(headInfo, NULL, 0);
headInfo.Clear();
}
}
}
else
{
data[getDataSize] = b;
++getDataSize;
if (getDataSize == dataSize)
{
PostCmdMsg(headInfo, data, dataSize);
delete[] data;
data = NULL;
dataSize = 0;
getData = false;
getDataSize = 0;
headInfo.Clear();
}
}
}
if (NULL != data)
{
delete[] data;
data = NULL;
dataSize = 0;
getData = false;
getDataSize = 0;
}
}
bool HttpUser::SendResponse(const char* httpVersion, HGUInt errCode, const char* errInfo,
const HGByte* data, HGUInt size, const char* contentType)
{
if (NULL == httpVersion || NULL == errInfo)
{
return false;
}
char response[256];
sprintf(response, "%s %u %s\r\n", httpVersion, errCode, errInfo);
char head[256];
if (NULL != data)
{
assert(0 != size);
assert(NULL != contentType);
sprintf(head, "%s: %u\r\n%s: %s\r\n%s: %s\r\n\r\n",
"Content-Length", size,
"Content-Type", contentType,
"Access-Control-Allow-Origin", "null");
}
else
{
assert(0 == size);
sprintf(head, "%s: %s\r\n\r\n",
"Access-Control-Allow-Origin", "null");
}
HGBase_EnterLock(m_cs);
send(m_sockConn, response, (int)strlen(response), 0);
send(m_sockConn, head, (int)strlen(head), 0);
if (NULL != data && 0 != size)
send(m_sockConn, (const char*)data, (int)size, 0);
HGBase_LeaveLock(m_cs);
return true;
}
}