/**
* SLOT
* Send a replay message to a game offer.
* @param name
* @param accept
*/
void Battleships::sendGameOfferReplay(const QString name, const bool accept)
{
QJsonObject object;
object.insert("type", "GAME_OFFER_REPLAY");
QJsonObject options;
options.insert("player_name", name);
options.insert("success", accept ? "true" : "false");
object.insert("options", options);
QJsonDocument *message = new QJsonDocument(object);
emit sendMessage(message);
}
QJsonObject RemDev::newError(QJsonValue id, int code, const QString &msg, const QJsonValue &data) const {
QJsonObject e;
e.insert("code", code);
e.insert("message", msg);
if (data.type() != QJsonValue::Undefined) e.insert("data", data);
QJsonObject o(rpc_seed);
o.insert("error", e);
if (id.type() == QJsonValue::Undefined) id = QJsonValue::Null;
o.insert("id", id);
return o;
}
void UserActivityLogger::changedModel(QString typeOfModel, QString modelURL) {
const QString ACTION_NAME = "changed_model";
QJsonObject actionDetails;
const QString TYPE_OF_MODEL = "type_of_model";
const QString MODEL_URL = "model_url";
actionDetails.insert(TYPE_OF_MODEL, typeOfModel);
actionDetails.insert(MODEL_URL, modelURL);
logAction(ACTION_NAME, actionDetails);
}
QJsonObject DmxAddress::toJson() const {
QJsonValue universeValue(universe);
QJsonValue offsetValue(offset);
QJsonObject obj;
obj.insert("universe", universeValue);
obj.insert("offset", offsetValue);
return obj;
}
QJsonDocument SplicePicturesPanel::getConfiguration() {
QJsonArray array;
for (QVector<SplicePicturesImageItem>::iterator iter = imageList.begin(); iter != imageList.end(); iter++) {
array.push_back(iter->toJsonObject());
}
QJsonObject json;
json.insert("zoom", (double)imageZoom);
json.insert("images", array);
QJsonDocument doc;
doc.setObject(json);
return doc;
}
QJsonDocument Wagnis::getRegistrationDocument()
{
qDebug() << "Wagnis::getRegistrationDocument";
QJsonObject jsonPayloadObject;
jsonPayloadObject.insert("id", wagnisId);
jsonPayloadObject.insert("country", ipInfo.value("country").toString());
jsonPayloadObject.insert("application", this->applicationName);
jsonPayloadObject.insert("version", this->applicationVersion);
QJsonDocument registrationDocument(jsonPayloadObject);
return registrationDocument;
}
void ServiceClient::Login(QString username, QString password){
QNetworkAccessManager* manager = new QNetworkAccessManager();
connect(manager, SIGNAL(finished(QNetworkReply*)),
this, SLOT(loginReplRead(QNetworkReply*)));
QNetworkRequest req(QUrl(GlobalSetting::serviceURI().
append("/Login")));
QJsonObject obj;
obj.insert("Email", username);
obj.insert("Password", password);
manager->post(req, QJsonDocument(obj).toBinaryData());
}
/*
* Build a message to be sent. Uses the right format defined by protocol
* Receive a QJsonObject to be inserted in data field and a message type to insert in the type field
*/
QJsonDocument RFIDMonitorDaemon::buildMessage(QJsonObject dataObj, QString type)
{
QJsonObject rootObj;
QJsonDocument rootDoc;
rootObj.insert("type", type);
rootObj.insert("datetime", QJsonValue(QDateTime::currentDateTime().toString(Qt::ISODate)));
rootObj.insert("data", QJsonValue(dataObj));
rootDoc.setObject(rootObj);
return rootDoc;
}
int StorageProxy::delFile(QString &fileName)
{
QJsonObject cmd;
cmd.insert("path",fileName);
cmd.insert("recusive",0);
QJsonDocument doc(cmd);
QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
return m_monitor->sendCmd(m_devid,PL_REQ_DEL_FILE,&jsonData);
}
int StorageProxy::newFile(QString &fileName,bool isDir)
{
QJsonObject cmd;
cmd.insert("path",fileName);
cmd.insert("isDir",isDir);
QJsonDocument doc(cmd);
QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
return m_monitor->sendCmd(m_devid,PL_REQ_NEW_FILE,&jsonData);
}
bool KNAccountDetailBox::okayPressed()
{
//Construct a JSON object for all these new data.
QJsonObject updatedInfo;
//Insert data.
updatedInfo.insert("displayName", m_nickName->text());
updatedInfo.insert("email", m_emailAddress->text());
//Emit the updated object.
emit requireUpdateInfo(updatedInfo);
//Mission complete.
return true;
}
void UserActivityLogger::connectedDevice(QString typeOfDevice, QString deviceName) {
const QString ACTION_NAME = "connected_device";
QJsonObject actionDetails;
const QString TYPE_OF_DEVICE = "type_of_device";
const QString DEVICE_NAME = "device_name";
actionDetails.insert(TYPE_OF_DEVICE, typeOfDevice);
actionDetails.insert(DEVICE_NAME, deviceName);
logAction(ACTION_NAME, actionDetails);
}
void UserActivityLogger::launch(QString applicationVersion, bool previousSessionCrashed, int previousSessionRuntime) {
const QString ACTION_NAME = "launch";
QJsonObject actionDetails;
QString VERSION_KEY = "version";
QString CRASH_KEY = "previousSessionCrashed";
QString RUNTIME_KEY = "previousSessionRuntime";
actionDetails.insert(VERSION_KEY, applicationVersion);
actionDetails.insert(CRASH_KEY, previousSessionCrashed);
actionDetails.insert(RUNTIME_KEY, previousSessionRuntime);
logAction(ACTION_NAME, actionDetails);
}
int StorageProxy::renameFile(QString &preName,QString &newName)
{
QJsonObject cmd;
cmd.insert("path",preName);
cmd.insert("newName",newName);
QJsonDocument doc(cmd);
QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
return m_monitor->sendCmd(m_devid,PL_REQ_RENAME_FILE,&jsonData);
}
QJsonObject*
SWGComplex::asJsonObject() {
QJsonObject* obj = new QJsonObject();
if(m_real_isSet){
obj->insert("real", QJsonValue(real));
}
if(m_imag_isSet){
obj->insert("imag", QJsonValue(imag));
}
return obj;
}
/**
* @brief Database::toJson
* @return
*/
QJsonObject Database::toJson() const
{
QJsonArray scopes;
for (auto &&scope : m_Scopes.values()) scopes.append(scope->toJson());
QJsonObject result;
result.insert("Name", m_Name);
result.insert("ID", m_ID);
result.insert("Scopes", scopes);
return result;
}
QJsonObject*
SWGMethodCountryMobile::asJsonObject() {
QJsonObject* obj = new QJsonObject();
toJsonValue(QString("method"), method, obj, QString("QString"));
obj->insert("country_code", QJsonValue(country_code));
obj->insert("phone_number", QJsonValue(phone_number));
return obj;
}
bool Program::writeJsonSettings(QJsonObject &json, bool exportOnly) const
{
// No export sensitive data.
Q_UNUSED(exportOnly)
json.insert("executable", m_executable);
json.insert("arguments", m_arguments);
json.insert("outputFilename", m_outputFilename);
json.insert("customLaunchTemplate", m_customLaunchTemplate);
json.insert("launchSyntax", static_cast<double>(m_launchSyntax));
return true;
}
QJsonRpcMessage QJsonRpcMessage::createResponse(const QJsonValue &result) const
{
QJsonRpcMessage response;
if (d->object->contains(QLatin1String("id"))) {
QJsonObject *object = response.d->object.data();
object->insert(QLatin1String("jsonrpc"), QLatin1String("2.0"));
object->insert(QLatin1String("id"), d->object->value(QLatin1String("id")));
object->insert(QLatin1String("result"), result);
response.d->type = QJsonRpcMessage::Response;
}
return response;
}
void ImageObject::setObject(const QJsonObject &object)
{
m_object = object;
QString fileId;
fileId = object.value("file").toObject().value("id").toString();
if (!fileId.isEmpty()) {
QJsonObject fileObject;
fileObject.insert("id", fileId);
fileObject.insert("variant", QString("thumbnail"));
EnginioReply *reply = m_enginio->downloadFile(fileObject);
connect(reply, SIGNAL(finished(EnginioReply*)), this, SLOT(replyFinished(EnginioReply*)));
} else {
void TransactionStoreTest::testInsert()
{
QJsonObject transaction;
transaction.insert("hash", "somehash1");
QVERIFY(_store.insert(transaction));
transaction.insert("hash", "somehash2");
QVERIFY(_store.insert(transaction));
transaction.insert("hash", "somehash3");
QVERIFY(_store.insert(transaction));
}
// Return a list of snapshots on a particular pool / dataset
QJsonObject LifePreserver::listSnap(QJsonObject jsin) {
QJsonObject retObject;
QString pool;
QStringList keys = jsin.keys();
if(! keys.contains("pool")){
retObject.insert("error", "Missing pool key");
return retObject;
}
// Check which pool we are looking at
pool = jsin.value("pool").toString();
// Make sure we have the pool key
if ( pool.isEmpty() ) {
retObject.insert("error", "Missing pool key");
return retObject;
}
QStringList output = General::RunCommand("lpreserver snapshot list " + pool ).split("\n");
QList<QStringList> snaps;
QStringList snapitems;
QRegExp sep("\\s+");
// Parse the output
bool inSection = false;
for ( int i = 0; i < output.size(); i++)
{
if ( output.at(i).indexOf("-----------------") != -1 ) {
inSection = true;
continue;
}
if (!inSection)
continue;
if ( output.at(i).isEmpty() || output.at(i).indexOf("-----------------") != -1 )
break;
// Breakdown this snapshot
snapitems.clear();
snapitems << output.at(i).section(sep, 0, 0).simplified();
snapitems << output.at(i).section(sep, 1, -1).simplified();
QJsonObject values;
values.insert("comment", snapitems.at(1));
retObject.insert(snapitems.at(0), values);
}
return retObject;
}
QJsonObject Nuria::Internal::JsonRpcUtil::serializeResponse (const JsonRpcResponse &response) {
static const QString jsonrpc2_0 = QStringLiteral("2.0");
static const QString jsonrpcField = QStringLiteral("jsonrpc");
static const QString idField = QStringLiteral("id");
static const QString resultField = QStringLiteral("result");
static const QString errorField = QStringLiteral("error");
QJsonObject object;
object.insert (jsonrpcField, jsonrpc2_0);
object.insert (idField, response.id.isUndefined () ? QJsonValue () : response.id);
object.insert (response.error ? errorField : resultField, response.response);
return object;
}
QJsonObject*
SWGLastTradeData::asJsonObject() {
QJsonObject* obj = new QJsonObject();
obj->insert("time", QJsonValue(time));
obj->insert("avg_rate", QJsonValue(avg_rate));
obj->insert("vol", QJsonValue(vol));
toJsonValue(QString("ord_type"), ord_type, obj, QString("QString"));
return obj;
}
QJsonObject FilterGroup::toJson() const
{
QJsonObject json;
json.insert(NameValueName, data->name);
json.insert(IdValueName, data->id.toString());
QJsonArray filterArray;
foreach (const FilterRule &rule, data->rules) {
filterArray.append(rule.toJson());
}
json.insert(RulesValueName, filterArray);
return json;
}
bool OneSixVersion::toOriginalFile()
{
if (original_file.isEmpty())
return false;
QSaveFile file(original_file);
if (!file.open(QIODevice::WriteOnly))
{
return false;
}
// serialize base attributes (those we care about anyway)
QJsonObject root;
root.insert("minecraftArguments", minecraftArguments);
root.insert("mainClass", mainClass);
root.insert("minimumLauncherVersion", minimumLauncherVersion);
root.insert("time", time);
root.insert("id", id);
root.insert("type", type);
// screw processArguments
root.insert("releaseTime", releaseTime);
QJsonArray libarray;
for (const auto &lib : libraries)
{
libarray.append(lib->toJson());
}
if (libarray.count())
root.insert("libraries", libarray);
QJsonDocument doc(root);
file.write(doc.toJson());
return file.commit();
}
void server::socketinit()
{
udpsender = new QUdpSocket(this); //实例化udpsender 对象
tcpServer = new tcpserver(this); //实例化tcpserver对象
udpsender->bind(QHostAddress(ip),0);
ui->multicastip->setText(broadcast); //设置udp广播地址
//加入广播组
udpsender->joinMulticastGroup(QHostAddress(ui->multicastip->text()));
//获取监听的端口和ip udp广播发送的信息
QJsonObject json;
json.insert("ip",ip);
json.insert("port",ui->tcpport->text().toInt());
QJsonDocument document;
document.setObject(json);
QByteArray datagram = document.toJson(QJsonDocument::Compact);
//启动udp广播线程
if(NULL == udpbro)
udpbro = new udpbroad(udpsender,datagram,ui->udpport->text().toInt(),ui->multicastip->text());
else
udpbro->reset(udpsender,datagram,ui->udpport->text().toInt(),ui->multicastip->text());
udpbro->start();
//监听tcp
if(!this->tcpServer->isListening()){
if(!this->tcpServer->listen(QHostAddress(ip),ui->tcpport->text().toInt()))
{
qDebug() << this->tcpServer->errorString();
}else{
}
ui->pushButton_2->setText(QString("正在监听"));
}else{
this->tcpServer->close(); //如果正在监听则关闭
ui->pushButton_2->setText(QString("开始监听"));
}
//关联新的tcp连接产生与更新界面
connect(tcpServer,SIGNAL(newclientsocket(QString,tcpsocket*)),this,SLOT(updatenewclient(QString,tcpsocket*)));
//关联接收数据的信号与更新界面
connect(tcpServer,SIGNAL(updateServer(QByteArray,tcpsocket*,QString)),this,SLOT(updatetabelwidget(QByteArray,tcpsocket*,QString)));
//关联连接断开与更新界面
connect(tcpServer,SIGNAL(disconnected(tcpsocket*,QString)),this,SLOT(disconnected(tcpsocket*,QString)));
//关联文件接收信号
connect(tcpServer,SIGNAL(updateServer_file(qint64,qint64,QString,tcpsocket*,QString)),this,SLOT(updatefileview(qint64,qint64,QString,tcpsocket*,QString)));
//关联新文件接收信号
connect(tcpServer,SIGNAL(updateServer_newfile(qint64,qint64,QString,tcpsocket*,QString)),this,SLOT(updatefileview_new(qint64,qint64,QString,tcpsocket*,QString)));
}
void Map::updateDataProvince()
{
QJsonObject postData;
postData.insert("type", "get_all");
postData.insert("player", mPlayer);
postData.insert("cls", "province");
postData.insert("id", "all");
postData.insert("atts", QJsonArray({mStripe0, mStripe1}));
QNetworkRequest request(mUrl);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
mManager->post(request, QJsonDocument(postData).toJson());
}
void ScriptService::getImpl(const QByteArray& operation, const APIParameters ¶meters, APIServiceResponse &response)
{
if(operation=="list")
{
//list all scripts, this should be thread safe
QStringList allScripts = scriptMgr->getScriptList();
response.writeJSON(QJsonDocument(QJsonArray::fromStringList(allScripts)));
}
else if (operation == "info")
{
if(parameters.contains("id"))
{
//retrieve detail about a single script
QString scriptId = QString::fromUtf8(parameters.value("id"));
if(parameters.contains("html"))
{
QString html = scriptMgr->getHtmlDescription(scriptId, false);
response.setHeader("Content-Type","text/html; charset=UTF-8");
response.setData(wrapHtml(html, scriptId).toUtf8());
return;
}
QJsonObject obj;
//if the script name is wrong, this will return empty strings
obj.insert("id",scriptId);
QString d = scriptMgr->getName(scriptId).trimmed();
obj.insert("name",d);
obj.insert("name_localized", StelTranslator::globalTranslator->qtranslate(d));
d = scriptMgr->getDescription(scriptId).trimmed();
obj.insert("description",d);
obj.insert("description_localized", StelTranslator::globalTranslator->qtranslate(d));
obj.insert("author",scriptMgr->getAuthor(scriptId).trimmed());
obj.insert("license",scriptMgr->getLicense(scriptId).trimmed());
//shortcut often causes a large delay because the whole file gets searched, and it is usually missing, so we ignore it
//obj.insert("shortcut",scriptMgr->getShortcut(scriptId));
response.writeJSON(QJsonDocument(obj));
}
else
{
response.writeRequestError("need parameter: id");
}
}
else if(operation == "status")
{
//generic script status
QJsonObject obj;
obj.insert("scriptIsRunning",scriptMgr->scriptIsRunning());
obj.insert("runningScriptId",scriptMgr->runningScriptId());
response.writeJSON(QJsonDocument(obj));
}
else
{
//TODO some sort of service description?
response.writeRequestError("unsupported operation. GET: list,info,status POST: run,stop");
}
}
bool
HrvMeasureParser::serialize(QString filename, QList<HrvMeasure> &data) {
// open file - truncate contents
QFile file(filename);
if (!file.open(QFile::WriteOnly)) {
QMessageBox msgBox;
msgBox.setIcon(QMessageBox::Critical);
msgBox.setText(QObject::tr("Problem Saving HRV Measurements"));
msgBox.setInformativeText(QObject::tr("File: %1 cannot be opened for 'Writing'. Please check file properties.").arg(filename));
msgBox.exec();
return false;
};
file.resize(0);
QTextStream out(&file);
out.setCodec("UTF-8");
HrvMeasure *m = NULL;
QJsonArray measures;
for (int i = 0; i < data.count(); i++) {
m = &data[i];
QJsonObject measure;
measure.insert("when", m->when.toMSecsSinceEpoch()/1000);
measure.insert("hr", m->hr);
measure.insert("avnn", m->avnn);
measure.insert("sdnn", m->sdnn);
measure.insert("rmssd", m->rmssd);
measure.insert("pnn50", m->pnn50);
measure.insert("lf", m->lf);
measure.insert("hf", m->hf);
measure.insert("recovery_points", m->recovery_points);
measure.insert("source", m->source);
measure.insert("originalsource", m->originalSource);
measures.append(measure);
}
QJsonObject jsonObject;
// add a version in case of format changes
jsonObject.insert("version", 1);
jsonObject.insert("measures", QJsonValue(measures));
QJsonDocument json;
json.setObject(jsonObject);
out << json.toJson();
out.flush();
file.close();
return true;
}
