QVariantMap RenderableModelEntityItem::parseTexturesToMap(QString textures) {
// If textures are unset, revert to original textures
if (textures.isEmpty()) {
return _originalTextures;
}
// Legacy: a ,\n-delimited list of filename:"texturepath"
if (*textures.cbegin() != '{') {
textures = "{\"" + textures.replace(":\"", "\":\"").replace(",\n", ",\"") + "}";
}
QJsonParseError error;
QJsonDocument texturesJson = QJsonDocument::fromJson(textures.toUtf8(), &error);
// If textures are invalid, revert to original textures
if (error.error != QJsonParseError::NoError) {
qCWarning(entitiesrenderer) << "Could not evaluate textures property value:" << textures;
return _originalTextures;
}
QVariantMap texturesMap = texturesJson.toVariant().toMap();
// If textures are unset, revert to original textures
if (texturesMap.isEmpty()) {
return _originalTextures;
}
return texturesJson.toVariant().toMap();
}
QString Posterous::getAuthToken(const QUrl &localUrl)
{
QUrl url(QLatin1String("http://posterous.com/api/2/auth/token"));
QString login = PosterousSettings::login();
QString pass = Choqok::PasswordManager::self()->readPassword(QStringLiteral("posterous_%1").arg(PosterousSettings::login()));
KIO::StoredTransferJob *job = KIO::storedGet(url, KIO::Reload, KIO::HideProgressInfo);
job->addMetaData(QLatin1String("customHTTPHeader"),
QLatin1String("Authorization: Basic ") + QLatin1String(QStringLiteral("%1:%2").arg(login).arg(pass).toUtf8().toBase64()));
job->exec();
if (!job->error()) {
const QByteArray data = job->data();
const QJsonDocument json = QJsonDocument::fromJson(data);
if (!json.isNull()) {
QVariantMap map = json.toVariant().toMap();
if (map.contains(QLatin1String("api_token"))) {
QString tkn = map.value(QLatin1String("api_token")).toString();
return tkn;
} else {
Q_EMIT uploadingFailed(localUrl, map.value(QLatin1String("error")).toString());
qWarning() << "Parse error:" << data;
}
}
} else {
qCritical() << "Job error:" << job->errorString();
}
return QString();
}
void EventPlugin::onDbEvent(const QString &name, QSqlDriver::NotificationSource source, const QVariant &payload)
{
qfLogFuncFrame() << "name:" << name << "source:" << source << "payload:" << payload;
if(name == QLatin1String(DBEVENT_NOTIFY_NAME)) {
if(source == QSqlDriver::OtherSource) {
QJsonDocument jsd = QJsonDocument::fromJson(payload.toString().toUtf8());
QVariantMap m = jsd.toVariant().toMap();
QString domain = m.value(QStringLiteral("domain")).toString();
if(domain.isEmpty()) {
qfWarning() << "DbNotify with invalid domain, payload:" << payload.toString();
return;
}
QString event_name = m.value(QStringLiteral("event")).toString();
if(event_name.isEmpty()) {
qfWarning() << "DbNotify with invalid event name, payload:" << payload.toString();
return;
}
if(event_name == eventName()) {
QVariant pl = m.value(QStringLiteral("payload"));
qfDebug() << "emitting domain:" << domain << "payload:" << pl;
emit dbEventNotify(domain, pl);
}
}
else {
//qfDebug() << "self db notify";
}
}
}
Client::MusicRes Client::music_daily() {
QJsonDocument root;
// Build a URI and get the contents
// The fist parameter forms the path part of the URI.
// The second parameter forms the CGI parameters.
get( { "browse", "all", "music" }, { { "format", "json" }
}, root);
// https://api2.sofurry.com/browse/all/photos?format=json
MusicRes result;
QVariantMap variant = root.toVariant().toMap();
for (const QVariant &i : variant["items"].toList()) {
QVariantMap item = i.toMap();
// Extract the temperature data
// Add a result to the weather list
result.musics.emplace_back(
Music {
item["thumbnail"].toString().toStdString(),
item["title"].toString().toStdString(),
item["author"].toString().toStdString(),
item["authorID"].toString().toStdString(),
item["link"].toString().toStdString(),
item["tags"].toString().toStdString(),
item["description"].toString().toStdString(),
});
}
return result;
}
QVariant loadJSON(const std::string& json) {
QJsonDocument doc = QJsonDocument::fromJson(toQString(json).toUtf8());
if (doc.isNull()) {
LOG_FREE_AND_THROW("openstudio.Json","Error parsing JSON");
}
return doc.toVariant();
}
Client::Email Client::messages_set_unread(const std::string& id, bool unread) {
std::string command = unread ? "addLabelIds" : "removeLabelIds";
std::string payload = "{ \"" + command + "\": [\"UNREAD\"] }";
QJsonDocument root;
post({ "users", "me", "messages", id, "modify" }, {}, payload, root);
return parse_email(root.toVariant());
}
void
YTVideoUrlFetcher::onProcessFinished(int code, QProcess::ExitStatus status)
{
qDebug() << "youtube-dl process finished, status:" << status
<< ", exit code:" << code;
if (status == QProcess::NormalExit && code == 0) {
QByteArray rawJson = _process->readAllStandardOutput();
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(rawJson, &error);
if (error.error != QJsonParseError::NoError) {
qCritical() << "JSON parse error:" << error.errorString();
emit failure();
} else {
Q_ASSERT(!doc.isNull());
QVariantMap response = parseResponse(doc);
if (!response.isEmpty()) {
QVariantMap map = doc.toVariant().toMap();
Q_ASSERT(!map.isEmpty() && map.contains("id"));
_response_cache.insert(map["id"].toString(), new QVariantMap(response));
emit success(response);
} else {
emit failure();
}
}
} else {
qCritical() << "YouTubeDL process did not finish cleanly:"
<< _process->readAllStandardError();
emit failure();
}
delete _process;
_process = NULL;
}
void DefaultReminderAttribute::deserialize(const QByteArray &data)
{
QJsonDocument json = QJsonDocument::fromJson(data);
if (json.isNull()) {
return;
}
QVariant var = json.toVariant();
const QVariantList list = var.toList();
for (const QVariant &l : list) {
QVariantMap reminder = l.toMap();
KGAPI2::ReminderPtr rem(new KGAPI2::Reminder);
if (reminder[QStringLiteral("type")].toString() == QLatin1String("display")) {
rem->setType(KCalCore::Alarm::Display);
} else if (reminder[QStringLiteral("type")].toString() == QLatin1String("email")) {
rem->setType(KCalCore::Alarm::Email);
}
KCalCore::Duration offset(reminder[QStringLiteral("time")].toInt(), KCalCore::Duration::Seconds);
rem->setStartOffset(offset);
m_reminders << rem;
}
}
Client::LabelList Client::get_labels() {
if (config_->labels.empty()) {
QJsonDocument root;
get({ "users", "me", "labels" }, {}, root);
LabelList::iterator iter;
QVariantMap variant = root.toVariant().toMap();
QVariantList labels = variant["labels"].toList();
for (const QVariant &i : labels) {
QVariantMap label_map = i.toMap();
if (label_map["messageListVisibility"] == "show") {
iter = config_->labels.begin();
std::string name = label_map["name"].toString().toStdString();
// Sort by names, case insensitively
while (iter != config_->labels.end() &&
strcasecmp(iter->second.c_str(), name.c_str()) <= 0)
iter += 1;
config_->labels.insert(iter,
std::make_pair(label_map["id"].toString().toStdString(),
name));
}
}
}
return config_->labels;
}
QMap<QUrl,QUrl>* Fetcher::parseJson(QByteArray json)
{
QMap<QUrl,QUrl>* urls = new QMap<QUrl,QUrl>();
QJsonDocument jsonDoc = QJsonDocument::fromJson(json);
QVariantMap result = jsonDoc.toVariant().toMap();
QVariantMap responseData = (*result.find("responseData")).toMap();
QVariantList resultList = (*responseData.find("results")).toList();
QVariantMap tmp;
QVariant tbUrl,imgUrl;
QString tbUrlString,imgUrlString;
QVariantList::iterator it;
for(it = resultList.begin() ; it != resultList.end() ; ++it)
{
tmp = (*it).toMap();
tbUrl = (*tmp.find("tbUrl"));
imgUrl = (*tmp.find("unescapedUrl"));
tbUrlString = tbUrl.toString();
imgUrlString = imgUrl.toString();
urls->insert(QUrl(imgUrlString),QUrl(tbUrlString));
}
return urls;
}
BookmarkItem* ChromeImporter::importBookmarks()
{
const QByteArray data = m_file.readAll();
m_file.close();
QJsonParseError err;
QJsonDocument json = QJsonDocument::fromJson(data, &err);
const QVariant res = json.toVariant();
if (err.error != QJsonParseError::NoError || res.type() != QVariant::Map) {
setError(BookmarksImporter::tr("Cannot parse JSON file!"));
return 0;
}
QVariantMap rootMap = res.toMap().value("roots").toMap();
BookmarkItem* root = new BookmarkItem(BookmarkItem::Folder);
root->setTitle("Chrome Import");
BookmarkItem* toolbar = new BookmarkItem(BookmarkItem::Folder, root);
toolbar->setTitle(rootMap.value("bookmark_bar").toMap().value("name").toString());
readBookmarks(rootMap.value("bookmark_bar").toMap().value("children").toList(), toolbar);
BookmarkItem* other = new BookmarkItem(BookmarkItem::Folder, root);
other->setTitle(rootMap.value("other").toMap().value("name").toString());
readBookmarks(rootMap.value("other").toMap().value("children").toList(), other);
BookmarkItem* synced = new BookmarkItem(BookmarkItem::Folder, root);
synced->setTitle(rootMap.value("synced").toMap().value("name").toString());
readBookmarks(rootMap.value("synced").toMap().value("synced").toList(), other);
return root;
}
QVariant ContentItemInterfacePrivate::parseReplyDataVariant(const QByteArray &replyData, bool *ok)
{
QVariant parsed;
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
QJson::Parser jsonParser;
parsed = jsonParser.parse(replyData, ok);
if (!*ok) {
qWarning() << Q_FUNC_INFO << "Error parsing JSON file:" << jsonParser.errorString()
<< "at" << jsonParser.errorLine();
}
#else
QJsonParseError jsonError;
QJsonDocument jsonDocument = QJsonDocument::fromJson(replyData, &jsonError);
*ok = !jsonDocument.isEmpty();
if (!*ok) {
qWarning() << Q_FUNC_INFO << "Error parsing JSON file:" << jsonError.errorString()
<< "at" << jsonError.offset;
}
parsed = jsonDocument.toVariant();
#endif
if (!*ok) {
parsed.clear();
}
return parsed;
}
bool LoadFromJSON(QVariantMap &data, QIODevice &f, const char *magicIdentifier, uint32_t magicVersion)
{
QByteArray json = f.readAll();
if(json.isEmpty())
{
qCritical() << "Read invalid empty JSON data from file " << f.errorString();
return false;
}
QJsonDocument doc = QJsonDocument::fromJson(json);
if(doc.isEmpty() || doc.isNull())
{
qCritical() << "Failed to convert file to JSON document";
return false;
}
data = doc.toVariant().toMap();
if(data.isEmpty() || !data.contains(magicIdentifier))
{
qCritical() << "Converted config data is invalid or unrecognised";
return false;
}
if(data[magicIdentifier].toUInt() != magicVersion)
{
qCritical() << "Converted config data is not the right version";
return false;
}
return true;
}
Query *Query::fromJSON(const QByteArray &json)
{
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(json, &error);
if (doc.isNull()) {
qWarning() << "Could not parse json query" << error.errorString();
return 0;
}
QVariantMap result = doc.toVariant().toMap();
const QString type = result[QStringLiteral("type")].toString().toLower();
if (type != QLatin1String("contact")) {
qWarning() << "Can only handle contact queries";
return 0;
}
ContactQuery *cq = new ContactQuery();
cq->matchName(result[QStringLiteral("name")].toString());
cq->matchNickname(result[QStringLiteral("nick")].toString());
cq->matchEmail(result[QStringLiteral("email")].toString());
cq->matchUID(result[QStringLiteral("uid")].toString());
cq->match(result[QStringLiteral("$")].toString());
const QString criteria = result[QStringLiteral("matchCriteria")].toString().toLower();
if (criteria == QLatin1String("exact")) {
cq->setMatchCriteria(ContactQuery::ExactMatch);
} else if (criteria == QLatin1String("startswith")) {
cq->setMatchCriteria(ContactQuery::StartsWithMatch);
}
cq->setLimit(result[QStringLiteral("limit")].toInt());
return cq;
}
QVariant JsonTranslationService::parseJson(const QByteArray &json)
{
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
QString js;
js.reserve(json.size() + 2);
js.append("(").append(QString::fromUtf8(json)).append(")");
static QScriptEngine engine;
if (!engine.canEvaluate(js)) {
m_error = tr("Couldn't parse response from the server because of an error: \"%1\"")
.arg(tr("Can't evaluate JSON data"));
return QVariant();
}
QScriptValue data = engine.evaluate(js);
if (engine.hasUncaughtException()) {
m_error = tr("Couldn't parse response from the server because of an error: \"%1\"")
.arg(engine.uncaughtException().toString());
return QVariant();
}
return data.toVariant();
#else
QJsonParseError err;
QJsonDocument doc = QJsonDocument::fromJson(json, &err);
if (err.error != QJsonParseError::NoError) {
m_error = tr("Couldn't parse response from the server because of an error: \"%1\"")
.arg(err.errorString());
return QVariant();
}
return doc.toVariant();
#endif
}
void Posterous::slotUpload(KJob *job)
{
QUrl localUrl = mUrlMap.take(job);
if (job->error()) {
qCritical() << "Job Error:" << job->errorString();
Q_EMIT uploadingFailed(localUrl, job->errorString());
return;
} else {
KIO::StoredTransferJob *stj = qobject_cast<KIO::StoredTransferJob *>(job);
//qDebug() << stj->data();
const QJsonDocument json = QJsonDocument::fromJson(stj->data());
if (!json.isNull()) {
const QVariantMap map = json.toVariant().toMap();
if (map.contains(QLatin1String("error"))) {
Q_EMIT uploadingFailed(localUrl, map.value(QLatin1String("error")).toString());
} else {
if (PosterousSettings::oauth()) {
Q_EMIT mediumUploaded(localUrl, map.value(QLatin1String("url")).toString());
}
if (PosterousSettings::basic()) {
Q_EMIT mediumUploaded(localUrl, map.value(QLatin1String("full_url")).toString());
}
}
} else {
Q_EMIT uploadingFailed(localUrl, i18n("Malformed response"));
qWarning() << "Parse error:" << stj->data();
}
}
}
Client::CodeRes Client::code(const string &query, const string &repo = NULL)
{
// This is the method that we will call from the Query class.
// It connects to an HTTP source and returns the results.
// In this case we are going to retrieve JSON data.
QJsonDocument root;
// Build a URI and get the contents.
// The fist parameter forms the path part of the URI.
// The second parameter forms the CGI parameters.
get(
{ "search", "code" },
{ { "q", query + "+repo:" + repo } },
root);
// e.g. http://api.openweathermap.org/data/2.5/weather?q=QUERY&units=metric
CodeRes result;
// Read out the city we found
QVariantMap variant = root.toVariant().toMap();
result.total_count = variant["total_count"].toUInt();
// Read the Users
QVariantList items = variant["items"].toList();
for (const QVariant &i : items) {
QVariantMap item = i.toMap();
QVariantMap repository = item["repository"].toMap();
QVariantMap owner = repository["owner"].toMap();
result.codes.emplace_back(
Code {
item["name"].toString().toStdString(),
item["path"].toString().toStdString(),
item["html_url"].toString().toStdString(),
Repository {
Owner {
owner["login"].toString().toStdString(),
owner["id"].toUInt(),
owner["avatar_url"].toString().toStdString(),
owner["html_url"].toString().toStdString()
},
repository["name"].toString().toStdString(),
repository["full_name"].toString().toStdString(),
repository["description"].toString().toStdString(),
repository["private"].toBool(),
repository["fork"].toBool(),
repository["html_url"].toString().toStdString(),
repository["language"].toString().toStdString(),
repository["forks_count"].toUInt(),
repository["stargazers_count"].toUInt(),
repository["watchers_count"].toUInt(),
repository["open_issues_count"].toUInt(),
repository["created_at"].toString().toStdString(),
repository["pushed_at"].toString().toStdString()
}
}
);
}
return result;
}
virtual void OnObserve(const char* aTopic, const PRUnichar* aData) {
// LOGT("aTopic: %s, data: %s", aTopic, NS_ConvertUTF16toUTF8(aData).get());
QString data((QChar*)aData);
if (!data.startsWith('{') && !data.startsWith('[') && !data.startsWith('"')) {
QVariant vdata = QVariant::fromValue(data);
Q_EMIT q->recvObserve(aTopic, vdata);
return;
}
bool ok = true;
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
QJson::Parser parser;
QVariant vdata = parser.parse(data.toUtf8(), &ok);
#else
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(data.toUtf8(), &error);
ok = error.error == QJsonParseError::NoError;
QVariant vdata = doc.toVariant();
#endif
if (ok) {
// LOGT("mesg:%s, data:%s", aTopic, data.toUtf8().data());
Q_EMIT q->recvObserve(aTopic, vdata);
} else {
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
LOGT("parse: s:'%s', err:%s, errLine:%i", data.toUtf8().data(), parser.errorString().toUtf8().data(), parser.errorLine());
#else
LOGT("parse: s:'%s', err:%s, errLine:%i", data.toUtf8().data(), error.errorString().toUtf8().data(), error.offset);
#endif
}
}
Client::RepositoryRes Client::repositories(const string& query,
bool name, bool description, bool readme) {
// This is the method that we will call from the Query class.
// It connects to an HTTP source and returns the results.
// In this case we are going to retrieve JSON data.
QJsonDocument root;
// Build a URI and get the contents.
// The fist parameter forms the path part of the URI.
// The second parameter forms the CGI parameters.
std::string in = "+in:";
if(name) in += "name,";
if(description) in += "description,";
if(readme) in += "readme,";
in = in.substr(0, in.size()-1);
get(
{ "search", "repositories" },
{ { "q", query + in } },
root);
// e.g. http://api.openweathermap.org/data/2.5/weather?q=QUERY&units=metric
RepositoryRes result;
// Read out the city we found
QVariantMap variant = root.toVariant().toMap();
result.total_count = variant["total_count"].toUInt();
// Read the Users
QVariantList items = variant["items"].toList();
for (const QVariant &i : items) {
QVariantMap item = i.toMap();
QVariantMap owner = item["owner"].toMap();
result.repositories.emplace_back(
Repository {
Owner {
owner["login"].toString().toStdString(),
owner["id"].toUInt(),
owner["avatar_url"].toString().toStdString(),
owner["html_url"].toString().toStdString()
},
item["name"].toString().toStdString(),
item["full_name"].toString().toStdString(),
item["description"].toString().toStdString(),
item["private"].toBool(),
item["fork"].toBool(),
item["html_url"].toString().toStdString(),
item["language"].toString().toStdString(),
item["forks_count"].toUInt(),
item["stargazers_count"].toUInt(),
item["watchers_count"].toUInt(),
item["open_issues_count"].toUInt(),
item["created_at"].toString().toStdString(),
item["pushed_at"].toString().toStdString()
}
);
}
return result;
}
void OpenSearchEngine::suggestionsObtained()
{
const QByteArray response = m_suggestionsReply->readAll();
m_suggestionsReply->close();
m_suggestionsReply->deleteLater();
m_suggestionsReply = 0;
QJsonParseError err;
QJsonDocument json = QJsonDocument::fromJson(response, &err);
const QVariant res = json.toVariant();
if (err.error != QJsonParseError::NoError || res.type() != QVariant::List)
return;
const QVariantList list = res.toList();
if (list.size() < 2)
return;
QStringList out;
foreach (const QVariant &v, list.at(1).toList())
out.append(v.toString());
emit suggestions(out);
}
void NetLogicMainProcess::task(NetCommunicationModule &NCM)
{
QTcpSocket *sock = NCM.sock;
QJsonParseError error;
QJsonDocument jsonDocument = QJsonDocument::fromJson(NCM.data, &error);
if (error.error != QJsonParseError::NoError){
qDebug() << "json parse error! in" << __FUNCSIG__;
qDebug() << "data of recieving is :\"" << NCM.data << "\"";
return;
}
QVariantMap data = jsonDocument.toVariant().toMap();
int protocol = Packet::Protocol(data);
auto pck = net::get(protocol);
if (!pck){
qDebug() << "非法协议号：" << protocol;
}
pck->write(data);
//事务开始
static Error err;
err.opt() = protocol;
transactionObject->lock(pck, sock, &err);
try{
(transactionObject->*transactionObject->getTransactionMap()[(NetCommunicationProtocol)protocol])();
}
catch (...){
qDebug() << "事务出现错误！协议号：" << protocol << "协议语言：" << net::ProtocolToString(protocol);
return;
}
//事务结束
anyPacket = transactionObject->unlockForResponse();
//处理Error，发送ServerBackPacket AND 客户端需要的数据
this->sendMsgDependsOnError(&err, sock);
}
void ExtScript::readJsonFilters()
{
QString fileName = QStandardPaths::locate(
QStandardPaths::GenericDataLocation,
QString(
"awesomewidgets/scripts/awesomewidgets-extscripts-filters.json"));
qCInfo(LOG_LIB) << "Filters file" << fileName;
QFile jsonFile(fileName);
if (!jsonFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
qCWarning(LOG_LIB) << "Could not open" << fileName;
return;
}
QString jsonText = jsonFile.readAll();
jsonFile.close();
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonText.toUtf8(), &error);
if (error.error != QJsonParseError::NoError) {
qCWarning(LOG_LIB) << "Parse error" << error.errorString();
return;
}
jsonFilters = jsonDoc.toVariant().toMap();
qCInfo(LOG_LIB) << "Filters" << jsonFilters;
}
Client::Email Client::send_message(const Client::Contact& to, const std::string& subject,
const std::string& body, const std::string& from_name,
const std::string& ref_id, const std::string& thread_id) {
QByteArray message;
Contact from;
from.address = users_address();
from.name = from_name;
add_rfc822_header(message, "In-Reply-To: " + ref_id);
add_rfc822_header(message, "References: " + ref_id);
if (from.address != "")
add_rfc822_header(message, "From: " + rfc822_address(from));
// Otherwise, Google will add a From header for us.
add_rfc822_header(message, "To: " + rfc822_address(to));
add_rfc822_header(message, "Subject: " + encode_rfc2074(subject));
end_rfc822_header(message, config_->user_agent);
add_rfc822_body(message, body);
std::string request_body = "{ \"raw\": \"" +
std::string(message.toBase64(QByteArray::Base64UrlEncoding).constData()) +
"\", \"threadId\": \"" + thread_id + "\" }";
std::cerr << request_body << std::endl;
QJsonDocument root;
post({ "users", "me", "messages", "send" }, {}, request_body, root);
return parse_email(root.toVariant());
}
void DevicePluginNetworkInfo::actionDataReady(const ActionId &actionId, const QByteArray &data)
{
// Convert the rawdata to a json document
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
// Check if we got a valid JSON document
if(error.error != QJsonParseError::NoError) {
qCWarning(dcNetworkInfo) << "Failed to parse JSON data" << data << ":" << error.errorString();
// the action execution is finished, and was not successfully
emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorHardwareFailure);
return;
}
// print the fetched data in json format to stdout
qCDebug(dcNetworkInfo) << jsonDoc.toJson();
// Get the device for this action
Device *device = m_asyncActions.take(actionId);
// Parse the data and update the states of our device
QVariantMap dataMap = jsonDoc.toVariant().toMap();
// Set the city state
if (dataMap.contains("city")) {
device->setStateValue(cityStateTypeId, dataMap.value("city").toString());
}
// Set the country state
if (dataMap.contains("countryCode")) {
device->setStateValue(countryStateTypeId, dataMap.value("countryCode").toString());
}
// Set the wan ip
if (dataMap.contains("query")) {
device->setStateValue(addressStateTypeId, dataMap.value("query").toString());
}
// Set the time zone state
if (dataMap.contains("timezone")) {
device->setStateValue(timeZoneStateTypeId, dataMap.value("timezone").toString());
}
// Set the longitude state
if (dataMap.contains("lon")) {
device->setStateValue(lonStateTypeId, dataMap.value("lon").toDouble());
}
// Set the latitude state
if (dataMap.contains("lat")) {
device->setStateValue(latStateTypeId, dataMap.value("lat").toDouble());
}
qCDebug(dcNetworkInfo) << "Action" << actionId << "execution finished successfully.";
// Emit the successfull action execution result to the device manager
emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorNoError);
}
std::string Client::users_address() {
if (config_->users_address.empty()) {
QJsonDocument root;
get({ "users", "me", "profile" }, {}, root);
config_->users_address = root.toVariant().toMap()["emailAddress"].toString().toStdString();
}
return config_->users_address;
}
QList<Course> IversityClient::courses(const QString &query)
{
QList<Course> list;
QByteArray data;
net::Uri::Path path;
net::Uri::QueryParameters params;
qCDebug(Iversity) << "Download started...";
if (data.isNull())
get( path, params, data);
qCDebug(Iversity) << "Data received:" << data.length() << "bytes";
QJsonDocument root = QJsonDocument::fromJson(data);
QVariantMap variant = root.toVariant().toMap();
QList<QVariant> courses = variant["courses"].toList();
qCDebug(Iversity) << "Element count:" << courses.length();
SearchEngine se(query);
for (const QVariant &i : courses)
{
QVariantMap map = i.toMap();
Course course;
course.id = map["id"].toString();
course.slug = map["url"].toString();
course.title = map["title"].toString();
course.description = map["description"].toString();
course.headline = map["subtitle"].toString();
course.art = map["cover"].toString();
course.link = map["url"].toString();
course.extra = grabExtra(map);
course.video = map["trailer_video"].toString();
QList<QVariant> instructors = map["instructors"].toList();
for (const QVariant& j : instructors)
{
QVariantMap imap = j.toMap();
Instructor instr;
instr.image = imap["image"].toString();
instr.bio = imap["biography"].toString();
instr.name = imap["name"].toString();
course.instructors.append(instr);
}
course.departments.append(map["discipline"].toString());
//qCDebug(Iversity) << "Category count: " << course.departments;
//qCDebug(Iversity) << "Instr count: " << course.instructors.size();
if (query.isEmpty() || se.isMatch(course))
list.append(course);
}
return list;
}
QVariant TaskScheduler::loadFromFile(QString fileName)
{
QFile file(fileName);
file.open(QIODevice::ReadOnly);
QByteArray fileContent = file.readAll();
QJsonDocument document = QJsonDocument::fromJson(fileContent);
file.close();
return document.toVariant();
}
void Server::processRequest(const QList<QByteArray> &request)
{
static quint64 counter = 0;
counter++;
// qDebug() << "Replier::requestReceived> " << counter << request;
QJsonDocument doc = QJsonDocument::fromJson(request[0]);
emit requestReceived(doc.toVariant());
}
void QSerienJunkiesReply::seriesSearchReplyFinished()
{
QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
if(!reply)
return;
QJsonParseError jsonError;
QJsonDocument jsonDocument = QJsonDocument::fromJson(reply->readAll(), &jsonError);
reply->deleteLater();
reply = nullptr;
if(jsonError.error != QJsonParseError::NoError) {
data->errorString = "The returned JSON was not valid: "+jsonError.errorString();
emit error();
return;
}
QVariant v = jsonDocument.toVariant();
if(static_cast<QMetaType::Type>(v.type()) != QMetaType::QVariantList) {
data->errorString = "The returned JSON is no list.";
emit error();
return;
}
QVariantList resultList = v.toList();
data->seasonCount = resultList.size();
if(data->seasonCount == 0) {
emit finished();
return;
}
// Get the given URLs, because the actual URL of a series is in the "Location" header of these URLs.
foreach(QVariant result, resultList) {
QVariantList list = result.toList();
if(list.size() != 2)
continue;
Series r;
r.id = list.at(0).toInt();
r.name = list.at(1).toString();
data->series.append(r);
QUrl url(QString("http://serienjunkies.org/?cat=%1").arg(r.id));
QNetworkReply *locationReply = QSerienJunkies::networkAccessManager()->get(QNetworkRequest(url));
locationReply->setProperty("index", data->series.size() - 1);
QObject::connect(locationReply, &QNetworkReply::finished,
this, &QSerienJunkiesReply::seriesLocationReplyFinished);
QObject::connect(locationReply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(onError()));
QObject::connect(this, &QObject::destroyed,
locationReply, &QNetworkReply::deleteLater);
}
Client::UserRes Client::users(const string& query) {
// This is the method that we will call from the Query class.
// It connects to an HTTP source and returns the results.
// In this case we are going to retrieve JSON data.
QJsonDocument root;
// Build a URI and get the contents.
// The fist parameter forms the path part of the URI.
// The second parameter forms the CGI parameters.
get(
{ "search", "users" },
{ { "q", query } },
root);
// e.g. http://api.openweathermap.org/data/2.5/weather?q=QUERY&units=metric
UserRes result;
// Read out the city we found
QVariantMap variant = root.toVariant().toMap();
result.total_count = variant["total_count"].toUInt();
// Read the Users
QVariantList items = variant["items"].toList();//.first().toMap();
for (const QVariant &i : items) {
QVariantMap item = i.toMap();
result.users.emplace_back(
User {
item["id"].toUInt(),
item["avatar_url"].toString().toStdString(),
item["html_url"].toString().toStdString(),
item["followers_url"].toString().toStdString(),
item["following_url"].toString().toStdString(),
item["gists_url"].toString().toStdString(),
item["starred_url"].toString().toStdString(),
item["organizations_url"].toString().toStdString(),
item["repos_url"].toString().toStdString(),
item["name"].toString().toStdString(),
item["company"].toString().toStdString(),
item["blog"].toString().toStdString(),
item["location"].toString().toStdString(),
item["email"].toString().toStdString(),
item["hireable"].toBool(),
item["bio"].toString().toStdString(),
item["public_repos"].toUInt(),
item["public_gists"].toUInt(),
item["followers"].toUInt(),
item["following"].toUInt()
}
);
}
return result;
}