void AddressManager::handleAPIResponse(QNetworkReply& requestReply) {
QJsonObject responseObject = QJsonDocument::fromJson(requestReply.readAll()).object();
QJsonObject dataObject = responseObject["data"].toObject();
if (!dataObject.isEmpty()) {
goToAddressFromObject(dataObject.toVariantMap(), requestReply);
} else if (responseObject.contains(DATA_OBJECT_DOMAIN_KEY)) {
goToAddressFromObject(responseObject.toVariantMap(), requestReply);
}
emit lookupResultsFinished();
}
void RenderableModelEntityItem::remapTextures() {
if (!_model) {
return; // nothing to do if we don't have a model
}
if (!_model->isLoadedWithTextures()) {
return; // nothing to do if the model has not yet loaded it's default textures
}
if (!_originalTexturesRead && _model->isLoadedWithTextures()) {
const QSharedPointer<NetworkGeometry>& networkGeometry = _model->getGeometry();
if (networkGeometry) {
_originalTextures = networkGeometry->getTextureNames();
_originalTexturesRead = true;
}
}
if (_currentTextures == _textures) {
return; // nothing to do if our recently mapped textures match our desired textures
}
// since we're changing here, we need to run through our current texture map
// and any textures in the recently mapped texture, that is not in our desired
// textures, we need to "unset"
QJsonDocument currentTexturesAsJson = QJsonDocument::fromJson(_currentTextures.toUtf8());
QJsonObject currentTexturesAsJsonObject = currentTexturesAsJson.object();
QVariantMap currentTextureMap = currentTexturesAsJsonObject.toVariantMap();
QJsonDocument texturesAsJson = QJsonDocument::fromJson(_textures.toUtf8());
QJsonObject texturesAsJsonObject = texturesAsJson.object();
QVariantMap textureMap = texturesAsJsonObject.toVariantMap();
foreach(const QString& key, currentTextureMap.keys()) {
// if the desired texture map (what we're setting the textures to) doesn't
// contain this texture, then remove it by setting the URL to null
if (!textureMap.contains(key)) {
QUrl noURL;
qDebug() << "Removing texture named" << key << "by replacing it with no URL";
_model->setTextureWithNameToURL(key, noURL);
}
}
// here's where we remap any textures if needed...
foreach(const QString& key, textureMap.keys()) {
QUrl newTextureURL = textureMap[key].toUrl();
qDebug() << "Updating texture named" << key << "to texture at URL" << newTextureURL;
_model->setTextureWithNameToURL(key, newTextureURL);
}
_currentTextures = _textures;
}
ConfigReader::ConfigReader(QString FileName):
QObject()
{
QFile *configFile = new QFile(FileName);
this->error = 0;
if (!configFile->open(QIODevice::ReadOnly))
{
this->error = Error_File_Not_Found;
} else {
QByteArray ba = configFile->readAll();
configFile->close();
if(ba.isNull())
{
this->error = Error_Config_Empty;
}
else
{
QJsonParseError *err = NULL;
QJsonDocument doc = QJsonDocument::fromJson(ba, err);
if( err != NULL || doc.isNull() )
{
this->error = Error_Config_Parse;
err = NULL;
}
QJsonObject jsonContents = doc.object();
contents = jsonContents.toVariantMap();
}
}
}
void Crawler::finished()
{
// Warning: Verbosity ahead
if (QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender())) {
activeDownloads--;
QJsonParseError parseError;
QJsonObject object = QJsonDocument::fromJson(reply->readAll(), &parseError).object();
reply->deleteLater();
if (parseError.error != QJsonParseError::NoError) {
qWarning(qPrintable(parseError.errorString()));
emit done();
return;
}
QVariant responseData = object.toVariantMap()["responseData"];
if (responseData.isNull()) {
// When responseData is null, the search reached the end
emit done();
return;
}
QVariantList results = responseData.toMap()["results"].toList();
QStringList titles;
foreach (QVariant result, results) {
QVariantMap resultMap = result.toMap();
titles << resultMap["title"].toString();
}
//******************************************************************************************
//function: doQuery
//params: const QString &lpzQuery
//return: QJsonArray
//Description:
//******************************************************************************************
QJsonArray WSClient::doQuery( const QString &lpzQuery )
{
if (!this->getCheckLogin()) {
throw WSClientException( this->jsLoginError );
}
QHash<QString, QString> params;
params.insert("query", lpzQuery);
QJsonObject response = Get("query", params);
params.clear();
if ( !response.isEmpty() ) {
QVariantMap map_json = response.toVariantMap();
QVariant success = map_json.value("success");
if ( success.toBool() ) {
return response.value("result").toArray();
}
else {
QJsonObject error = response.value("error").toObject();
throw WSClientException( error );
}
}
throw WSClientException( jsNoData );
}
void Dialog::loadHistory(const int count) {
QMap<QString,QString> params;
params.insert("count", QString::number(count));
params.insert("user_id",userId);
QJsonObject result = application->getApiMethodExecutor().executeMethod("messages.getHistory",params);
QVariantList messageList = result.toVariantMap().take("response").toMap().take("items").toList();
//messageList.removeFirst();
QString historyHtml = "";
if (messageList.size()>0) {
for(int idx=messageList.size()-1; idx>=0; idx--) {
QVariantMap messageMap = messageList.value(idx).toMap();
QString messageId = messageMap.value("id").toString();
QString fromId = messageMap.value("from_id").toString();
uint timestamp = messageMap.value("date").toString().toUInt();
QString body = messageMap.value("body").toString();
bool isRead = messageMap.value("read_state").toString().toInt() > 0;
applyReadState(messageId, fromId, isRead);
QVariantList variantAttachments = messageMap.value("attachments").toList();
QList<QString> attachmentHtmls = prepareAttachmentHtmls(variantAttachments);
historyHtml.append(prepareMessageHtml(messageId,fromId,timestamp,body,isRead, attachmentHtmls));
}
}
ui->webView->setHtml(historyHtml);
}
//******************************************************************************************
//function: doRetrieve
//params: const QString id
//return: QJsonObject
//Description:
//******************************************************************************************
QJsonObject WSClient::doRetrieve(const QString id)
{
if (!this->getCheckLogin()) {
throw WSClientException( this->jsLoginError );
}
QHash<QString, QString> params;
params.insert("id", id);
QJsonObject response = Get("retrieve", params);
params.clear();
if ( !response.isEmpty() ) {
QVariantMap map_json = response.toVariantMap();
QVariant success = map_json.value("success");
if ( success.toBool() ) {
return response.value("result").toObject();
}
else {
QJsonObject error = response.value("error").toObject();
throw WSClientException( error );
}
}
return response;
}
void ServerCore::sendCommandToDevice(QString deviceUID, QVariantMap paramMap)
{
QTcpSocket *socket = createSocket(deviceUID);
QObject::connect(socket, &QTcpSocket::readyRead, [=]
{
QByteArray byteArray = socket->readAll();
QJsonDocument jsonDoc = QJsonDocument::fromJson(byteArray);
QJsonObject jsonObj = jsonDoc.object();
if (jsonObj[JSON_KEY_STATUS].toInt() == STATUS_SUCCESSFUL)
{
QVariantMap retMap = jsonObj.toVariantMap();
Q_EMIT commandReturned(deviceUID, retMap);
}
socket->disconnectFromHost();
});
QObject::connect(socket, &QTcpSocket::disconnected, [=]
{
socket->deleteLater();
});
QString jsonCmd = JsonGenerator::GenerateJsonCommand(TCP_COMMAND_TYPE::SEND_COMMAND_TO_DEVICE, paramMap);
socket->write(jsonCmd.toLatin1());
socket->waitForBytesWritten();
socket->waitForReadyRead();
}
//******************************************************************************************
//function: doSetRelated
//params: const QString &relate_this_id, const QString &with_this_ids
//return: QJsonObject
//Description:
//Set relation between records.
//param relate_this_id string ID of record we want to related other records with
//param with_this_ids string/array either a string with one unique ID or an array of IDs to relate to the first parameter
//******************************************************************************************
QJsonObject WSClient::doSetRelated(const QString &relate_this_id, const QString &with_these_ids)
{
if (!this->getCheckLogin()) {
throw WSClientException( this->jsLoginError );
}
QHash<QString, QString> params;
params.insert("relate_this_id", relate_this_id);
params.insert("with_these_ids", with_these_ids);
qDebug() << params;
QJsonObject response = Post("SetRelation", params);
params.clear();
if ( !response.isEmpty() ) {
QVariantMap map_json = response.toVariantMap();
QVariant success = map_json.value("success");
if ( success.toBool() ) {
return response.value("result").toObject();
}
else {
QJsonObject error = response.value("error").toObject();
throw WSClientException( error );
}
}
throw WSClientException( jsNoData );
}
void ServerCore::queryDeviceDisplayInfo(QString deviceUID)
{
QTcpSocket *socket = createSocket(deviceUID);
QObject::connect(socket, &QTcpSocket::readyRead, [=]
{
QByteArray byteArray = socket->readAll();
QJsonDocument jsonDoc = QJsonDocument::fromJson(byteArray);
QJsonObject jsonObj = jsonDoc.object();
if (jsonObj[JSON_KEY_STATUS].toInt() == STATUS_SUCCESSFUL)
{
QVariantMap retMap = jsonObj.toVariantMap();
Q_EMIT displayInfoRecieved(deviceUID, retMap);
}
socket->disconnectFromHost();
});
QObject::connect(socket, &QTcpSocket::disconnected, [=]
{
socket->deleteLater();
});
QVariantMap paramMap;
paramMap.insert(JSON_KEY_SEQ, 1234);
QString jsonCmd = JsonGenerator::GenerateJsonCommand(TCP_COMMAND_TYPE::QUERY_DEVICE_DISPLAY_INFO, paramMap);
socket->write(jsonCmd.toLatin1());
}
void ModelEntityItem::setAnimationSettings(const QString& value) {
// the animations setting is a JSON string that may contain various animation settings.
// if it includes fps, currentFrame, or running, those values will be parsed out and
// will over ride the regular animation settings
QJsonDocument settingsAsJson = QJsonDocument::fromJson(value.toUtf8());
QJsonObject settingsAsJsonObject = settingsAsJson.object();
QVariantMap settingsMap = settingsAsJsonObject.toVariantMap();
if (settingsMap.contains("fps")) {
float fps = settingsMap["fps"].toFloat();
setAnimationFPS(fps);
}
// old settings used frameIndex
if (settingsMap.contains("frameIndex")) {
float currentFrame = settingsMap["frameIndex"].toFloat();
#ifdef WANT_DEBUG
if (isAnimatingSomething()) {
qCDebug(entities) << "ModelEntityItem::setAnimationSettings() calling setAnimationFrameIndex()...";
qCDebug(entities) << " model URL:" << getModelURL();
qCDebug(entities) << " animation URL:" << getAnimationURL();
qCDebug(entities) << " settings:" << value;
qCDebug(entities) << " settingsMap[frameIndex]:" << settingsMap["frameIndex"];
qCDebug(entities" currentFrame: %20.5f", currentFrame);
}
#endif
setAnimationCurrentFrame(currentFrame);
}
if (settingsMap.contains("running")) {
bool running = settingsMap["running"].toBool();
if (running != getAnimationIsPlaying()) {
setAnimationIsPlaying(running);
}
}
if (settingsMap.contains("firstFrame")) {
float firstFrame = settingsMap["firstFrame"].toFloat();
setAnimationFirstFrame(firstFrame);
}
if (settingsMap.contains("lastFrame")) {
float lastFrame = settingsMap["lastFrame"].toFloat();
setAnimationLastFrame(lastFrame);
}
if (settingsMap.contains("loop")) {
bool loop = settingsMap["loop"].toBool();
setAnimationLoop(loop);
}
if (settingsMap.contains("hold")) {
bool hold = settingsMap["hold"].toBool();
setAnimationHold(hold);
}
_dirtyFlags |= Simulation::DIRTY_UPDATEABLE;
}
qint64 NodeList::sendStatsToDomainServer(const QJsonObject& statsObject) {
QByteArray statsPacket = byteArrayWithPopulatedHeader(PacketTypeNodeJsonStats);
QDataStream statsPacketStream(&statsPacket, QIODevice::Append);
statsPacketStream << statsObject.toVariantMap();
return writeUnverifiedDatagram(statsPacket, _domainHandler.getSockAddr());
}
void AddressManager::handleAPIResponse(QNetworkReply& requestReply) {
QJsonObject responseObject = QJsonDocument::fromJson(requestReply.readAll()).object();
QJsonObject dataObject = responseObject["data"].toObject();
goToAddressFromObject(dataObject.toVariantMap(), requestReply);
emit lookupResultsFinished();
}
void AuthDialog::on_pushButton_clicked()
{
qint32 iPage = 1;
qint32 iOffset = 0;
qint32 iCountRec = 0;
QFile file("id_list.txt");
file.open(QIODevice::WriteOnly);
QUrl urlSearch = QUrl("https://api.vk.com/method/users.search?&sort=1&count=5&city=109&v=5.40&sex=1&age_from=22&age_to=25&has_photo=1&access_token=TOKEN");
QNetworkAccessManager * manager = new QNetworkAccessManager();
QNetworkReply *rep = manager->get(QNetworkRequest(urlSearch));
QEventLoop wait; // ждем ответа от сервера
QObject::connect(manager, SIGNAL(finished(QNetworkReply*)),&wait, SLOT(quit())); //соеденяем сигнал менеджера со слотом лупа
QTimer:: singleShot(10000, &wait,SLOT(quit())); // ждем еще 10 сек ответа
wait.exec();
QString sJson = (QString)rep->readAll();
qDebug() << sJson;
QJsonDocument jsonResp = QJsonDocument::fromJson(sJson.toUtf8());
QJsonObject jsonObj = jsonResp.object();
iCountRec = jsonObj.value("response").toObject()["count"].toInt();
while(true)
{
QUrl urlSearch = QUrl(QString("https://api.vk.com/method/users.search?&sort=1&offset=%1&count=200&city=109&v=5.40&sex=1&age_from=22&age_to=25&has_photo=1&access_token=TOKEN")
.arg(iOffset));
iOffset = iPage*200;
QNetworkAccessManager * manager = new QNetworkAccessManager();
QNetworkReply *rep = manager->get(QNetworkRequest(urlSearch));
QEventLoop wait; // ждем ответа от сервера
QObject::connect(manager, SIGNAL(finished(QNetworkReply*)),&wait, SLOT(quit())); //соеденяем сигнал менеджера со слотом лупа
QTimer:: singleShot(10000, &wait,SLOT(quit())); // ждем еще 10 сек ответа
wait.exec();
QString json = (QString)rep->readAll();
//qDebug() << json;
QJsonDocument jsonResponse = QJsonDocument::fromJson(json.toUtf8());
QJsonObject jsonObject = jsonResponse.object();
/*QJsonArray jsonArray =*/
qDebug()<< jsonObject.toVariantMap()/*.value("items").toArray()*/;
/* foreach (const QJsonValue & value, jsonArray) {
QJsonObject obj = value.toObject();
qDebug() << obj["id"].toString();
}*/
iPage++;
if (iOffset >= iCountRec)
break;
}
}
void PAAlternativeLauncher::streamsFinished()
{
QNetworkReply *reply = dynamic_cast<QNetworkReply *>(sender());
if(reply)
{
if(reply->error() == QNetworkReply::NoError)
{
info.log("Streams", "Streams received.", true);
setState(download_state);
QSettings settings;
// Curly braces for signal blocker
{
const QSignalBlocker blocker(mStreamsComboBox);
mStreamsComboBox->clear();
settings.beginGroup("streams");
info.log("Streams", "Decoding data.", true);
QJsonDocument authjson = QJsonDocument::fromJson(reply->readAll());
QJsonArray streams = authjson.object()["Streams"].toArray();
info.log("Streams", "Processing streams.", true);
for(QJsonArray::const_iterator stream = streams.constBegin(); stream != streams.constEnd(); ++stream)
{
QJsonObject object = (*stream).toObject();
QString download_url = object["DownloadUrl"].toString();
QString title_folder = object["TitleFolder"].toString();
QString manifest_name = object["ManifestName"].toString();
QString auth_suffix = object["AuthSuffix"].toString();
QString stream_name = object["StreamName"].toString();
info.log("Streams", QString("Adding %1.").arg(stream_name), true);
mStreamsComboBox->addItem(stream_name, object.toVariantMap());
settings.setValue(stream_name + "/name", stream_name);
info.log("Streams", "Retrieving news", true);
// Get the news
QNetworkRequest request(QUrl("https://uberent.com/Launcher/StreamNews?StreamName=" + stream_name + "&ticket=" + mSessionTicket));
request.setRawHeader("X-Authorization", mSessionTicket.toUtf8());
request.setRawHeader("X-Clacks-Overhead", "GNU Terry Pratchett");
request.setRawHeader("User-Agent", QString("PAAlternativeLauncher/%1").arg(VERSION).toUtf8());
request.setAttribute(QNetworkRequest::User, stream_name);
QNetworkReply *stream_news_reply = mNetworkAccessManager->get(request);
connect(stream_news_reply, SIGNAL(finished()), SLOT(streamNewsReplyFinished()));
}
settings.endGroup();
}
mStreamsComboBox->setCurrentText(settings.value("streams/defaultstream").toString());
}
else
{
info.critical(tr("Streams"), tr("Error while getting streams.\n%1").arg(reply->errorString()));
setState(login_state);
}
reply->deleteLater();
}
}
Utils::Utils(QObject *parent) :
QObject(parent) {
mkdir(path(Utils::SettingsLocation));
QJsonObject json;
json = QJsonDocument::fromJson(read(path(Utils::SettingsLocation), "sb-settings.json").toUtf8()).object();
m_settings = json.toVariantMap();
}
void KonvergoWindow::saveGeometry()
{
QRect rc = geometry();
QJsonObject obj;
obj.insert("x", rc.x());
obj.insert("y", rc.y());
obj.insert("width", rc.width());
obj.insert("height", rc.height());
SettingsComponent::Get().setValue(SETTINGS_SECTION_STATE, "geometry", obj.toVariantMap());
}
void DispositivoNet::getReply(QJsonDocument _ServerReply)
{
if (!_ServerReply.isNull())
{
QJsonObject respuesta = _ServerReply.object();
QVariantMap allData = respuesta.toVariantMap();
infoArrive(allData);
}
//m_sincronizandose = false;
}
//******************************************************************************************
//function: doListTypes
//params: None
//return: QList<listTypeInfo>
//Description:
//******************************************************************************************
QList<listTypeInfo> WSClient::doListTypes()
{
if (!this->getCheckLogin()) {
throw WSClientException( this->jsLoginError );
}
QList<listTypeInfo> lp_info;
QHash<QString, QString> params;
QJsonObject response = Get("listtypes", params);
params.clear();
if ( !response.isEmpty() ) {
QVariantMap map_json = response.toVariantMap();
QVariant success = map_json.value("success");
if ( success.toBool() ) {
QJsonObject data = response.value("result").toObject();
QJsonObject info = data.value("information").toObject();
QVariantMap mp_info = info.toVariantMap();
for(QVariantMap::const_iterator iter = mp_info.begin(); iter != mp_info.end(); ++iter) {
QString module = iter.key();
QJsonObject options = info.value(module).toObject();
listTypeInfo lp_item;
lp_item.isEntity = options.value("isEntity").toBool();
lp_item.label = options.value("label").toString();
lp_item.singular = options.value("singular").toString();
lp_item.information = options;
lp_info.append(lp_item);
}
}
else {
QJsonObject error = response.value("error").toObject();
throw WSClientException( error );
}
}
return lp_info;
}
void ignnetwork::setProxy(const QVariant &config){
/* json parsing */
QJsonParseError *err = new QJsonParseError();
QJsonDocument json = QJsonDocument::fromVariant(config);
if (err->error != 0) {
qDebug() << err->errorString();
exit (1);
}
QJsonObject jObject = json.object();
QVariantMap set_proxy = jObject.toVariantMap();
if(set_proxy["type"].toString() != ""){
QNetworkProxy proxy;
QString proxy_type = set_proxy["type"].toString();
if(proxy_type == "http"){
proxy.setType(QNetworkProxy::HttpProxy);
}
else if(proxy_type == "socks5"){
proxy.setType(QNetworkProxy::Socks5Proxy);
}
else if(proxy_type == "ftp"){
proxy.setType(QNetworkProxy::FtpCachingProxy);
}
else if(proxy_type == "httpCaching"){
proxy.setType(QNetworkProxy::HttpCachingProxy);
}
else{
qDebug()<<"Please input your type proxy (http,socks5,ftp,httpCaching)!";
}
if(set_proxy["url"].toString() != ""){
QString url = set_proxy["url"].toString();
QStringList url_proxy = url.split(":");
proxy.setHostName(url_proxy.at(0));
proxy.setPort(url_proxy.at(1).toInt());
}
else{
qDebug()<<"Please input your hostname:port Ex: 127.0.0.1:8080!";
}
if(set_proxy["username"].toString() != ""){
proxy.setUser(set_proxy["username"].toString());
}
if(set_proxy["password"].toString() != ""){
proxy.setPassword(set_proxy["password"].toString());
}
QNetworkProxy::setApplicationProxy(proxy);
}
}
QVariantMap toMap(const QByteArray &val)
{
QJsonParseError jError;
QJsonDocument jDoc = QJsonDocument::fromJson(val, &jError);
if (jError.error == QJsonParseError::NoError) {
if (jDoc.isObject()) {
QJsonObject jObj = jDoc.object();
return jObj.toVariantMap();
}
}
QVariantMap ret;
return ret;
}
QVariantMap JsonRestListModel::getVariantMap(QByteArray bytes)
{
QString str = QString::fromUtf8(bytes.data(), bytes.size());
QJsonParseError parseError;
QJsonDocument document = QJsonDocument::fromJson(bytes, &parseError);
QJsonObject obj = document.object();
if (parseError.error != QJsonParseError::NoError) {
qDebug() << parseError.errorString();
}
return obj.toVariantMap();
}
int jsonparser::jsonParse(QJsonDocument jDoc){
ActiveOptionsContainer* activeOpts = new ActiveOptionsContainer();
VariableHandler* varHandler = new VariableHandler();
EnvironmentContainer* envContainer = new EnvironmentContainer(this,varHandler);
JasonCore* jCore = new JasonCore(this,varHandler,envContainer);
QVariantMap* totalMap = new QVariantMap();
connect(varHandler,&VariableHandler::sendProgressTextUpdate,[=](QString message){this->sendProgressTextUpdate(message);});
connect(jCore,&JasonCore::reportError,[=](int severity,QString message){this->reportError(severity,message);});
QJsonObject mainTree = jDoc.object();
if((mainTree.isEmpty())||(jDoc.isEmpty())){
// sendProgressTextUpdate(tr("No objects found. Will not proceed."));
return 1;
}
QVariantMap *mainMap = new QVariantMap(mainTree.toVariantMap());
getMap(mainMap,totalMap,activeOpts,jCore);
QList<QVariant> shellOpts = activeOpts->getOption("shell.properties");
QProcessEnvironment sysEnv = QProcessEnvironment::systemEnvironment();
for(QVariant opt : shellOpts){
QMap<QString,QVariant> optMap = opt.toMap();
for(QString var : optMap.value("import-env-variables").toString().split(",")){
varHandler->variableHandle(var,sysEnv.value(var));
}
for(QString key : optMap.keys()){
if(key=="shell")
shellString = optMap.value(key).toString();
if(key=="shell.argument")
shellArgString = optMap.value(key).toString();
}
}
QList<QVariant> jOpts = activeOpts->getOption("global.jason-opts");
for(QVariant optMap : jOpts){
QMap<QString,QVariant> opts = optMap.toMap();
for(QString optkey : opts.keys())
windowOpts.insert(optkey,opts.value(optkey));
}
runQueue = jCore->resolveDependencies(totalMap,activeOpts);
if(runQueue->getQueue().size()>0)
b_hasCompleted = true;
return 0;
}
void Wagnis::validateRegistrationData(const QByteArray ®istrationData, const bool &saveData)
{
qDebug() << "Wagnis::validateRegistrationData";
QJsonDocument jsonDocument = QJsonDocument::fromJson(registrationData);
if (jsonDocument.isObject()) {
QJsonObject responseObject = jsonDocument.object();
QVariantMap registrationInformation = responseObject.toVariantMap();
QString registrationContent = registrationInformation.value("registration").toString();
QString registrationSignature = registrationInformation.value("signature").toString();
qDebug() << "[Wagnis] Payload: " << registrationContent;
qDebug() << "[Wagnis] Signature: " << registrationSignature;
QJsonDocument registrationContentJson = QJsonDocument::fromJson(registrationContent.toUtf8());
bool wagnisIdVerified = false;
if (registrationContentJson.isObject()) {
QVariantMap wagnisInformation = registrationContentJson.object().toVariantMap();
if ( wagnisInformation.value("id").toString() == this->wagnisId ) {
qDebug() << "[Wagnis] ID verified!";
wagnisIdVerified = true;
}
}
if (wagnisIdVerified && isSignatureValid(registrationContent, registrationSignature)) {
qDebug() << "[Wagnis] Registration valid!";
this->validatedRegistration = registrationContentJson.object().toVariantMap();
QDateTime registrationTime = QDateTime::fromString(this->validatedRegistration.value("timestamp").toString(), "yyyy-MM-dd hh:mm:ss");
QDateTime currentTime = QDateTime::currentDateTime();
this->remainingSeconds = 1209600 - registrationTime.secsTo(currentTime);
if (this->remainingSeconds < 0 ) {
this->remainingSeconds = 0;
}
emit registrationValid(this->validatedRegistration);
if (saveData) {
QFile registrationFile(getRegistrationFileName());
if (registrationFile.open(QIODevice::WriteOnly | QIODevice::Text)) {
qDebug() << "[Wagnis] Writing registration file to " << registrationFile.fileName();
registrationFile.write(registrationData);
registrationFile.close();
}
}
} else {
qDebug() << "[Wagnis] Registration INVALID!";
emit registrationInvalid();
}
}
}
void Wagnis::handleGetIpInfoFinished()
{
qDebug() << "Wagnis::handleGetIpInfoFinished";
QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
reply->deleteLater();
if (reply->error() != QNetworkReply::NoError) {
return;
}
QJsonDocument jsonDocument = QJsonDocument::fromJson(reply->readAll());
if (jsonDocument.isObject()) {
QJsonObject responseObject = jsonDocument.object();
this->ipInfo = responseObject.toVariantMap();
qDebug() << "[Wagnis] Country: " << ipInfo.value("country").toString();
}
}
void RequestPlan::parseDates(QNetworkReply *reply)
{
QString strReply= (QString)reply->readAll();
if(strReply == "[]"){
emit noPlansAvailable();
}else{
QJsonDocument doc = QJsonDocument::fromJson(strReply.toUtf8());
QJsonArray allDates = doc.array();
foreach (QJsonValue date, allDates) {
QJsonObject dateObj = date.toObject();
QVariantMap dateMap = dateObj.toVariantMap();
emit datesReceived(dateMap);
}
}
bool Config::load(){
QFile configFile("config/liri-config.json");
if (!configFile.open(QIODevice::ReadOnly)) {
qWarning("Couldn't open config file.");
return false;
}
QByteArray jsonData = configFile.readAll();
QJsonDocument configDoc (QJsonDocument::fromJson(jsonData));
auto json = configDoc.object();
QJsonObject pluginsObject = json["plugins"].toObject();
this->plugins = pluginsObject.toVariantMap();
return true;
}
QString ParticleEffectEntityItem::getAnimationSettings() const {
// the animations setting is a JSON string that may contain various animation settings.
// if it includes fps, frameIndex, or running, those values will be parsed out and
// will over ride the regular animation settings
QString value = _animationSettings;
QJsonDocument settingsAsJson = QJsonDocument::fromJson(value.toUtf8());
QJsonObject settingsAsJsonObject = settingsAsJson.object();
QVariantMap settingsMap = settingsAsJsonObject.toVariantMap();
QVariant fpsValue(getAnimationFPS());
settingsMap["fps"] = fpsValue;
QVariant frameIndexValue(getAnimationFrameIndex());
settingsMap["frameIndex"] = frameIndexValue;
QVariant runningValue(getAnimationIsPlaying());
settingsMap["running"] = runningValue;
QVariant firstFrameValue(getAnimationFirstFrame());
settingsMap["firstFrame"] = firstFrameValue;
QVariant lastFrameValue(getAnimationLastFrame());
settingsMap["lastFrame"] = lastFrameValue;
QVariant loopValue(getAnimationLoop());
settingsMap["loop"] = loopValue;
QVariant holdValue(getAnimationHold());
settingsMap["hold"] = holdValue;
QVariant startAutomaticallyValue(getAnimationStartAutomatically());
settingsMap["startAutomatically"] = startAutomaticallyValue;
settingsAsJsonObject = QJsonObject::fromVariantMap(settingsMap);
QJsonDocument newDocument(settingsAsJsonObject);
QByteArray jsonByteArray = newDocument.toJson(QJsonDocument::Compact);
QString jsonByteString(jsonByteArray);
return jsonByteString;
}
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();
}
//******************************************************************************************
//function: doChallenge
//params: const QString &lpzUserName
//return: QJsonObject
//Description:
//******************************************************************************************
QJsonObject WSClient::doChallenge(const QString &lpzUserName)
{
QHash<QString, QString> params;
params.insert("username", lpzUserName);
QJsonObject response = Get("getchallenge", params);
params.clear();
if ( !response.isEmpty() ) {
QVariantMap map_json = response.toVariantMap();
QVariant success = map_json.value("success");
if ( success.toBool() ) {
response = response.value("result").toObject();
}
else {
QJsonObject error = response.value("error").toObject();
throw WSClientException( error );
}
}
return response;
}
