From f115bdceda578374a1d99db6abac12230b16f687 Mon Sep 17 00:00:00 2001 From: luoliangyi <87842688@qq.com> Date: Wed, 8 Jun 2022 18:54:34 +0800 Subject: [PATCH] =?UTF-8?q?websdk=EF=BC=9A=E5=AE=9E=E7=8E=B0=E7=BC=A9?= =?UTF-8?q?=E7=95=A5=E5=9B=BE=E4=B8=AD=E7=9A=84=E5=9B=BE=E5=83=8F=E7=A7=BB?= =?UTF-8?q?=E5=8A=A8=E3=80=81=E4=B9=A6=E7=B1=8D=E6=8E=92=E5=BA=8F=E3=80=81?= =?UTF-8?q?=E5=9B=BE=E5=83=8F=E4=BF=AE=E6=94=B9=E3=80=81=E5=9B=BE=E5=83=8F?= =?UTF-8?q?=E5=8A=A0=E8=BD=BD=E7=AD=89=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- sdk/webservice/ManagerV2.cpp | 1045 +++++++++++++++++++++++++++++++++- sdk/webservice/ManagerV2.h | 2 + test/webservice/demo.html | 2 +- 3 files changed, 1019 insertions(+), 30 deletions(-) diff --git a/sdk/webservice/ManagerV2.cpp b/sdk/webservice/ManagerV2.cpp index ca63cac9..0ac2d4b1 100644 --- a/sdk/webservice/ManagerV2.cpp +++ b/sdk/webservice/ManagerV2.cpp @@ -23,6 +23,16 @@ extern "C" namespace ver_2 { + static bool MainTableSort(const std::pair &pr1, const std::pair &pr2) + { + return pr1.first < pr2.first; + } + + static bool BatchTableSort(const std::pair& pr1, const std::pair& pr2) + { + return pr1.second < pr2.second; + } + ManagerV2::ManagerV2(HGMsgPump msgPump) : Manager(msgPump) { @@ -84,7 +94,7 @@ namespace ver_2 int ret = sqlite3_exec(m_sqlite, "create table table_ (id integer primary key autoincrement, name text)", NULL, NULL, NULL); if (0 == ret) { - ret = sqlite3_exec(m_sqlite, "create table 'table_default' (idx integer, tag text, image blob)", NULL, NULL, NULL); + ret = sqlite3_exec(m_sqlite, "create table 'table_default' (id integer primary key autoincrement, idx integer, format text, tag text, image blob)", NULL, NULL, NULL); assert(0 == ret); ret = sqlite3_exec(m_sqlite, "insert into table_ (name) values ('default')", NULL, NULL, NULL); assert(0 == ret); @@ -118,7 +128,7 @@ namespace ver_2 sqlite3_free_table(result); assert(!tables.empty()); - // tables是否需要按照id进行排序 + std::sort(tables.begin(), tables.end(), MainTableSort); m_currBatchId = tables[tables.size() - 1].second; } } @@ -1048,7 +1058,7 @@ namespace ver_2 sqlite3_free_table(result); assert(!tables.empty()); - // tables是否需要按照id进行排序 + std::sort(tables.begin(), tables.end(), MainTableSort); for (int i = 0; i < (int)tables.size(); ++i) batchIdList.push_back(tables[i].second); @@ -1114,21 +1124,11 @@ namespace ver_2 return -1; char sql[256]; - sprintf(sql, "create table 'table_%s' (idx integer, tag text, image blob)", batchId.c_str()); + sprintf(sql, "create table 'table_%s' (id integer primary key autoincrement, idx integer, format text, tag text, image blob)", batchId.c_str()); int ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); if (0 != ret) return -1; - /* - char** result = NULL; - int rows, cols; - int rr = sqlite3_get_table(m_sqlite, "select name from sqlite_master where type = 'table' order by name", - &result, &rows, &cols, NULL); - for (int i = 0; i < rows; ++i) - HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "%s", result[i + 1]); - sqlite3_free_table(result); - */ - sprintf(sql, "insert into table_ (name) values ('%s')", batchId.c_str()); ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); assert(0 == ret); @@ -1162,13 +1162,12 @@ namespace ver_2 char sql[256]; sprintf(sql, "alter table 'table_%s' rename to 'table_%s'", batchId.c_str(), newBatchId.c_str()); - char* err = NULL; - int ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, &err); + int ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); if (0 != ret) return -1; sprintf(sql, "update table_ set name = '%s' where name = '%s'", newBatchId.c_str(), batchId.c_str()); - ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, &err); + ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); assert(0 == ret); if (batchId == m_currBatchId) @@ -1179,62 +1178,1036 @@ namespace ver_2 int ManagerV2::GetImageCount(int& imageCount, std::string& errInfo) { - return -1; + imageCount = 0; + errInfo = "错误"; + + if (NULL == m_sqlite) + return -1; + + char** result = NULL; + char sql[256]; + sprintf(sql, "select id from 'table_%s'", m_currBatchId.c_str()); + int rows, cols; + int ret = sqlite3_get_table(m_sqlite, sql, &result, &rows, &cols, NULL); + assert(0 == ret); + + imageCount = rows; + sqlite3_free_table(result); + + errInfo.clear(); + return 0; } int ManagerV2::LoadImage(int imageIndex, std::string& imageTag, std::string& imageBase64, std::string& errInfo) { - return -1; + imageTag.clear(); + imageBase64.clear(); + errInfo = "错误"; + + if (NULL == m_sqlite) + return -1; + + int rc = -1; + + sqlite3_stmt* stmt = NULL; + char sql[256]; + sprintf(sql, "select * from 'table_%s'", m_currBatchId.c_str()); + int ret = sqlite3_prepare(m_sqlite, sql, -1, &stmt, NULL); + assert(0 == ret); + + ret = sqlite3_step(stmt); + while (SQLITE_ROW == ret) + { + int idx = sqlite3_column_int(stmt, 1); + if (idx == imageIndex) + { + std::string imgFmt = (const char*)sqlite3_column_text(stmt, 2); + imageTag = (const char*)sqlite3_column_text(stmt, 3); + const void* imgData = sqlite3_column_blob(stmt, 4); + int imgSize = sqlite3_column_bytes(stmt, 4); + + GetBase64((const HGByte *)imgData, imgSize, imageBase64); + assert(!imageBase64.empty()); + + std::string prefix; + if ("jpg" == imgFmt) + prefix = "data:image/jpeg;base64,"; + else if ("bmp" == imgFmt) + prefix = "data:image/bmp;base64,"; + else if ("png" == imgFmt) + prefix = "data:image/png;base64,"; + else if ("tif" == imgFmt) + prefix = "data:image/tiff;base64,"; + else if ("pdf" == imgFmt) + prefix = "data:image/pdf;base64,"; + else if ("ofd" == imgFmt) + prefix = "data:image/ofd;base64,"; + imageBase64.insert(0, prefix); + + errInfo.clear(); + rc = 0; + break; + } + + ret = sqlite3_step(stmt); + } + + ret = sqlite3_finalize(stmt); + assert(0 == ret); + return rc; } int ManagerV2::SaveImage(int imageIndex, std::string& imagePath, std::string& errInfo) { - return -1; + imagePath.clear(); + errInfo = "错误"; + + if (NULL == m_sqlite) + return -1; + + int rc = -1; + + sqlite3_stmt* stmt = NULL; + char sql[256]; + sprintf(sql, "select * from 'table_%s'", m_currBatchId.c_str()); + int ret = sqlite3_prepare(m_sqlite, sql, -1, &stmt, NULL); + assert(0 == ret); + + ret = sqlite3_step(stmt); + while (SQLITE_ROW == ret) + { + int idx = sqlite3_column_int(stmt, 1); + if (idx == imageIndex) + { + std::string imgFmt = (const char*)sqlite3_column_text(stmt, 2); + const void* imgData = sqlite3_column_blob(stmt, 4); + int imgSize = sqlite3_column_bytes(stmt, 4); + + bool saveRet = false; + std::string imagePath2 = GetFilePath(imgFmt.c_str()); + FILE* file = fopen(imagePath2.c_str(), "wb"); + if (NULL != file) + { + size_t writeLen = fwrite(imgData, 1, imgSize, file); + if (writeLen == (size_t)imgSize) + saveRet = true; + fclose(file); + } + + if (!saveRet) + { + HGBase_DeleteFile(imagePath2.c_str()); + } + else + { + imagePath = imagePath2; + HGBase_EnterLock(m_lock); + m_saveFilePathList.push_back(imagePath); + RestoreSaveFilePathList(m_saveFilePathList); + HGBase_LeaveLock(m_lock); + + errInfo.clear(); + rc = 0; + } + + break; + } + + ret = sqlite3_step(stmt); + } + + ret = sqlite3_finalize(stmt); + assert(0 == ret); + return rc; } int ManagerV2::InsertLocalImage(const std::string& imagePath, int insertPos, const std::string& imageTag, std::string& errInfo) { - return -1; + errInfo = "错误"; + + if (NULL == m_sqlite || imagePath.empty() || insertPos < -1) + return -1; + + HGUInt imgType = 0; + HGImgFmt_GetImgFmtType(imagePath.c_str(), &imgType); + if (0 == imgType) + return -1; + + std::string format; + if (HGIMGFMT_TYPE_JPEG == imgType) + format = "jpg"; + else if (HGIMGFMT_TYPE_BMP == imgType) + format = "bmp"; + else if (HGIMGFMT_TYPE_PNG == imgType) + format = "png"; + else if (HGIMGFMT_TYPE_TIFF == imgType) + format = "tif"; + else if (HGIMGFMT_TYPE_PDF == imgType) + format = "pdf"; + else if (HGIMGFMT_TYPE_OFD == imgType) + format = "ofd"; + + if (format.empty()) + return - 1; + + HGByte* imgData = NULL; + HGUInt imgSize = 0; + + FILE* file = fopen(imagePath.c_str(), "rb"); + if (NULL != file) + { + fseek(file, 0, SEEK_END); + imgSize = ftell(file); + fseek(file, 0, SEEK_SET); + + if (imgSize > 0) + { + imgData = new HGByte[imgSize]; + HGUInt readLen = (HGUInt)fread(imgData, 1, imgSize, file); + if (readLen != imgSize) + { + delete[] imgData; + imgData = NULL; + imgSize = 0; + } + } + + fclose(file); + } + + if (NULL == imgData) + return -1; + + std::vector> tables; + + char** result = NULL; + char sql[256]; + sprintf(sql, "select id, idx from 'table_%s'", m_currBatchId.c_str()); + int rows, cols; + int ret = sqlite3_get_table(m_sqlite, sql, &result, &rows, &cols, NULL); + assert(0 == ret); + + for (int i = 0; i < rows; i++) + { + std::pair pr; + for (int j = 0; j < cols; j++) + { + if (0 == strcmp("id", result[j])) + { + pr.first = atoi(result[(i + 1) * cols + j]); + } + else if (0 == strcmp("idx", result[j])) + { + pr.second = atoi(result[(i + 1) * cols + j]); + } + } + + tables.push_back(pr); + } + + sqlite3_free_table(result); + std::sort(tables.begin(), tables.end(), BatchTableSort); + + if (tables.empty()) + { + if (-1 == insertPos) + insertPos = 0; + else if (0 != insertPos) + { + delete[] imgData; + return -1; + } + } + else + { + if (-1 == insertPos) + insertPos = tables[tables.size() - 1].second + 1; + else if (insertPos > tables[tables.size() - 1].second + 1) + { + delete[] imgData; + return -1; + } + } + + for (int i = 0; i < (int)tables.size(); ++i) + { + if (tables[i].second >= insertPos) + { + sprintf(sql, "update 'table_%s' set idx = '%d' where id = '%d'", + m_currBatchId.c_str(), tables[i].second + 1, tables[i].first); + ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); + assert(0 == ret); + } + } + + sprintf(sql, "insert into 'table_%s' (idx, format, tag, image) values ('%d', '%s', '%s', ?)", m_currBatchId.c_str(), + insertPos, format.c_str(), imageTag.c_str()); + sqlite3_stmt* stmt = NULL; + ret = sqlite3_prepare(m_sqlite, sql, -1, &stmt, NULL); + assert(0 == ret); + ret = sqlite3_bind_blob(stmt, 1, imgData, (int)imgSize, NULL); + assert(0 == ret); + sqlite3_step(stmt); + ret = sqlite3_finalize(stmt); + assert(0 == ret); + + delete[] imgData; + errInfo.clear(); + return 0; } int ManagerV2::InsertImage(const std::string& imageBase64, int insertPos, const std::string& imageTag, std::string& errInfo) { - return -1; + errInfo = "错误"; + + if (NULL == m_sqlite || imageBase64.empty() || insertPos < -1) + return -1; + + size_t pos = imageBase64.find(','); + if (std::string::npos == pos) + return -1; + + std::string format; + std::string prefix = imageBase64.substr(0, pos + 1); + if ("data:image/jpeg;base64," == prefix) + format = "jpg"; + else if ("data:image/bmp;base64," == prefix) + format = "bmp"; + else if ("data:image/png;base64," == prefix) + format = "png"; + else if ("data:image/tiff;base64," == prefix) + format = "tif"; + else if ("data:image/pdf;base64," == prefix) + format = "pdf"; + else if ("data:image/ofd;base64," == prefix) + format = "ofd"; + + if (format.empty()) + return -1; + + HGByte* imgData = NULL; + HGSize imgSize = 0; + + const HGChar *base64Data = imageBase64.c_str() + pos + 1; + HGSize base64Size = (HGSize)strlen(base64Data); + HGBase_Base64Decode((const HGByte*)base64Data, (HGSize)base64Size, NULL, &imgSize); + if (0 != imgSize) + { + imgData = new HGByte[imgSize]; + HGBase_Base64Decode((const HGByte*)base64Data, (HGSize)base64Size, imgData, &imgSize); + } + + if (NULL == imgData) + return -1; + + std::vector> tables; + + char** result = NULL; + char sql[256]; + sprintf(sql, "select id, idx from 'table_%s'", m_currBatchId.c_str()); + int rows, cols; + int ret = sqlite3_get_table(m_sqlite, sql, &result, &rows, &cols, NULL); + assert(0 == ret); + + for (int i = 0; i < rows; i++) + { + std::pair pr; + for (int j = 0; j < cols; j++) + { + if (0 == strcmp("id", result[j])) + { + pr.first = atoi(result[(i + 1) * cols + j]); + } + else if (0 == strcmp("idx", result[j])) + { + pr.second = atoi(result[(i + 1) * cols + j]); + } + } + + tables.push_back(pr); + } + + sqlite3_free_table(result); + std::sort(tables.begin(), tables.end(), BatchTableSort); + + if (tables.empty()) + { + if (-1 == insertPos) + insertPos = 0; + else if (0 != insertPos) + { + delete[] imgData; + return -1; + } + } + else + { + if (-1 == insertPos) + insertPos = tables[tables.size() - 1].second + 1; + else if (insertPos > tables[tables.size() - 1].second + 1) + { + delete[] imgData; + return -1; + } + } + + for (int i = 0; i < (int)tables.size(); ++i) + { + if (tables[i].second >= insertPos) + { + sprintf(sql, "update 'table_%s' set idx = '%d' where id = '%d'", + m_currBatchId.c_str(), tables[i].second + 1, tables[i].first); + ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); + assert(0 == ret); + } + } + + sprintf(sql, "insert into 'table_%s' (idx, format, tag, image) values ('%d', '%s', '%s', ?)", m_currBatchId.c_str(), + insertPos, format.c_str(), imageTag.c_str()); + sqlite3_stmt* stmt = NULL; + ret = sqlite3_prepare(m_sqlite, sql, -1, &stmt, NULL); + assert(0 == ret); + ret = sqlite3_bind_blob(stmt, 1, imgData, (int)imgSize, NULL); + assert(0 == ret); + sqlite3_step(stmt); + ret = sqlite3_finalize(stmt); + assert(0 == ret); + + delete[] imgData; + errInfo.clear(); + return 0; } int ManagerV2::ModifyImageTag(const std::vector& imageIndexList, const std::vector& imageTagList, std::string& errInfo) { - return -1; + errInfo = "错误"; + + if (NULL == m_sqlite || imageIndexList.empty() || imageTagList.empty() + || imageIndexList.size() != imageTagList.size()) + return -1; + + std::vector> tables; + + char** result = NULL; + char sql[256]; + sprintf(sql, "select id, idx from 'table_%s'", m_currBatchId.c_str()); + int rows, cols; + int ret = sqlite3_get_table(m_sqlite, sql, &result, &rows, &cols, NULL); + assert(0 == ret); + + for (int i = 0; i < rows; i++) + { + std::pair pr; + for (int j = 0; j < cols; j++) + { + if (0 == strcmp("id", result[j])) + { + pr.first = atoi(result[(i + 1) * cols + j]); + } + else if (0 == strcmp("idx", result[j])) + { + pr.second = atoi(result[(i + 1) * cols + j]); + } + } + + tables.push_back(pr); + } + + sqlite3_free_table(result); + std::sort(tables.begin(), tables.end(), BatchTableSort); + + bool indexValid = true; + for (int i = 0; i < (int)imageIndexList.size(); ++i) + { + bool find = false; + for (int j = 0; j < (int)tables.size(); ++j) + { + if (imageIndexList[i] == tables[j].second) + { + find = true; + break; + } + } + + if (!find) + { + indexValid = false; + break; + } + } + + if (!indexValid) + return -1; + + for (int i = 0; i < (int)imageIndexList.size(); ++i) + { + sprintf(sql, "update 'table_%s' set tag = '%s' where idx = '%d'", m_currBatchId.c_str(), + imageTagList[i].c_str(), imageIndexList[i]); + ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); + assert(0 == ret); + } + + errInfo.clear(); + return 0; } int ManagerV2::DeleteImage(const std::vector& imageIndexList, std::string& errInfo) { - return -1; + errInfo = "错误"; + + if (NULL == m_sqlite || imageIndexList.empty()) + return -1; + + std::vector> tables; + + char** result = NULL; + char sql[256]; + sprintf(sql, "select id, idx from 'table_%s'", m_currBatchId.c_str()); + int rows, cols; + int ret = sqlite3_get_table(m_sqlite, sql, &result, &rows, &cols, NULL); + assert(0 == ret); + + for (int i = 0; i < rows; i++) + { + std::pair pr; + for (int j = 0; j < cols; j++) + { + if (0 == strcmp("id", result[j])) + { + pr.first = atoi(result[(i + 1) * cols + j]); + } + else if (0 == strcmp("idx", result[j])) + { + pr.second = atoi(result[(i + 1) * cols + j]); + } + } + + tables.push_back(pr); + } + + sqlite3_free_table(result); + std::sort(tables.begin(), tables.end(), BatchTableSort); + + bool indexValid = true; + for (int i = 0; i < (int)imageIndexList.size(); ++i) + { + bool find = false; + for (int j = 0; j < (int)tables.size(); ++j) + { + if (imageIndexList[i] == tables[j].second) + { + find = true; + break; + } + } + + if (!find) + { + indexValid = false; + break; + } + } + + if (!indexValid) + return -1; + + for (int i = 0; i < (int)imageIndexList.size(); ++i) + { + sprintf(sql, "delete from 'table_%s' where idx = '%d'", m_currBatchId.c_str(), imageIndexList[i]); + ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); + assert(0 == ret); + } + + int value = 0; + for (int i = 0; i < (int)tables.size(); ++i) + { + bool find = false; + for (int j = 0; j < (int)imageIndexList.size(); ++j) + { + if (tables[i].second == imageIndexList[j]) + { + find = true; + break; + } + } + + if (find) + { + ++value; + } + else + { + if (value > 0) + { + sprintf(sql, "update 'table_%s' set idx = '%d' where id = '%d'", + m_currBatchId.c_str(), tables[i].second - value, tables[i].first); + ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); + assert(0 == ret); + } + } + } + + errInfo.clear(); + return 0; } int ManagerV2::ClearImageList(std::string& errInfo) { - return -1; + errInfo = "错误"; + + if (NULL == m_sqlite) + return -1; + + char sql[256]; + sprintf(sql, "delete from 'table_%s'", m_currBatchId.c_str()); + int ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); + assert(0 == ret); + + errInfo.clear(); + return 0; } int ManagerV2::ModifyImage(int imageIndex, const std::string& imageBase64, std::string& errInfo) { - return -1; + errInfo = "错误"; + + if (NULL == m_sqlite || imageIndex < 0 || imageBase64.empty()) + return -1; + + size_t pos = imageBase64.find(','); + if (std::string::npos == pos) + return -1; + + std::string format; + std::string prefix = imageBase64.substr(0, pos + 1); + if ("data:image/jpeg;base64," == prefix) + format = "jpg"; + else if ("data:image/bmp;base64," == prefix) + format = "bmp"; + else if ("data:image/png;base64," == prefix) + format = "png"; + else if ("data:image/tiff;base64," == prefix) + format = "tif"; + else if ("data:image/pdf;base64," == prefix) + format = "pdf"; + else if ("data:image/ofd;base64," == prefix) + format = "ofd"; + + if (format.empty()) + return -1; + + HGByte* imgData = NULL; + HGSize imgSize = 0; + + const HGChar* base64Data = imageBase64.c_str() + pos + 1; + HGSize base64Size = (HGSize)strlen(base64Data); + HGBase_Base64Decode((const HGByte*)base64Data, (HGSize)base64Size, NULL, &imgSize); + if (0 != imgSize) + { + imgData = new HGByte[imgSize]; + HGBase_Base64Decode((const HGByte*)base64Data, (HGSize)base64Size, imgData, &imgSize); + } + + if (NULL == imgData) + return -1; + + std::vector> tables; + + char** result = NULL; + char sql[256]; + sprintf(sql, "select id, idx from 'table_%s'", m_currBatchId.c_str()); + int rows, cols; + int ret = sqlite3_get_table(m_sqlite, sql, &result, &rows, &cols, NULL); + assert(0 == ret); + + for (int i = 0; i < rows; i++) + { + std::pair pr; + for (int j = 0; j < cols; j++) + { + if (0 == strcmp("id", result[j])) + { + pr.first = atoi(result[(i + 1) * cols + j]); + } + else if (0 == strcmp("idx", result[j])) + { + pr.second = atoi(result[(i + 1) * cols + j]); + } + } + + tables.push_back(pr); + } + + sqlite3_free_table(result); + std::sort(tables.begin(), tables.end(), BatchTableSort); + + bool find = false; + for (int i = 0; i < (int)tables.size(); ++i) + { + if (tables[i].second == imageIndex) + { + find = true; + break; + } + } + + if (!find) + { + delete[] imgData; + return -1; + } + + sprintf(sql, "update 'table_%s' set format = '%s', image = ? where idx = '%d'", + m_currBatchId.c_str(), format.c_str(), imageIndex); + sqlite3_stmt* stmt = NULL; + ret = sqlite3_prepare(m_sqlite, sql, -1, &stmt, NULL); + assert(0 == ret); + ret = sqlite3_bind_blob(stmt, 1, imgData, (int)imgSize, NULL); + assert(0 == ret); + sqlite3_step(stmt); + ret = sqlite3_finalize(stmt); + assert(0 == ret); + + delete[] imgData; + errInfo.clear(); + return 0; } int ManagerV2::ModifyImageByLocal(int imageIndex, const std::string& imagePath, std::string& errInfo) { - return -1; + errInfo = "错误"; + + if (NULL == m_sqlite || imageIndex < 0 || imagePath.empty()) + return -1; + + HGUInt imgType = 0; + HGImgFmt_GetImgFmtType(imagePath.c_str(), &imgType); + if (0 == imgType) + return -1; + + std::string format; + if (HGIMGFMT_TYPE_JPEG == imgType) + format = "jpg"; + else if (HGIMGFMT_TYPE_BMP == imgType) + format = "bmp"; + else if (HGIMGFMT_TYPE_PNG == imgType) + format = "png"; + else if (HGIMGFMT_TYPE_TIFF == imgType) + format = "tif"; + else if (HGIMGFMT_TYPE_PDF == imgType) + format = "pdf"; + else if (HGIMGFMT_TYPE_OFD == imgType) + format = "ofd"; + + if (format.empty()) + return -1; + + HGByte* imgData = NULL; + HGUInt imgSize = 0; + + FILE* file = fopen(imagePath.c_str(), "rb"); + if (NULL != file) + { + fseek(file, 0, SEEK_END); + imgSize = ftell(file); + fseek(file, 0, SEEK_SET); + + if (imgSize > 0) + { + imgData = new HGByte[imgSize]; + HGUInt readLen = (HGUInt)fread(imgData, 1, imgSize, file); + if (readLen != imgSize) + { + delete[] imgData; + imgData = NULL; + imgSize = 0; + } + } + + fclose(file); + } + + if (NULL == imgData) + return -1; + + std::vector> tables; + + char** result = NULL; + char sql[256]; + sprintf(sql, "select id, idx from 'table_%s'", m_currBatchId.c_str()); + int rows, cols; + int ret = sqlite3_get_table(m_sqlite, sql, &result, &rows, &cols, NULL); + assert(0 == ret); + + for (int i = 0; i < rows; i++) + { + std::pair pr; + for (int j = 0; j < cols; j++) + { + if (0 == strcmp("id", result[j])) + { + pr.first = atoi(result[(i + 1) * cols + j]); + } + else if (0 == strcmp("idx", result[j])) + { + pr.second = atoi(result[(i + 1) * cols + j]); + } + } + + tables.push_back(pr); + } + + sqlite3_free_table(result); + std::sort(tables.begin(), tables.end(), BatchTableSort); + + bool find = false; + for (int i = 0; i < (int)tables.size(); ++i) + { + if (tables[i].second == imageIndex) + { + find = true; + break; + } + } + + if (!find) + { + delete[] imgData; + return -1; + } + + sprintf(sql, "update 'table_%s' set format = '%s', image = ? where idx = '%d'", + m_currBatchId.c_str(), format.c_str(), imageIndex); + sqlite3_stmt* stmt = NULL; + ret = sqlite3_prepare(m_sqlite, sql, -1, &stmt, NULL); + assert(0 == ret); + ret = sqlite3_bind_blob(stmt, 1, imgData, (int)imgSize, NULL); + assert(0 == ret); + sqlite3_step(stmt); + ret = sqlite3_finalize(stmt); + assert(0 == ret); + + delete[] imgData; + errInfo.clear(); + return 0; } int ManagerV2::MoveImage(const std::vector& imageIndexList, const std::string& mode, int target, std::string& errInfo) { - return -1; + errInfo = "错误"; + + if (NULL == m_sqlite || imageIndexList.empty() || target < 0) + return -1; + + if ("pos" != mode && "index" != mode) + return -1; + + std::vector> tables; + + char** result = NULL; + char sql[256]; + sprintf(sql, "select id, idx from 'table_%s'", m_currBatchId.c_str()); + int rows, cols; + int ret = sqlite3_get_table(m_sqlite, sql, &result, &rows, &cols, NULL); + assert(0 == ret); + + for (int i = 0; i < rows; i++) + { + std::pair pr; + for (int j = 0; j < cols; j++) + { + if (0 == strcmp("id", result[j])) + { + pr.first = atoi(result[(i + 1) * cols + j]); + } + else if (0 == strcmp("idx", result[j])) + { + pr.second = atoi(result[(i + 1) * cols + j]); + } + } + + tables.push_back(pr); + } + + sqlite3_free_table(result); + std::sort(tables.begin(), tables.end(), BatchTableSort); + + if (tables.empty()) + return -1; + if ("pos" == mode && target > tables[tables.size() - 1].second + 1) + return -1; + if ("index" == mode && target > tables[tables.size() - 1].second) + return -1; + + bool indexValid = true; + for (int i = 0; i < (int)imageIndexList.size(); ++i) + { + bool find = false; + for (int j = 0; j < (int)tables.size(); ++j) + { + if (imageIndexList[i] == tables[j].second) + { + find = true; + break; + } + } + + if (!find) + { + indexValid = false; + break; + } + } + + if (!indexValid) + return -1; + + if ("pos" == mode) + { + int posEx = target; + for (int i = 0; i < (int)imageIndexList.size(); ++i) + { + int oldIndex = -1; + for (int j = 0; j < (int)tables.size(); ++j) + { + if (imageIndexList[i] == tables[j].second) + { + oldIndex = j; + break; + } + } + + assert(-1 != oldIndex); + std::pair pr = tables[oldIndex]; + + if (oldIndex < posEx) + --posEx; + + tables.erase(tables.begin() + oldIndex); + if (posEx != (int)tables.size()) + tables.insert(tables.begin() + posEx, pr); + else + tables.push_back(pr); + + ++posEx; + } + } + else + { + std::vector> prs; + for (int i = 0; i < (int)imageIndexList.size(); ++i) + { + int oldIndex = -1; + for (int j = 0; j < (int)tables.size(); ++j) + { + if (imageIndexList[i] == tables[j].second) + { + oldIndex = j; + break; + } + } + + assert(-1 != oldIndex); + std::pair pr = tables[oldIndex]; + + tables.erase(tables.begin() + oldIndex); + prs.push_back(pr); + } + + if (target < (int)tables.size()) + { + int indexEx = target; + for (int i = 0; i < (int)prs.size(); ++i) + { + tables.insert(tables.begin() + indexEx, prs[i]); + ++indexEx; + } + } + else + { + for (int i = 0; i < (int)prs.size(); ++i) + { + tables.push_back(prs[i]); + } + } + } + + for (int i = 0; i < (int)tables.size(); ++i) + { + sprintf(sql, "update 'table_%s' set idx = '%d' where id = '%d'", + m_currBatchId.c_str(), i, tables[i].first); + ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); + assert(0 == ret); + } + + errInfo.clear(); + return 0; } int ManagerV2::ImageBookSort(std::string& errInfo) { - return -1; + errInfo = "错误"; + + if (NULL == m_sqlite) + return -1; + + std::vector> tables; + + char** result = NULL; + char sql[256]; + sprintf(sql, "select id, idx from 'table_%s'", m_currBatchId.c_str()); + int rows, cols; + int ret = sqlite3_get_table(m_sqlite, sql, &result, &rows, &cols, NULL); + assert(0 == ret); + + for (int i = 0; i < rows; i++) + { + std::pair pr; + for (int j = 0; j < cols; j++) + { + if (0 == strcmp("id", result[j])) + { + pr.first = atoi(result[(i + 1) * cols + j]); + } + else if (0 == strcmp("idx", result[j])) + { + pr.second = atoi(result[(i + 1) * cols + j]); + } + } + + tables.push_back(pr); + } + + sqlite3_free_table(result); + std::sort(tables.begin(), tables.end(), BatchTableSort); + + std::list> prs1, prs2; + for (int i = 0; i < (int)tables.size(); ++i) + { + std::pair pr = tables[i]; + if (0 == i % 2) + prs1.push_back(pr); + else + prs2.push_front(pr); + } + + tables.clear(); + std::list>::const_iterator iter; + for (iter = prs1.begin(); iter != prs1.end(); ++iter) + tables.push_back(*iter); + for (iter = prs2.begin(); iter != prs2.end(); ++iter) + tables.push_back(*iter); + + for (int i = 0; i < (int)tables.size(); ++i) + { + sprintf(sql, "update 'table_%s' set idx = '%d' where id = '%d'", + m_currBatchId.c_str(), i, tables[i].first); + ret = sqlite3_exec(m_sqlite, sql, NULL, NULL, NULL); + assert(0 == ret); + } + + errInfo.clear(); + return 0; } int ManagerV2::MergeImage(const std::vector& imageIndexList, const std::string& mode, @@ -1972,6 +2945,20 @@ namespace ver_2 return ret; } + void ManagerV2::GetBase64(const HGByte* data, HGUInt size, std::string& base64) + { + assert(NULL != data && 0 != size); + base64.clear(); + + HGSize base64Size = 0; + HGBase_Base64Encode(data, size, NULL, &base64Size); + uint8_t* p = new uint8_t[base64Size + 1]; + HGBase_Base64Encode(data, size, p, &base64Size); + p[base64Size] = 0; + base64 = (const char*)p; + delete[] p; + } + int ManagerV2::sane_ex_callback(SANE_Handle hdev, int code, void* data, unsigned int* len, void* param) { (void)hdev; diff --git a/sdk/webservice/ManagerV2.h b/sdk/webservice/ManagerV2.h index f5b81b41..dc0fa518 100644 --- a/sdk/webservice/ManagerV2.h +++ b/sdk/webservice/ManagerV2.h @@ -310,6 +310,8 @@ namespace ver_2 static void RestoreDeviceParam(const std::string& devName, const DeviceParam& devParam); static int SetParamToDevice(SANE_Handle hdev, const DeviceParam& devParam, HGUInt mask); static int GetParamFromDevice(SANE_Handle hdev, DeviceParam& devParam); + static void GetBase64(const HGByte* data, HGUInt size, std::string &base64); + static int sane_ex_callback(SANE_Handle hdev, int code, void* data, unsigned int* len, void* param); private: diff --git a/test/webservice/demo.html b/test/webservice/demo.html index e6ec209c..a895deeb 100644 --- a/test/webservice/demo.html +++ b/test/webservice/demo.html @@ -387,7 +387,7 @@ { socket.send(JSON.stringify({ 'func':'modify_batch_id', - 'new_batch_id':'yyy' + 'new_batch_id':'新批次名2' })); }