terrama2::core::TerraMA2Init::TerraMA2Init(const std::string& serviceType, const int listeningPort)
{
curl_global_init(CURL_GLOBAL_ALL);
terrama2::core::initializeTerralib();
terrama2::core::initializeLogger(serviceType+"_"+std::to_string(listeningPort)+"_terrama2.log");
auto& semanticsManager = terrama2::core::SemanticsManager::getInstance();
//read semantics from json file
std::string semanticsPath = FindInTerraMA2Path("share/terrama2/semantics.json");
QFile semantcisFile(QString::fromStdString(semanticsPath));
semantcisFile.open(QFile::ReadOnly);
QByteArray bytearray = semantcisFile.readAll();
QJsonDocument jsonDoc = QJsonDocument::fromJson(bytearray);
auto array = jsonDoc.array();
for(const auto& json : array)
{
auto obj = json.toObject();
auto jsonProvidersTypes = obj["providers_type_list"].toArray();
std::vector<DataProviderType> providersTypes;
for(const auto& providerType : jsonProvidersTypes)
providersTypes.push_back(providerType.toString().toStdString());
auto jsonMetadata = obj["metadata"].toObject();
std::unordered_map<std::string, std::string> metadata;
for(auto it = jsonMetadata.constBegin(); it != jsonMetadata.constEnd(); ++it)
metadata.emplace(it.key().toStdString(), it.value().toString().toStdString()) ;
semanticsManager.addSemantics(obj["code"].toString().toStdString(),
obj["name"].toString().toStdString(),
dataSeriesTypeFromString(obj["type"].toString().toStdString()),
dataSeriesTemporalityFromString(obj["temporality"].toString().toStdString()),
obj["format"].toString().toStdString(),
providersTypes,
metadata);
}
}
void AnnouncementApi::handleAnnounceResponse(QNetworkReply *reply)
{
QJsonParseError error;
QByteArray body = reply->readAll();
QJsonDocument doc = QJsonDocument::fromJson(body, &error);
if(error.error != QJsonParseError::NoError)
throw ResponseError(QStringLiteral("Error parsing announcement response: %1").arg(error.errorString()));
Announcement a;
a.apiUrl = reply->property("API_URL").toUrl();
a.id = reply->property("SESSION_ID").toString();
a.updateKey = doc.object()["key"].toString();
a.listingId = doc.object()["id"].toInt();
logger::debug() << "Announced session. Got listing ID" << a.listingId;
emit sessionAnnounced(a);
QString welcome = doc.object()["message"].toString();
if(!welcome.isEmpty())
emit messageReceived(doc.object()["message"].toString());
}
void JsArchitecturalMetricsConfig::setMetricDefault()
{
QFile jsonFile(_jsArchitecturalMetricsDir+"/"+_jsonFileName);
QString contentJsonFile;
if (!jsonFile.open(QIODevice::ReadWrite | QIODevice::Text)) {
qWarning("Couldn't open json file.");
return;
}
contentJsonFile = jsonFile.readAll();
QJsonDocument jsonDocument = QJsonDocument::fromJson(contentJsonFile.toUtf8());
QJsonObject jsonObject = jsonDocument.object();
jsonObject["MetricDefault"] = _ui->metricDefaultComboBox->currentData().toString();
jsonDocument.setObject(jsonObject);
jsonFile.resize(0);
jsonFile.write(jsonDocument.toJson());
jsonFile.close();
}
bool DatabaseBackup::readContents(const QString &filename) {
qDebug() << "Read contents from " + filename;
QFile file(filename);
QSqlQueryModel query;
bool res = false;
if (file.open(QIODevice::ReadOnly)) {
QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
if (doc.isObject()) {
res = true;
QJsonArray tables = doc.object().take("database").toObject().take("tables").toArray();
QJsonArray::const_iterator i = tables.constBegin();
while (i != tables.constEnd()) {
QString tableName = (*i).toObject().take("name").toString();
qDebug() << tableName;
QJsonArray records = (*i).toObject().take("records").toArray();
QJsonArray::const_iterator recordIterator = records.constBegin();
while (recordIterator != records.constEnd()) {
QVariantMap record = (*recordIterator).toObject().toVariantMap();
QStringList fields = record.keys();
QStringList values;
QStringList::const_iterator fieldIterator = fields.constBegin();
while (fieldIterator != fields.constEnd()) {
values << record.take(*fieldIterator).toString();
++fieldIterator;
}
qDebug() << "INSERT INTO " + tableName + " (" + fields.join(',') + ")" + " VALUES ('" + values.join("','") + "')";
query.setQuery( QSqlQuery("INSERT INTO " + tableName + " (" + fields.join(',') + ")" + " VALUES ('" + values.join("','") + "')") );
qDebug() << "Errors?" << query.lastError();
++ recordIterator;
}
++i;
}
}
query.submit();
}
file.close();
return res;
}
QVariantMap DMenuPrivate::toVariantMap() const
{
QVariantList items;
QVariantMap menuJsonContent;
QVariantMap menuMap = menuVariant;
for (DAction *action : menuActions) {
QVariantMap map = action->d_func()->toVariantMap();
map["itemId"] = createActionId(action);
items.push_back(map);
}
menuJsonContent["items"] = items;
QJsonDocument menuJsonContentDoc = QJsonDocument::fromVariant(menuJsonContent);
auto menuJsonContentStr = menuJsonContentDoc.toJson();
menuMap["menuJsonContent"] = menuJsonContentStr;
return menuMap;
}
QVariantList CBAttachmentsProvider::attributesForId(const QString &recId)
{
if (QDir(pathForId(recId)).exists()){
QString filename=attributePath(recId);
QFile file(filename);
if (!file.open(QIODevice::ReadOnly)){
qWarning("Cannot open attribute json");
}
QString jsonData = file.readAll();
file.close();
QJsonDocument sd = QJsonDocument::fromJson(jsonData.toUtf8());
if (sd.isNull()){
qWarning("Wrong file attribute json format");
}
return sd.array().toVariantList();
}
else{
return QVariantList();
}
}
void Helpers::importAddresses(QByteArray &data, const QDir& keystore) {
QStringList existingList;
const QStringList nameFilter("UTC*");
foreach ( const QString fileName, keystore.entryList(nameFilter) ) {
QFile file(keystore.filePath(fileName));
file.open(QFile::ReadOnly);
const QByteArray raw = file.readAll();
file.close();
const QJsonDocument doc = QJsonDocument::fromJson(raw);
const QJsonObject contents = doc.object();
existingList.append(contents.value("address").toString("invalid"));
}
QDataStream stream(&data, QIODevice::ReadOnly);
while ( !stream.atEnd() ) {
quint32 size = 0;
stream >> size;
if ( size == 0 ) {
throw QString("Invalid size in address datastream: " + QString::number(size, 10));
}
QByteArray raw(size, '\0');
stream >> raw;
const QJsonObject wrapper = QJsonDocument::fromBinaryData(raw).object();
// check for existing address NOTE: filename can differ! using address to address check
const QString address = wrapper.value("address").toString();
if ( existingList.contains(address, Qt::CaseInsensitive) ) {
continue;
}
const QJsonObject contents = wrapper.value("contents").toObject();
QFile file(keystore.filePath(wrapper.value("filename").toString("invalid")));
file.open(QFile::WriteOnly);
file.write(QJsonDocument(contents).toJson(QJsonDocument::Compact));
file.close();
}
}
BtsApiNotifier *BtsApi::setFolderHosts(const QString &secret, const QStringList &hosts)
{
QueryList ql;
ql << QueryPair("secret", secret)
<< QueryPair("hosts", hosts.join(','));
QUrl apiUrl = getApiUrl(p, "set_folder_hosts", ql);
QString queryString = apiUrl.query(QUrl::FullyEncoded);
QNetworkReply *reply = p->nam->get(QNetworkRequest(apiUrl));
BtsApiNotifier *notifier = new BtsApiNotifier(this);
connect(reply, &QNetworkReply::finished, [this, reply, notifier, secret]()
{
notifier->deleteLater();
if(checkForError(reply, notifier))
return;
QJsonDocument doc = QJsonDocument::fromJson(reply->readAll());
if(checkForError(doc, notifier))
return;
QJsonObject obj = doc.object();
QJsonArray arr = obj.value("hosts").toArray();
QStringList res;
for(const QJsonValue &val: arr)
res << val.toString();
emit setFolderHostsResult(res, secret);
emit notifier->setFolderHostsResult(res, secret);
});
return notifier;
}
void CoapTests::jsonMessage()
{
CoapRequest request(QUrl("coap://coap.me:5683/5"));
qDebug() << request.url().toString();
QSignalSpy spy(m_coap, SIGNAL(replyFinished(CoapReply*)));
CoapReply *reply = m_coap->get(request);
spy.wait();
QVERIFY2(spy.count() > 0, "Did not get a response.");
QCOMPARE(reply->messageType(), CoapPdu::Acknowledgement);
QCOMPARE(reply->statusCode(), CoapPdu::Content);
QCOMPARE(reply->contentType(), CoapPdu::ApplicationJson);
QCOMPARE(reply->error(), CoapReply::NoError);
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(reply->payload(), &error);
QCOMPARE(error.error, QJsonParseError::NoError);
qDebug() << jsonDoc.toJson();
reply->deleteLater();
}
void JsonHandler::parseJson(QString path) {
QFile file;
file.setFileName(path);
file.open(QIODevice::ReadOnly | QIODevice::Text);
QJsonDocument document = QJsonDocument::fromJson(file.readAll());
file.close();
QJsonObject jsonObject = document.object();
QJsonArray jsonArray = jsonObject["circles"].toArray();
QJsonObject circle = jsonArray.at(0).toObject();
QJsonObject position = circle["position"].toObject();
int R = circle["R"].toInt();
int x = position["x"].toInt();
int y = position["y"].toInt();
params = new Params(x, y, R);
QJsonObject panel = jsonObject["panel"].toObject();
QJsonObject jsonSize = panel["size"].toObject();
size.setHeight(jsonSize["y"].toInt());
size.setWidth(jsonSize["x"].toInt());
}
void AnimatorApplication::animate(){
printed = 0;
QDir sourceDir(rootQML->property("sourceDirectory").toUrl().toLocalFile());
destinationDir = rootQML->property("destinationDirectory").toUrl().toLocalFile();
QString pathToSave(destinationDir);
QDir saveDir(sourceDir);
QStringList nameFilters;
nameFilters << QString("*.json");
QStringList filelist = saveDir.entryList(nameFilters);
//QMap сам сортирует по ключу вроде как
QMap<int,GenAlgObject> map;
QMap<int,double> fitnessMap;
foreach(QString file, filelist){
int popNum = file.split("-")[0].toInt();
QFile jsonFile(sourceDir.absolutePath()+"\\" + file);
jsonFile.open(QIODevice::ReadOnly);
QByteArray data = jsonFile.readAll();
QJsonDocument doc = QJsonDocument::fromJson(data);
map[popNum] = GenAlgObject(doc.object());
fitnessMap[popNum] = file.split("-")[1].toDouble();
}
void SDRdaemonSinkGui::networkManagerFinished(QNetworkReply *reply)
{
if (reply->error())
{
ui->apiAddressLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }");
ui->statusText->setText(reply->errorString());
return;
}
QString answer = reply->readAll();
try
{
QByteArray jsonBytes(answer.toStdString().c_str());
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(jsonBytes, &error);
if (error.error == QJsonParseError::NoError)
{
ui->apiAddressLabel->setStyleSheet("QLabel { background-color : green; }");
ui->statusText->setText(QString("API OK"));
analyzeApiReply(doc.object());
}
else
{
ui->apiAddressLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }");
QString errorMsg = QString("Reply JSON error: ") + error.errorString() + QString(" at offset ") + QString::number(error.offset);
ui->statusText->setText(QString("JSON error. See log"));
qInfo().noquote() << "SDRdaemonSinkGui::networkManagerFinished" << errorMsg;
}
}
catch (const std::exception& ex)
{
ui->apiAddressLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }");
QString errorMsg = QString("Error parsing request: ") + ex.what();
ui->statusText->setText("Error parsing request. See log for details");
qInfo().noquote() << "SDRdaemonSinkGui::networkManagerFinished" << errorMsg;
}
}
void CzmlReader::read(QString filename, QVector<SensorData>& data)
{
//file opening
QFile czmlFile;
QString czmlString;
czmlFile.setFileName(filename);
if(!czmlFile.open(QIODevice::ReadOnly | QIODevice::Text)){
return;
}
czmlString = czmlFile.readAll();
czmlFile.close();
//json
QJsonDocument czmlDoc = QJsonDocument::fromJson(czmlString.toUtf8());
QJsonArray czmlArray = czmlDoc.array();
for(int i = 1; i < czmlArray.size(); i++){
QJsonObject czmlObject = czmlArray.at(i).toObject();
data.append(writeToSensorData(czmlObject));
}
}
ContactPtr JSONToContact(const QByteArray& jsonData)
{
QJsonDocument document = QJsonDocument::fromJson(jsonData);
const QVariantMap data = document.toVariant().toMap();
const QVariantMap entry = data.value(QStringLiteral("entry")).toMap();
const QVariantList categories = entry.value(QStringLiteral("category")).toList();
bool isContact = false;
Q_FOREACH(const QVariant &c, categories) {
const QVariantMap category = c.toMap();
if (category.value(QStringLiteral("term")).toString() == QLatin1String("http://schemas.google.com/contact/2008#contact")) {
isContact = true;
break;
}
}
if (!isContact) {
return ContactPtr();
}
return Private::JSONToContact(entry).staticCast<Contact>();
}
void GetPocketApi::handleRemoveBookmarks(const QStringList& ids)
{
emit requestFinished(true);
bool ok = false;
QJsonDocument doc = PreparsingReply(sender(), ok);
if (!ok)
{
qWarning() << Q_FUNC_INFO << "Failed preparsing reply phase";
return;
}
const auto& rootObject = doc.object();
if(rootObject ["status"].toInt() == 1)
{
emit bookmarksRemoved(ids);
}
else
{
emit error(tr("Unable to remove bookamark"));
}
}
void Storage::readDefaultLimits()
{
QString filename = QString(CLEPSYDRA_CONFIG_FOLDER).append(CLEPSYDRA_JSON_DEFAULTS_FILENAME);
QFile file;
QString data=NULL;
file.setFileName(filename);
if (file.open(QIODevice::ReadOnly | QIODevice::Text)==true) {
data = file.readAll();
file.close();
} else {
qDebug () << filename << "json file not found";
return;
}
QJsonDocument d = QJsonDocument::fromJson(data.toUtf8());
if (d.isEmpty()) {
qDebug () << "Not valid document.";
return;
}
QJsonObject obj = d.object();
QVariantMap tempData = obj.toVariantMap();
m_defaultLimits = tempData.take("default").toMap();
}
void GetPocketApi::handleTagsUpdated(const QString& id, const QString& tags)
{
emit requestFinished(true);
bool ok = false;
QJsonDocument doc = PreparsingReply(sender(), ok);
if (!ok)
{
qWarning() << Q_FUNC_INFO << "Failed preparsing reply phase";
return;
}
const auto& rootObject = doc.object();
if(rootObject ["status"].toInt() == 1)
{
emit tagsUpdated(id, tags);
}
else
{
emit error(tr("Unable to update tags"));
}
}
void ThemeSelectorWidget::populateThemeList() {
QDir dir;
dir.cd("Themes");
QStringList dirList = dir.entryList(QDir::AllDirs);
QString themeItem;
foreach (themeItem, dirList) {
if(themeItem == "." || themeItem == "..") continue;
dir.cd(themeItem);
QFile *file = new QFile(dir.absoluteFilePath("ThemeInfo.json"));
file->open(QIODevice::ReadOnly);
QTextStream stream(file);
QString json = stream.readAll();
file->close();
QJsonDocument document = QJsonDocument::fromJson(json.toUtf8());
QJsonObject object = document.object();
QString themeName = object.take("Name").toString();
QString themeIcon = object.take("Icon").toString();
QString themeAuthor = object.take("Author").toString();
QString themeDesc = object.take("Desc").toString();
QString themeVer = object.take("Version").toString();
QString themeJS = object.take("ThemeScript").toString();
QString appBG = object.take("AppBackgroundColor").toString();
QString appTextColorScheme = object.take("AppTextColorScheme").toString();
QStringList itemData;
itemData << dir.absoluteFilePath(themeJS);
itemData << appBG;
itemData << appTextColorScheme;
itemDataList.append(itemData);
QListWidgetItem *item = new QListWidgetItem(QIcon(dir.absoluteFilePath(themeIcon)),themeName);
item->setToolTip(themeDesc + "\nAuthor: " + themeAuthor + "\nVersion: " +themeVer);
ui->listWidget->addItem(new QListWidgetItem(QIcon(dir.absoluteFilePath(themeIcon)),themeName));
dir.cdUp();
}
if(ui->listWidget->count() == 0) {
ui->applyButton->setDisabled(true);
} else {
ui->applyButton->setDisabled(false);
}
}
void LoginManager::onGetUserRequestReady(QByteArray ba)
{
//qDebug() << "onGetUserRequestReady" << ba;
disconnect(_oauthManager, SIGNAL(requestReady(QByteArray)),
this, SLOT(onGetUserRequestReady(QByteArray)));
if (_oauthManager->lastError() == KQOAuthManager::NoError) {
QJsonDocument jsonResponse = QJsonDocument::fromJson(ba);
QJsonObject user = jsonResponse.object();
if (user.value("name") != QJsonValue::Undefined) {
_userName = user.value("name").toString();
_uid = user.value("id").toString().toInt();
emit getUserSuccess();
}
else {
emit getUserError(tr("Error while getting user info. Please try again"));
}
}
else if (_oauthManager->lastError() != KQOAuthManager::NetworkError) {
emit getUserError(tr("Error while getting user info: %1").arg(_oauthManager->lastError()));
}
}
QString CurrencyPane::SaveCurrencyRates()
{
QJsonDocument doc;
QJsonArray array;
for (int i = 0; i < ui->currencyTable->rowCount(); i++) {
QTableWidgetItem* header = ui->currencyTable->verticalHeaderItem(i);
QWidget* widget = ui->currencyTable->cellWidget(i, 1);
QSpinBox* currencyBox = widget->findChild<QSpinBox*>("CurrencyCount");
QSpinBox* chaosBox = widget->findChild<QSpinBox*>("ChaosCount");
if (currencyBox && chaosBox) {
QJsonObject obj;
obj.insert("currency", header->text());
obj.insert("count", currencyBox->value());
obj.insert("chaos", chaosBox->value());
array.append(obj);
}
}
doc.setArray(array);
return doc.toJson(QJsonDocument::Compact);
}
bool Parser::ParseCart(const QString &str, Cart &cart,
const QHash<QString, Goods *> &pGoodsMap) {
QJsonDocument doc = QJsonDocument::fromJson(str.toUtf8());
if (doc.isNull()) {
return false;
}
// json array containing all items
QJsonArray jCodeArray = doc.array();
if (jCodeArray.isEmpty()) { // no items or error json data
return false;
}
// parse each item
for (int i = 0; i < jCodeArray.size(); ++i) {
QJsonValue jValue = jCodeArray.at(i);
if (jValue.isString()) {
QString strItem = jValue.toString();
QString strCode;
int nCnt = 0;
// parse barcode and count
int pos = strItem.indexOf("-");
if (-1 == pos) {
strCode = strItem;
nCnt = 1;
} else {
strCode = strItem.left(pos);
nCnt = strItem.mid(pos + 1).toInt();
nCnt = (nCnt > 0) ? nCnt : 1;
}
// add item
cart.Insert(pGoodsMap.value(strCode), nCnt);
}
}
return true;
}
void Mod::ReadLiteModInfo(QByteArray contents)
{
QJsonParseError jsonError;
QJsonDocument jsonDoc = QJsonDocument::fromJson(contents, &jsonError);
auto object = jsonDoc.object();
if(object.contains("name"))
{
m_mod_id = m_name = object.value("name").toString();
}
if(object.contains("version"))
{
m_version=object.value("version").toString("");
}
else
{
m_version=object.value("revision").toString("");
}
m_mcversion = object.value("mcversion").toString();
m_authors = object.value("author").toString();
m_description = object.value("description").toString();
m_homeurl = object.value("url").toString();
}
void DBTalker::parseResponseListFolders(const QByteArray& data)
{
QJsonParseError err;
QJsonDocument doc = QJsonDocument::fromJson(data, &err);
if (err.error != QJsonParseError::NoError)
{
emit signalBusy(false);
emit signalListAlbumsFailed(i18n("Failed to list folders"));
return;
}
QJsonObject jsonObject = doc.object();
QJsonArray jsonArray = jsonObject[QString::fromLatin1("contents")].toArray();
QList<QPair<QString, QString> > list;
list.clear();
list.append(qMakePair(QString::fromLatin1("/"), QString::fromLatin1("root")));
foreach (const QJsonValue& value, jsonArray)
{
QString path(QString::fromLatin1(""));
bool isDir;
QJsonObject obj = value.toObject();
path = obj[QString::fromLatin1("path")].toString();
isDir = obj[QString::fromLatin1("is_dir")].toBool();
qCDebug(KIPIPLUGINS_LOG) << "Path is "<<path<<" Is Dir "<<isDir;
if(isDir)
{
qCDebug(KIPIPLUGINS_LOG) << "Path is "<<path<<" Is Dir "<<isDir;
QString name = path.section(QLatin1Char('/'), -2);
qCDebug(KIPIPLUGINS_LOG) << "str " << name;
list.append(qMakePair(path,name));
m_queue.enqueue(path);
}
}
void RunModel::loadded()
{
mDatas.clear();
beginResetModel();
qDebug()<<"received";
QNetworkReply * reply = qobject_cast<QNetworkReply*>(sender());
if (reply->error() != QNetworkReply::NoError)
{
emit error(reply->errorString());
return;
}
QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
mTotalCount = document.object().value("meta").toObject().value("total_count").toInt();
mLimit = document.object().value("meta").toObject().value("limit").toInt();
mOffset = document.object().value("meta").toObject().value("offset").toInt();
qDebug()<<Q_FUNC_INFO<<"total "<<mTotalCount;
QJsonArray array = document.object().value("objects").toArray();
foreach (QJsonValue value, array)
{
RunItem item;
item.name = value.toObject().value("resultsName").toString();
item.date = QDateTime::fromString(value.toObject().value("timeStamp").toString(),Qt::ISODate);
item.id = value.toObject().value("id").toInt();
item.reportLink = QUrl(value.toObject().value("reportLink").toString());
item.status = value.toObject().value("status").toString();
mDatas.append(item);
}
bool HistoryModel::save(const QString &path) const
{
if (SessionsManager::isReadOnly())
{
return false;
}
QSaveFile file(path);
if (!file.open(QIODevice::WriteOnly))
{
return false;
}
QJsonArray array;
for (int i = 0; i < rowCount(); ++i)
{
QStandardItem *entry(item(i));
if (entry)
{
QJsonObject object;
object.insert(QLatin1String("url"), entry->data(UrlRole).toUrl().toString());
object.insert(QLatin1String("title"), entry->data(TitleRole).toString());
object.insert(QLatin1String("time"), entry->data(TimeVisitedRole).toDateTime().toString(QLatin1String("yyyy-MM-dd hh:mm:ss")));
array.prepend(object);
}
}
QJsonDocument document;
document.setArray(array);
file.write(document.toJson(QJsonDocument::Indented));
return file.commit();
}
bool SyncEngine::sync(const QJsonDocument &response_document)
{
bool changed = false;
emit syncStarted();
QJsonObject root = {
{"version", F_LEAKLOG_VERSION},
{"db_version", F_DB_VERSION},
{"source_uuid", sourceUUID()},
{"database_uuid", databaseUUID()},
{"database_name", databaseName()},
{"journal_version", JournalEntry::Version},
};
QJsonObject journal_state = journalState();
if (response_document.isObject()) {
QJsonObject response = response_document.object();
QJsonObject local_journal_state = journalStateForVersion(journal_state, response.value("journal_version").toInt());
QJsonObject server_journal_state = journalStateForVersion(response.value("journal").toObject(), JournalEntry::Version);
if (local_journal_state == server_journal_state) {
return changed;
}
QJsonArray entries;
QStringList local_journal_state_keys = local_journal_state.keys();
if (local_journal_state_keys.count()) {
QStringList predicates;
QVariantList values;
foreach (const QJsonValue &source_uuid, local_journal_state_keys) {
QStringList components = source_uuid.toString().split(':');
predicates << QString("(source_uuid = ? AND entry_id > ?)");
values << components.first();
values << server_journal_state.value(source_uuid.toString()).toInt();
}
void FbxAPI::requestAuthorizeStatusFinished()
{
QNetworkReply * reply = qobject_cast<QNetworkReply*>(sender());
QJsonDocument doc = QJsonDocument::fromJson(reply->readAll());
if(parseResult(doc)) {
QString statusString = doc.object().value("result").toObject().value("status").toString();
AuthStatus status;
if (statusString == "unknown")
status = UnknownStatus;
if (statusString == "pending")
status = PendingStatus;
if (statusString == "timeout")
status = TimeOutStatus;
if (statusString == "granted")
status = GrantedStatus;
if (statusString == "denied")
status = DeniedStatus;
qDebug()<<statusString<<status;
emit authorizeStatusChanged(status);
}
reply->deleteLater();
}
bool Splitter::split(const QString &json)
{
// drapeau ok initialisé baissé
bool ok = false;
// récupération du calcul à fragmenter à partir du json
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8(), &error);
QVariantMap params;
if(!error.error && doc.isObject())
{ if(doc.object().contains(CS_JSON_KEY_CALC_PARAMS) && doc.object().value(CS_JSON_KEY_CALC_PARAMS).isObject())
{ params = doc.object().value(CS_JSON_KEY_CALC_PARAMS).toObject().toVariantMap();
}
else
{ _error = QString("Missing '%1' field in calculation !")
.arg(CS_JSON_KEY_CALC_PARAMS);
}
}
else
{ _error = "Missing json object !";
}
// vérification des paramètres
if(params.contains(PARAM_MIN_LEN) &&
params.contains(PARAM_MAX_LEN))
{ /*
* La fragmentation stupide pour le bruteforce consiste a distribuer
* en donnant une taille de mot de passe pour chaque fragment
*/
// -- récupération des valeurs de min et max len dans les champs des paramètres
uint min_len = params.value(PARAM_MIN_LEN).toInt();
uint max_len = params.value(PARAM_MAX_LEN).toInt();
QJsonArray fragments;
// -- pour chaque longueur entre min et max len, création d'un fragment
for (uint l = min_len; l <= max_len; ++l) {
// --- récupération de l'objet calcul de base
QJsonObject frag = doc.object();
// --- identifiant du bloc de calcul
frag.insert(CS_JSON_KEY_FRAG_ID, QString::number(l-min_len+1));
// --- récupération des paramètres du calcul de base
QVariantMap frag_params = params;
// --- modification des champs min et max len dans les paramètre
frag_params.insert(PARAM_MIN_LEN, l);
frag_params.insert(PARAM_MAX_LEN, l);
// --- modification du champ paramètre
frag.insert(CS_JSON_KEY_CALC_PARAMS, QJsonObject::fromVariantMap(frag_params));
// --- insertion du fragment dans la liste
fragments.append(frag);
}
// -- insertion des fragment dans l'attribut résultat de l'objet splitter
_result = QJsonDocument(fragments).toJson(QJsonDocument::Compact);
// on lève le drapeau
ok = true;
}
else
{ _error = QString("Missing fields '%1' and '%2' in field '%3' calculation !")
.arg(PARAM_MAX_LEN, PARAM_MAX_LEN, CS_JSON_KEY_CALC_PARAMS);
}
return ok;
}
bool loadConfig(const QString& filename, QMainWindow *mainWindow)
{
// Load Existing Configuration /////////////////////////////////////////////
QFile file(filename);
if( !file.open(QFile::ReadOnly) ) {
return false;
}
QJsonParseError error;
const QJsonDocument cfgDoc = QJsonDocument::fromJson(file.readAll(), &error);
file.close();
if( error.error != QJsonParseError::NoError ) {
return false;
}
const QJsonObject cfgObj = cfgDoc.object();
if( cfgObj.isEmpty() ) {
return false;
}
// WMainWindow /////////////////////////////////////////////////////////////
const QJsonObject mainObj = cfgObj[QStringLiteral("mainWindow")].toObject();
if( !mainObj.isEmpty() ) {
loadGeometry(mainWindow, mainObj);
}
// WPlotWindow /////////////////////////////////////////////////////////////
WPlotWindow::loadConfig(cfgObj);
// WValuesWindow ///////////////////////////////////////////////////////////
WValuesWindow::loadConfig(cfgObj);
return true;
}
//--------------------------------------------------------------------------------------------
void Begin2DSceneMessage::build(const axtrace_time_s& traceTime, const axtrace_head_s& head, cyclone::RingBuf* ringBuf)
{
memcpy(&m_time, &traceTime, sizeof(axtrace_time_s));
m_processID = head.pid;
m_threadID = head.tid;
axtrace_2d_begin_scene_s value_head;
size_t len = ringBuf->memcpy_out(&value_head, sizeof(value_head));
assert(len == sizeof(value_head));
m_sceneRect = QRectF(value_head.left, value_head.top, value_head.right-value_head.left, value_head.bottom-value_head.top);
//copy name
char tempBuf[AXTRACE_MAX_SCENE_DEFINE_LENGTH];
int name_length = value_head.name_len;
//TODO: check name length
len = ringBuf->memcpy_out(tempBuf, name_length);
assert(len == name_length);
tempBuf[name_length - 1] = 0; //make sure last char is '\0'
m_sceneName = QString::fromUtf8(tempBuf);
//copy define
int define_length = value_head.define_len;
len = ringBuf->memcpy_out(tempBuf, define_length);
assert(len == define_length);
tempBuf[define_length] = 0;
//make json object
if (define_length > 0)
{
QJsonParseError jerror;
QJsonDocument jsonDocument = QJsonDocument::fromJson(tempBuf, &jerror);
if (jerror.error == QJsonParseError::NoError)
{
m_sceneDefine = jsonDocument.object();
}
}
}
