void TestUserInfo::initTestCase()
{
b_engine = new MockBaseEngine;
m_ipbxid = QString("testipbx");
m_linelist.append("23");
m_phoneidlist.append(QString("%0/%1").arg(m_ipbxid).arg("23"));
m_linelist.append("42");
m_phoneidlist.append(QString("%0/%1").arg(m_ipbxid).arg("42"));
m_phoneidlist.sort();
m_prop1["fullname"] = "testfullname";
m_prop1["voicemailid"] = "2345";
m_prop1["agentid"] = "1234";
m_prop1["enableclient"] = true;
m_prop1["enablevoicemail"] = true;
m_prop1["incallfilter"] = false;
m_prop1["enablednd"] = false;
m_prop1["enableunc"] = false;
m_prop1["enablerna"] = true;
m_prop1["destrna"] = "1002";
m_prop1["enablebusy"] = false;
m_prop1["mobilephonenumber"] = "4185555555";
m_prop1["linelist"] = m_linelist;
m_prop1["availstate"] = "available";
m_prop1["connection"] = "yes";
MockPhoneInfo * phoneinfo;
QVariantMap config;
phoneinfo = new MockPhoneInfo("asterisk", "p1");
config.clear();
config["identity"] = "SIP/sip1";
config["xchannels"] = "SIP/sip1-01";
config["number"] = "101";
phoneinfo->setConfig(config);
b_engine->setPhone("asterisk/p1", phoneinfo);
phoneinfo = new MockPhoneInfo("asterisk", "p2");
config.clear();
config["identity"] = "SIP/sip2";
config["xchannels"] = "SIP/sip2-02";
config["number"] = "102";
phoneinfo->setConfig(config);
b_engine->setPhone("asterisk/p2", phoneinfo);
MockChannelInfo *channelinfo;
channelinfo = new MockChannelInfo("asterisk", "SIP/sip1-01");
config.clear();
config["talkingto_id"] = "SIP/sip2-02";
channelinfo->setConfig(config);
b_engine->setChannel("SIP/sip1-01", channelinfo);
channelinfo = new MockChannelInfo("asterisk", "SIP/sip2-02");
config.clear();
config["talkingto_id"] = "SIP/sip1-01";
channelinfo->setConfig(config);
b_engine->setChannel("SIP/sip2-02", channelinfo);
}
bool FindValueOperation::test() const
{
QVariantMap testMap;
QVariantMap subKeys;
QVariantMap cur;
cur.insert(QLatin1String("testint2"), 53);
subKeys.insert(QLatin1String("subsubkeys"), cur);
subKeys.insert(QLatin1String("testbool"), true);
subKeys.insert(QLatin1String("testbool2"), false);
subKeys.insert(QLatin1String("otherint"), 53);
testMap.insert(QLatin1String("subkeys"), subKeys);
subKeys.clear();
testMap.insert(QLatin1String("subkeys2"), subKeys);
testMap.insert(QLatin1String("testint"), 23);
subKeys.clear();
QVariantList list1;
list1.append(QLatin1String("ignore this"));
list1.append(QLatin1String("ignore this2"));
QVariantList list2;
list2.append(QLatin1String("somevalue"));
subKeys.insert(QLatin1String("findMe"), QLatin1String("FindInList"));
list2.append(subKeys);
list2.append(QLatin1String("someothervalue"));
list1.append(QVariant(list2));
testMap.insert(QLatin1String("aList"), list1);
QStringList result;
result = findValue(testMap, QVariant(23));
if (result.count() != 1
|| !result.contains(QLatin1String("testint")))
return false;
result = findValue(testMap, QVariant(53));
if (result.count() != 2
|| !result.contains(QLatin1String("subkeys/subsubkeys/testint2"))
|| !result.contains(QLatin1String("subkeys/otherint")))
return false;
result = findValue(testMap, QVariant(23456));
if (!result.isEmpty())
return false;
result = findValue(testMap, QVariant(QString::fromLatin1("FindInList")));
if (result.count() != 1
|| !result.contains(QLatin1String("aList[2][1]/findMe")))
return false;
return true;
}
StateHandler::StateHandler(QObject *parent) :
JsonHandler(parent)
{
QVariantMap params;
QVariantMap returns;
params.clear(); returns.clear();
setDescription("GetStateType", "Get the StateType for the given stateTypeId.");
params.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetStateType", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:stateType", JsonTypes::stateTypeRef());
setReturns("GetStateType", returns);
}
void CTransaction::proRobotDevice(ROBOT_DATA t_data, QByteArray s_data)
{
if(changing)
return;
int change = 0, i = 0;
for(i = 0; i < statusDataBuf.count();i++)
{
if(t_data.hrg_num == statusDataBuf[i].hrg_num)
{
t_data = checkMeaningful(statusDataBuf[i], t_data, change);
if(change)
{
statusDataBuf.removeAt(i);
i = 0;
}
break;
}
}
if(change == 1 ||
statusDataBuf.count() == i)
{
robotStatusData * deviceData= new robotStatusData(t_data);
QVariantMap deviceMap = toVariantMap(deviceData);
QVariant deviceJson = toJsonVariant(deviceMap);
emit uploadRobotDevice(deviceJson);
deviceMap.clear();
deviceJson.clear();
statusDataBuf.append(t_data);
if(deviceData != NULL)
{
delete deviceData;
deviceData = NULL;
}
}
}
void TestDevices::setPluginConfig()
{
QFETCH(PluginId, pluginId);
QFETCH(QVariant, value);
QFETCH(DeviceManager::DeviceError, error);
QVariantMap params;
params.insert("pluginId", pluginId);
QVariantList configuration;
QVariantMap configParam;
configParam.insert("name", "configParamInt");
configParam.insert("value", value);
configuration.append(configParam);
params.insert("configuration", configuration);
QVariant response = injectAndWait("Devices.SetPluginConfiguration", params);
verifyDeviceError(response, error);
if (error == DeviceManager::DeviceErrorNoError) {
params.clear();
params.insert("pluginId", pluginId);
response = injectAndWait("Devices.GetPluginConfiguration", params);
verifyDeviceError(response);
qDebug() << "222" << response.toMap().value("params").toMap().value("configuration").toList().first();
QVERIFY2(response.toMap().value("params").toMap().value("configuration").toList().first().toMap().value("name") == "configParamInt", "Value not set correctly");
QVERIFY2(response.toMap().value("params").toMap().value("configuration").toList().first().toMap().value("value") == value, "Value not set correctly");
}
}
bool FindKeyOperation::test() const
{
QVariantMap testMap;
QVariantMap subKeys;
QVariantMap cur;
cur.insert(QLatin1String("testint"), 53);
subKeys.insert(QLatin1String("subsubkeys"), cur);
subKeys.insert(QLatin1String("testbool"), true);
testMap.insert(QLatin1String("subkeys"), subKeys);
subKeys.clear();
testMap.insert(QLatin1String("subkeys2"), subKeys);
testMap.insert(QLatin1String("testint"), 23);
testMap.insert(QLatin1String("testbool"), true);
QStringList result;
result = findKey(testMap, QLatin1String("missing"));
if (!result.isEmpty())
return false;
result = findKey(testMap, QLatin1String("testint"));
if (result.count() != 2
|| !result.contains(QLatin1String("testint"))
|| !result.contains(QLatin1String("subkeys/subsubkeys/testint")))
return false;
result = findKey(testMap, QLatin1String("testbool"));
if (result.count() != 2
|| !result.contains(QLatin1String("testbool")))
return false;
return true;
}
void BaseOp::stagePostFinished()
{
if (isAborted() || m_reply == NULL) {
DBGLOG(LOG_DEBUG, 10, QString::fromUtf8("Aborted at 'post' stage"));
return report(WTFStatus_Aborted);
}
if (m_reply->error() != QNetworkReply::NoError) {
DBGLOG(LOG_ERROR, 2, QString::fromUtf8("Network error, code=%1").arg(m_reply->error()));
setProperty("varNetworkError", m_reply->error());
m_reply->deleteLater();
m_reply = NULL;
return report(WTFStatus_NetworkError);
}
QByteArray responseData = m_reply->readAll();
m_reply->deleteLater();
m_reply = NULL;
DBGLOG(LOG_DEBUG, 10, QString::fromUtf8("response data: %1").arg(QString::fromUtf8(responseData)));
QVariantMap result;
if (!parseResultXml(responseData, result)) {
DBGLOG(LOG_DEBUG, 2, QString::fromUtf8("parseResultXml failed!"));
result.clear();
}
report(processImpl(responseData, result));
}
QVariantList Core::readOra(const QString& oraPath) {
QZipReader zipReader(oraPath, QIODevice::ReadOnly);
QByteArray xmlByteArray = zipReader.fileData("stack.xml");
QXmlStreamReader stream(xmlByteArray);
QVariantMap map;
QVariantList list;
while (!stream.atEnd()) {
if (stream.isStartElement()) {
if (stream.name() == "layer") {
for (int i = 0; i < stream.attributes().size(); i++) {
map[stream.attributes().at(i).name().toString()] = stream.attributes().at(i).value().toString();
}
QByteArray ba = zipReader.fileData(stream.attributes().value("src").toString());
map["image"] = QString(ba.toBase64());
list.append(map);
map.clear();
}
}
stream.readNextStartElement();
}
zipReader.close();
return list;
}
bool GetOperation::test() const
{
QVariantMap testMap;
QVariantMap subKeys;
QVariantMap cur;
cur.insert(QLatin1String("testint2"), 53);
subKeys.insert(QLatin1String("subsubkeys"), cur);
subKeys.insert(QLatin1String("testbool"), true);
testMap.insert(QLatin1String("subkeys"), subKeys);
subKeys.clear();
testMap.insert(QLatin1String("subkeys2"), subKeys);
testMap.insert(QLatin1String("testint"), 23);
QVariant result;
result = get(testMap, QLatin1String("testint"));
if (result.toString() != QLatin1String("23"))
return false;
result = get(testMap, QLatin1String("subkeys/testbool"));
if (result.toString() != QLatin1String("true"))
return false;
result = get(testMap, QLatin1String("subkeys/subsubkeys"));
if (result.type() != QVariant::Map)
return false;
result = get(testMap, QLatin1String("nonexistant"));
if (result.isValid())
return false;
return true;
}
// Convienence function to send notifications. This function does some processing
// of the arguments. In these functions:
// expire_timeout: The amount of time in milliseconds the message is shown.
// A value of -1 means timeout is based on server's settings.
// overwrite : Will overwrite the previous message sent from this function.
// It will not overwrite notifications sent by other programs.
//
//
// Show notification with summary, app_name, and body text
void NotifyClient::sendNotification ()
{
// make sure we have a connection we can send the notification to.
if (! b_validconnection) return;
// variables
QString app_name = s_app_name;
quint32 replaces_id = 0;
QString app_icon = "";
QString body = "";
QString summary = s_summary;
QStringList actions = QStringList();
QVariantMap hints;
int expire_timeout = i_expire_timeout;
// set replaces_id
if (b_overwrite) replaces_id = current_id;
// assemble the hints
hints.clear();
hints.insert("urgency", QVariant::fromValue(static_cast<uchar>(i_urgency)) );
//if (! app_icon.isEmpty() ) hints.insert("image-path", QVariant::fromValue(app_icon));
// make sure we can display the text on this server
if (sl_capabilities.contains("body", Qt::CaseInsensitive) ) {
body = s_body;
if (! sl_capabilities.contains ("body-markup", Qt::CaseInsensitive) ) {
QTextDocument td;
td.setHtml(body);
body = td.toPlainText();
} // if server cannot display markup
} // if capabilities contains body
// process the icon, if we are using a fallback icon create a temporary file to hold it
QTemporaryFile tempfileicon;
if (! s_icon.isEmpty() ) {
if (sl_capabilities.filter("icon-", Qt::CaseInsensitive).count() > 0 ) {
if ( QIcon::hasThemeIcon(s_icon) ) app_icon = s_icon;
else {
if (QFile::exists(s_icon) ) {
if (tempfileicon.open() ) {
QPixmap px = QPixmap(s_icon);
px.save(tempfileicon.fileName(),"PNG");
app_icon = tempfileicon.fileName().prepend("file://");
} // if tempfileicon could be opened
} // if s_icon exists as a disk file
} // else not a theme icon
} // if capabilities support icons
} // if s_icon is not empty
QDBusReply<quint32> reply = notifyclient->call(QLatin1String("Notify"), app_name, replaces_id, app_icon, summary, body, actions, hints, expire_timeout);
if (reply.isValid() )
current_id = reply.value();
else
qCritical("CMST - Error reply received to the Notify method: %s", qPrintable(reply.error().message()) );
return;
}
Playlist Read2Sources (const QString& path)
{
QFile file (path);
if (!file.open (QIODevice::ReadOnly))
{
qWarning () << Q_FUNC_INFO
<< "unable to open"
<< path
<< file.errorString ();
return {};
}
const auto& m3uDir = QFileInfo (path).absoluteDir ();
QVariantMap lastMetadata;
Playlist result;
while (!file.atEnd ())
{
const auto& line = file.readLine ().trimmed ();
if (line.startsWith ('#'))
{
const auto& pair = ParseMetadata (line);
if (!pair.first.isEmpty ())
lastMetadata [pair.first] = pair.second;
continue;
}
const auto& url = QUrl::fromEncoded (line);
auto src = QString::fromUtf8 (line);
const auto mdGuard = std::shared_ptr<void> (nullptr,
[&lastMetadata] (void*) { lastMetadata.clear (); });
#ifdef Q_OS_WIN32
if (url.scheme ().size () > 1)
#else
if (!url.scheme ().isEmpty ())
#endif
{
result.Append ({ url, lastMetadata });
continue;
}
src.replace ('\\', '/');
const QFileInfo fi (src);
if (fi.isRelative ())
src = m3uDir.absoluteFilePath (src);
if (fi.suffix () == "m3u" || fi.suffix () == "m3u8")
result += Read2Sources (src);
else
result.Append ({ src, lastMetadata });
}
return result;
}
LoggingHandler::LoggingHandler(QObject *parent) :
JsonHandler(parent)
{
QVariantMap params;
QVariantMap returns;
QVariantMap timeFilter;
params.clear(); returns.clear();
setDescription("GetLogEntries", "Get the LogEntries matching the given filter. "
"Each list element of a given filter will be connected with OR "
"to each other. Each of the given filters will be connected with AND "
"to each other.");
timeFilter.insert("o:startDate", JsonTypes::basicTypeToString(JsonTypes::Int));
timeFilter.insert("o:endDate", JsonTypes::basicTypeToString(JsonTypes::Int));
params.insert("o:timeFilters", QVariantList() << timeFilter);
params.insert("o:loggingSources", QVariantList() << JsonTypes::loggingSourceRef());
params.insert("o:loggingLevels", QVariantList() << JsonTypes::loggingLevelRef());
params.insert("o:eventTypes", QVariantList() << JsonTypes::loggingEventTypeRef());
params.insert("o:typeIds", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("o:deviceIds", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("o:values", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Variant));
setParams("GetLogEntries", params);
returns.insert("loggingError", JsonTypes::loggingErrorRef());
returns.insert("o:logEntries", QVariantList() << JsonTypes::logEntryRef());
setReturns("GetLogEntries", returns);
// Notifications
params.clear();
setDescription("LogEntryAdded", "Emitted whenever an entry is appended to the logging system. ");
params.insert("logEntry", JsonTypes::logEntryRef());
setParams("LogEntryAdded", params);
params.clear();
setDescription("LogDatabaseUpdated", "Emitted whenever the database was updated. "
"The database will be updated when a log entry was deleted. A log "
"entry will be deleted when the corresponding device or a rule will "
"be removed, or when the oldest entry of the database was deleted to "
"keep to database in the size limits.");
setParams("LogDatabaseUpdated", params);
connect(GuhCore::instance()->logEngine(), &LogEngine::logEntryAdded, this, &LoggingHandler::logEntryAdded);
connect(GuhCore::instance()->logEngine(), &LogEngine::logDatabaseUpdated, this, &LoggingHandler::logDatabaseUpdated);
}
QVariantList PieChart::generateLegend()
{
QVariantList list;
QVariantMap map;
for(PieSlice *slice: slicesList){
map.clear();
map.insert("name", slice->name());
map.insert("color", slice->color());
list.append(map);
}
return list;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QQmlApplicationEngine engine("../EventManager/playground/qml_gui/MainWindow.qml");
QList<QObject *> Roots = engine.rootObjects();
assert(Roots.size() == 1);
QObject *MainWindow = Roots[0];
QObject *QmlFancyTab = MainWindow->findChild<QObject *>("FancyTabWidget");
assert(QmlFancyTab);
QVariantMap newElement; // QVariantMap will implicitly translates into JS-object
newElement.clear();
newElement.insert("name", "Im12age 13" );
newElement.insert("cost", "/mnt/freedata/home/Void/FFPics/1332603325_p04.jpg");
newElement.insert("componentName", "/mnt/freedata/home/Void/devel/EventManager/playground/qml_gui/SomeWidget1.qml");
QMetaObject::invokeMethod(QmlFancyTab, "addTab", Q_ARG(QVariant, QVariant::fromValue(newElement)));
newElement.clear();
newElement.insert("name", "Image 13" );
newElement.insert("cost", "/mnt/freedata/home/Void/FFPics/148.gif");
newElement.insert("componentName", "/mnt/freedata/home/Void/devel/Qt5Bin/5.1.0/gcc_64/qml/QtQuick/Controls/CheckBox.qml");
QMetaObject::invokeMethod(QmlFancyTab, "addTab", Q_ARG(QVariant, QVariant::fromValue(newElement)));
newElement.clear();
newElement.insert("name", "Im12age 13" );
newElement.insert("cost", "/mnt/freedata/home/Void/FFPics/1332603325_p04.jpg");
newElement.insert("componentName", "/mnt/freedata/home/Void/devel/EventManager/playground/qml_gui/SomeWidget2.qml");
QMetaObject::invokeMethod(QmlFancyTab, "addTab", Q_ARG(QVariant, QVariant::fromValue(newElement)));
QMetaObject::invokeMethod(QmlFancyTab, "showTab", Q_ARG(QVariant, QVariant::fromValue(0)));
// TQMLFancyTabWidget *FancyTabWidget = new TQMLFancyTabWidget;
// QObject::connect(QmlFancyTab, SIGNAL(clicked(int)), FancyTabWidget, SLOT(OnItemClicked(int)));
return app.exec();
}
void Storage::readGroups2Map(QVariantMap& target, const QString &file)
{
target.clear();
QSettings* limits = new QSettings (file, QSettings::IniFormat, this);
QStringList groups = limits->childGroups();
if (groups.count()) {
foreach (const QString& group, groups) {
QVariantMap variantMap;
limits->beginGroup(group);
QStringList keylist = limits->allKeys();
foreach (const QString& key, keylist) {
variantMap.insert(key, limits->value(key));
}
/*! Constructs a new \l EventHandler with the given \a parent. */
EventHandler::EventHandler(QObject *parent) :
JsonHandler(parent)
{
QVariantMap params;
QVariantMap returns;
// Notifications
params.clear(); returns.clear();
setDescription("EventTriggered", "Emitted whenever an Event is triggered.");
params.insert("event", JsonTypes::eventRef());
setParams("EventTriggered", params);
params.clear(); returns.clear();
setDescription("GetEventType", "Get the EventType for the given eventTypeId.");
params.insert("eventTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetEventType", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:eventType", JsonTypes::eventTypeRef());
setReturns("GetEventType", returns);
connect(GuhCore::instance(), &GuhCore::eventTriggered, this, &EventHandler::eventTriggered);
}
void UnpackTest::test_map()
{
QVariantMap m;
QVariantMap unpacked_m;
qint64 ll = 339625541;
m["ll"] = ll;
unpacked_m = MsgPack::unpack(MsgPack::pack(m)).toMap();
qDebug() << m << "<=>" << unpacked_m;
QVERIFY(m == unpacked_m);
m.clear();
ll = 3333642741;
m["ll"] = ll;
QByteArray packArray = MsgPack::pack(m);
unpacked_m = MsgPack::unpack(packArray).toMap();
qDebug() << m << "<=>" << unpacked_m;
QVERIFY(m == unpacked_m);
m.clear();
ll = 33336427413;
m["ll"] = ll;
unpacked_m = MsgPack::unpack(MsgPack::pack(m)).toMap();
qDebug() << m << "<=>" << unpacked_m;
QVERIFY(m == unpacked_m);
m.clear();
ll = 932838457459459;
m["ll"] = ll;
unpacked_m = MsgPack::unpack(MsgPack::pack(m)).toMap();
qDebug() << m << "<=>" << unpacked_m;
QVERIFY(m == unpacked_m);
}
void TestLogging::removeDevice()
{
// enable notifications
QCOMPARE(enableNotifications(), true);
// get this logentry with filter
QVariantMap params;
params.insert("deviceIds", QVariantList() << m_mockDeviceId);
QVariant response = injectAndWait("Logging.GetLogEntries", params);
verifyLoggingError(response);
QVariantList logEntries = response.toMap().value("params").toMap().value("logEntries").toList();
QVERIFY(logEntries.count() > 0);
QSignalSpy clientSpy(m_mockTcpServer, SIGNAL(outgoingData(QUuid,QByteArray)));
// Remove the device
params.clear();
params.insert("deviceId", m_mockDeviceId);
response = injectAndWait("Devices.RemoveConfiguredDevice", params);
verifyDeviceError(response);
clientSpy.wait(200);
QVariant notification = checkNotification(clientSpy, "Logging.LogDatabaseUpdated");
QVERIFY(!notification.isNull());
// verify that the logs from this device where removed from the db
params.clear();
params.insert("deviceIds", QVariantList() << m_mockDeviceId);
response = injectAndWait("Logging.GetLogEntries", params);
verifyLoggingError(response);
logEntries = response.toMap().value("params").toMap().value("logEntries").toList();
QCOMPARE(logEntries.count(), 0);
// disable notifications
QCOMPARE(disableNotifications(), true);
}
QVariantList MemoryUsageModel::labels() const
{
QVariantList result;
QVariantMap element;
element.insert(QLatin1String("description"), tr("Memory Allocation"));
element.insert(QLatin1String("id"), HeapPage);
result << element;
element.clear();
element.insert(QLatin1String("description"), tr("Memory Usage"));
element.insert(QLatin1String("id"), SmallItem);
result << element;
return result;
}
QList<QVariantMap> TcDataAccess::fetchAll(const QString &sql,
const QVariantList &bind /* = QVariantList() */)
{
_prepareExec(sql, bind);
QList<QVariantMap> result;
QVariantMap row;
while (_query->next())
{
QSqlRecord rec = _query->record();
for (int i = rec.count() - 1; i > -1; i--)
{
row[_case(rec.fieldName(i))] = _trim(rec.value(i));
}
result << row;
row.clear();
}
return result;
}
QList<QVariantMap> DataAccess::fetchAll(const QString &sql,
const QVariantList &bind /* = QVariantList() */)
{
QSqlQuery *q = _prepareExec(sql, bind);
QList<QVariantMap> result;
QVariantMap row;
while (q->next())
{
QSqlRecord rec = q->record();
for (int i = rec.count() - 1; i > -1; i--)
{
row[rec.fieldName(i)] = rec.value(i);
}
result << row;
row.clear();
}
delete q;
return result;
}
QVariantList SettingsUi::getApplications()
{
QVariantList tmp;
QVariantMap map;
QFileInfoList list;
QDir dir;
dir.setPath("/usr/share/applications/");
dir.setFilter(QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks);
dir.setNameFilters(QStringList() << "*.desktop");
dir.setSorting(QDir::Name);
list = dir.entryInfoList();
for (int i=0 ; i<list.size() ; i++)
{
MDesktopEntry app(list.at(i).absoluteFilePath());
if (!app.hidden() && !app.icon().isEmpty() && !app.noDisplay() && !app.notShowIn().contains("X-Meego"))
{
map.clear();
map.insert("filePath", list.at(i).absoluteFilePath());
map.insert("name", app.name());
if (app.icon().startsWith("icon-launcher-") || app.icon().startsWith("icon-l-") || app.icon().startsWith("icons-Applications"))
map.insert("iconId", QString("image://theme/%1").arg(app.icon()));
else if (app.icon().startsWith("/"))
map.insert("iconId", QString("%1").arg(app.icon()));
else
map.insert("iconId", QString("/usr/share/icons/hicolor/86x86/apps/%1.png").arg(app.icon()));
map.insert("isAndroid", app.exec().contains("apkd-launcher"));
tmp.append(map);
}
}
// sort them by application name
std::sort(tmp.begin(), tmp.end(), appNameLessThan);
return tmp;
}
QVariantList SettingsUi::getCurrentShortcuts()
{
QVariantList tmp;
QVariantMap map;
QSettings settings("harbour-tohkbd2", "tohkbd2");
settings.beginGroup("applicationshortcuts");
for (int i = KEY_1 ; i<=KEY_EQUAL ; i++)
{
QString appPath = settings.value(QString("KEY_F%1").arg((i-KEY_1)+1), "none" ).toString();
map.clear();
map.insert("key", QString("F%1").arg((i-KEY_1)+1));
map.insert("filePath", appPath);
MDesktopEntry app(appPath);
if (app.isValid())
map.insert("name", app.name());
else
map.insert("name", "Not configured");
if (app.icon().startsWith("icon-launcher-") || app.icon().startsWith("icon-l-") || app.icon().startsWith("icons-Applications"))
map.insert("iconId", QString("image://theme/%1").arg(app.icon()));
else if (app.icon().startsWith("/"))
map.insert("iconId", QString("%1").arg(app.icon()));
else
map.insert("iconId", QString("/usr/share/icons/hicolor/86x86/apps/%1.png").arg(app.icon()));
map.insert("isAndroid", app.exec().contains("apkd-launcher"));
tmp.append(map);
}
settings.endGroup();
return tmp;
}
QVariantMap SettingsMessage::toVariantMap(const SettingsMessage & message,
const Sender & sender,
const Reciever & reciever,
const Recievers & recievers,
const ReliableTime & reliableTime) {
QVariantMap map;
map["header"] = QVariantMap() = {
{ "sender", sender.isEmpty() ? message.sender() : sender },
{ "reciever", reciever.isEmpty() ? message.reciever() : reciever },
{ "recievers", recievers.isEmpty() ? QVariant(message.recievers()) : QVariant(recievers) },
{ "reliableTime", reliableTime == ReliableTime(-1) ? message.reliableTime() : reliableTime }
};
QVariantMap mapData;
QVariantMap mapKeyVarMS;
QVariantMap mapKeyMS;
for (const QString & key : message.data.keys()) {
if (key != "action") {
mapKeyMS = message.data[key].toMap();
for (const QString & keykey : mapKeyMS.keys()) {
mapKeyVarMS[keykey] = mapKeyMS[keykey];
}
mapData[key] = mapKeyVarMS;
mapKeyVarMS.clear();
}
}
mapData["action"] = message.data["action"];
map["data"] = mapData;
return map;
}
void text_helper::checkAndProcessColumnHeaders( QTextStream &stream, const QString &delimiter,
QList<QVariantMap> &metaData, int firstDataColumn )
{
qint64 streamStartingPosition = stream.pos();
QString line = QString(stream.readLine());
QStringList strings = line.split(delimiter);
bool headerFound = true;
int column;
QVariantMap variantMap;
//Check if the first line is not a header (only contains spaces, numbers, decimal points)
QRegExp re("^[ .0-9]*$");
if (re.exactMatch(line)) {
//reset stream and return
stream.seek(streamStartingPosition);
headerFound = false;
}
for (column = firstDataColumn; column < strings.size(); column++) {
variantMap.clear();
if (headerFound) {
if (strings.value(column).size() != 0) {
variantMap["Key Field"] = strings.value(column);
variantMap["Data Source"] = column;
}
} else {
//Use column number as the header
variantMap["Key Field"] = QString(tr("Column ")) + QString::number(column);
variantMap["Data Source"] = column;
}
if (!variantMap.isEmpty())
metaData.append(variantMap);
}
}
JsonRPCServer::JsonRPCServer(QObject *parent):
JsonHandler(parent),
#ifdef TESTING_ENABLED
m_tcpServer(new MockTcpServer(this)),
#else
m_tcpServer(new TcpServer(this)),
#endif
m_notificationId(0)
{
// First, define our own JSONRPC methods
QVariantMap returns;
QVariantMap params;
params.clear(); returns.clear();
setDescription("Introspect", "Introspect this API.");
setParams("Introspect", params);
returns.insert("methods", JsonTypes::basicTypeToString(JsonTypes::Object));
returns.insert("types", JsonTypes::basicTypeToString(JsonTypes::Object));
setReturns("Introspect", returns);
params.clear(); returns.clear();
setDescription("Version", "Version of this Guh/JSONRPC interface.");
setParams("Version", params);
returns.insert("version", JsonTypes::basicTypeToString(JsonTypes::String));
returns.insert("protocol version", JsonTypes::basicTypeToString(JsonTypes::String));
setReturns("Version", returns);
params.clear(); returns.clear();
setDescription("SetNotificationStatus", "Enable/Disable notifications for this connections.");
params.insert("enabled", JsonTypes::basicTypeToString(JsonTypes::Bool));
setParams("SetNotificationStatus", params);
returns.insert("enabled", JsonTypes::basicTypeToString(JsonTypes::Bool));
setReturns("SetNotificationStatus", returns);
// Now set up the logic
connect(m_tcpServer, SIGNAL(clientConnected(const QUuid &)), this, SLOT(clientConnected(const QUuid &)));
connect(m_tcpServer, SIGNAL(clientDisconnected(const QUuid &)), this, SLOT(clientDisconnected(const QUuid &)));
connect(m_tcpServer, SIGNAL(dataAvailable(const QUuid &, QByteArray)), this, SLOT(processData(const QUuid &, QByteArray)));
m_tcpServer->startServer();
QMetaObject::invokeMethod(this, "setup", Qt::QueuedConnection);
}
void QueryTest::testResponse_data()
{
QTest::addColumn<bool>("isSuccess");
QTest::addColumn<QByteArray>("xml");
QTest::addColumn<QVariantList>("arguments");
QVariantMap map;
map[QLatin1String("faultCode")] = 10;
map[QLatin1String("faultString")] = QLatin1String("Fatal Server Error");
QTest::newRow("fault") << false
<< XML_FAULT_HEAD
"<value><struct>"
"<member><name>faultCode</name><value><int>10</int></value></member>"
"<member><name>faultString</name><value><string><![CDATA[Fatal Server Error]]></string></value></member>"
"</struct></value>"
XML_FAULT_END
<< (QVariantList() << map);
QTest::newRow("string") << true
<< XML_RESPONSE_HEAD
"<param>"
"<value><STRING><![CDATA[result]]></STRING></value>"
"</param>"
XML_RESPONSE_END
<< (QVariantList() << QLatin1String("result"));
QTest::newRow("int") << true
<< XML_RESPONSE_HEAD
"<param>"
"<value><INT>1</INT></value>"
"</param>"
XML_RESPONSE_END
<< (QVariantList() << 1);
QTest::newRow("i4") << true
<< XML_RESPONSE_HEAD
"<param><value><I4>42</I4></value></param>"
XML_RESPONSE_END
<< (QVariantList() << 42);
QTest::newRow("boolean (num)") << true
<< XML_RESPONSE_HEAD
"<param><value><BOOLEAN>1</BOOLEAN></value></param>"
XML_RESPONSE_END
<< (QVariantList() << true);
QTest::newRow("boolean (str)") << true
<< XML_RESPONSE_HEAD
"<param><value><BOOLEAN>TruE</BOOLEAN></value></param>"
XML_RESPONSE_END
<< (QVariantList() << true);
QTest::newRow("base64") << true
<< XML_RESPONSE_HEAD
"<param><value><BASE64>VmFsaWQgcmVzcG9uc2UK</BASE64></value></param>"
XML_RESPONSE_END
<< (QVariantList() << QByteArray("Valid response\n"));
QTest::newRow("datetime") << true
<< XML_RESPONSE_HEAD
"<param><value><DATETIME>2015-01-05T18:02:22</DATETIME></value></param>"
XML_RESPONSE_END
<< (QVariantList() << QDateTime(QDate(2015, 01, 05), QTime(18, 02, 22)));
QTest::newRow("datetime 2") << true
<< XML_RESPONSE_HEAD
"<param><value><dateTime.iso8601>2015-01-05T17:03:15Z</dateTime.iso8601></value></param>"
XML_RESPONSE_END
<< (QVariantList() << QDateTime(QDate(2015, 01, 05), QTime(17, 03, 15), Qt::UTC));
QTest::newRow("array") << true
<< XML_RESPONSE_HEAD
"<param><value><ARRAY><data>"
"<value><STRING><![CDATA[item 1]]></STRING></value>"
"<value><STRING><![CDATA[item 2]]></STRING></value>"
"</data></ARRAY></value></param>"
XML_RESPONSE_END
<< (QVariantList() << QVariant(QVariantList() << QLatin1String("item 1")
<< QLatin1String("item 2")));
map.clear();
map[QLatin1String("Key 1")] = 15;
map[QLatin1String("Key 2")] = QLatin1String("Value");
QTest::newRow("struct") << true
<< XML_RESPONSE_HEAD
"<param><value><STRUCT>"
"<member><name>Key 1</name><value><I4>15</I4></value></member>"
"<member><name>Key 2</name><value><string><![CDATA[Value]]></string></value></member>"
"</STRUCT></value></param>"
XML_RESPONSE_END
<< (QVariantList() << map);
}
RulesHandler::RulesHandler(QObject *parent) :
JsonHandler(parent)
{
QVariantMap params;
QVariantMap returns;
params.clear(); returns.clear();
setDescription("GetRules", "Get the descriptions of all configured rules. If you need more information about a specific rule use the "
"method Rules.GetRuleDetails.");
setParams("GetRules", params);
returns.insert("ruleDescriptions", QVariantList() << JsonTypes::ruleDescriptionRef());
setReturns("GetRules", returns);
params.clear(); returns.clear();
setDescription("GetRuleDetails", "Get details for the rule identified by ruleId");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetRuleDetails", params);
returns.insert("o:rule", JsonTypes::ruleRef());
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("GetRuleDetails", returns);
params.clear(); returns.clear();
setDescription("AddRule", "Add a rule. You can describe rules by one or many EventDesciptors and a StateEvaluator. Note that only "
"one of either eventDescriptor or eventDescriptorList may be passed at a time. A rule can be created but left disabled, "
"meaning it won't actually be executed until set to enabled. If not given, enabled defaults to true.");
params.insert("o:eventDescriptor", JsonTypes::eventDescriptorRef());
params.insert("o:eventDescriptorList", QVariantList() << JsonTypes::eventDescriptorRef());
params.insert("o:stateEvaluator", JsonTypes::stateEvaluatorRef());
params.insert("o:exitActions", QVariantList() << JsonTypes::ruleActionRef());
params.insert("o:enabled", JsonTypes::basicTypeToString(JsonTypes::Bool));
params.insert("o:executable", JsonTypes::basicTypeToString(JsonTypes::Bool));
params.insert("name", JsonTypes::basicTypeToString(JsonTypes::String));
QVariantList actions;
actions.append(JsonTypes::ruleActionRef());
params.insert("actions", actions);
setParams("AddRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
returns.insert("o:ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("AddRule", returns);
params.clear(); returns.clear(); actions.clear();
setDescription("EditRule", "Edit the parameters of a rule. The configuration of the rule with the given ruleId "
"will be replaced with the new given configuration. In ordert to enable or disable a Rule, please use the "
"methods \"Rules.EnableRule\" and \"Rules.DisableRule\". If successfull, the notification \"Rule.RuleConfigurationChanged\" "
"will be emitted.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("name", JsonTypes::basicTypeToString(JsonTypes::String));
params.insert("o:eventDescriptor", JsonTypes::eventDescriptorRef());
params.insert("o:eventDescriptorList", QVariantList() << JsonTypes::eventDescriptorRef());
params.insert("o:stateEvaluator", JsonTypes::stateEvaluatorRef());
params.insert("o:exitActions", QVariantList() << JsonTypes::ruleActionRef());
params.insert("o:enabled", JsonTypes::basicTypeToString(JsonTypes::Bool));
params.insert("o:executable", JsonTypes::basicTypeToString(JsonTypes::Bool));
actions.append(JsonTypes::ruleActionRef());
params.insert("actions", actions);
setParams("EditRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
returns.insert("o:rule", JsonTypes::ruleRef());
setReturns("EditRule", returns);
params.clear(); returns.clear();
setDescription("RemoveRule", "Remove a rule");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("RemoveRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("RemoveRule", returns);
params.clear(); returns.clear();
setDescription("FindRules", "Find a list of rules containing any of the given parameters.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("FindRules", params);
returns.insert("ruleIds", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("FindRules", returns);
params.clear(); returns.clear();
setDescription("EnableRule", "Enabled a rule that has previously been disabled."
"If successfull, the notification \"Rule.RuleConfigurationChanged\" will be emitted.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("EnableRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("EnableRule", returns);
params.clear(); returns.clear();
setDescription("DisableRule", "Disable a rule. The rule won't be triggered by it's events or state changes while it is disabled. "
"If successfull, the notification \"Rule.RuleConfigurationChanged\" will be emitted.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("DisableRule", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("DisableRule", returns);
params.clear(); returns.clear();
setDescription("ExecuteActions", "Execute the action list of the rule with the given ruleId.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("ExecuteActions", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("ExecuteActions", returns);
params.clear(); returns.clear();
setDescription("ExecuteExitActions", "Execute the exit action list of the rule with the given ruleId.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("ExecuteExitActions", params);
returns.insert("ruleError", JsonTypes::ruleErrorRef());
setReturns("ExecuteExitActions", returns);
// Notifications
params.clear(); returns.clear();
setDescription("RuleRemoved", "Emitted whenever a Rule was removed.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("RuleRemoved", params);
params.clear(); returns.clear();
setDescription("RuleAdded", "Emitted whenever a Rule was added.");
params.insert("rule", JsonTypes::ruleRef());
setParams("RuleAdded", params);
params.clear(); returns.clear();
setDescription("RuleActiveChanged", "Emitted whenever the active state of a Rule changed.");
params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("active", JsonTypes::basicTypeToString(JsonTypes::Bool));
setParams("RuleActiveChanged", params);
params.clear(); returns.clear();
setDescription("RuleConfigurationChanged", "Emitted whenever the configuration of a Rule changed.");
params.insert("rule", JsonTypes::ruleRef());
setParams("RuleConfigurationChanged", params);
connect(GuhCore::instance(), &GuhCore::ruleAdded, this, &RulesHandler::ruleAddedNotification);
connect(GuhCore::instance(), &GuhCore::ruleRemoved, this, &RulesHandler::ruleRemovedNotification);
connect(GuhCore::instance(), &GuhCore::ruleActiveChanged, this, &RulesHandler::ruleActiveChangedNotification);
connect(GuhCore::instance(), &GuhCore::ruleConfigurationChanged, this, &RulesHandler::ruleConfigurationChangedNotification);
}
// Parameter List:
// Name - String displayed as name in Qt Creator
// qmake path - location of the qmake binary
// Type identifier - Desktop, Simulator, Symbian, ...
// SDK identifier - unique string to identify Qt version inside of the SDK (eg. desk473, simu11, ...)
// System Root Path
// sbs path
bool RegisterQtInCreatorV23Operation::performOperation()
{
const QStringList args = arguments();
if (args.count() < 4) {
setError(InvalidArguments);
setErrorString(tr("Invalid arguments in %0: %1 arguments given, minimum 4 expected.")
.arg(name()).arg(args.count()));
return false;
}
PackageManagerCore *const core = qVariantValue<PackageManagerCore*>(value(QLatin1String("installer")));
if (!core) {
setError(UserDefinedError);
setErrorString(tr("Needed installer object in \"%1\" operation is empty.").arg(name()));
return false;
}
const QString &rootInstallPath = core->value(scTargetDir);
if (rootInstallPath.isEmpty() || !QDir(rootInstallPath).exists()) {
setError(UserDefinedError);
setErrorString(tr("The given TargetDir %1 is not a valid/existing dir.").arg(rootInstallPath));
return false;
}
const QString qtVersionsFileName = rootInstallPath
+ QLatin1String(QtVersionSettingsSuffixPath);
int argCounter = 0;
const QString &versionName = args.at(argCounter++);
const QString &path = QDir::toNativeSeparators(args.value(argCounter++));
const QString versionQmakePath = absoluteQmakePath(path);
const QString &versionTypeIdentifier = args.at(argCounter++);
const QString &versionSDKIdentifier = args.at(argCounter++);
const QString &versionSystemRoot = fromNativeSeparatorsAllOS(args.value(argCounter++));
const QString &versionSbsPath = fromNativeSeparatorsAllOS(args.value(argCounter++));
ProjectExplorer::PersistentSettingsReader reader;
int qtVersionCount = 0;
QVariantMap map;
if (reader.load(qtVersionsFileName)) {
map = reader.restoreValues();
qtVersionCount = map.value(QLatin1String("QtVersion.Count")).toInt();
map.remove(QLatin1String("QtVersion.Count"));
map.remove(QLatin1String("Version"));
}
ProjectExplorer::PersistentSettingsWriter writer;
// Store old qt versions
if (!map.isEmpty()) {
for (int i = 0; i < qtVersionCount; ++i) {
writer.saveValue(QString::fromLatin1("QtVersion.%1").arg(i)
, map[QLatin1String("QtVersion.") + QString::number(i)].toMap());
}
map.clear();
}
// Enter new version
map.insert(QLatin1String("Id"), -1);
map.insert(QLatin1String("Name"), versionName);
map.insert(QLatin1String("QMakePath"), versionQmakePath);
map.insert(QLatin1String("QtVersion.Type"),
QLatin1String("Qt4ProjectManager.QtVersion.") + versionTypeIdentifier);
map.insert(QLatin1String("isAutodetected"), true);
map.insert(QLatin1String("autodetectionSource"),
QLatin1String("SDK.") + versionSDKIdentifier);
if (!versionSystemRoot.isEmpty())
map.insert(QLatin1String("SystemRoot"), versionSystemRoot);
if (!versionSbsPath.isEmpty())
map.insert(QLatin1String("SBSv2Directory"), versionSbsPath);
writer.saveValue(QLatin1String("QtVersion.") + QString::number(qtVersionCount), map);
writer.saveValue(QLatin1String("Version"), 1);
writer.saveValue(QLatin1String("QtVersion.Count"), qtVersionCount + 1);
QDir().mkpath(QFileInfo(qtVersionsFileName).absolutePath());
writer.save(qtVersionsFileName, QLatin1String("QtCreatorQtVersions"));
return true;
}
int BdLogic::SetDataModelOrdering(int order)
{
QVariantMap actionMapFromJson;
QVariantList actionListFromJson;
QVariantMap actionFromJson;
QVariantMap actionForQml;
m_actionListOrderedForQML.clear();
switch(order)
{
case BdLogic::OrderByBox:
default:
for(int boxIx = DLSTATE_INBOX; boxIx < DLSTATE_FINISHED; boxIx++)
{
actionMapFromJson = m_boxMapParsedJson[BoxNames[boxIx]].toMap();
actionListFromJson = actionMapFromJson["entities"].toList();
actionForQml.clear();
actionForQml["itemType"] = 1;
actionForQml["name"] = BoxNames[boxIx];
m_actionListOrderedForQML.push_back(actionForQml);
for(int actionIx = 0; actionIx < actionListFromJson.length(); actionIx++)
{
actionFromJson = actionListFromJson[actionIx].toMap();
actionForQml.clear();
actionForQml["itemType"] = 0;
actionForQml["name"] = actionFromJson["title"];
actionForQml["box"] = actionFromJson["attribute"];
actionForQml["project"] = getProjectNameFromJsonAction(actionFromJson);
actionForQml["context"] = getContextNameFromJsonAction(actionFromJson);
actionForQml["priority"] = actionFromJson["priority"].toInt();
m_actionListOrderedForQML.push_back(actionForQml);
}
}
break;
case BdLogic::OrderByContext:
{
QVariantMap resourcesMapFromJson;
QVariantList contextListFromJson;
QVariantMap contextFromJson;
resourcesMapFromJson = m_boxMapParsedJson[BoxNames[DLSTATE_RESOURCES]].toMap();
resourcesMapFromJson = resourcesMapFromJson["resources"].toMap();
contextListFromJson = resourcesMapFromJson["contexts"].toList();
// Add an extra context entry with an empty name string
// to match against actions with no context
contextFromJson["name"] = QString("No context");
contextListFromJson.push_back(contextFromJson);
for(int contextIx = 0; contextIx < contextListFromJson.length(); contextIx++)
{
contextFromJson = contextListFromJson[contextIx].toMap();
actionForQml.clear();
actionForQml["itemType"] = 1;
actionForQml["name"] = contextFromJson["name"].toString();
m_actionListOrderedForQML.push_back(actionForQml);
for(int boxIx = DLSTATE_INBOX; boxIx < DLSTATE_FINISHED; boxIx++)
{
actionMapFromJson = m_boxMapParsedJson[BoxNames[boxIx]].toMap();
actionListFromJson = actionMapFromJson["entities"].toList();
for(int actionIx = 0; actionIx < actionListFromJson.length(); actionIx++)
{
actionFromJson = actionListFromJson[actionIx].toMap();
if( (actionFromJson["context"].toString() == contextFromJson["uuid"].toString()) ||
((actionIx == contextListFromJson.length()) && (actionFromJson["context"].toString() == QString())) )
{
actionForQml.clear();
actionForQml["itemType"] = 0;
actionForQml["name"] = actionFromJson["title"];
actionForQml["box"] = actionFromJson["attribute"];
actionForQml["project"] = getProjectNameFromJsonAction(actionFromJson);
actionForQml["context"] = getContextNameFromJsonAction(actionFromJson);
actionForQml["priority"] = actionFromJson["priority"].toInt();
m_actionListOrderedForQML.push_back(actionForQml);
}
}
}
}
}
break;
case BdLogic::OrderByProject:
{
QVariantMap resourcesMapFromJson;
QVariantList projectListFromJson;
QVariantMap projectFromJson;
resourcesMapFromJson = m_boxMapParsedJson[BoxNames[DLSTATE_RESOURCES]].toMap();
resourcesMapFromJson = resourcesMapFromJson["resources"].toMap();
projectListFromJson = resourcesMapFromJson["projects"].toList();
// Add an extra project entry with an empty name string
// to match against actions with no project
projectFromJson["name"] = QString("No project");
projectListFromJson.push_back(projectFromJson);
for(int projectIx = 0; projectIx < projectListFromJson.length(); projectIx++)
{
projectFromJson = projectListFromJson[projectIx].toMap();
actionForQml.clear();
actionForQml["itemType"] = 1;
actionForQml["name"] = projectFromJson["name"].toString();
m_actionListOrderedForQML.push_back(actionForQml);
for(int boxIx = DLSTATE_INBOX; boxIx < DLSTATE_FINISHED; boxIx++)
{
actionMapFromJson = m_boxMapParsedJson[BoxNames[boxIx]].toMap();
actionListFromJson = actionMapFromJson["entities"].toList();
for(int actionIx = 0; actionIx < actionListFromJson.length(); actionIx++)
{
actionFromJson = actionListFromJson[actionIx].toMap();
if( (actionFromJson["project"].toString() == projectFromJson["uuid"].toString()) ||
((actionIx == projectListFromJson.length()) && (actionFromJson["project"].toString() == QString())) )
{
actionForQml.clear();
actionForQml["itemType"] = 0;
actionForQml["name"] = actionFromJson["title"];
actionForQml["box"] = actionFromJson["attribute"];
actionForQml["project"] = getProjectNameFromJsonAction(actionFromJson);
actionForQml["context"] = getContextNameFromJsonAction(actionFromJson);
actionForQml["priority"] = actionFromJson["priority"].toInt();
m_actionListOrderedForQML.push_back(actionForQml);
}
}
}
}
}
break;
case BdLogic::OrderByPriority:
for(int priority = 3; priority >= 0; priority--)
{
actionForQml.clear();
actionForQml["itemType"] = 1;
QString prioHeaderName("Priority: ");
switch(priority)
{
case 3:
prioHeaderName += "High";
break;
case 2:
prioHeaderName += "Medium";
break;
case 1:
prioHeaderName += "Low";
break;
case 0:
default:
prioHeaderName += "None";
break;
}
actionForQml["name"] = prioHeaderName;
m_actionListOrderedForQML.push_back(actionForQml);
for(int boxIx = DLSTATE_INBOX; boxIx < DLSTATE_FINISHED; boxIx++)
{
actionMapFromJson = m_boxMapParsedJson[BoxNames[boxIx]].toMap();
actionListFromJson = actionMapFromJson["entities"].toList();
for(int actionIx = 0; actionIx < actionListFromJson.length(); actionIx++)
{
actionFromJson = actionListFromJson[actionIx].toMap();
if( actionFromJson["priority"].toInt() == priority )
{
actionForQml.clear();
actionForQml["itemType"] = 0;
actionForQml["name"] = actionFromJson["title"];
actionForQml["box"] = actionFromJson["attribute"];
actionForQml["project"] = getProjectNameFromJsonAction(actionFromJson);
actionForQml["context"] = getContextNameFromJsonAction(actionFromJson);
actionForQml["priority"] = actionFromJson["priority"].toInt();
m_actionListOrderedForQML.push_back(actionForQml);
}
}
}
}
break;
}
return 0;
}
