/***********************************************************************
* block factory - make blocks from JSON object
**********************************************************************/
static Pothos::Proxy makeBlock(
const Pothos::Proxy ®istry,
const Pothos::Proxy &evaluator,
const Poco::JSON::Object::Ptr &blockObj)
{
const auto id = blockObj->getValue<std::string>("id");
if (not blockObj->has("path")) throw Pothos::DataFormatException(
"Pothos::Topology::make()", "blocks["+id+"] missing 'path' field");
const auto path = blockObj->getValue<std::string>("path");
//load up the constructor args
Poco::JSON::Array::Ptr argsArray;
if (blockObj->isArray("args")) argsArray = blockObj->getArray("args");
const auto ctorArgs = evalArgsArray(evaluator, argsArray);
//create the block
auto block = registry.getHandle()->call(path, ctorArgs.data(), ctorArgs.size());
//make the calls
Poco::JSON::Array::Ptr callsArray;
if (blockObj->isArray("calls")) callsArray = blockObj->getArray("calls");
if (callsArray) for (size_t i = 0; i < callsArray->size(); i++)
{
const auto callArray = callsArray->getArray(i);
auto name = callArray->getElement<std::string>(0);
const auto callArgs = evalArgsArray(evaluator, callArray, 1/*offset*/);
block.getHandle()->call(name, callArgs.data(), callArgs.size());
}
return block;
}
void updateTasksList()
{
printf("updateTasksList()\n");
tasksNum = task_manager->getTasksNumber();
if(tasksNum > 0)
{
Poco::JSON::Object::Ptr pObj = new Poco::JSON::Object;
task_manager->getTasks(pObj);
Poco::DynamicStruct ds = *pObj;
printf("ds:%s\n", ds.toString().c_str());
if(pObj->has("tasks"))
printf("pObj has tasks\n");
if(pObj->isArray("tasks"))
printf("pObj is array tasks\n");
Poco::JSON::Array::Ptr pArray = pObj->getArray("tasks");
printf("tasksNum:%d, array size:%d\n", tasksNum, pArray->size());
for(int i = 0; i < tasksNum; i++)
{
memset(pTask[i], 0, sizeof(TaskInfo));
Poco::Dynamic::Var var = pArray->get(i);
Poco::DynamicStruct dss = var.extract<Poco::DynamicStruct>();
pTask[i]->id = (Poco::Int64)dss["id"].extract<Poco::Int64>();
pTask[i]->option = dss["option"].extract<int>();
pTask[i]->hour = dss["hour"].extract<int>();
pTask[i]->minute = dss["minute"].extract<int>();
pTask[i]->weekday = dss["weekday"].extract<int>();
}
}
}
void Controller::searchSimilarRequest(std::map<std::string, std::string>& params, const Poco::Dynamic::Var& request) {
Record record;
vector<uint8_t>* image_data = NULL;
int count = 10;
if (params.count("blockHash")) {
record.getHashes()[BlockHash] = str2bin(params["blockHash"]);
}
if (params.count("dHash")) {
record.getHashes()[DHash] = str2bin(params["dHash"]);
}
if (params.count("gaussDHash")) {
record.getHashes()[GaussDHash] = str2bin(params["gaussDHash"]);
}
if (params.count("gauss2DHash")) {
record.getHashes()[Gauss2DHash] = str2bin(params["gauss2DHash"]);
}
if (params.count("gaussBlockHash")) {
record.getHashes()[GaussBlockHash] = str2bin(params["gaussBlockHash"]);
}
if (params.count("url")) {
image_data = Image::fromUrl(params["url"]);
}
if (params.count("count")) {
count = atoi(params["count"].c_str());
}
if (!request.isEmpty()) {
Poco::JSON::Object::Ptr json = request.extract<Poco::JSON::Object::Ptr>();
if (!image_data && json->has("image_base64")) {
image_data = Image::fromBase64(json->getValue<string>("image_base64"));
}
if (!image_data && json->has("image_url")) {
image_data = Image::fromUrl(json->getValue<string>("image_url"));
}
}
if (image_data) {
HashAlgorithmManager::getInstance().attachSimilarHashes(record, image_data);
delete image_data;
}
appio::print_ok(HashManager::getInstance().searchSimilar(record, count));
}
void AffinityZoneEditor::loadFromConfig(const Poco::JSON::Object::Ptr &config)
{
if (config->has("color"))
{
auto color = QString::fromStdString(config->getValue<std::string>("color"));
_colorPicker->blockSignals(true);
_colorPicker->setCurrentColor(QColor(color));
_colorPicker->blockSignals(false);
}
if (config->has("hostUri"))
{
auto uri = QString::fromStdString(config->getValue<std::string>("hostUri"));
this->selectThisUri(uri);
}
if (config->has("processName"))
{
auto name = QString::fromStdString(config->getValue<std::string>("processName"));
_processNameEdit->setText(name);
}
if (config->has("numThreads"))
{
_numThreadsSpin->setValue(config->getValue<int>("numThreads"));
}
if (config->has("priority"))
{
_prioritySpin->setValue(int(config->getValue<double>("priority")*100));
}
if (config->has("affinityMode") and config->has("affinityMask"))
{
auto mode = config->getValue<std::string>("affinityMode");
auto mask = config->getArray("affinityMask");
std::vector<size_t> selection;
for (size_t i = 0; i < mask->size(); i++) selection.push_back(mask->getElement<int>(i));
_cpuSelection->setup(mode, selection);
}
if (config->has("yieldMode"))
{
auto mode = QString::fromStdString(config->getValue<std::string>("yieldMode"));
for (int i = 0; i < _yieldModeBox->count(); i++)
{
if (_yieldModeBox->itemData(i).toString() == mode) _yieldModeBox->setCurrentIndex(i);
}
}
}
void AuthorityServiceController::inquire()
{
Poco::JSON::Object::Ptr pcfParameters;
if ( data().has("filter") && data().isObject("filter") )
{
pcfParameters = data().getObject("filter");
// There is a bug in MQCMD_INQUIRE_AUTH_SERVICE, AuthServiceAttrs is required!
if ( !pcfParameters->has("AuthServiceAttrs") )
{
Poco::JSON::Array::Ptr attrs = new Poco::JSON::Array();
attrs->add("All");
pcfParameters->set("AuthServiceAttrs", attrs);
}
}
else
{
pcfParameters = new Poco::JSON::Object();
set("filter", pcfParameters);
Poco::JSON::Array::Ptr attrs = new Poco::JSON::Array();
formElementToJSONArray("AuthServiceAttrs", attrs);
if ( attrs->size() == 0 ) // Nothing found for AuthServiceAttrs, try Attrs
{
formElementToJSONArray("Attrs", attrs);
}
if ( attrs->size() == 0 ) // Default must be specified for this command!
{
attrs->add("All");
}
pcfParameters->set("AuthServiceAttrs", attrs);
if ( form().has("ServiceComponent") )
{
pcfParameters->set("ServiceComponent", form().get("ServiceComponent"));
}
handleFilterForm(pcfParameters);
}
AuthorityServiceMapper mapper(*commandServer(), pcfParameters);
set("authservices", mapper.inquire());
}
bool CSystemManager::getDevVersion(Poco::JSON::Object::Ptr& param, std::string& detail)
{
CConfigManager* config = CConfigManager::instance();
JSON::Object::Ptr pUpdate;
config->getConfig("Update", pUpdate);
if(pUpdate.isNull() || !pUpdate->has("infoPath"))
{
detail = "901";
return false;
}
std::string infoPath = pUpdate->getValue<std::string>("infoPath");
File file(infoPath);
if(!file.exists())
{
detail = "465";
return false;
}
Util::JSONConfiguration info;
std::string version;
std::string buildtime;
try
{
info.load(infoPath);
version = info.getString(UPDATE_VERSION_STR);
buildtime = info.getString(UPDATE_BUILDTIME_STR);
}
catch(Exception& e)
{
detail = "465";
warnf("%s, %d: Load device info file failed, %s", __FILE__, __LINE__, e.message().c_str());
return false;
}
if(param->has(REG_TOKEN_STR))
{
param->remove(REG_TOKEN_STR);
}
param->set(SYSTEM_VERSION_STR, version);
param->set(SYSTEM_BUILDTIME_STR, buildtime);
return true;
}
std::string Pothos::Topology::dumpJSON(const std::string &request)
{
//extract input request
Poco::JSON::Parser p; p.parse(request.empty()?"{}":request);
auto configObj = p.getHandler()->asVar().extract<Poco::JSON::Object::Ptr>();
assert(configObj);
const auto modeConfig = configObj->optValue<std::string>("mode", "flat");
//parse request into traversal arguments
const bool flatten = (modeConfig == "flat");
const bool traverse = (modeConfig != "rendered");
const auto &flows = (modeConfig == "rendered")?_impl->activeFlatFlows:_impl->flows;
//replace rendered names with names from flattened hierarchy
Poco::JSON::Object::Ptr flatBlocks;
if (modeConfig == "rendered")
{
Poco::JSON::Parser pFlat; pFlat.parse(this->dumpJSON("{\"mode\":\"flat\"}"));
auto flatObj = pFlat.getHandler()->asVar().extract<Poco::JSON::Object::Ptr>();
assert(flatObj);
flatBlocks = flatObj->getObject("blocks");
assert(flatBlocks);
}
//output object
Poco::JSON::Object::Ptr topObj(new Poco::JSON::Object());
//create blocks map
Poco::JSON::Object::Ptr blocksObj(new Poco::JSON::Object());
topObj->set("blocks", blocksObj);
for (const auto &block : getObjSetFromFlowList(flows))
{
//gather block info
Poco::JSON::Object::Ptr blockObj(new Poco::JSON::Object());
const auto blockId = block.call<std::string>("uid");
blocksObj->set(blockId, blockObj);
//replace rendered names with names from flattened hierarchy
blockObj->set("name", block.call<std::string>("getName"));
if (flatBlocks and flatBlocks->has(blockId))
{
blockObj->set("name", flatBlocks->getObject(blockId)->getValue<std::string>("name"));
}
//input port info
Poco::JSON::Array::Ptr inputsArray(new Poco::JSON::Array());
for (const auto &portInfo : block.call<std::vector<PortInfo>>("inputPortInfo"))
{
inputsArray->add(portInfoToObj(portInfo));
}
if (inputsArray->size() > 0) blockObj->set("inputs", inputsArray);
//output port info
Poco::JSON::Array::Ptr outputsArray(new Poco::JSON::Array());
for (const auto &portInfo : block.call<std::vector<PortInfo>>("outputPortInfo"))
{
outputsArray->add(portInfoToObj(portInfo));
}
if (outputsArray->size() > 0) blockObj->set("outputs", outputsArray);
//sub-topology info
if (traverse and this->uid() != blockId) try
{
auto subDump = block.call<std::string>("dumpJSON", "{\"mode\":\"top\"}");
Poco::JSON::Parser psub; psub.parse(subDump);
auto subObj = psub.getHandler()->asVar().extract<Poco::JSON::Object::Ptr>();
assert(subObj);
std::vector<std::string> names; subObj->getNames(names);
for (const auto &name : names) blockObj->set(name, subObj->get(name));
}
catch (const Pothos::Exception &){}
}
//create connections list
Poco::JSON::Array::Ptr connsArray(new Poco::JSON::Array());
topObj->set("connections", connsArray);
for (const auto &flow : flows)
{
Poco::JSON::Object::Ptr connObj(new Poco::JSON::Object());
connsArray->add(connObj);
connObj->set("srcId", flow.src.uid);
connObj->set("srcName", flow.src.name);
connObj->set("dstId", flow.dst.uid);
connObj->set("dstName", flow.dst.name);
}
//recursive flatten when instructed
while (flatten and flattenDump(topObj));
//return the string-formatted result
std::stringstream ss; topObj->stringify(ss, 4);
return ss.str();
}
static bool blockIsHier(const Poco::JSON::Object::Ptr &blockObj)
{
assert(blockObj);
return blockObj->has("connections");
}
/***********************************************************************
* Parse a single documentation block for markup
**********************************************************************/
static Poco::JSON::Object::Ptr parseCommentBlockForMarkup(const CodeBlock &commentBlock)
{
Poco::JSON::Object::Ptr topObj(new Poco::JSON::Object());
Poco::JSON::Array calls;
Poco::JSON::Array keywords;
Poco::JSON::Array::Ptr aliases(new Poco::JSON::Array());
Poco::JSON::Array categories;
Poco::JSON::Array params;
Poco::JSON::Array::Ptr topDocs(new Poco::JSON::Array());
Poco::JSON::Object::Ptr currentParam;
std::string state;
std::string indent;
std::string instruction;
std::string payload;
//search for the markup begin tag and record the indent
for (const auto &codeLine : commentBlock)
{
std::string line = codeLine.text;
Poco::RegularExpression::MatchVec matches;
if (not state.empty())
{
if (line.size() >= indent.size() and line.substr(0, indent.size()) != indent)
{
if (codeLine.lineNo == commentBlock.back().lineNo) line = "";
else throw Pothos::SyntaxException("Inconsistent indentation", codeLine.toString());
}
if (line.size() >= indent.size()) line = line.substr(indent.size());
else line = "";
Poco::RegularExpression("^\\|(\\w+)\\s+(.*)$").match(line, 0, matches);
if (not matches.empty())
{
assert(matches.size() == 3);
instruction = line.substr(matches[1].offset, matches[1].length);
payload = line.substr(matches[2].offset, matches[2].length);
}
}
if (state.empty())
{
Poco::RegularExpression("^(.*)\\|PothosDoc\\s+(.*)$").match(line, 0, matches);
if (matches.empty()) continue;
assert(matches.size() == 3);
indent = line.substr(matches[1].offset, matches[1].length);
topObj->set("name", Poco::trim(line.substr(matches[2].offset, matches[2].length)));
state = "DOC";
}
else if (matches.empty() and state == "DOC")
{
topDocs->add(line);
}
else if (matches.empty() and state == "PARAM")
{
auto array = currentParam->getArray("desc");
array->add(line);
currentParam->set("desc", stripDocArray(array));
}
else if (instruction == "category" and state == "DOC")
{
categories.add(Poco::trim(payload));
}
else if (instruction == "keywords" and state == "DOC")
{
for (const auto &keyword : Poco::StringTokenizer(
payload, " \t", Poco::StringTokenizer::TOK_TRIM | Poco::StringTokenizer::TOK_IGNORE_EMPTY))
{
keywords.add(Poco::trim(keyword));
}
}
else if (instruction == "alias" and state == "DOC")
{
const std::string alias(Poco::trim(payload));
try {Pothos::PluginPath(alias);}
catch (const Pothos::PluginPathError &)
{
throw Pothos::SyntaxException("Invalid alias path", codeLine.toString());
}
aliases->add(alias);
}
else if (instruction == "param" and (state == "DOC" or state == "PARAM"))
{
payload = bracketEscapeEncode(payload);
Poco::RegularExpression::MatchVec fields;
Poco::RegularExpression("^\\s*(\\w+)(\\s*\\[(.*)\\]\\s*)?(.*)$").match(payload, 0, fields);
if (fields.empty()) throw Pothos::SyntaxException(
"Expected |param key[name] description",
codeLine.toString());
assert(fields.size() == 5);
const std::string key = bracketEscapeDecode(Poco::trim(payload.substr(fields[1].offset, fields[1].length)));
std::string name = titleCase(key);
if (fields[3].length != 0) name = bracketEscapeDecode(Poco::trim(payload.substr(fields[3].offset, fields[3].length)));
const std::string desc = bracketEscapeDecode(Poco::trim(payload.substr(fields[4].offset, fields[4].length)));
currentParam = Poco::JSON::Object::Ptr(new Poco::JSON::Object());
params.add(currentParam);
currentParam->set("key", key);
currentParam->set("name", name);
Poco::JSON::Array::Ptr descArr(new Poco::JSON::Array());
descArr->add(desc);
currentParam->set("desc", descArr);
state = "PARAM";
}
else if (instruction == "default" and state == "PARAM")
{
if (currentParam->has("default")) throw Pothos::SyntaxException(
"Multiple occurrence of |default for param",
codeLine.toString());
currentParam->set("default", payload);
}
else if (instruction == "units" and state == "PARAM")
{
if (currentParam->has("units")) throw Pothos::SyntaxException(
"Multiple occurrence of |units for param",
codeLine.toString());
currentParam->set("units", payload);
}
else if (instruction == "widget" and state == "PARAM")
{
if (currentParam->has("widgetType")) throw Pothos::SyntaxException(
"Multiple occurrence of |widget for param",
codeLine.toString());
Poco::RegularExpression::MatchVec fields;
Poco::RegularExpression("^\\s*(\\w+)\\s*\\((.*)\\)$").match(payload, 0, fields);
if (fields.empty()) throw Pothos::SyntaxException(
"Expected |widget SpinBox(args...)",
codeLine.toString());
assert(fields.size() == 3);
const std::string widgetType = Poco::trim(payload.substr(fields[1].offset, fields[1].length));
const std::string argsStr = Poco::trim(payload.substr(fields[2].offset, fields[2].length));
currentParam->set("widgetType", widgetType);
loadArgs(codeLine, *currentParam, argsStr, "widgetArgs", "widgetKwargs");
}
else if (instruction == "tab" and state == "PARAM")
{
if (currentParam->has("tab")) throw Pothos::SyntaxException(
"Multiple occurrence of |tab for param",
codeLine.toString());
currentParam->set("tab", payload);
}
else if (instruction == "preview" and state == "PARAM")
{
if (currentParam->has("preview")) throw Pothos::SyntaxException(
"Multiple occurrence of preview for param",
codeLine.toString());
Poco::RegularExpression::MatchVec fields;
Poco::RegularExpression("^\\s*(\\w+)(\\s*\\((.*)\\))?$").match(payload, 0, fields);
if (fields.empty()) throw Pothos::SyntaxException(
"Expected |preview previewType(args...)",
codeLine.toString());
assert(fields.size() == 2 or fields.size() == 4);
const std::string previewType = Poco::trim(payload.substr(fields[1].offset, fields[1].length));
if (previewType != "disable" and
previewType != "enable" and
previewType != "valid" and
previewType != "invalid" and
previewType != "when"
) throw Pothos::SyntaxException(
"Only supports enable/disable/valid/invalid/when as value for preview option of param",
codeLine.toString());
currentParam->set("preview", previewType);
if (fields.size() == 4)
{
const std::string argsStr = Poco::trim(payload.substr(fields[3].offset, fields[3].length));
loadArgs(codeLine, *currentParam, argsStr, "previewArgs", "previewKwargs");
}
}
else if (instruction == "option" and state == "PARAM")
{
payload = bracketEscapeEncode(payload);
Poco::RegularExpression::MatchVec fields;
Poco::RegularExpression("^(\\s*\\[(.*)\\]\\s*)?(.*)$").match(payload, 0, fields);
if (fields.empty()) throw Pothos::SyntaxException(
"Expected |option [name] value",
codeLine.toString());
assert(fields.size() == 4);
const std::string value = bracketEscapeDecode(Poco::trim(payload.substr(fields[3].offset, fields[3].length)));
std::string name = titleCase(value);
if (fields[2].length != 0) name = bracketEscapeDecode(Poco::trim(payload.substr(fields[2].offset, fields[2].length)));
Poco::JSON::Object option;
option.set("value", value);
option.set("name", name);
if (not currentParam->has("options")) currentParam->set(
"options", Poco::JSON::Array::Ptr(new Poco::JSON::Array()));
currentParam->getArray("options")->add(option);
}
else if (instruction == "factory" and (state == "DOC" or state == "PARAM"))
{
Poco::RegularExpression::MatchVec fields;
Poco::RegularExpression("^\\s*(/.*)\\s*\\((.*)\\)$").match(payload, 0, fields);
if (fields.empty()) throw Pothos::SyntaxException(
"Expected |factory /registry/path(args...)",
codeLine.toString());
assert(fields.size() == 3);
const std::string path = Poco::trim(payload.substr(fields[1].offset, fields[1].length));
const std::string argsStr = Poco::trim(payload.substr(fields[2].offset, fields[2].length));
//add the path
try {Pothos::PluginPath(path);}
catch (const Pothos::PluginPathError &)
{
throw Pothos::SyntaxException("Invalid factory path", codeLine.toString());
}
if (topObj->has("path")) throw Pothos::SyntaxException(
"Multiple occurrence of |factory", codeLine.toString());
topObj->set("path", path);
//split and extract args
loadArgs(codeLine, *topObj, argsStr);
state = "DOC";
}
else if ((instruction == "setter" or instruction == "initializer") and (state == "DOC" or state == "PARAM"))
{
Poco::RegularExpression::MatchVec fields;
Poco::RegularExpression("^\\s*(\\w+)\\s*\\((.*)\\)$").match(payload, 0, fields);
if (fields.empty()) throw Pothos::SyntaxException(
"Expected |"+instruction+" setFooBar(args...)",
codeLine.toString());
assert(fields.size() == 3);
const std::string callName = Poco::trim(payload.substr(fields[1].offset, fields[1].length));
const std::string argsStr = Poco::trim(payload.substr(fields[2].offset, fields[2].length));
//add to calls
Poco::JSON::Object call;
call.set("type", instruction);
call.set("name", callName);
loadArgs(codeLine, call, argsStr);
calls.add(call);
state = "DOC";
}
else if (instruction == "mode" and (state == "DOC" or state == "PARAM"))
{
if (topObj->has("mode")) throw Pothos::SyntaxException(
"Multiple occurrence of |mode",
codeLine.toString());
topObj->set("mode", payload);
}
}
//empty state means this was a regular comment block, return null
if (state.empty()) return Poco::JSON::Object::Ptr();
topDocs = stripDocArray(topDocs);
if (topDocs->size() > 0) topObj->set("docs", topDocs);
if (categories.size() > 0) topObj->set("categories", categories);
if (keywords.size() > 0) topObj->set("keywords", keywords);
if (aliases->size() > 0) topObj->set("aliases", aliases);
if (params.size() > 0) topObj->set("params", params);
if (calls.size() > 0) topObj->set("calls", calls);
//sanity check for required stuff
if (not topObj->has("path"))
{
throw Pothos::SyntaxException("missing |factory declaration");
}
return topObj;
}
void Dictionary::mapToJSON(const PCF& pcf, Poco::JSON::Object::Ptr& json, bool alwaysCreate) const
{
std::vector<MQLONG> parameters = pcf.getParameters();
for(std::vector<MQLONG>::iterator it = parameters.begin(); it != parameters.end(); ++it)
{
std::string name = getName(*it);
if ( name.empty() )
{
if ( alwaysCreate )
{
name = "id_" + Poco::NumberFormatter::format(*it);
}
else
{
continue;
}
}
if ( json->has(name) ) continue; // Don't overwrite already added properties
Poco::JSON::Object::Ptr field = new Poco::JSON::Object();
json->set(name, field);
field->set("id", *it);
if ( pcf.isNumber(*it) )
{
MQLONG value = pcf.getParameterNum(*it);
field->set("value", value);
if ( hasDisplayMap(*it) )
{
std::string displayValue = getDisplayValue(*it, value);
if ( displayValue.empty() )
{
displayValue = "Unknown value " + Poco::NumberFormatter::format(value) + " for " + Poco::NumberFormatter::format(*it);
}
field->set("display", displayValue);
}
}
else if ( pcf.isString(*it) )
{
field->set("value", pcf.getParameterString(*it));
}
else if ( pcf.isNumberList(*it) )
{
std::vector<MQLONG> values = pcf.getParameterNumList(*it);
Poco::JSON::Array::Ptr jsonValues = new Poco::JSON::Array();
field->set("value", jsonValues);
if ( hasDisplayMap(*it) )
{
for(std::vector<MQLONG>::iterator vit = values.begin(); vit != values.end(); ++vit)
{
Poco::JSON::Object::Ptr jsonValueObject = new Poco::JSON::Object();
std::string displayValue = getDisplayValue(*it, *vit);
if ( displayValue.empty() )
{
displayValue = "Unknown value " + Poco::NumberFormatter::format(*vit) + " for " + Poco::NumberFormatter::format(*it);
}
jsonValueObject->set("value", *vit);
jsonValueObject->set("display", displayValue);
jsonValues->add(jsonValueObject);
}
}
else
{
for(std::vector<MQLONG>::iterator vit = values.begin(); vit != values.end(); ++vit)
{
jsonValues->add(*vit);
}
}
}
else if ( pcf.isStringList(*it) )
{
Poco::JSON::Array::Ptr jsonValues = new Poco::JSON::Array();
field->set("value", jsonValues);
std::vector<std::string> strings = pcf.getParameterStringList(*it);
for(std::vector<std::string>::iterator vit = strings.begin(); vit != strings.end(); ++vit)
{
jsonValues->add(*vit);
}
}
else
{
poco_assert_dbg(false);
}
}
}
void Controller::ingestRequest(const Poco::Dynamic::Var& request) {
if (request.type() != typeid(Poco::JSON::Array::Ptr)) {
throw RequestException("Invalid JSON format, root must be array.");
}
try {
Poco::JSON::Array::Ptr jsonArray = request.extract<Poco::JSON::Array::Ptr>();
for (Poco::JSON::Array::ConstIterator it = jsonArray->begin(); it != jsonArray->end(); it++) {
Poco::JSON::Object::Ptr json = it->extract<Poco::JSON::Object::Ptr>();
Record record;
vector<uint8_t>* image_data = NULL;
if (json->has("id")) {
record.setId(json->getValue<string>("id"));
}
if (json->has("thumbnail")) {
record.setThumbnail(json->getValue<string>("thumbnail"));
}
if (json->has("metadata")) {
record.setMetadata(json->getValue<string>("metadata"));
}
if (json->has("blockHash")) {
record.getHashes()[BlockHash] = str2bin(json->getValue<string>("blockHash"));
}
if (json->has("dHash")) {
record.getHashes()[DHash] = str2bin(json->getValue<string>("dHash"));
}
if (json->has("gaussDHash")) {
record.getHashes()[GaussDHash] = str2bin(json->getValue<string>("gaussDHash"));
}
if (json->has("gauss2DHash")) {
record.getHashes()[Gauss2DHash] = str2bin(json->getValue<string>("gauss2DHash"));
}
if (json->has("gaussBlockHash")) {
record.getHashes()[GaussBlockHash] = str2bin(json->getValue<string>("gaussBlockHash"));
}
if (json->has("image_base64")) {
image_data = Image::fromBase64(json->getValue<string>("image_base64"));
}
if (!image_data && json->has("image_url")) {
image_data = Image::fromUrl(json->getValue<string>("image_url"));
}
if (json->has("status")) {
string status = json->getValue<string>("status");
if (status == "deleted") {
deleteRequest(record);
continue;
} else {
throw RequestException("Invalid status value.");
}
}
if (image_data) {
HashAlgorithmManager::getInstance().attachHashes(record, image_data);
delete image_data;
}
putRequest(record);
}
} catch (Poco::JSON::JSONException& e) {
throw RequestException("Invalid JSON format.");
}
appio::print_ok("Data was successfully changed.");
}