346 lines
10 KiB
C++
346 lines
10 KiB
C++
#include "ManagerV2.h"
|
|
#include "base/HGBuffer.h"
|
|
#include "base/HGBase64.h"
|
|
#include "base/HGUtility.h"
|
|
#include "base/HGInfo.h"
|
|
#include "imgfmt/HGJpeg.h"
|
|
#include "imgfmt/HGOfd.h"
|
|
#include "imgfmt/HGPdf.h"
|
|
#include "imgfmt/HGTiff.h"
|
|
#include "imgfmt/HGImgFmt.h"
|
|
#include "HGString.h"
|
|
|
|
namespace ver_2
|
|
{
|
|
ManagerV2::ManagerV2(HGMsgPump msgPump)
|
|
: Manager(msgPump)
|
|
{
|
|
|
|
}
|
|
|
|
ManagerV2::~ManagerV2()
|
|
{
|
|
|
|
}
|
|
|
|
void ManagerV2::ScanFinish(const ScanFinishParam* param)
|
|
{
|
|
assert(NULL != param && this == param->mgr);
|
|
}
|
|
|
|
int ManagerV2::SetGlobalConfig(const GlobalConfig& cfg)
|
|
{
|
|
if ("date_time" != cfg.fileNameMode && "random" != cfg.fileNameMode)
|
|
return -1;
|
|
if ("jpg" != cfg.imageFormat && "bmp" != cfg.imageFormat && "png" != cfg.imageFormat && "tif" != cfg.imageFormat
|
|
&& "pdf" != cfg.imageFormat && "ofd" != cfg.imageFormat && "ocr-pdf" != cfg.imageFormat && "ocr-ofd" != cfg.imageFormat)
|
|
return -1;
|
|
if (cfg.imageJpegQuality < 0 || cfg.imageJpegQuality > 100)
|
|
return -1;
|
|
if ("none" != cfg.imageTiffCompression && "lzw" != cfg.imageTiffCompression && "jpeg" != cfg.imageTiffCompression)
|
|
return -1;
|
|
if (cfg.imageTiffJpegQuality < 0 || cfg.imageTiffJpegQuality > 100)
|
|
return -1;
|
|
|
|
SetCfgStringValue("global", "fileSavePath", Utf8ToStdString(cfg.fileSavePath));
|
|
SetCfgStringValue("global", "fileNamePrefix", Utf8ToStdString(cfg.fileNamePrefix));
|
|
SetCfgStringValue("global", "fileNameMode", cfg.fileNameMode);
|
|
SetCfgStringValue("global", "imageFormat", cfg.imageFormat);
|
|
SetCfgIntValue("global", "imageJpegQuality", cfg.imageJpegQuality);
|
|
SetCfgStringValue("global", "imageTiffCompression", cfg.imageTiffCompression);
|
|
SetCfgIntValue("global", "imageTiffJpegQuality", cfg.imageTiffJpegQuality);
|
|
SetCfgStringValue("global", "uploadHttpHost", cfg.uploadHttpHost);
|
|
SetCfgIntValue("global", "uploadHttpPort", cfg.uploadHttpPort);
|
|
SetCfgStringValue("global", "uploadHttpPath", cfg.uploadHttpPath);
|
|
SetCfgStringValue("global", "uploadFtpUser", cfg.uploadFtpUser);
|
|
SetCfgStringValue("global", "uploadFtpPassword", cfg.uploadFtpPassword);
|
|
SetCfgStringValue("global", "uploadFtpHost", cfg.uploadFtpHost);
|
|
SetCfgIntValue("global", "uploadFtpPort", cfg.uploadFtpPort);
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::GetGlobalConfig(GlobalConfig& cfg)
|
|
{
|
|
HGChar docPath[256];
|
|
HGBase_GetDocumentsPath(docPath, 256);
|
|
cfg.fileSavePath = StdStringToUtf8(GetCfgStringValue("global", "fileSavePath", docPath));
|
|
cfg.fileNamePrefix = StdStringToUtf8(GetCfgStringValue("global", "fileNamePrefix", "Huago"));
|
|
cfg.fileNameMode = GetCfgStringValue("global", "fileNameMode", "date_time");
|
|
cfg.imageFormat = GetCfgStringValue("global", "imageFormat", "jpg");
|
|
cfg.imageJpegQuality = GetCfgIntValue("global", "imageJpegQuality", 80);
|
|
cfg.imageTiffCompression = GetCfgStringValue("global", "imageTiffCompression", "lzw");
|
|
cfg.imageTiffJpegQuality = GetCfgIntValue("global", "imageTiffJpegQuality", 80);
|
|
cfg.uploadHttpHost = GetCfgStringValue("global", "uploadHttpHost", "");
|
|
cfg.uploadHttpPort = GetCfgIntValue("global", "uploadHttpPort", 80);
|
|
cfg.uploadHttpPath = GetCfgStringValue("global", "uploadHttpPath", "/upload.cgi");
|
|
cfg.uploadFtpUser = GetCfgStringValue("global", "uploadFtpUser", "");
|
|
cfg.uploadFtpPassword = GetCfgStringValue("global", "uploadFtpPassword", "");
|
|
cfg.uploadFtpHost = GetCfgStringValue("global", "uploadFtpHost", "");
|
|
cfg.uploadFtpPort = GetCfgIntValue("global", "uploadFtpPort", 21);
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::LoadLocalImage(const std::string& imagePath, std::string& imgBase64)
|
|
{
|
|
imgBase64.clear();
|
|
|
|
HGUInt imgType = 0;
|
|
HGImgFmt_GetImgFmtType(Utf8ToStdString(imagePath).c_str(), &imgType);
|
|
if (0 == imgType)
|
|
return -1;
|
|
|
|
int ret = LoadBase64(Utf8ToStdString(imagePath), imgBase64);
|
|
if (0 != ret)
|
|
return ret;
|
|
|
|
std::string prefix = "data:image/jpeg;base64,";
|
|
if (HGIMGFMT_TYPE_BMP == imgType)
|
|
prefix = "data:image/bmp;base64,";
|
|
else if (HGIMGFMT_TYPE_PNG == imgType)
|
|
prefix = "data:image/png;base64,";
|
|
else if (HGIMGFMT_TYPE_TIFF == imgType)
|
|
prefix = "data:image/tiff;base64,";
|
|
else if (HGIMGFMT_TYPE_PDF == imgType)
|
|
prefix = "data:image/pdf;base64,";
|
|
else if (HGIMGFMT_TYPE_OFD == imgType)
|
|
prefix = "data:image/ofd;base64,";
|
|
imgBase64.insert(0, prefix);
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::SaveLocalImage(const std::string& imgBase64, std::string& imagePath)
|
|
{
|
|
imagePath.clear();
|
|
|
|
size_t pos = imgBase64.find(',');
|
|
if (std::string::npos == pos)
|
|
return -1;
|
|
|
|
std::string prefix = imgBase64.substr(0, pos + 1);
|
|
|
|
std::string suffix = "jpg";
|
|
if ("data:image/bmp;base64," == prefix)
|
|
suffix = "bmp";
|
|
else if ("data:image/png;base64," == prefix)
|
|
suffix = "png";
|
|
else if ("data:image/tiff;base64," == prefix)
|
|
suffix = "tif";
|
|
else if ("data:image/pdf;base64," == prefix)
|
|
suffix = "pdf";
|
|
else if ("data:image/ofd;base64," == prefix)
|
|
suffix = "ofd";
|
|
|
|
std::string imagePath2 = GetFilePath(suffix);
|
|
int ret = SaveBase64(imgBase64.c_str() + pos + 1, imagePath2);
|
|
if (0 != ret)
|
|
return ret;
|
|
|
|
imagePath = StdStringToUtf8(imagePath2);
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::DeleteLocalFile(const std::string& filePath)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::ClearGlobalFileSavePath()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::MergeLocalImage(const std::vector<std::string>& imagePathList, const std::string& mode,
|
|
const std::string& align, int interval, std::string& outImagePath)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::LocalMakeMultiImage(const std::vector<std::string>& imagePathList, const std::string& format,
|
|
const std::string& tiffCompression, int tiffJpegQuality, std::string& outImagePath)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::SplitLocalImage(const std::string& imagePath, const std::string& mode, int location,
|
|
std::vector<std::string>& outImagePathList)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::LocalMakeZipFile(const std::vector<std::string>& filePathList, std::string& outZipPath)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::LocalImageDeskew(const std::string& imagePath, std::string& outImagePath)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int ManagerV2::UploadLocalFile(const std::string& filePath, const std::string& mode, const std::string& remoteFilePath)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
std::string ManagerV2::GetCfgStringValue(const std::string& app, const std::string& key, const std::string& def)
|
|
{
|
|
HGChar cfgPath[256];
|
|
HGBase_GetConfigPath(cfgPath, 256);
|
|
strcat(cfgPath, "config2.ini");
|
|
|
|
HGChar val[256] = { 0 };
|
|
HGBase_GetProfileString(cfgPath, app.c_str(), key.c_str(), def.c_str(), val, 256);
|
|
return val;
|
|
}
|
|
|
|
int ManagerV2::GetCfgIntValue(const std::string& app, const std::string& key, int def)
|
|
{
|
|
HGChar cfgPath[256];
|
|
HGBase_GetConfigPath(cfgPath, 256);
|
|
strcat(cfgPath, "config2.ini");
|
|
|
|
HGInt val = 0;
|
|
HGBase_GetProfileInt(cfgPath, app.c_str(), key.c_str(), def, &val);
|
|
return val;
|
|
}
|
|
|
|
bool ManagerV2::GetCfgBoolValue(const std::string& app, const std::string& key, bool def)
|
|
{
|
|
HGChar cfgPath[256];
|
|
HGBase_GetConfigPath(cfgPath, 256);
|
|
strcat(cfgPath, "config2.ini");
|
|
|
|
HGInt val = 0;
|
|
HGBase_GetProfileInt(cfgPath, app.c_str(), key.c_str(), (HGInt)def, &val);
|
|
return (bool)val;
|
|
}
|
|
|
|
bool ManagerV2::SetCfgStringValue(const std::string& app, const std::string& key, const std::string& val)
|
|
{
|
|
HGChar cfgPath[256];
|
|
HGBase_GetConfigPath(cfgPath, 256);
|
|
HGBase_CreateDir(cfgPath);
|
|
strcat(cfgPath, "config2.ini");
|
|
|
|
return (HGBASE_ERR_OK == HGBase_SetProfileString(cfgPath, app.c_str(), key.c_str(), val.c_str()));
|
|
}
|
|
|
|
bool ManagerV2::SetCfgIntValue(const std::string& app, const std::string& key, int val)
|
|
{
|
|
HGChar cfgPath[256];
|
|
HGBase_GetConfigPath(cfgPath, 256);
|
|
HGBase_CreateDir(cfgPath);
|
|
strcat(cfgPath, "config2.ini");
|
|
|
|
return (HGBASE_ERR_OK == HGBase_SetProfileInt(cfgPath, app.c_str(), key.c_str(), val));
|
|
}
|
|
|
|
bool ManagerV2::SetCfgBoolValue(const std::string& app, const std::string& key, bool val)
|
|
{
|
|
HGChar cfgPath[256];
|
|
HGBase_GetConfigPath(cfgPath, 256);
|
|
HGBase_CreateDir(cfgPath);
|
|
strcat(cfgPath, "config2.ini");
|
|
|
|
return (HGBASE_ERR_OK == HGBase_SetProfileInt(cfgPath, app.c_str(), key.c_str(), (HGInt)val));
|
|
}
|
|
|
|
int ManagerV2::LoadBase64(const std::string& fileName, std::string& base64)
|
|
{
|
|
base64.clear();
|
|
|
|
int ret = -1;
|
|
FILE* file = fopen(fileName.c_str(), "rb");
|
|
if (NULL != file)
|
|
{
|
|
fseek(file, 0, SEEK_END);
|
|
long size = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
if (size > 0)
|
|
{
|
|
HGByte* data = new HGByte[size];
|
|
long readLen = (long)fread(data, 1, size, file);
|
|
if (readLen == size)
|
|
{
|
|
HGSize base64Size = 0;
|
|
HGBase_Base64Encode(data, size, NULL, &base64Size);
|
|
uint8_t* base64Data = new uint8_t[base64Size + 1];
|
|
HGBase_Base64Encode(data, size, base64Data, &base64Size);
|
|
base64Data[base64Size] = 0;
|
|
base64 = (const char*)base64Data;
|
|
delete[] base64Data;
|
|
ret = 0;
|
|
}
|
|
|
|
delete[] data;
|
|
}
|
|
|
|
fclose(file);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ManagerV2::SaveBase64(const std::string& base64, const std::string& fileName)
|
|
{
|
|
if (base64.empty())
|
|
return -1;
|
|
|
|
const char* base64Data = base64.c_str();
|
|
size_t base64Size = base64.size();
|
|
|
|
int ret = -1;
|
|
FILE* file = fopen(fileName.c_str(), "wb");
|
|
if (NULL != file)
|
|
{
|
|
HGSize size = 0;
|
|
HGBase_Base64Decode((const HGByte*)base64Data, (HGSize)base64Size, NULL, &size);
|
|
uint8_t* data = new HGByte[size];
|
|
HGBase_Base64Decode((const HGByte*)base64Data, (HGSize)base64Size, data, &size);
|
|
|
|
size_t writeLen = fwrite(data, 1, size, file);
|
|
if (writeLen == (size_t)size)
|
|
ret = 0;
|
|
|
|
delete[] data;
|
|
fclose(file);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
std::string ManagerV2::GetFilePath(const std::string& suffix)
|
|
{
|
|
HGChar docPath[256];
|
|
HGBase_GetDocumentsPath(docPath, 256);
|
|
std::string fileSavePath = GetCfgStringValue("global", "fileSavePath", docPath);
|
|
std::string fileNamePrefix = GetCfgStringValue("global", "fileNamePrefix", "Huago");
|
|
std::string fileNameMode = GetCfgStringValue("global", "fileNameMode", "date_time");
|
|
|
|
char filePath[256] = { 0 };
|
|
if ("random" == fileNameMode)
|
|
{
|
|
HGChar uuid[256];
|
|
HGBase_GetUuid(uuid, 256);
|
|
sprintf(filePath, "%s%s%s.%s", fileSavePath.c_str(), fileNamePrefix.c_str(), uuid, suffix.c_str());
|
|
}
|
|
else
|
|
{
|
|
timeb tb;
|
|
ftime(&tb);
|
|
struct tm* p = localtime(&tb.time);
|
|
sprintf(filePath, "%s%s%04d%02d%02d%02d%02d%02d.%s", fileSavePath.c_str(), fileNamePrefix.c_str(), (1900 + p->tm_year),
|
|
(1 + p->tm_mon), p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec, suffix.c_str());
|
|
}
|
|
|
|
return filePath;
|
|
}
|
|
|
|
std::string ManagerV2::GetImagePath()
|
|
{
|
|
std::string imageFormat = GetCfgStringValue("global", "imageFormat", "jpg");
|
|
return GetFilePath(imageFormat);
|
|
}
|
|
}
|