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/ManagerV2.cpp

346 lines
10 KiB
C++
Raw Blame History

#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);
}
}
Reference in New Issue View Git Blame Copy Permalink