MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent), ui(new Ui::MainWindow) {
ui->setupUi(this);
QFile styleFile(":/style.css");
styleFile.open(QFile::ReadOnly);
QString styleSheet = QLatin1String(styleFile.readAll());
qApp->setStyleSheet(styleSheet);
QPixmap window_icon;
QFile iconFile(":/icon.png");
iconFile.open(QFile::ReadOnly);
QByteArray icon_data = iconFile.readAll();
window_icon.loadFromData(icon_data);
qApp->setWindowIcon(QIcon(window_icon));
awesome = new QtAwesome(qApp);
settings = new Settings(this);
window_watcher = new WindowWatcher(this);
anitomy = new AnitomyWrapper();
event_timer = new QTimer(this);
watch_timer = new QTimer(this);
uptime_timer = new QElapsedTimer;
progress_bar = new QProgressBar(ui->statusBar);
over = new Overlay(this);
torrent_refresh_time = 0;
user_refresh_time =
settings->getValue(Settings::UserRefreshTime, D_USER_REFRESH_TIME)
.toInt();
download_rule = 0;
download_count = 0;
hasUser = false;
uptime_timer->start();
watch_timer->setSingleShot(true);
awesome->initFontAwesome();
bool check_for_updates =
settings->getValue(Settings::CheckUpdates, D_CHECK_FOR_UPDATES).toBool();
if (check_for_updates) {
connect(FvUpdater::sharedUpdater(), &FvUpdater::restartRequested,
[&]() { // NOLINT
QString app = QApplication::applicationFilePath();
QStringList arguments = QApplication::arguments();
QString wd = QDir::currentPath();
QProcess::startDetached(app, arguments, wd);
elegantClose(true);
});
FvUpdater::sharedUpdater()->CheckForUpdatesSilent();
}
QFont font = ui->listTabs->tabBar()->font();
font.setCapitalization(QFont::Capitalize);
ui->listTabs->tabBar()->setFont(font);
int currentYear = QDate::currentDate().year();
int lowerYear = currentYear - 10;
while (currentYear > lowerYear) {
ui->comboYear->addItem(QString::number(currentYear));
currentYear--;
}
QWidget *container = new QWidget(ui->scrollArea);
layout = new FlowLayout(container);
ui->scrollArea->setWidget(container);
container->setLayout(layout);
QWidget *container2 = new QWidget(ui->scrollArea_2);
layout2 = new FlowLayout(container2);
layout2->disableSort();
ui->scrollArea_2->setWidget(container2);
container2->setLayout(layout2);
QVariantMap black;
black.insert("color", QColor(0, 0, 0));
black.insert("color-active", QColor(0, 0, 0));
black.insert("color-disabled", QColor(0, 0, 0));
black.insert("color-selected", QColor(0, 0, 0));
ui->airingButton->setIcon(awesome->icon(fa::clocko, black));
ui->torrentsButton->setIcon(awesome->icon(fa::rss, black));
ui->animeButton->setIcon(awesome->icon(fa::bars, black));
ui->seasonsButton->setIcon(awesome->icon(fa::th, black));
ui->statisticsButton->setIcon(awesome->icon(fa::piechart, black));
ui->tabWidget->tabBar()->hide();
ui->tabWidget->setCurrentIndex(UserTabs::tAnime);
ui->listTabs->setCurrentIndex(0);
ui->statusBar->addWidget(progress_bar);
ui->statusBar->layout()->setContentsMargins(1, 0, 0, 0);
progress_bar->setRange(0, 100);
progress_bar->setValue(5);
progress_bar->setFormat("Authorizing");
QSettings s;
restoreGeometry(s.value("mainWindowGeometry").toByteArray());
restoreState(s.value("mainWindowState").toByteArray());
connect(&user_future_watcher, SIGNAL(finished()), SLOT(userLoaded()));
connect(&user_list_future_watcher, SIGNAL(finished()),
SLOT(userListLoaded()));
connect(ui->animeButton, SIGNAL(clicked()), SLOT(showAnimeTab()));
connect(ui->airingButton, SIGNAL(clicked()), SLOT(showAiringTab()));
connect(ui->torrentsButton, SIGNAL(clicked()), SLOT(showTorrentsTab()));
connect(ui->seasonsButton, SIGNAL(clicked()), SLOT(showBrowseTab()));
connect(ui->actionSettings, SIGNAL(triggered()), SLOT(showSettings()));
connect(ui->statisticsButton, SIGNAL(clicked()), SLOT(showStatisticsTab()));
connect(ui->actionExit, &QAction::triggered, [&, this]() { // NOLINT
this->elegantClose();
});
connect(ui->actionAbout, &QAction::triggered, [&, this]() { // NOLINT
About *about = new About(this);
about->show();
});
connect(ui->actionHelp, &QAction::triggered, [&, this]() { // NOLINT
QDesktopServices::openUrl(QUrl("http://app.shinjiru.me/support.php"));
});
connect(ui->actionRL, &QAction::triggered, [&, this]() { // NOLINT
loadUser();
});
connect(ui->actionAS, &QAction::triggered, [&]() { // NOLINT
SearchPanel *sp = new SearchPanel(this);
sp->show();
});
connect(ui->actionARR, &QAction::triggered, [&, this]() { // NOLINT
SettingsDialog *s = new SettingsDialog(this);
s->showSmartTitles();
connect(s, &QDialog::accepted, [&, this]() { // NOLINT
Settings set;
toggleAnimeRecognition(
set.getValue(Settings::AnimeRecognitionEnabled, D_ANIME_RECOGNITION)
.toBool());
torrents_enabled =
set.getValue(Settings::TorrentsEnabled, D_TORRENTS_ENABLED).toBool();
reloadSmartTitles();
reloadRules();
});
});
connect(qApp, SIGNAL(aboutToQuit()), SLOT(elegantClose()));
connect(ui->actionVAL, SIGNAL(triggered()), SLOT(viewAnimeList()));
connect(ui->actionVD, SIGNAL(triggered()), SLOT(viewDashboard()));
connect(ui->actionVP, SIGNAL(triggered()), SLOT(viewProfile()));
connect(ui->actionEAR, SIGNAL(triggered(bool)),
SLOT(toggleAnimeRecognition(bool)));
connect(ui->actionExport, SIGNAL(triggered()), SLOT(exportListJSON()));
connect(ui->actionUpdate, SIGNAL(triggered()), FvUpdater::sharedUpdater(),
SLOT(CheckForUpdatesNotSilent()));
connect(window_watcher, SIGNAL(title_found(QString)), SLOT(watch(QString)));
connect(watch_timer, SIGNAL(timeout()), SLOT(updateEpisode()));
connect(event_timer, SIGNAL(timeout()), SLOT(eventTick()));
connect(ui->torrentTable, SIGNAL(customContextMenuRequested(QPoint)),
SLOT(torrentContextMenu(QPoint)));
connect(ui->torrentFilter, SIGNAL(textChanged(QString)),
SLOT(filterTorrents(QString)));
connect(ui->chkHideUnknown, SIGNAL(toggled(bool)),
SLOT(filterTorrents(bool)));
connect(ui->refreshButton, SIGNAL(clicked()), SLOT(refreshTorrentListing()));
connect(ui->actionEAR, SIGNAL(toggled(bool)), SLOT(applyEAR()));
connect(ui->tabWidget, &QTabWidget::currentChanged, [&, this]( // NOLINT
int tab) {
if (tab != 0) {
this->over->removeDrawing("blank_table");
this->over->removeDrawing("no anime");
ui->listTabs->show();
ui->listFilterLineEdit->show();
} else {
this->filterList(3);
if (hasUser && (User::sharedUser()->getAnimeList().count() == 0)) {
this->addNoAnimePrompt();
}
}
});
ui->actionEAR->setChecked(
settings->getValue(Settings::AnimeRecognitionEnabled, D_ANIME_RECOGNITION)
.toBool());
this->toggleAnimeRecognition(ui->actionEAR->isChecked());
QString genrelist =
"Action, Adult, Adventure, Cars, Comedy, Dementia, Demons, Doujinshi, "
"Drama, Ecchi, Fantasy, Game, Gender Bender, Harem, Hentai, Historical, "
"Horror, Josei, Kids, Magic, Martial Arts, Mature, Mecha, Military, "
"Motion Comic, Music, Mystery, Mythological , Parody, Police, "
"Psychological, Romance, Samurai, School, Sci-Fi, Seinen, Shoujo, Shoujo "
"Ai, Shounen, Shounen Ai, Slice of Life, Space, Sports, Super Power, "
"Supernatural, Thriller, Tragedy, Vampire, Yaoi, Yuri";
QStringList genres = genrelist.split(", ");
for (QString genre : genres) {
QCheckBox *chk = new QCheckBox();
chk->setText(genre);
chk->setTristate(true);
ui->genreList->addWidget(chk);
}
connect(ui->listFilterLineEdit, SIGNAL(textChanged(QString)),
SLOT(filterList(QString)));
connect(ui->listFilterLineEdit, SIGNAL(returnPressed()), SLOT(showSearch()));
connect(ui->listTabs, SIGNAL(currentChanged(int)), SLOT(filterList(int)));
connect(ui->browseButton, SIGNAL(clicked()), SLOT(loadBrowserData()));
this->show();
createActions();
initTray();
trayIcon->show();
int result = API::sharedAPI()->verifyAPI();
if (result == AniListAPI::OK) {
connect(API::sharedAPI()->sharedAniListAPI(), &AniListAPI::access_granted,
[&, this]() { // NOLINT
progress_bar->setValue(10);
progress_bar->setFormat("Access granted");
loadUser();
event_timer->start(1000);
});
connect(API::sharedAPI()->sharedAniListAPI(), &AniListAPI::access_denied,
[&, this](QString error) { // NOLINT
qCritical() << error;
if (isVisible()) {
QMessageBox::critical(this, "Shinjiru", tr("Error: ") + error);
}
});
} else if (result == AniListAPI::NO_CONNECTION) {
qDebug() << "Starting Shinjiru in offline mode";
hasUser = User::sharedUser()->loadLocal();
}
reloadRules();
}
QVariantMap JpgHead::getExif()
{
if (!isProcessFile) return QVariantMap();
QVariantMap map;
map.insert("FileName", ImageInfo.FileName);
map.insert("FileDateTime", ImageInfo.FileDateTime);
map.insert("FileSize", ImageInfo.FileSize);
map.insert("CameraMake", ImageInfo.CameraMake);
map.insert("CameraModel", ImageInfo.CameraModel);
map.insert("DateTime", ImageInfo.DateTime);
map.insert("Height", ImageInfo.Height);
map.insert("Width", ImageInfo.Width);
map.insert("Orientation", ImageInfo.Orientation);
map.insert("IsColor", ImageInfo.IsColor);
map.insert("FocalLength35mmEquiv",ImageInfo.FocalLength35mmEquiv);
map.insert("ExposureTime", ImageInfo.ExposureTime);
return map;
//struct {
// // Info in the jfif header.
// // This info is not used much - jhead used to just replace it with default
// // values, and over 10 years, only two people pointed this out.
// char Present;
// char ResolutionUnits;
// short XDensity;
// short YDensity;
//}JfifHeader;
//int Process;
//int FlashUsed;
//float FocalLength;
//float ExposureTime;
//float ApertureFNumber;
//float Distance;
//float CCDWidth;
//float ExposureBias;
//float DigitalZoomRatio;
//int FocalLength35mmEquiv; // Exif 2.2 tag - usually not present.
//int Whitebalance;
//int MeteringMode;
//int ExposureProgram;
//int ExposureMode;
//int ISOequivalent;
//int LightSource;
//int DistanceRange;
//float xResolution;
//float yResolution;
//int ResolutionUnit;
//char Comments[MAX_COMMENT_SIZE];
//int CommentWidthchars; // If nonzero, widechar comment, indicates number of chars.
//unsigned ThumbnailOffset; // Exif offset to thumbnail
//unsigned ThumbnailSize; // Size of thumbnail.
//unsigned LargestExifOffset; // Last exif data referenced (to check if thumbnail is at end)
//char ThumbnailAtEnd; // Exif header ends with the thumbnail
//// (we can only modify the thumbnail if its at the end)
//int ThumbnailSizeOffset;
//int DateTimeOffsets[MAX_DATE_COPIES];
//int numDateTimeTags;
//int GpsInfoPresent;
//char GpsLat[31];
//char GpsLong[31];
//char GpsAlt[20];
}
QVariantMap IDevice::toMap() const
{
QVariantMap map;
map.insert(QLatin1String(DisplayNameKey), d->displayName);
map.insert(QLatin1String(TypeKey), d->type.toString());
map.insert(QLatin1String(IdKey), d->id.toSetting());
map.insert(QLatin1String(OriginKey), d->origin);
map.insert(QLatin1String(MachineTypeKey), d->machineType);
map.insert(QLatin1String(HostKey), d->sshParameters.host);
map.insert(QLatin1String(SshPortKey), d->sshParameters.port);
map.insert(QLatin1String(UserNameKey), d->sshParameters.userName);
map.insert(QLatin1String(AuthKey), d->sshParameters.authenticationType);
map.insert(QLatin1String(PasswordKey), d->sshParameters.password);
map.insert(QLatin1String(KeyFileKey), d->sshParameters.privateKeyFile);
map.insert(QLatin1String(TimeoutKey), d->sshParameters.timeout);
map.insert(QLatin1String(PortsSpecKey), d->freePorts.toString());
map.insert(QLatin1String(VersionKey), d->version);
map.insert(QLatin1String(DebugServerKey), d->debugServerPath);
return map;
}
QVariantMap AndroidToolChain::toMap() const
{
QVariantMap result = GccToolChain::toMap();
result.insert(QLatin1String(ANDROID_NDK_TC_VERION), m_ndkToolChainVersion);
return result;
}
void IntegerMutation::mutate(QVariantMap &map, QString key){
int newValue = this->mutate(map.value(key).toInt());
map.remove(key);
map.insert(key,QVariant((int)newValue));
}
QVariant
Result::toVariant() const
{
QVariantMap m;
m.insert( "artist", artist()->name() );
m.insert( "album", album()->name() );
m.insert( "track", track() );
if ( !collection().isNull() )
m.insert( "source", collection()->source()->friendlyName() );
else
m.insert( "source", friendlySource() );
m.insert( "mimetype", mimetype() );
m.insert( "size", size() );
m.insert( "bitrate", bitrate() );
m.insert( "duration", duration() );
m.insert( "score", score() );
m.insert( "sid", id() );
return m;
}
QVariantMap QgsBufferAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
std::unique_ptr< QgsFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !source )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, source->fields(), QgsWkbTypes::Polygon, source->sourceCrs() ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
// fixed parameters
bool dissolve = parameterAsBool( parameters, QStringLiteral( "DISSOLVE" ), context );
int segments = parameterAsInt( parameters, QStringLiteral( "SEGMENTS" ), context );
QgsGeometry::EndCapStyle endCapStyle = static_cast< QgsGeometry::EndCapStyle >( 1 + parameterAsInt( parameters, QStringLiteral( "END_CAP_STYLE" ), context ) );
QgsGeometry::JoinStyle joinStyle = static_cast< QgsGeometry::JoinStyle>( 1 + parameterAsInt( parameters, QStringLiteral( "JOIN_STYLE" ), context ) );
double miterLimit = parameterAsDouble( parameters, QStringLiteral( "MITER_LIMIT" ), context );
double bufferDistance = parameterAsDouble( parameters, QStringLiteral( "DISTANCE" ), context );
bool dynamicBuffer = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "DISTANCE" ) );
QgsExpressionContext expressionContext = createExpressionContext( parameters, context, dynamic_cast< QgsProcessingFeatureSource * >( source.get() ) );
QgsProperty bufferProperty;
if ( dynamicBuffer )
{
bufferProperty = parameters.value( QStringLiteral( "DISTANCE" ) ).value< QgsProperty >();
}
long count = source->featureCount();
QgsFeature f;
QgsFeatureIterator it = source->getFeatures();
double step = count > 0 ? 100.0 / count : 1;
int current = 0;
QVector< QgsGeometry > bufferedGeometriesForDissolve;
QgsAttributes dissolveAttrs;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( dissolveAttrs.isEmpty() )
dissolveAttrs = f.attributes();
QgsFeature out = f;
if ( out.hasGeometry() )
{
double distance = bufferDistance;
if ( dynamicBuffer )
{
expressionContext.setFeature( f );
distance = bufferProperty.valueAsDouble( expressionContext, bufferDistance );
}
QgsGeometry outputGeometry = f.geometry().buffer( distance, segments, endCapStyle, joinStyle, miterLimit );
if ( !outputGeometry )
{
QgsMessageLog::logMessage( QObject::tr( "Error calculating buffer for feature %1" ).arg( f.id() ), QObject::tr( "Processing" ), Qgis::Warning );
}
if ( dissolve )
bufferedGeometriesForDissolve << outputGeometry;
else
out.setGeometry( outputGeometry );
}
if ( !dissolve )
sink->addFeature( out, QgsFeatureSink::FastInsert );
feedback->setProgress( current * step );
current++;
}
if ( dissolve )
{
QgsGeometry finalGeometry = QgsGeometry::unaryUnion( bufferedGeometriesForDissolve );
QgsFeature f;
f.setGeometry( finalGeometry );
f.setAttributes( dissolveAttrs );
sink->addFeature( f, QgsFeatureSink::FastInsert );
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
return outputs;
}
DeviceHandler::DeviceHandler(QObject *parent) :
JsonHandler(parent)
{
QVariantMap returns;
QVariantMap params;
params.clear(); returns.clear();
setDescription("GetSupportedVendors", "Returns a list of supported Vendors.");
setParams("GetSupportedVendors", params);
QVariantList vendors;
vendors.append(JsonTypes::vendorRef());
returns.insert("vendors", vendors);
setReturns("GetSupportedVendors", returns);
params.clear(); returns.clear();
setDescription("GetSupportedDevices", "Returns a list of supported Device classes, optionally filtered by vendorId.");
params.insert("o:vendorId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetSupportedDevices", params);
QVariantList deviceClasses;
deviceClasses.append(JsonTypes::deviceClassRef());
returns.insert("deviceClasses", deviceClasses);
setReturns("GetSupportedDevices", returns);
params.clear(); returns.clear();
setDescription("GetPlugins", "Returns a list of loaded plugins.");
setParams("GetPlugins", params);
QVariantList plugins;
plugins.append(JsonTypes::pluginRef());
returns.insert("plugins", plugins);
setReturns("GetPlugins", returns);
params.clear(); returns.clear();
setDescription("GetPluginConfiguration", "Get a plugin's params.");
params.insert("pluginId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetPluginConfiguration", params);
QVariantList pluginParams;
pluginParams.append(JsonTypes::paramRef());
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:configuration", pluginParams);
setReturns("GetPluginConfiguration", returns);
params.clear(); returns.clear();
setDescription("SetPluginConfiguration", "Set a plugin's params.");
params.insert("pluginId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("configuration", pluginParams);
setParams("SetPluginConfiguration", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
setReturns("SetPluginConfiguration", returns);
params.clear(); returns.clear();
setDescription("AddConfiguredDevice", "Add a configured device with a setupMethod of SetupMethodJustAdd. "
"For devices with a setupMethod different than SetupMethodJustAdd, use PairDevice. "
"Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. "
"CreateMethodJustAdd takes the parameters you want to have with that device. "
"CreateMethodDiscovery requires the use of a deviceDescriptorId."
);
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("o:deviceDescriptorId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
QVariantList deviceParams;
deviceParams.append(JsonTypes::paramRef());
params.insert("o:deviceParams", deviceParams);
setParams("AddConfiguredDevice", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("AddConfiguredDevice", returns);
returns.clear(); // Reused params from above!
setDescription("PairDevice", "Pair a device. "
"Use this for DeviceClasses with a setupMethod different than SetupMethodJustAdd. "
"Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. "
"CreateMethodJustAdd takes the parameters you want to have with that device. "
"CreateMethodDiscovery requires the use of a deviceDescriptorId. "
"If success is true, the return values will contain a pairingTransactionId, a displayMessage and "
"the setupMethod. Depending on the setupMethod you should either proceed with AddConfiguredDevice "
"or PairDevice."
);
setParams("PairDevice", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:pairingTransactionId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
returns.insert("o:displayMessage", JsonTypes::basicTypeToString(JsonTypes::String));
returns.insert("o:setupMethod", JsonTypes::setupMethodRef());
setReturns("PairDevice", returns);
params.clear(); returns.clear();
setDescription("ConfirmPairing", "Confirm an ongoing pairing. In case of SetupMethodEnterPin also provide the pin in the params.");
params.insert("pairingTransactionId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("o:secret", JsonTypes::basicTypeToString(JsonTypes::String));
setParams("ConfirmPairing", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("ConfirmPairing", returns);
params.clear(); returns.clear();
setDescription("GetConfiguredDevices", "Returns a list of configured devices.");
setParams("GetConfiguredDevices", params);
QVariantList devices;
devices.append(JsonTypes::deviceRef());
returns.insert("devices", devices);
setReturns("GetConfiguredDevices", returns);
params.clear(); returns.clear();
setDescription("GetDiscoveredDevices", "Performs a device discovery and returns the results. This function may take a while to return.");
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
QVariantList discoveryParams;
discoveryParams.append(JsonTypes::paramRef());
params.insert("o:discoveryParams", discoveryParams);
setParams("GetDiscoveredDevices", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
QVariantList deviceDescriptors;
deviceDescriptors.append(JsonTypes::deviceDescriptorRef());
returns.insert("o:deviceDescriptors", deviceDescriptors);
setReturns("GetDiscoveredDevices", returns);
params.clear(); returns.clear();
setDescription("EditDevice", "Edit the parameters of a device. The device params will be set to the "
"passed parameters and the setup device will be called. If the device is discoverable, "
"you can perform a GetDiscoveredDevices before calling this method and pass "
"the new DeviceDescriptor (rediscover). If a parameter is not writable, you will find a "
"'readOnly': true in the ParamType. By default, every Param is writable.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("o:deviceDescriptorId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
QVariantList newDeviceParams;
newDeviceParams.append(JsonTypes::paramRef());
params.insert("o:deviceParams", newDeviceParams);
setParams("EditDevice", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
setReturns("EditDevice", returns);
params.clear(); returns.clear();
setDescription("RemoveConfiguredDevice", "Remove a device from the system.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
QVariantList removePolicyList;
QVariantMap policy;
policy.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
policy.insert("policy", JsonTypes::removePolicyRef());
removePolicyList.append(policy);
params.insert("o:removePolicy", JsonTypes::removePolicyRef());
params.insert("o:removePolicyList", removePolicyList);
setParams("RemoveConfiguredDevice", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:ruleIds", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Uuid));
setReturns("RemoveConfiguredDevice", returns);
params.clear(); returns.clear();
setDescription("GetEventTypes", "Get event types for a specified deviceClassId.");
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetEventTypes", params);
QVariantList events;
events.append(JsonTypes::eventTypeRef());
returns.insert("eventTypes", events);
setReturns("GetEventTypes", returns);
params.clear(); returns.clear();
setDescription("GetActionTypes", "Get action types for a specified deviceClassId.");
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetActionTypes", params);
QVariantList actions;
actions.append(JsonTypes::actionTypeRef());
returns.insert("actionTypes", actions);
setReturns("GetActionTypes", returns);
params.clear(); returns.clear();
setDescription("GetStateTypes", "Get state types for a specified deviceClassId.");
params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetStateTypes", params);
QVariantList states;
states.append(JsonTypes::stateTypeRef());
returns.insert("stateTypes", states);
setReturns("GetStateTypes", returns);
params.clear(); returns.clear();
setDescription("GetStateValue", "Get the value of the given device and the given stateType");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetStateValue", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
returns.insert("o:value", JsonTypes::basicTypeToString(JsonTypes::Variant));
setReturns("GetStateValue", returns);
params.clear(); returns.clear();
setDescription("GetStateValues", "Get all the state values of the given device.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("GetStateValues", params);
returns.insert("deviceError", JsonTypes::deviceErrorRef());
states.clear();
QVariantMap state;
state.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
state.insert("value", JsonTypes::basicTypeToString(JsonTypes::Variant));
states.append(state);
returns.insert("o:values", states);
setReturns("GetStateValues", returns);
// Notifications
params.clear(); returns.clear();
setDescription("StateChanged", "Emitted whenever a State of a device changes.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
params.insert("value", JsonTypes::basicTypeToString(JsonTypes::Variant));
setParams("StateChanged", params);
params.clear(); returns.clear();
setDescription("DeviceRemoved", "Emitted whenever a Device was removed.");
params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid));
setParams("DeviceRemoved", params);
params.clear(); returns.clear();
setDescription("DeviceAdded", "Emitted whenever a Device was added.");
params.insert("device", JsonTypes::deviceRef());
setParams("DeviceAdded", params);
params.clear(); returns.clear();
setDescription("DeviceParamsChanged", "Emitted whenever the params of a Device changed (by editing or rediscovering).");
params.insert("device", JsonTypes::deviceRef());
setParams("DeviceParamsChanged", params);
connect(GuhCore::instance(), &GuhCore::deviceStateChanged, this, &DeviceHandler::deviceStateChanged);
connect(GuhCore::instance(), &GuhCore::deviceRemoved, this, &DeviceHandler::deviceRemovedNotification);
connect(GuhCore::instance(), &GuhCore::deviceAdded, this, &DeviceHandler::deviceAddedNotification);
connect(GuhCore::instance(), &GuhCore::deviceParamsChanged, this, &DeviceHandler::deviceParamsChangedNotification);
connect(GuhCore::instance(), &GuhCore::devicesDiscovered, this, &DeviceHandler::devicesDiscovered, Qt::QueuedConnection);
connect(GuhCore::instance(), &GuhCore::deviceSetupFinished, this, &DeviceHandler::deviceSetupFinished);
connect(GuhCore::instance(), &GuhCore::deviceEditFinished, this, &DeviceHandler::deviceEditFinished);
connect(GuhCore::instance(), &GuhCore::pairingFinished, this, &DeviceHandler::pairingFinished);
}
void
Api_v1_5::playback( QxtWebRequestEvent* event, const QString& command )
{
if ( command == "next")
{
JSON_REPLY( QMetaObject::invokeMethod( AudioEngine::instance(), "next", Qt::QueuedConnection ) , "Skipping to the next track failed." );
}
else if ( command == "previous" )
{
JSON_REPLY( QMetaObject::invokeMethod( AudioEngine::instance(), "previous", Qt::QueuedConnection ), "Rewinding to the previous track failed." );
}
else if ( command == "playpause" )
{
JSON_REPLY( QMetaObject::invokeMethod( AudioEngine::instance(), "playPause", Qt::QueuedConnection ), "Play/Pause failed." );
}
else if ( command == "play" )
{
JSON_REPLY( QMetaObject::invokeMethod( AudioEngine::instance(), "play", Qt::QueuedConnection ), "Starting the playback failed." );
}
else if ( command == "pause" )
{
JSON_REPLY( QMetaObject::invokeMethod( AudioEngine::instance(), "pause", Qt::QueuedConnection ), "Pausing the current track failed." );
}
else if ( command == "stop" )
{
JSON_REPLY( QMetaObject::invokeMethod( AudioEngine::instance(), "stop", Qt::QueuedConnection ), "Stopping the current track failed." );
}
else if ( command == "lowervolume" )
{
JSON_REPLY( QMetaObject::invokeMethod( AudioEngine::instance(), "lowerVolume", Qt::QueuedConnection ), "Lowering volume failed." );
}
else if ( command == "raisevolume" )
{
JSON_REPLY( QMetaObject::invokeMethod( AudioEngine::instance(), "raiseVolume", Qt::QueuedConnection ), "Raising volume failed." );
}
else if ( command == "currenttrack" )
{
QByteArray json;
Tomahawk::result_ptr currentTrack = AudioEngine::instance()->currentTrack();
if ( currentTrack.isNull() )
{
json = "{ \"playing\": false }";
}
else
{
QVariantMap trackInfo;
trackInfo.insert( "playing", true );
trackInfo.insert( "paused", AudioEngine::instance()->isPaused() );
trackInfo.insert( "position", AudioEngine::instance()->currentTime() / 1000 );
trackInfo.insert( "bitrate", currentTrack->bitrate() );
if ( currentTrack->resolvedBy() ) {
QString resolverName = currentTrack->resolvedBy()->name();
trackInfo.insert( "resolvedBy", resolverName );
} else {
trackInfo.insert( "resolvedBy", "<unknown resolver>" );
}
trackInfo.insert( "score", currentTrack->score() );
trackInfo.insert( "album", currentTrack->track()->album() );
trackInfo.insert( "albumpos", currentTrack->track()->albumpos() );
trackInfo.insert( "artist", currentTrack->track()->artist() );
trackInfo.insert( "duration", currentTrack->track()->duration() );
trackInfo.insert( "track", currentTrack->track()->track() );
bool ok;
json = TomahawkUtils::toJson( trackInfo, &ok );
Q_ASSERT( ok );
}
QxtWebPageEvent * e = new QxtWebPageEvent( event->sessionID, event->requestID, json );
e->headers.insert( "Access-Control-Allow-Origin", "*" );
e->contentType = "application/json";
m_service->postEvent( e );
}
else if ( command == "volume" )
{
QByteArray json = QString( "{ \"result\": \"ok\", \"volume\": %1}" ).arg( AudioEngine::instance()->volume() ).toUtf8();
QxtWebPageEvent * e = new QxtWebPageEvent( event->sessionID, event->requestID, json );
e->headers.insert( "Access-Control-Allow-Origin", "*" );
e->contentType = "application/json";
m_service->postEvent( e );
}
else
{
m_service->sendJsonError( event, "No such playback command." );
}
}
QVariantMap BuildStep::toMap() const
{
QVariantMap map = ProjectConfiguration::toMap();
map.insert(QLatin1String(buildStepEnabledKey), m_enabled);
return map;
}
JsonReply* DeviceHandler::GetSupportedDevices(const QVariantMap ¶ms) const
{
QVariantMap returns;
returns.insert("deviceClasses", JsonTypes::packSupportedDevices(VendorId(params.value("vendorId").toString())));
return createReply(returns);
}
QVariantMap QmlJSOutlineWidget::settings() const
{
QVariantMap map;
map.insert(QLatin1String("QmlJSOutline.ShowBindings"), m_showBindingsAction->isChecked());
return map;
}
static void sendPropertiesChanged(const QDBusAbstractAdaptor *adaptor, const char *property, const QVariant &value) {
QVariantMap properties; properties.insert(property, value); sendPropertiesChanged(adaptor, properties);
}
bool SessionManager::save()
{
if (debug)
qDebug() << "SessionManager - saving session" << d->m_sessionName;
emit m_instance->aboutToSaveSession();
if (!d->m_writer || d->m_writer->fileName() != sessionNameToFileName(d->m_sessionName)) {
delete d->m_writer;
d->m_writer = new PersistentSettingsWriter(sessionNameToFileName(d->m_sessionName),
QLatin1String("QtCreatorSession"));
}
QVariantMap data;
// save the startup project
if (d->m_startupProject)
data.insert(QLatin1String("StartupProject"), d->m_startupProject->projectFilePath());
QColor c = StyleHelper::requestedBaseColor();
if (c.isValid()) {
QString tmp = QString::fromLatin1("#%1%2%3")
.arg(c.red(), 2, 16, QLatin1Char('0'))
.arg(c.green(), 2, 16, QLatin1Char('0'))
.arg(c.blue(), 2, 16, QLatin1Char('0'));
data.insert(QLatin1String("Color"), tmp);
}
QStringList projectFiles;
foreach (Project *pro, d->m_projects)
projectFiles << pro->projectFilePath();
// Restore infromation on projects that failed to load:
// don't readd projects to the list, which the user loaded
foreach (const QString &failed, d->m_failedProjects)
if (!projectFiles.contains(failed))
projectFiles << failed;
data.insert(QLatin1String("ProjectList"), projectFiles);
QMap<QString, QVariant> depMap;
QMap<QString, QStringList>::const_iterator i = d->m_depMap.constBegin();
while (i != d->m_depMap.constEnd()) {
QString key = i.key();
QStringList values;
foreach (const QString &value, i.value()) {
values << value;
}
depMap.insert(key, values);
++i;
}
data.insert(QLatin1String("ProjectDependencies"), QVariant(depMap));
data.insert(QLatin1String("EditorSettings"), EditorManager::saveState().toBase64());
QMap<QString, QVariant>::const_iterator it, end = d->m_values.constEnd();
QStringList keys;
for (it = d->m_values.constBegin(); it != end; ++it) {
data.insert(QLatin1String("value-") + it.key(), it.value());
keys << it.key();
}
data.insert(QLatin1String("valueKeys"), keys);
bool result = d->m_writer->save(data, Core::ICore::mainWindow());
if (!result) {
QMessageBox::warning(0, tr("Error while saving session"),
tr("Could not save session to file %1").arg(d->m_writer->fileName().toUserOutput()));
}
if (debug)
qDebug() << "SessionManager - saving session returned " << result;
return result;
}
void QWSTreeWidget::createProjectDataset()
{
if (!m_pDatabaseAdapter || !m_treeModel)
return;
QSqlQuery sqlQuery = m_pDatabaseAdapter->sqlQuery();
QString sql;
bool bRel;
QList<QVariantMap> recordList;
//Project
sql = "select ProjectName from TblProject";
bRel = sqlQuery.exec(sql);
QString strProjectName;
if (bRel)
{
while (sqlQuery.next())
{
QVariantMap m;
QString name = sqlQuery.value(0).toString();
strProjectName = "TblProject#1";
m.insert(DEFAULT_ID_FIELD, strProjectName);
m.insert(DEFAULT_TEXT_FIELD, QStringLiteral("工程：") + name);
m.insert(DEFAULT_PID_FIELD, QVariant());
m.insert(DEFAULT_ICON_FIELD, ":/project.png");
m.insert(DEFAULT_TYPE_FIELD, TYPE_PROJECT);
recordList.append(m);
}
}
//UC
sql = "select UCID, UCName from TblUC";
bRel = sqlQuery.exec(sql);
QMap<int, QString> ucMap;
if (bRel)
{
while (sqlQuery.next())
{
QVariantMap m;
QString ucName = sqlQuery.value(1).toString();
QString ucIDStr = "TblUC#" + sqlQuery.value(0).toString();
m.insert(DEFAULT_ID_FIELD, ucIDStr);
m.insert(DEFAULT_TEXT_FIELD, ucName);
m.insert(DEFAULT_PID_FIELD, strProjectName);
m.insert(DEFAULT_ICON_FIELD, ":/uc.png");
m.insert(DEFAULT_TYPE_FIELD, TYPE_UC);
recordList.append(m);
ucMap.insert(sqlQuery.value(0).toInt(), ucIDStr);
}
}
//PORT
QMap<int, QString>::const_iterator it = ucMap.constBegin();
QMap<int, QString> portMap;
while (it != ucMap.constEnd())
{
sql = QString("select PortID from TblPort where UCID = %1").arg(it.key());
bRel = sqlQuery.exec(sql);
if (bRel)
{
while (sqlQuery.next())
{
QVariantMap m;
QString portIDStr = "TblPort#" + sqlQuery.value(0).toString();
m.insert(DEFAULT_ID_FIELD, portIDStr);
m.insert(DEFAULT_TEXT_FIELD, QStringLiteral("端口-P%1").arg(sqlQuery.value(0).toInt()));
m.insert(DEFAULT_PID_FIELD, it.value());
m.insert(DEFAULT_ICON_FIELD, ":/port.png");
m.insert(DEFAULT_TYPE_FIELD, TYPE_PORT);
recordList.append(m);
portMap.insert(sqlQuery.value(0).toInt(), portIDStr);
}
}
++it;
}
//DEVICE
it = portMap.constBegin();
while (it != portMap.constEnd())
{
sql = QString("select DevID, Address, DevType, DevDsp from TblDevice where PortID = %1").arg(it.key());
bRel = sqlQuery.exec(sql);
if (bRel)
{
while (sqlQuery.next())
{
QVariantMap m;
QString devID = "TblDevice#" + sqlQuery.value(0).toString();
QString devAdd = sqlQuery.value(1).toString();
QString devType = sqlQuery.value(2).toString();
QString devDsp = sqlQuery.value(3).toString();
m.insert(DEFAULT_ID_FIELD, devID);
m.insert(DEFAULT_TEXT_FIELD, devAdd + " " + devType + " " + devDsp);
m.insert(DEFAULT_PID_FIELD, it.value());
m.insert(DEFAULT_ICON_FIELD, ":/device.png");
m.insert(DEFAULT_TYPE_FIELD, TYPE_DEVICE);
recordList.append(m);
}
}
++it;
}
//Protocol
QVariantMap m;
QString strProtocolName = "TblProtocol#1";
m.insert(DEFAULT_ID_FIELD, strProtocolName);
m.insert(DEFAULT_TEXT_FIELD, QStringLiteral("协议管理"));
m.insert(DEFAULT_PID_FIELD, strProjectName);
m.insert(DEFAULT_ICON_FIELD, ":/protocol.png");
m.insert(DEFAULT_TYPE_FIELD, TYPE_PROTOCOL);
recordList.append(m);
m_treeModel->setDataSet(recordList);
}
void Group::setOn(bool on)
{
QVariantMap params;
params.insert("on", on);
HueBridgeConnection::instance()->put("groups/" + QString::number(m_id) + "/action", params, this, "setStateFinished");
}
void DiscoverRouterSoapOp::process()
{
QStringList ls1;
QList<QVariantMap> ls2;
for (int i = 0; i < m_opList.count(); i++)
{
AsyncOp *op = m_opList.at(i);
if (op->isFinished() && op->result() == NoError)
{
ls1.append(m_ls.at(i));
ls2.append(op->values());
}
}
if (ls1.isEmpty())
{
LOG_DEBUG(QString::fromUtf8("No router found!"));
notifyFinished(UnknownError);
return;
}
QSet<QString> set1;
int count = ls1.count();
int i = 0;
while (i < count)
{
const QVariantMap& varMap = ls2.at(i);
QString mac = varMap.value(QLatin1String("newwlanmacaddress")).toString().toUpper();
if (set1.find(mac) == set1.end())
{
set1.insert(mac);
i++;
}
else
{
ls1.removeAt(i);
ls2.removeAt(i);
count--;
}
}
int matchIndex = -1;
QVariantList fullList;
LOG_DEBUG(QString::fromUtf8("found %1 router(s)").arg(ls1.count()));
for (int i = 0; i < ls1.count(); i++)
{
QString hostName = ls1.at(i);
QVariantMap varMap = ls2.at(i);
varMap.insert(QLatin1String("soapHostName"), hostName);
QString mac = varMap.value(QLatin1String("newwlanmacaddress")).toString().toUpper();
fullList.push_back(varMap);
m_mac = mac;
//if (!m_mac.isNull() && mac.compare(m_mac, Qt::CaseInsensitive) == 0) {
matchIndex = i;
//}
LOG_DEBUG(QString::fromUtf8("%1 [%2]").arg(hostName).arg(mac));
}
setValue("fullList", fullList);
setValue("matchIndex", matchIndex);
notifyFinished(NoError);
}
void
StatSyncing::FastForwardTrack::doCommit( const qint64 fields )
{
m_connection->transaction();
bool ok = true;
const QString query = "SELECT deviceid, uniqueid FROM uniqueid WHERE url = :url";
QVariantMap bindValues;
bindValues.insert( ":url", m_trackUrl );
const QList<QVariantList> result = m_connection->query( query, bindValues, &ok );
if( !ok )
{
m_connection->rollback();
return;
}
const int deviceId = result.front()[0].toInt();
const QString uniqueId = result.front()[1].toString();
QStringList updates;
QVariantMap uBindValues;
if( fields & Meta::valFirstPlayed )
{
updates << "createdate = :createdate";
uBindValues.insert( ":createdate", m_statistics.value( Meta::valFirstPlayed ) );
}
if( fields & Meta::valLastPlayed )
{
updates << "accessdate = :accessdate";
uBindValues.insert( ":accessdate", m_statistics.value( Meta::valLastPlayed ) );
}
if( fields & Meta::valRating )
{
updates << "rating = :rating";
uBindValues.insert( ":rating", m_statistics.value( Meta::valRating ) );
}
if( fields & Meta::valPlaycount )
{
updates << "playcounter = :playcount";
uBindValues.insert( ":playcount", m_statistics.value( Meta::valPlaycount ) );
}
if( !updates.isEmpty() )
{
const QString query = "SELECT COUNT(*) FROM statistics WHERE url = :url";
QVariantMap bindValues;
bindValues.insert( ":url", m_trackUrl );
const QList<QVariantList> result = m_connection->query( query, bindValues, &ok );
if( !ok )
{
m_connection->rollback();
return;
}
// Statistic row doesn't exist
if( !result.front()[0].toInt() )
{
const QString query = "INSERT INTO statistics (url, deviceid, uniqueid) "
"VALUES ( :url, :devid, :uniqid )";
QVariantMap bindValues;
bindValues.insert( ":url", m_trackUrl );
bindValues.insert( ":devid", deviceId );
bindValues.insert( ":url", uniqueId );
m_connection->query( query, bindValues, &ok );
if( !ok )
{
m_connection->rollback();
return;
}
}
// Update statistics
const QString uQuery = "UPDATE statistics SET " + updates.join(", ") +
" WHERE url = :url";
uBindValues.insert( ":url", m_trackUrl );
m_connection->query( uQuery, uBindValues, &ok );
if( !ok )
{
m_connection->rollback();
return;
}
}
if( fields & Meta::valLabel )
{
// Drop old label associations
const QString query = "DELETE FROM tags_labels WHERE url = :url";
QVariantMap bindValues;
bindValues.insert( ":url", m_trackUrl );
m_connection->query( query, bindValues, &ok );
if( !ok )
{
m_connection->rollback();
return;
}
foreach( const QString &label, m_labels )
{
{
// Check if the label exists
const QString query = "SELECT COUNT(*) FROM labels WHERE name = :name";
QVariantMap bindValues;
bindValues.insert( ":name", label );
const QList<QVariantList> result = m_connection->query( query, bindValues,
&ok );
if( !ok )
{
m_connection->rollback();
return;
}
// Insert label if it doesn't
if( !result.front()[0].toInt() )
{
const QString query = "INSERT INTO labels (name, type) "
"VALUES (:name, 1)";
QVariantMap bindValues;
bindValues.insert( ":name", label );
m_connection->query( query, bindValues, &ok );
if( !ok )
{
m_connection->rollback();
return;
}
}
}
// Insert track <-> label association
const QString query = "INSERT INTO tags_labels (deviceid, url, uniqueid, "
"labelid) VALUES ( :devid, :url, :uniqid, "
"(SELECT id FROM labels WHERE name = :name) )";
QVariantMap bindValues;
bindValues.insert( ":devid", deviceId );
bindValues.insert( ":url", m_trackUrl );
bindValues.insert( ":uniqid", uniqueId );
bindValues.insert( ":name", label );
m_connection->query( query, bindValues, &ok );
if( !ok )
{
m_connection->rollback();
return;
}
}
}
QVariantMap AndroidDeployStep::toMap() const
{
QVariantMap map = ProjectExplorer::BuildStep::toMap();
map.insert(QLatin1String(DEPLOY_ACTION_KEY), m_deployAction);
return map;
}
QVariantMap WebBridgeRS::searchKeywords(const QString& keywords, QVariantMap searchOptions)
{
std::cerr << "webscriptrs: keywords in " << keywords.toStdString().c_str() << std::endl;
QVariantMap qReturn;
QVariantList qResults;
if (keywords.length() < 3){
std::cerr << "webscriptrs: not searching due to keywords.length = " << keywords.length() << std::endl;
qReturn.insert("message","search terms < 3 chars");
qReturn.insert("status","fail");
qReturn.insert("results",qResults);
return qReturn;
}
QStringList qWords = keywords.split(" ", QString::SkipEmptyParts);
std::list<std::string> words;
QStringListIterator qWordsIter(qWords);
while (qWordsIter.hasNext())
words.push_back(qWordsIter.next().toUtf8().constData());
int n = words.size() ;
if (n < 1){
std::cerr << "webscriptrs: searching due to words.size() = " << n << std::endl;
qReturn.insert("message","search terms < 1 word");
qReturn.insert("status","fail");
qReturn.insert("results",qResults);
return qReturn;
}
NameExpression exprs(ContainsAllStrings,words,true) ;
LinearizedExpression lin_exp ;
exprs.linearize(lin_exp) ;
TurtleRequestId req_id ;
if(searchOptions.value("turtle", false).toBool())
{
if(n==1)
req_id = rsTurtle->turtleSearch(words.front()) ;
else
req_id = rsTurtle->turtleSearch(lin_exp) ;
qReturn.insert("turtleID",req_id);
}
else
req_id = ((((uint32_t)rand()) << 16)^0x1e2fd5e4) + (((uint32_t)rand())^0x1b19acfe) ; // generate a random 32 bits request id
/* extract keywords from lineEdit */
// make a compound expression with an AND
//
//std::list<DirDetails> finalResults ;
std::list<DirDetails> initialResults;
//RS_FILE_HINTS_REMOTE
//rsFiles->SearchBoolExp(&exprs, initialResults, RS_FILE_HINTS_LOCAL);// | DIR_FLAGS_NETWORK_WIDE | DIR_FLAGS_BROWSABLE) ;
FileSearchFlags fsf;
if (searchOptions.value("localindexed", false).toBool()){
//std::cerr << "incuding local\n";
fsf = RS_FILE_HINTS_LOCAL;
}
if (searchOptions.value("remoteindexed", false).toBool()){
//std::cerr << "incuding remote\n";
fsf |= RS_FILE_HINTS_REMOTE;
}
if (searchOptions.value("boolexp", false).toBool()){
rsFiles->SearchBoolExp(&exprs, initialResults, fsf);
}else{
rsFiles->SearchKeywords(words, initialResults, fsf);
}
//if(searchFriends) fsf = RS_FILE_HINTS_REMOTE;
//rsFiles->getSharedDirectories();
//SharedDirInfo sdinfo;
//sdinfo.
std::cerr << "webscriptrs: result count: " << initialResults.size() << std::endl;
/* which extensions do we use? */
DirDetails dd;
for(std::list<DirDetails>::iterator resultsIter = initialResults.begin(); resultsIter != initialResults.end(); resultsIter ++)
{
//std::cout << "webscriptrs: " << dd.hash << std::endl;
dd = *resultsIter;
QVariantMap qdd;
qdd.insert("age",dd.age);//QString::number(dir.age)?
//qdd.insert("message",dd.children);
qdd.insert("size",QString::number(dd.count));
//qdd.insert("message",dd.flags);
qdd.insert("hash",QString::fromStdString(dd.hash));
qdd.insert("id",QString::fromStdString(dd.id));
qdd.insert("mind_age",dd.min_age);
qdd.insert("srname",QString::fromUtf8(dd.name.c_str()));
//qdd.insert("message",dd.parent);
//qdd.insert("message",dd.parent_groups);
qdd.insert("path",QString::fromUtf8(dd.path.c_str()));
qdd.insert("prow",dd.prow);
//qdd.insert("message",dd.ref);
qdd.insert("type",dd.type);
FileInfo info;
//The flags copied from SearchDialog.cpp:1096
if (rsFiles->FileDetails(dd.hash, RS_FILE_HINTS_EXTRA | RS_FILE_HINTS_LOCAL | RS_FILE_HINTS_BROWSABLE | RS_FILE_HINTS_NETWORK_WIDE | RS_FILE_HINTS_SPEC_ONLY, info)){
/* make path for downloaded or downloading files */
//QFileInfo qinfo;
std::string path;
path = info.path.substr(0,info.path.length()-info.fname.length());
QDir apath = QDir(QString::fromUtf8(path.c_str()));
qdd.insert("fullpath", apath.absolutePath());
/* open folder with a suitable application */
/*qinfo.setFile(QString::fromUtf8(path.c_str()));
if (qinfo.exists() && qinfo.isDir()) {
if (!RsUrlHandler::openUrl(QUrl::fromLocalFile(qinfo.absoluteFilePath()))) {
std::cerr << "openFolderSearch(): can't open folder " << path << std::endl;
}
}*/
} else {
std::cout << "file details failed\n";
}
qResults.push_back(qdd);
//finalResults.push_back(dd);
}
/* abstraction to allow reusee of tree rendering code */
//resultsToTree(keywords,req_id, finalResults);
qReturn.insert("status","sucess");
qReturn.insert("results",qResults);
return qReturn;
}
QgsFeatureSink *QgsProcessingUtils::createFeatureSink( QString &destination, QgsProcessingContext &context, const QgsFields &fields, QgsWkbTypes::Type geometryType, const QgsCoordinateReferenceSystem &crs, const QVariantMap &createOptions, QgsFeatureSink::SinkFlags sinkFlags )
{
QVariantMap options = createOptions;
if ( !options.contains( QStringLiteral( "fileEncoding" ) ) )
{
// no destination encoding specified, use default
options.insert( QStringLiteral( "fileEncoding" ), context.defaultEncoding().isEmpty() ? QStringLiteral( "system" ) : context.defaultEncoding() );
}
if ( destination.isEmpty() || destination.startsWith( QLatin1String( "memory:" ) ) )
{
// strip "memory:" from start of destination
if ( destination.startsWith( QLatin1String( "memory:" ) ) )
destination = destination.mid( 7 );
if ( destination.isEmpty() )
destination = QStringLiteral( "output" );
// memory provider cannot be used with QgsVectorLayerImport - so create layer manually
std::unique_ptr< QgsVectorLayer > layer( QgsMemoryProviderUtils::createMemoryLayer( destination, fields, geometryType, crs ) );
if ( !layer || !layer->isValid() )
{
throw QgsProcessingException( QObject::tr( "Could not create memory layer" ) );
}
// update destination to layer ID
destination = layer->id();
// this is a factory, so we need to return a proxy
std::unique_ptr< QgsProcessingFeatureSink > sink( new QgsProcessingFeatureSink( layer->dataProvider(), destination, context ) );
context.temporaryLayerStore()->addMapLayer( layer.release() );
return sink.release();
}
else
{
QString providerKey;
QString uri;
QString layerName;
QString format;
QString extension;
bool useWriter = false;
parseDestinationString( destination, providerKey, uri, layerName, format, options, useWriter, extension );
QgsFields newFields = fields;
if ( useWriter && providerKey == QLatin1String( "ogr" ) )
{
// use QgsVectorFileWriter for OGR destinations instead of QgsVectorLayerImport, as that allows
// us to use any OGR format which supports feature addition
QString finalFileName;
std::unique_ptr< QgsVectorFileWriter > writer = qgis::make_unique< QgsVectorFileWriter >( destination, options.value( QStringLiteral( "fileEncoding" ) ).toString(), newFields, geometryType, crs, format, QgsVectorFileWriter::defaultDatasetOptions( format ),
QgsVectorFileWriter::defaultLayerOptions( format ), &finalFileName, QgsVectorFileWriter::NoSymbology, sinkFlags );
if ( writer->hasError() )
{
throw QgsProcessingException( QObject::tr( "Could not create layer %1: %2" ).arg( destination, writer->errorMessage() ) );
}
destination = finalFileName;
return new QgsProcessingFeatureSink( writer.release(), destination, context, true );
}
else
{
//create empty layer
std::unique_ptr< QgsVectorLayerExporter > exporter( new QgsVectorLayerExporter( uri, providerKey, newFields, geometryType, crs, true, options, sinkFlags ) );
if ( exporter->errorCode() )
{
throw QgsProcessingException( QObject::tr( "Could not create layer %1: %2" ).arg( destination, exporter->errorMessage() ) );
}
// use destination string as layer name (eg "postgis:..." )
if ( !layerName.isEmpty() )
uri += QStringLiteral( "|layername=%1" ).arg( layerName );
std::unique_ptr< QgsVectorLayer > layer( new QgsVectorLayer( uri, destination, providerKey ) );
// update destination to layer ID
destination = layer->id();
context.temporaryLayerStore()->addMapLayer( layer.release() );
return new QgsProcessingFeatureSink( exporter.release(), destination, context, true );
}
}
return nullptr;
}
//const std::string &ssl_or_gpg_id, RsPeerDetails &d
QVariantMap WebBridgeRS::getPeerDetails(QString ssl_id){
RsPeerDetails d;
rsPeers->getPeerDetails(ssl_id.toStdString(),d);
QVariantMap qdd;
qdd.insert("trustLvl",d.trustLvl);
qdd.insert("connectPeriod",d.connectPeriod);
qdd.insert("connectState",d.connectState);
qdd.insert("connectStateString",QString::fromStdString(d.connectStateString));
qdd.insert("hasSignedMe",d.hasSignedMe);
//qdd.insert("gpgSigners",d.gpgSigners);
qdd.insert("extAddr",QString::fromStdString(d.extAddr));
qdd.insert("extPort",d.extPort);
qdd.insert("email",QString::fromStdString(d.email));
qdd.insert("id",QString::fromStdString(d.id));
qdd.insert("gpg_id",QString::fromStdString(d.gpg_id));
//qdd.insert("ipAddressList",d.ipAddressList);
qdd.insert("localAddr",QString::fromStdString(d.localAddr));
qdd.insert("localPort",d.localPort);
qdd.insert("location",QString::fromStdString(d.location));
qdd.insert("name",QString::fromUtf8(d.name.c_str()));
qdd.insert("validLvl",d.validLvl);
qdd.insert("visState",d.visState);
return qdd;
}
QVariantMap QgsJoinWithLinesAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
if ( parameters.value( QStringLiteral( "SPOKES" ) ) == parameters.value( QStringLiteral( "HUBS" ) ) )
throw QgsProcessingException( QObject::tr( "Same layer given for both hubs and spokes" ) );
std::unique_ptr< QgsProcessingFeatureSource > hubSource( parameterAsSource( parameters, QStringLiteral( "HUBS" ), context ) );
if ( !hubSource )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "HUBS" ) ) );
std::unique_ptr< QgsProcessingFeatureSource > spokeSource( parameterAsSource( parameters, QStringLiteral( "SPOKES" ), context ) );
if ( !hubSource || !spokeSource )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "SPOKES" ) ) );
QString fieldHubName = parameterAsString( parameters, QStringLiteral( "HUB_FIELD" ), context );
int fieldHubIndex = hubSource->fields().lookupField( fieldHubName );
const QStringList hubFieldsToCopy = parameterAsFields( parameters, QStringLiteral( "HUB_FIELDS" ), context );
QString fieldSpokeName = parameterAsString( parameters, QStringLiteral( "SPOKE_FIELD" ), context );
int fieldSpokeIndex = spokeSource->fields().lookupField( fieldSpokeName );
const QStringList spokeFieldsToCopy = parameterAsFields( parameters, QStringLiteral( "SPOKE_FIELDS" ), context );
if ( fieldHubIndex < 0 || fieldSpokeIndex < 0 )
throw QgsProcessingException( QObject::tr( "Invalid ID field" ) );
const bool geodesic = parameterAsBool( parameters, QStringLiteral( "GEODESIC" ), context );
const double geodesicDistance = parameterAsDouble( parameters, QStringLiteral( "GEODESIC_DISTANCE" ), context ) * 1000;
bool dynamicGeodesicDistance = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "GEODESIC_DISTANCE" ) );
QgsExpressionContext expressionContext = createExpressionContext( parameters, context, hubSource.get() );
QgsProperty geodesicDistanceProperty;
if ( dynamicGeodesicDistance )
{
geodesicDistanceProperty = parameters.value( QStringLiteral( "GEODESIC_DISTANCE" ) ).value< QgsProperty >();
}
const bool splitAntimeridian = parameterAsBool( parameters, QStringLiteral( "ANTIMERIDIAN_SPLIT" ), context );
QgsDistanceArea da;
da.setSourceCrs( hubSource->sourceCrs(), context.transformContext() );
da.setEllipsoid( context.project()->ellipsoid() );
QgsFields hubOutFields;
QgsAttributeList hubFieldIndices;
if ( hubFieldsToCopy.empty() )
{
hubOutFields = hubSource->fields();
hubFieldIndices.reserve( hubOutFields.count() );
for ( int i = 0; i < hubOutFields.count(); ++i )
{
hubFieldIndices << i;
}
}
else
{
hubFieldIndices.reserve( hubOutFields.count() );
for ( const QString &field : hubFieldsToCopy )
{
int index = hubSource->fields().lookupField( field );
if ( index >= 0 )
{
hubFieldIndices << index;
hubOutFields.append( hubSource->fields().at( index ) );
}
}
}
QgsAttributeList hubFields2Fetch = hubFieldIndices;
hubFields2Fetch << fieldHubIndex;
QgsFields spokeOutFields;
QgsAttributeList spokeFieldIndices;
if ( spokeFieldsToCopy.empty() )
{
spokeOutFields = spokeSource->fields();
spokeFieldIndices.reserve( spokeOutFields.count() );
for ( int i = 0; i < spokeOutFields.count(); ++i )
{
spokeFieldIndices << i;
}
}
else
{
for ( const QString &field : spokeFieldsToCopy )
{
int index = spokeSource->fields().lookupField( field );
if ( index >= 0 )
{
spokeFieldIndices << index;
spokeOutFields.append( spokeSource->fields().at( index ) );
}
}
}
QgsAttributeList spokeFields2Fetch = spokeFieldIndices;
spokeFields2Fetch << fieldSpokeIndex;
QgsFields fields = QgsProcessingUtils::combineFields( hubOutFields, spokeOutFields );
QgsWkbTypes::Type outType = geodesic ? QgsWkbTypes::MultiLineString : QgsWkbTypes::LineString;
bool hasZ = false;
if ( QgsWkbTypes::hasZ( hubSource->wkbType() ) || QgsWkbTypes::hasZ( spokeSource->wkbType() ) )
{
outType = QgsWkbTypes::addZ( outType );
hasZ = true;
}
bool hasM = false;
if ( QgsWkbTypes::hasM( hubSource->wkbType() ) || QgsWkbTypes::hasM( spokeSource->wkbType() ) )
{
outType = QgsWkbTypes::addM( outType );
hasM = true;
}
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields,
outType, hubSource->sourceCrs() ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
auto getPointFromFeature = [hasZ, hasM]( const QgsFeature & feature )->QgsPoint
{
QgsPoint p;
if ( feature.geometry().type() == QgsWkbTypes::PointGeometry && !feature.geometry().isMultipart() )
p = *static_cast< const QgsPoint *>( feature.geometry().constGet() );
else
p = *static_cast< const QgsPoint *>( feature.geometry().pointOnSurface().constGet() );
if ( hasZ && !p.is3D() )
p.addZValue( 0 );
if ( hasM && !p.isMeasure() )
p.addMValue( 0 );
return p;
};
QgsFeatureIterator hubFeatures = hubSource->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( hubFields2Fetch ), QgsProcessingFeatureSource::FlagSkipGeometryValidityChecks );
double step = hubSource->featureCount() > 0 ? 100.0 / hubSource->featureCount() : 1;
int i = 0;
QgsFeature hubFeature;
while ( hubFeatures.nextFeature( hubFeature ) )
{
i++;
if ( feedback->isCanceled() )
{
break;
}
feedback->setProgress( i * step );
if ( !hubFeature.hasGeometry() )
continue;
QgsPoint hubPoint = getPointFromFeature( hubFeature );
// only keep selected attributes
QgsAttributes hubAttributes;
for ( int j = 0; j < hubFeature.attributes().count(); ++j )
{
if ( !hubFieldIndices.contains( j ) )
continue;
hubAttributes << hubFeature.attribute( j );
}
QgsFeatureRequest spokeRequest = QgsFeatureRequest().setDestinationCrs( hubSource->sourceCrs(), context.transformContext() );
spokeRequest.setSubsetOfAttributes( spokeFields2Fetch );
spokeRequest.setFilterExpression( QgsExpression::createFieldEqualityExpression( fieldSpokeName, hubFeature.attribute( fieldHubIndex ) ) );
QgsFeatureIterator spokeFeatures = spokeSource->getFeatures( spokeRequest, QgsProcessingFeatureSource::FlagSkipGeometryValidityChecks );
QgsFeature spokeFeature;
while ( spokeFeatures.nextFeature( spokeFeature ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( !spokeFeature.hasGeometry() )
continue;
QgsPoint spokePoint = getPointFromFeature( spokeFeature );
QgsGeometry line;
if ( !geodesic )
{
line = QgsGeometry( new QgsLineString( QVector< QgsPoint >() << hubPoint << spokePoint ) );
if ( splitAntimeridian )
line = da.splitGeometryAtAntimeridian( line );
}
else
{
double distance = geodesicDistance;
if ( dynamicGeodesicDistance )
{
expressionContext.setFeature( hubFeature );
distance = geodesicDistanceProperty.valueAsDouble( expressionContext, distance );
}
std::unique_ptr< QgsMultiLineString > ml = qgis::make_unique< QgsMultiLineString >();
std::unique_ptr< QgsLineString > l = qgis::make_unique< QgsLineString >( QVector< QgsPoint >() << hubPoint );
QVector< QVector< QgsPointXY > > points = da.geodesicLine( QgsPointXY( hubPoint ), QgsPointXY( spokePoint ), distance, splitAntimeridian );
QVector< QgsPointXY > points1 = points.at( 0 );
points1.pop_front();
if ( points.count() == 1 )
points1.pop_back();
QgsLineString geodesicPoints( points1 );
l->append( &geodesicPoints );
if ( points.count() == 1 )
l->addVertex( spokePoint );
ml->addGeometry( l.release() );
if ( points.count() > 1 )
{
QVector< QgsPointXY > points2 = points.at( 1 );
points2.pop_back();
l = qgis::make_unique< QgsLineString >( points2 );
if ( hasZ )
l->addZValue( std::numeric_limits<double>::quiet_NaN() );
if ( hasM )
l->addMValue( std::numeric_limits<double>::quiet_NaN() );
l->addVertex( spokePoint );
ml->addGeometry( l.release() );
}
line = QgsGeometry( std::move( ml ) );
}
QgsFeature outFeature;
QgsAttributes outAttributes = hubAttributes;
// only keep selected attributes
QgsAttributes spokeAttributes;
for ( int j = 0; j < spokeFeature.attributes().count(); ++j )
{
if ( !spokeFieldIndices.contains( j ) )
continue;
spokeAttributes << spokeFeature.attribute( j );
}
outAttributes.append( spokeAttributes );
outFeature.setAttributes( outAttributes );
outFeature.setGeometry( line );
sink->addFeature( outFeature, QgsFeatureSink::FastInsert );
}
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
return outputs;
}
QVariantMap AddQtOperation::initializeQtVersions()
{
QVariantMap map;
map.insert(QLatin1String(VERSION), 1);
return map;
}
void GdbServerProviderFactory::idToMap(QVariantMap &data, const QString id)
{
data.insert(QLatin1String(idKeyC), id);
}
QVariantList parseRetrievedVideosList(const QByteArray &result, const QString& userId)
{
std::cout << QString(result).toStdString() << std::endl;
QVariantList list;
QScriptEngine engine;
QScriptValue response = engine.evaluate("(" + QString(result) + ")").property(RESPONSE);
QScriptValueIterator it(response);
while (it.hasNext()) {
it.next();
// Parse vid & oid
QString vid = it.value().property(VID).toString();
QString oid = it.value().property(OWNER_ID).toString();
// Parse title
QByteArray rawText = it.value().property(TITLE).toVariant().toByteArray();
QString title = QString::fromUtf8(rawText, rawText.size());
rawText.clear();
// Parse description
rawText = it.value().property(DESCRIPTION).toVariant().toByteArray();
QString description = QString::fromUtf8(rawText, rawText.size());
// Parse duration
int duration = it.value().property(DURATION).toInteger();
// Parse link
QString link = it.value().property(LINK).toString();
//Parse image url
QString image = it.value().property(IMAGE).toString();
//Parse date
QString date = QDateTime::fromTime_t(it.value().property(DATE).toUInt32()).toString(DATE_TIME_FORMAT);
//Parse player
QString player = it.value().property(PLAYER).toString();
if (!vid.isEmpty() && !oid.isEmpty() && !title.isEmpty() &&
!description.isEmpty() && !link.isEmpty() && !image.isEmpty() &&
!player.isEmpty() && !date.isEmpty())
{
QVariantMap video;
video.insert(VID, vid);
video.insert(OWNER_ID, oid);
video.insert(OWNED, userId.toInt() == oid.toInt());
video.insert(TITLE, title);
video.insert(DESCRIPTION,description);
video.insert(DURATION, seconds_toHHMMSS(duration));
video.insert(LINK, link);
video.insert(IMAGE, image);
video.insert(DATE, date);
video.insert(PLAYER,player);
list.append(video);
}
}
return list;
}
TranslationInterface::TranslationInterface(QObject *parent)
: QObject(parent)
, m_service(NULL)
, m_serviceItem(NULL)
, m_busy(false)
, m_suppressRetranslate(false)
, m_sourceLanguages(new LanguageListModel(this))
, m_targetLanguages(new LanguageListModel(this))
, m_sourceLanguage(NULL)
, m_targetLanguage(NULL)
, m_dict(new DictionaryModel(this))
#ifdef Q_OS_SAILFISH
, m_settings(new QSettings("harbour-taot", "taot", this))
#else
, m_settings(new QSettings(QCoreApplication::organizationName(), "taot", this))
# ifdef WITH_ANALYTICS
, m_analytics(new QAmplitudeAnalytics(AMPLITUDE_API_KEY))
# endif
#endif
{
#ifdef WITH_ANALYTICS
# if defined(Q_OS_SAILFISH)
QString path = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation);
path.append(QDir::separator()).append("harbour-taot");
QDir dir(path);
if (!dir.exists())
dir.mkpath(".");
m_analytics.reset(new QAmplitudeAnalytics(AMPLITUDE_API_KEY,
dir.filePath("QtInAppAnalytics.ini")));
// HACK: Get proper manufacturer and model values
// TODO: Remove when QtSystemInfo is allowed in Harbour
QAmplitudeAnalytics::DeviceInfo di = m_analytics->deviceInfo();
org::nemo::ssu ssu("org.nemo.ssu", "/org/nemo/ssu", QDBusConnection::systemBus());
di.manufacturer = ssu.displayName(0 /*Ssu::DeviceManufacturer*/);
di.model = ssu.displayName(1 /*Ssu::DeviceModel*/);
m_analytics->setDeviceInfo(di);
# endif
updatePersistentProperties();
m_privacyLevel = PrivacyLevel(m_settings->value("PrivacyLevel", UndefinedPrivacy).toInt());
if (m_privacyLevel != NoPrivacy)
m_analytics->setPrivacyEnabled(true);
if (m_settings->contains("AppInfo/CurrentVersion")) {
const QString version = m_settings->value("AppInfo/CurrentVersion").toString();
if (version != QCoreApplication::applicationVersion()) {
QVariantMap props;
props.insert("Old Version", version);
props.insert("New Version", QCoreApplication::applicationVersion());
m_analytics->trackEvent("Upgrade", props);
m_settings->setValue("AppInfo/CurrentVersion", QCoreApplication::applicationVersion());
}
} else {
QVariantMap props;
props.insert("Version", QCoreApplication::applicationVersion());
m_analytics->trackEvent("Installation", props);
m_settings->setValue("AppInfo/CurrentVersion", QCoreApplication::applicationVersion());
}
if (m_privacyLevel == NoPrivacy) {
trackSessionStart();
}
#endif
setTranscription(new SourceTranslatedTextPair());
setTranslit(new SourceTranslatedTextPair());
QStringList list;
list.insert(GoogleTranslateService, GoogleTranslate::displayName());
list.insert(MicrosoftTranslatorService, MicrosoftTranslator::displayName());
list.insert(YandexTranslateService, YandexTranslate::displayName());
list.insert(YandexDictionariesService, YandexDictionaries::displayName());
m_services = new TranslationServicesModel(list, this);
createService(m_settings->value("SelectedService", 0).toUInt());
connect(this, SIGNAL(sourceLanguageChanged()), SLOT(retranslate()));
connect(this, SIGNAL(targetLanguageChanged()), SLOT(retranslate()));
connect(this, SIGNAL(sourceLanguageChanged()), SIGNAL(canSwapLanguagesChanged()));
connect(this, SIGNAL(targetLanguageChanged()), SIGNAL(canSwapLanguagesChanged()));
connect(this, SIGNAL(detectedLanguageChanged()), SIGNAL(canSwapLanguagesChanged()));
connect(this, SIGNAL(error(QString)), SLOT(onError(QString)));
#ifdef Q_OS_SYMBIAN
connect(qApp, SIGNAL(visibilityChanged()), this, SIGNAL(appVisibilityChanged()));
#endif
#ifdef Q_OS_BLACKBERRY
m_invoker = new bb::system::InvokeManager();
connect(m_invoker, SIGNAL(invoked(bb::system::InvokeRequest)),
this, SLOT(onInvoked(bb::system::InvokeRequest)));
#endif
}
QVariantMap QgsJoinWithLinesAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
if ( parameters.value( QStringLiteral( "SPOKES" ) ) == parameters.value( QStringLiteral( "HUBS" ) ) )
throw QgsProcessingException( QObject::tr( "Same layer given for both hubs and spokes" ) );
std::unique_ptr< QgsFeatureSource > hubSource( parameterAsSource( parameters, QStringLiteral( "HUBS" ), context ) );
std::unique_ptr< QgsFeatureSource > spokeSource( parameterAsSource( parameters, QStringLiteral( "SPOKES" ), context ) );
if ( !hubSource || !spokeSource )
return QVariantMap();
QString fieldHubName = parameterAsString( parameters, QStringLiteral( "HUB_FIELD" ), context );
int fieldHubIndex = hubSource->fields().lookupField( fieldHubName );
const QStringList hubFieldsToCopy = parameterAsFields( parameters, QStringLiteral( "HUB_FIELDS" ), context );
QString fieldSpokeName = parameterAsString( parameters, QStringLiteral( "SPOKE_FIELD" ), context );
int fieldSpokeIndex = spokeSource->fields().lookupField( fieldSpokeName );
const QStringList spokeFieldsToCopy = parameterAsFields( parameters, QStringLiteral( "SPOKE_FIELDS" ), context );
if ( fieldHubIndex < 0 || fieldSpokeIndex < 0 )
throw QgsProcessingException( QObject::tr( "Invalid ID field" ) );
QgsFields hubOutFields;
QgsAttributeList hubFieldIndices;
if ( hubFieldsToCopy.empty() )
{
hubOutFields = hubSource->fields();
for ( int i = 0; i < hubOutFields.count(); ++i )
{
hubFieldIndices << i;
}
}
else
{
for ( const QString &field : hubFieldsToCopy )
{
int index = hubSource->fields().lookupField( field );
if ( index >= 0 )
{
hubFieldIndices << index;
hubOutFields.append( hubSource->fields().at( index ) );
}
}
}
QgsAttributeList hubFields2Fetch = hubFieldIndices;
hubFields2Fetch << fieldHubIndex;
QgsFields spokeOutFields;
QgsAttributeList spokeFieldIndices;
if ( spokeFieldsToCopy.empty() )
{
spokeOutFields = spokeSource->fields();
for ( int i = 0; i < spokeOutFields.count(); ++i )
{
spokeFieldIndices << i;
}
}
else
{
for ( const QString &field : spokeFieldsToCopy )
{
int index = spokeSource->fields().lookupField( field );
if ( index >= 0 )
{
spokeFieldIndices << index;
spokeOutFields.append( spokeSource->fields().at( index ) );
}
}
}
QgsAttributeList spokeFields2Fetch = spokeFieldIndices;
spokeFields2Fetch << fieldSpokeIndex;
QgsFields fields = QgsProcessingUtils::combineFields( hubOutFields, spokeOutFields );
QgsWkbTypes::Type outType = QgsWkbTypes::LineString;
bool hasZ = false;
if ( QgsWkbTypes::hasZ( hubSource->wkbType() ) || QgsWkbTypes::hasZ( spokeSource->wkbType() ) )
{
outType = QgsWkbTypes::addZ( outType );
hasZ = true;
}
bool hasM = false;
if ( QgsWkbTypes::hasM( hubSource->wkbType() ) || QgsWkbTypes::hasM( spokeSource->wkbType() ) )
{
outType = QgsWkbTypes::addM( outType );
hasM = true;
}
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields,
outType, hubSource->sourceCrs() ) );
if ( !sink )
return QVariantMap();
auto getPointFromFeature = [hasZ, hasM]( const QgsFeature & feature )->QgsPoint
{
QgsPoint p;
if ( feature.geometry().type() == QgsWkbTypes::PointGeometry && !feature.geometry().isMultipart() )
p = *static_cast< const QgsPoint *>( feature.geometry().constGet() );
else
p = *static_cast< const QgsPoint *>( feature.geometry().pointOnSurface().constGet() );
if ( hasZ && !p.is3D() )
p.addZValue( 0 );
if ( hasM && !p.isMeasure() )
p.addMValue( 0 );
return p;
};
QgsFeatureIterator hubFeatures = hubSource->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( hubFields2Fetch ) );
double step = hubSource->featureCount() > 0 ? 100.0 / hubSource->featureCount() : 1;
int i = 0;
QgsFeature hubFeature;
while ( hubFeatures.nextFeature( hubFeature ) )
{
i++;
if ( feedback->isCanceled() )
{
break;
}
feedback->setProgress( i * step );
if ( !hubFeature.hasGeometry() )
continue;
QgsPoint hubPoint = getPointFromFeature( hubFeature );
// only keep selected attributes
QgsAttributes hubAttributes;
for ( int j = 0; j < hubFeature.attributes().count(); ++j )
{
if ( !hubFieldIndices.contains( j ) )
continue;
hubAttributes << hubFeature.attribute( j );
}
QgsFeatureRequest spokeRequest = QgsFeatureRequest().setDestinationCrs( hubSource->sourceCrs(), context.transformContext() );
spokeRequest.setSubsetOfAttributes( spokeFields2Fetch );
spokeRequest.setFilterExpression( QgsExpression::createFieldEqualityExpression( fieldSpokeName, hubFeature.attribute( fieldHubIndex ) ) );
QgsFeatureIterator spokeFeatures = spokeSource->getFeatures( spokeRequest );
QgsFeature spokeFeature;
while ( spokeFeatures.nextFeature( spokeFeature ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( !spokeFeature.hasGeometry() )
continue;
QgsPoint spokePoint = getPointFromFeature( spokeFeature );
QgsGeometry line( new QgsLineString( QVector< QgsPoint >() << hubPoint << spokePoint ) );
QgsFeature outFeature;
QgsAttributes outAttributes = hubAttributes;
// only keep selected attributes
QgsAttributes spokeAttributes;
for ( int j = 0; j < spokeFeature.attributes().count(); ++j )
{
if ( !spokeFieldIndices.contains( j ) )
continue;
spokeAttributes << spokeFeature.attribute( j );
}
outAttributes.append( spokeAttributes );
outFeature.setAttributes( outAttributes );
outFeature.setGeometry( line );
sink->addFeature( outFeature, QgsFeatureSink::FastInsert );
}
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
return outputs;
}
QVariantMap addTransaction(int row)
{
QModelIndex status = ttm->index (row, TransactionTableModel::Status);
QModelIndex date = status.sibling(row, TransactionTableModel::Date);
QModelIndex address = status.sibling(row, TransactionTableModel::ToAddress);
QModelIndex amount = status.sibling(row, TransactionTableModel::Amount);
QVariantMap transaction;
transaction.insert("id", status.data(TransactionTableModel::TxIDRole).toString());
transaction.insert("tt", status.data(Qt::ToolTipRole).toString());
transaction.insert("c", status.data(TransactionTableModel::ConfirmationsRole).toLongLong());
transaction.insert("s", status.data(Qt::DecorationRole).toString());
transaction.insert("d", date.data(Qt::EditRole).toInt());
transaction.insert("d_s", date.data().toString());
transaction.insert("t", TransactionRecord::getTypeShort(status.data(TransactionTableModel::TypeRole).toInt()));
transaction.insert("t_l", status.sibling(row, TransactionTableModel::Type).data().toString());
transaction.insert("ad_c", address.data(Qt::ForegroundRole).value<QColor>().name());
transaction.insert("ad", address.data(TransactionTableModel::AddressRole).toString());
transaction.insert("ad_l", address.data(TransactionTableModel::LabelRole).toString());
transaction.insert("ad_d", address.data().toString());
transaction.insert("n", status.sibling(row, TransactionTableModel::Narration).data().toString());
transaction.insert("am_c", amount.data(Qt::ForegroundRole).value<QColor>().name());
transaction.insert("am", amount.data(TransactionTableModel::AmountRole).toString());
transaction.insert("am_d", amount.data().toString());
return transaction;
}
QVariantMap toJson(const PokeBattle &poke)
{
QVariantMap ret;
ret.insert("num", poke.num().pokenum);
if (poke.num().subnum) {
ret.insert("forme", poke.num().subnum);
}
ret.insert("name", poke.nick());
ret.insert("level", poke.level());
if (poke.gender()) {
ret.insert("gender", poke.gender());
}
if (poke.shiny()) {
ret.insert("shiny", poke.shiny());
}
ret.insert("percent", poke.lifePercent());
if (poke.status() != Pokemon::Fine) {
ret.insert("status", poke.status());
}
ret.insert("life", poke.lifePoints());
ret.insert("totalLife", poke.totalLifePoints());
ret.insert("happiness", poke.happiness());
ret.insert("item", poke.item());
ret.insert("ability", poke.ability());
QVariantList moves;
for (int i = 0; i < 4; i++) {
moves.push_back(toJson(poke.move(i)));
}
ret.insert("moves", moves);
QVariantList evs;
for (int i = 0; i < 6; i++) {
evs.push_back(poke.evs()[i]);
}
QVariantList ivs;
for (int i = 0; i < 6; i++) {
ivs.push_back(poke.dvs()[i]);
}
ret.insert("evs", evs);
ret.insert("ivs", ivs);
return ret;
}
