void ConsoleSessionManager::onOpenConsoleSessionFinished(Invocation* invocation)
{
RESTInvocation* inv = qobject_cast<RESTInvocation*>(invocation);
if (!inv) {
ERROR("Failed to cast to RESTInvocation");
invocation->deleteLater();
return;
}
// console might have responded an http error
if (inv->responseHttpStatusCode() != HTTPInvocationDefinition::OK_200)
{
emit consoleSessionOpenFailed(QString("HTTP Status Code:").append(inv->responseHttpStatusCode()));
return;
}
// or error data
QJsonDocument jsondoc(QJsonDocument::fromJson(inv->responseString().toLatin1()));
QJsonObject json = jsondoc.object();
if (json.contains("response_type") && json["response_type"] == "error")
{
QString errMsg = json["error_message"].toString();
emit consoleSessionOpenFailed(QString("Console responded:") + errMsg);
}
if (json.contains("response_type") && json["response_type"] == "ok")
{
QString token = json["token"].toString(); // TODO: validation of this
openWebsocket(token);
}
inv->deleteLater();
}
void HeadData::fromJson(const QJsonObject& json) {
if (json.contains(JSON_AVATAR_HEAD_BLENDSHAPE_COEFFICIENTS)) {
auto jsonValue = json[JSON_AVATAR_HEAD_BLENDSHAPE_COEFFICIENTS];
if (jsonValue.isArray()) {
QVector<float> blendshapeCoefficients;
QJsonArray blendshapeCoefficientsJson = jsonValue.toArray();
for (const auto& blendshapeCoefficient : blendshapeCoefficientsJson) {
blendshapeCoefficients.push_back((float)blendshapeCoefficient.toDouble());
}
setBlendshapeCoefficients(blendshapeCoefficients);
} else if (jsonValue.isObject()) {
QJsonObject blendshapeCoefficientsJson = jsonValue.toObject();
for (const QString& name : blendshapeCoefficientsJson.keys()) {
float value = (float)blendshapeCoefficientsJson[name].toDouble();
setBlendshape(name, value);
}
} else {
qWarning() << "Unable to deserialize head json: " << jsonValue;
}
}
if (json.contains(JSON_AVATAR_HEAD_LOOKAT)) {
auto relativeLookAt = vec3FromJsonValue(json[JSON_AVATAR_HEAD_LOOKAT]);
if (glm::length2(relativeLookAt) > 0.01f) {
setLookAtPosition((_owningAvatar->getOrientation() * relativeLookAt) + _owningAvatar->getPosition());
}
}
if (json.contains(JSON_AVATAR_HEAD_ROTATION)) {
setHeadOrientation(quatFromJsonValue(json[JSON_AVATAR_HEAD_ROTATION]));
}
}
bool VDirectoryTree::pasteAvailable() const
{
QJsonObject obj = VUtils::clipboardToJson();
if (obj.isEmpty()) {
return false;
}
if (!obj.contains(ClipboardConfig::c_type)) {
return false;
}
ClipboardOpType type = (ClipboardOpType)obj[ClipboardConfig::c_type].toInt();
if (type != ClipboardOpType::CopyDir) {
return false;
}
if (!obj.contains(ClipboardConfig::c_magic)
|| !obj.contains(ClipboardConfig::c_isCut)
|| !obj.contains(ClipboardConfig::c_dirs)) {
return false;
}
int magic = obj[ClipboardConfig::c_magic].toInt();
if (!checkMagic(magic)) {
return false;
}
QJsonArray dirs = obj[ClipboardConfig::c_dirs].toArray();
return !dirs.isEmpty();
}
void ReverseHashDServer::processTextMessage(QString message) {
QWebSocket *pClient = qobject_cast<QWebSocket *>(sender());
std::cout << QDateTime::currentDateTimeUtc().toString().toStdString() << " [WS] <<< " << message.toStdString() << "\n";
QJsonDocument doc = QJsonDocument::fromJson(message.toUtf8());
QJsonObject jsonData = doc.object();
int id = 0;
if(jsonData.contains("id")){
id = jsonData["id"].toInt();
}
if(!jsonData.contains("cmd")){
this->sendMessageError(pClient, "cmd", id, Error(400, "Invalid command format (Not found cmd)"));
return;
}
QString cmd = jsonData["cmd"].toString();
if(m_mapCmdHandlers.contains(cmd)){
ICmdHandler *pCmdHandler = m_mapCmdHandlers[cmd];
pCmdHandler->handle(pClient, this, jsonData);
}else{
qDebug() << "Unknown command: " << cmd;
this->sendMessageError(pClient, cmd, id, Error(404, "Unknown command"));
}
}
bool autobots_toutiao::GetCode(const QByteArray& rp_data, QString& hash_code, QString& public_key)
{
QJsonParseError json_error;
QJsonDocument parse_doucment = QJsonDocument::fromJson(rp_data, &json_error);
if(json_error.error == QJsonParseError::NoError)
{
if(parse_doucment.isObject())
{
QJsonObject obj = parse_doucment.object();
if(obj.contains("hash"))
{
QJsonValue name_value = obj.take("hash");
if(name_value.isString())
{
hash_code = name_value.toString();
}
}
if(obj.contains("key"))
{
QJsonValue name_value = obj.take("key");
if(name_value.isString())
{
public_key = name_value.toString();
}
}
}
}
if (!hash_code.isEmpty() && !public_key.isEmpty())
{
return true;
}
return false;
}
static QGeoAddress parseAddressObject(const QJsonObject &object)
{
QGeoAddress address;
address.setText(object.value(QStringLiteral("display_name")).toString());
QJsonObject ao = object.value(QStringLiteral("address")).toObject();
// setCountry
address.setCountry(ao.value(QStringLiteral("country")).toString());
// setCountryCode
address.setCountryCode(ao.value(QStringLiteral("country_code")).toString());
// setState
address.setState(ao.value(QStringLiteral("state")).toString());
// setCity
if (ao.contains(QLatin1String("city")))
address.setCity(ao.value(QStringLiteral("city")).toString());
else if (ao.contains(QLatin1String("town")))
address.setCity(ao.value(QLatin1String("town")).toString());
else if (ao.contains(QLatin1String("village")))
address.setCity(ao.value(QLatin1String("village")).toString());
else
address.setCity(ao.value(QLatin1String("hamlet")).toString());
// setDistrict
address.setDistrict(ao.value(QStringLiteral("suburb")).toString());
// setPostalCode
address.setPostalCode(ao.value(QStringLiteral("postcode")).toString());
// setStreet
address.setStreet(ao.value(QStringLiteral("road")).toString());
return address;
}
VersionString extractOpenStudioVersion(const QVariant& variant) {
QJsonObject topLevel = QJsonDocument::fromVariant(variant).object();
if (topLevel.contains("metadata")) {
topLevel = topLevel["metadata"].toObject();
}
OptionalVersionString version;
if (topLevel.contains("openstudio_version")) {
version = VersionString(topLevel["openstudio_version"].toString().toStdString());
}
else if (topLevel.contains("version")) {
version = VersionString(topLevel["version"].toString().toStdString());
}
else {
LOG_FREE_AND_THROW("openstudio.core.Json","No version identifier found in QJSON variant.");
}
OS_ASSERT(version);
if (version.get() > VersionString(openStudioVersion())) {
LOG_FREE(Warn,"openstudio.Json","Loading json file from version " << version
<< " with OpenStudio version " << VersionString(openStudioVersion())
<< ". OpenStudio json files are not designed to be forwards-compatible. "
<< "Unexpected behavior may result.")
}
return version.get();
}
bool CategoryParser::parse(const QString &fileName)
{
m_exploreObject = QJsonObject();
m_tree.clear();
m_errorString.clear();
QFile mappingFile(fileName);
if (mappingFile.open(QIODevice::ReadOnly)) {
QJsonDocument document = QJsonDocument::fromJson(mappingFile.readAll());
if (document.isObject()) {
QJsonObject docObject = document.object();
if (docObject.contains(QLatin1String("offline_explore"))) {
m_exploreObject = docObject.value(QLatin1String("offline_explore"))
.toObject();
if (m_exploreObject.contains(QLatin1String("ROOT"))) {
processCategory(0, QString());
return true;
}
} else {
m_errorString = fileName + QLatin1String("does not contain the "
"offline_explore property");
return false;
}
} else {
m_errorString = fileName + QLatin1String("is not an json object");
return false;
}
}
m_errorString = QString::fromLatin1("Unable to open ") + fileName;
return false;
}
/**
* @brief Algorithm::initialize Loads the corresponding QJsonObject for this algorithm
* @param loader The plugin loader which loads the QJsonObject
* @return True, if all went well.
*/
bool Algorithm::initialize(QPluginLoader *loader) {
//read the QJsonObject parameter
if (!loader) return false;
QJsonObject tmp = loader->metaData();
if (tmp.isEmpty()) return false;
QJsonValue v = tmp.value("MetaData");
if (v.isUndefined()) return false;
QJsonObject o = v.toObject();
if (o.isEmpty()) return false;
mId = "";
mName = "";
mDescription = "";
QString version = "";
if (o.contains("Author")) {}
if (o.contains("Date")) {}
if (o.contains("Name")) mName = o.value("Name").toString();
else {} //LOG WARNING
if (o.contains("Version")) version = o.value("Version").toString();
else {} //LOG WARNING
if (o.contains("Description")) mDescription = o.value("Description").toString();
else {} //LOG WARNING
mId = mName + " " + version;
if (mId.trimmed() == "") {} //LOG WARNING
if (o.contains("Properties")) mDefaultParameters = o.value("Properties").toObject();
else {} //LOG WARNING
return true;
}
DomainServerSettingsManager::DomainServerSettingsManager() :
_descriptionArray(),
_configMap()
{
// load the description object from the settings description
QFile descriptionFile(QCoreApplication::applicationDirPath() + SETTINGS_DESCRIPTION_RELATIVE_PATH);
descriptionFile.open(QIODevice::ReadOnly);
QJsonDocument descriptionDocument = QJsonDocument::fromJson(descriptionFile.readAll());
if (descriptionDocument.isObject()) {
QJsonObject descriptionObject = descriptionDocument.object();
const QString DESCRIPTION_VERSION_KEY = "version";
if (descriptionObject.contains(DESCRIPTION_VERSION_KEY)) {
// read the version from the settings description
_descriptionVersion = descriptionObject[DESCRIPTION_VERSION_KEY].toDouble();
if (descriptionObject.contains(DESCRIPTION_SETTINGS_KEY)) {
_descriptionArray = descriptionDocument.object()[DESCRIPTION_SETTINGS_KEY].toArray();
return;
}
}
}
static const QString MISSING_SETTINGS_DESC_MSG =
QString("Did not find settings decription in JSON at %1 - Unable to continue. domain-server will quit.")
.arg(SETTINGS_DESCRIPTION_RELATIVE_PATH);
static const int MISSING_SETTINGS_DESC_ERROR_CODE = 6;
QMetaObject::invokeMethod(QCoreApplication::instance(), "queuedQuit", Qt::QueuedConnection,
Q_ARG(QString, MISSING_SETTINGS_DESC_MSG),
Q_ARG(int, MISSING_SETTINGS_DESC_ERROR_CODE));
}
void DomainServerSettingsManager::recurseJSONObjectAndOverwriteSettings(const QJsonObject& postedObject,
QVariantMap& settingsVariant,
QJsonObject descriptionObject) {
foreach(const QString& key, postedObject.keys()) {
QJsonValue rootValue = postedObject[key];
// we don't continue if this key is not present in our descriptionObject
if (descriptionObject.contains(key)) {
if (rootValue.isString()) {
settingsVariant[key] = rootValue.toString();
} else if (rootValue.isBool()) {
settingsVariant[key] = rootValue.toBool();
} else if (rootValue.isObject()) {
// there's a JSON Object to explore, so attempt to recurse into it
QJsonObject nextDescriptionObject = descriptionObject[key].toObject();
if (nextDescriptionObject.contains(DESCRIPTION_SETTINGS_KEY)) {
if (!settingsVariant.contains(key)) {
// we don't have a map below this key yet, so set it up now
settingsVariant[key] = QVariantMap();
}
recurseJSONObjectAndOverwriteSettings(rootValue.toObject(),
*reinterpret_cast<QVariantMap*>(settingsVariant[key].data()),
nextDescriptionObject[DESCRIPTION_SETTINGS_KEY].toObject());
}
}
}
}
}
void VstSettings::read(const QJsonObject &in)
{
foldersToScan.clear();
if (in.contains("scanPaths")) {
QJsonArray scanPathsArray = in["scanPaths"].toArray();
for (int i = 0; i < scanPathsArray.size(); ++i)
foldersToScan.append(scanPathsArray.at(i).toString());
}
cachedPlugins.clear();
if (in.contains("cachedPlugins")) {
QJsonArray cacheArray = in["cachedPlugins"].toArray();
for (int x = 0; x < cacheArray.size(); ++x) {
QString pluginFile = cacheArray.at(x).toString();
if (QFile(pluginFile).exists()) // if a cached plugin is removed from the disk we need skip this file
cachedPlugins.append(pluginFile);
}
}
blackedPlugins.clear();
if (in.contains("BlackListPlugins")) {
QJsonArray cacheArray = in["BlackListPlugins"].toArray();
for (int x = 0; x < cacheArray.size(); ++x)
blackedPlugins.append(cacheArray.at(x).toString());
}
}
void ChatClient::singleWho()
{
QtJsonDb::QJsonDbReadRequest *request = qobject_cast<QtJsonDb::QJsonDbReadRequest*>(sender());
if (!request)
return;
QList<QJsonObject> whoResults = request->takeResults();
if (whoResults.isEmpty()) {
fprintf(stderr, "Unknown user\n");
return;
}
QJsonObject who = whoResults.takeFirst();
request->deleteLater();
QStringList results;
results << QString("User: %1").arg(who.value(QLatin1String("username")).toString());
results << QString("Logged in: %1").arg(who.value(QLatin1String("time")).toString());
if (who.contains(QLatin1String("name")))
results << QString("Real name: %1").arg(who.value(QLatin1String("name")).toString());
if (who.contains(QLatin1String("status")))
results << QString("Status: %1").arg(who.value(QLatin1String("status")).toString());
fprintf(stderr, "%s\n", qPrintable(results.join("\n")));
}
void RPCWallet::transferResponse(const QJsonObject& pObjResponse, const QJsonObject& pObjOriginalParams)
{
qDebug() << "Received transfer resposnse";
qDebug() << pObjResponse;
qDebug() << "With original params : ";
qDebug() << pObjOriginalParams;
/* Error */
if ( pObjResponse["error"].isObject() ) {
const QJsonObject lError = pObjResponse["error"].toObject();
int lErrorCode = -1;
QString lErrorMessage;
if ( lError.contains("message") ) {
lErrorMessage = lError["message"].toString();
}
if ( lError.contains("code") ) {
lErrorCode = lError["code"].toInt();
}
this->onTransferError(lErrorCode, lErrorMessage);
return;
}
if ( !pObjResponse["tx_hash"].isString() ) {
qWarning() << "Bad JSON response for transfer : " << pObjResponse;
return;
}
/* TOOD : Create a serialization:deserialization function for this stuff */
if ( !pObjOriginalParams["destinations"].isArray() ) {
qCritical() << "transferResponse brought bad original params : " << pObjOriginalParams;
return;
}
QJsonArray lDsts = pObjOriginalParams["destinations"].toArray();
const QJsonObject& lDestination = lDsts.first().toObject();
if ( !lDestination["address"].isString() || !lDestination["amount"].isDouble() ) {
qCritical() << "transferResponse brought bad original params : " << pObjOriginalParams;
return;
}
unsigned long long lOriginalFee = 5000000000uLL;
if ( pObjOriginalParams["fee"].isDouble() ) {
lOriginalFee = pObjOriginalParams["fee"].toDouble();
}
/* OK */
onTransferSuccessful(pObjResponse["tx_hash"].toString(), lDestination["amount"].toDouble(), lDestination["address"].toString(), lOriginalFee);
}
void SystemClass::read(const QJsonObject &json){
SystemLang::read(json);
QJsonArray tab;
QList<QStandardItem *> row;
SystemStatisticProgression* statisticProgression;
SystemClassSkill* classSkill;
// Experience
m_initialLevel = -1;
m_maxLevel = -1;
m_expBase = -1;
m_expInflation = -1;
if (json.contains(jsonInitialLevel)) {
m_initialLevel = json[jsonInitialLevel].toInt();
}
if (json.contains(jsonMaxLevel)) {
m_maxLevel = json[jsonMaxLevel].toInt();
}
if (json.contains(jsonExpBase)) {
m_expBase = json[jsonExpBase].toInt();
}
if (json.contains(jsonExpInflation)) {
m_expInflation = json[jsonExpInflation].toInt();
}
// Exp table
tab = json[jsonExpTable].toArray();
for (int i = 0; i < tab.size(); i++){
QJsonObject obj = tab.at(i).toObject();
int level = obj["k"].toInt();
int value = obj["v"].toInt();
m_expTable[level] = value;
}
// Statistics
tab = json[jsonStats].toArray();
for (int i = 0; i < tab.size(); i++){
statisticProgression = new SystemStatisticProgression;
statisticProgression->read(tab[i].toObject());
row = statisticProgression->getModelRow();
m_statisticsProgression->insertRow(
m_statisticsProgression->invisibleRootItem()->rowCount()-1,
row);
}
// Skills
tab = json[jsonSkills].toArray();
for (int i = 0; i < tab.size(); i++){
classSkill = new SystemClassSkill;
classSkill->read(tab[i].toObject());
row = classSkill->getModelRow();
m_skills->insertRow(m_skills->invisibleRootItem()->rowCount()-1, row);
}
}
void HistoryEntry::deSerialize(const QJsonObject & json)
{
*this = HistoryEntry();
if (json.contains("expression"))
m_expr = json["expression"].toString();
if (json.contains("result"))
m_result = Quantity(json["result"].toObject());
return;
}
/**
* @brief Agent::fromJSON Update agent from JsonObject sent from frontend or importer
* @param json {geometry : {} , properties : {}}
*/
void Agent::fromJSON(QJsonObject json){
QJsonObject properties = json["properties"].toObject();
if( properties.contains("name") ){ this->setObjectName( properties["name"].toObject()["value"].toString() ); }
if( properties.contains("style") ){ this->style->fromJSON( properties["style"].toObject() ); }
if( json.contains( "geometry" ) ){
Geometry* geometry = GeoJsonToGeometry::format( json["geometry"].toObject() );
if( geometry != 0 && geometry->isValid() ){
this->setGeometry( geometry );
}
}
}
bool feedBackMessage::loadfromJson(QByteArray textJson)
{
QJsonParseError jsonParseError;
QJsonDocument jsonDocument = QJsonDocument::fromJson(textJson, &jsonParseError);
if(jsonParseError.error == QJsonParseError::NoError)
{
if(jsonDocument.isObject())
{
QJsonObject jsonObject = jsonDocument.object();
if(jsonObject.contains("username"))
{
QJsonValue jsonValue = jsonObject.take("username");
if(jsonValue.isString())
{
user = jsonValue.toString();
}
else
{
return false;
}
}
else
{
return false;
}
if(jsonObject.contains("status"))
{
QJsonValue jsonValue = jsonObject.take("status");
if(jsonValue.isString())
{
stat = jsonValue.toString();
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
return true;
}
ColorGradient ColorGradient::fromJson(const QJsonObject & jsonObject)
{
if (jsonObject.isEmpty())
return {};
auto gradient = ColorGradient{};
auto value = QJsonValue{};
if (!jsonObject.contains("type") || !jsonObject.value("type").isString())
gradient.setType(s_defaultType);
else
gradient.setType(type(jsonObject.value("type").toString()));
if (!jsonObject.contains("steps") || !jsonObject.value("steps").isDouble())
gradient.setSteps(s_defaultSteps);
else
gradient.setSteps(jsonObject.value("steps").toDouble());
if (!jsonObject.contains("stops") || !jsonObject.value("stops").isArray())
return {};
auto stops = ColorGradientStops{};
auto jsonStops = jsonObject.value("stops").toArray();
for (const QJsonValue & jsonStop : jsonStops)
{
if (!jsonStop.isObject())
return {};
auto stop = jsonStop.toObject();
if (!stop.contains("color") ||
!stop.value("color").isString() ||
!stop.contains("position") ||
!stop.value("position").isDouble())
return {};
auto color = QColor{};
color.setNamedColor(stop.value("color").toString());
const auto position = stop.value("position").toDouble();
auto midpoint = ColorGradientStop::s_defaultMidpoint;
if (stop.contains("midpoint") &&
stop.value("midpoint").isDouble())
midpoint = stop.value("midpoint").toDouble();
stops.append(ColorGradientStop{color, position, midpoint});
}
gradient.setStops(stops);
return gradient;
}
BaseJob::Status PasswordLogin::parseJson(const QJsonDocument& data)
{
QJsonObject json = data.object();
if( !json.contains("access_token") || !json.contains("home_server") || !json.contains("user_id") )
{
return { UserDefinedError, "No expected data" };
}
d->returned_token = json.value("access_token").toString();
d->returned_server = json.value("home_server").toString();
d->returned_id = json.value("user_id").toString();
return Success;
}
void UserManagementAPI::handleUserLoginPost(HttpRequest &request, HttpResponse &response)
{
QByteArray rawData = request.getRawData();
QJsonParseError error;
QJsonDocument data = QJsonDocument::fromJson(rawData, &error);
if (error.error != QJsonParseError::NoError)
{
respondJsonParseError(response, error);
return;
}
QJsonObject dataObject = data.object();
if (dataObject.contains("email") && dataObject.contains("password") && dataObject.contains("g_recaptcha_response"))
{
QString email = dataObject["email"].toString();
QByteArray password = dataObject["password"].toString().toLatin1();
QString g_recaptcha_response = dataObject["g_recaptcha_response"].toString();
if (!ReCAPTCHAVerifier::getSingleton().verify(g_recaptcha_response, request.getFromIPAddress()))
{
respond(response, StatusCode::reCAPTCHAFailed, "reCAPTCHA check failed!");
return;
}
QHash<QString, QVariant> extraFields;
QString errorMessage;
QString userId;
if(m_userManager.login(email, password, userId, extraFields, errorMessage))
{
QByteArray sessionId;
if (m_sessionManager.newSession(userId, email, sessionId))
{
QHash<QString, QString> additionalFields;
additionalFields["session_id"] = sessionId;
respond(response, StatusCode::NoError, "Logged in!", 0, additionalFields);
}
else
{
respond(response, StatusCode::CreateSessionFailed, errorMessage);
}
}
else
{
respond(response, StatusCode::LoginFailed, errorMessage);
}
}
else
{
respondParameterMissing(response);
}
}
QStringList LOCACC :: getElementTreeData(QTreeWidgetItem *elementItem)
{
QJsonObject screenObj = fetchScreenJObject(QStringList(elementItem->parent()->text(0)));
QJsonObject elementObj = fetchElementJObject(QStringList (elementItem->text(0)),screenObj["elements"].toArray());
QStringList elementData;
elementData << elementObj["id"].toString() << elementObj["accId"].toString() << elementObj["type"].toString()
<< elementObj["role"].toString()
<< (elementObj.contains("tabIndex") ? QString::number(elementObj["tabIndex"].toInt()) : "")
<< (elementObj.contains("offsetTop") ? QString::number(elementObj["offsetTop"].toInt()) : "")
<< (elementObj.contains("offsetLeft") ? QString::number(elementObj["offsetLeft"].toInt()) : "");
return elementData;
}
QJsonObject AccountManager::dataObjectFromResponse(QNetworkReply* requestReply) {
QJsonObject jsonObject = QJsonDocument::fromJson(requestReply->readAll()).object();
static const QString STATUS_KEY = "status";
static const QString DATA_KEY = "data";
if (jsonObject.contains(STATUS_KEY) && jsonObject[STATUS_KEY] == "success" && jsonObject.contains(DATA_KEY)) {
return jsonObject[DATA_KEY].toObject();
} else {
return QJsonObject();
}
}
void BoardWindow::parseResponse()
{
QString data = Socket::readData();
QJsonDocument d = QJsonDocument::fromJson(data.toUtf8());
QJsonObject json = d.object();
if (json.contains("request"))
{
std::string request_type = json["request"].toString().toStdString();
if (request_type == "message") {
QDateTime timestamp;
timestamp.setTime_t(json["timestamp"].toString().toInt());
ui->chatTextEdit->append("[" + timestamp.toString("hh:mm") + "] " +
json["nick"].toString() + ": " + json["message"].toString());
}
else if (request_type == "board")
{
waiting = false;
resetBoard();
time = json["time"].toString();
ui->turnsLabel->setText("Turn: " + json["current color"].toString());
yourTurn = json["current color"].toString() == color ? true : false;
// ui->chatTextEdit->append("Loading board");
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
board[i][j] = json["board"].toArray()[i].toArray()[j].toString()[0].toLatin1();
loadBoard();
}
else if (request_type == "game_over")
{
ui->chatTextEdit->append("GAME OVER!");
if (json["winner"] == color) {
ui->chatTextEdit->append("Congratulatons, you won!");
}
else {
ui->chatTextEdit->append("Unfortunately, you lost. Maybe next time?");
}
}
}
else if (json.contains("status"))
{
auto status = json["status"].toString();
if (status != "ok")
{
if (status == "wrong move") {
waiting = false;
revokeMoves();
}
ui->chatTextEdit->append("Error: " + status);
}
}
}
// ------------ TwqUser::P_Name ------------
void TwqUser::P_Name::receiveInfo(const QJsonObject& jobj) {
// from Search
if(jobj.contains(JSONKWD::TWEET::FromUserName)) {
_v.name = jobj.find(JSONKWD::TWEET::FromUserName).value().toString(); // 表示名
_v.scrName = jobj.find(JSONKWD::TWEET::FromUser).value().toString(); // アカ名
haveF |= Flag;
} else if(jobj.contains(JSONKWD::USER::Name)) {
// from Home
_v.name = jobj.find(JSONKWD::USER::Name).value().toString();
_v.scrName = jobj.find(JSONKWD::USER::Screen_name).value().toString();
haveF |= Flag;
}
}
void AppModel::handleWeatherNetworkData(QObject *replyObj)
{
qCDebug(requestsLog) << "got weather network data";
QNetworkReply *networkReply = qobject_cast<QNetworkReply*>(replyObj);
if (!networkReply)
return;
if (!networkReply->error()) {
foreach (WeatherData *inf, d->forecast)
delete inf;
d->forecast.clear();
QJsonDocument document = QJsonDocument::fromJson(networkReply->readAll());
if (document.isObject()) {
QJsonObject obj = document.object();
QJsonObject tempObject;
QJsonValue val;
if (obj.contains(QStringLiteral("weather"))) {
val = obj.value(QStringLiteral("weather"));
QJsonArray weatherArray = val.toArray();
val = weatherArray.at(0);
tempObject = val.toObject();
d->now.setWeatherDescription(tempObject.value(QStringLiteral("description")).toString());
d->now.setWeatherIcon(tempObject.value("icon").toString());
}
if (obj.contains(QStringLiteral("main"))) {
val = obj.value(QStringLiteral("main"));
tempObject = val.toObject();
val = tempObject.value(QStringLiteral("temp"));
d->now.setTemperature(niceTemperatureString(val.toDouble()));
}
}
}
networkReply->deleteLater();
//retrieve the forecast
QUrl url("http://api.openweathermap.org/data/2.5/forecast/daily");
QUrlQuery query;
query.addQueryItem("q", d->city);
query.addQueryItem("mode", "json");
query.addQueryItem("cnt", "5");
url.setQuery(query);
QNetworkReply *rep = d->nam->get(QNetworkRequest(url));
// connect up the signal right away
d->forecastReplyMapper->setMapping(rep, rep);
connect(rep, SIGNAL(finished()), d->forecastReplyMapper, SLOT(map()));
}
QString BasePlugin::translatedObject(QString obj){
QJsonObject tmp = data.value(obj).toObject();
//Get the current locale
QString locale = getenv("LC_ALL");
if(locale.isEmpty()){ locale = getenv("LC_MEBaseAGES"); }
if(locale.isEmpty()){ locale = getenv("LANG"); }
if(locale.isEmpty()){ locale = "default"; }
if(locale.contains(".")){ locale = locale.section(".",0,0); } //chop any charset code off the end
//Now find which localized string is available and return it
if(tmp.contains(locale)){ return tmp.value(locale).toString(); }
locale = locale.section("_",0,0); //full locale not found - look for shortened form
if(tmp.contains(locale)){ return tmp.value(locale).toString(); }
return tmp.value("default").toString(); //use the default version
}
QString Expression::createView(QJsonObject prop) const {
QString key = prop["name"].toString();
QStringList types;
if (prop.contains("what")) {
QJsonArray whats = prop["what"].toArray();
for (int i = 0; i < whats.size(); i++) {
types.append(whats[i].toString());
}
}
if (prop.contains("type")) types.append(prop["type"].toString());
if (types.size() > 0) key += "(" + types.join("/") + ")";
if (prop.contains("description")) key += "; " + prop["description"].toString();
return key;
}
void UserManagementAPI::handleUserSignupPost(HttpRequest &request, HttpResponse &response)
{
QByteArray rawData = request.getRawData();
QJsonParseError error;
QJsonDocument data = QJsonDocument::fromJson(rawData, &error);
if (error.error != QJsonParseError::NoError)
{
respondJsonParseError(response, error);
return;
}
QJsonObject dataObject = data.object();
if (dataObject.contains("email") && dataObject.contains("password") && dataObject.contains("g_recaptcha_response"))
{
QString email = dataObject["email"].toString();
QByteArray password = dataObject["password"].toString().toLatin1();
QString g_recaptcha_response = dataObject["g_recaptcha_response"].toString();
if (!ReCAPTCHAVerifier::getSingleton().verify(g_recaptcha_response, request.getFromIPAddress()))
{
respond(response, StatusCode::reCAPTCHAFailed, "reCAPTCHA check failed!");
return;
}
QHash<QString, QVariant> extraFields;
QString errorMessage;
QByteArray activationCode;
if(m_userManager.signup(email, password, extraFields, errorMessage, activationCode))
{
if (sendActivationEmail(email, QString::fromLatin1(activationCode)))
{
respondSuccess(response);
}
else
{
respond(response, StatusCode::SendActivationEmailFailed, "failed to send activation email!");
}
}
else
{
respond(response, StatusCode::SignupFailed, "Signup failed: " % errorMessage);
}
}
else
{
respondParameterMissing(response);
}
}
void MusicRadioSongsThread::downLoadFinished()
{
if(m_reply == nullptr)
{
deleteAll();
return;
}
if(m_reply->error() == QNetworkReply::NoError)
{
QByteArray bytes = m_reply->readAll();
#ifdef MUSIC_QT_5
QJsonParseError jsonError;
QJsonDocument parseDoucment = QJsonDocument::fromJson(bytes, &jsonError);
///Put the data into Json
if(jsonError.error != QJsonParseError::NoError ||
!parseDoucment.isObject())
{
deleteAll();
return ;
}
QJsonObject jsonObject = parseDoucment.object();
if(jsonObject.contains("data"))
{
jsonObject = jsonObject.value("data").toObject();
if(jsonObject.contains("songList"))
{
QJsonArray array = jsonObject.value("songList").toArray();
foreach(QJsonValue value, array)
{
if(!value.isObject())
{
continue;
}
QJsonObject object = value.toObject();
m_songInfo.m_songUrl = object.value("songLink").toString();
m_songInfo.m_songName = object.value("songName").toString();
m_songInfo.m_artistName = object.value("artistName").toString();
m_songInfo.m_songPicUrl = object.value("songPicRadio").toString();
m_songInfo.m_albumName = object.value("albumName").toString();
QString lrcLink = object.value("lrcLink").toString();
if(!lrcLink.contains( LRC_PREFIX ))
{
lrcLink = LRC_PREFIX + lrcLink;
}
m_songInfo.m_lrcUrl = lrcLink;
}
}
