void FilteredModelTests::filterTitleAndKeywordsTest() {
DECLARE_MODELS_AND_GENERATE(10);
Models::SettingsModel settingsModel;
settingsModel.setSearchUsingAnd(false);
commandManagerMock.InjectDependency(&settingsModel);
for (int i = 0; i < 10; ++i) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
if (i % 2 == 0) {
metadata->initialize("title", "description", QStringList() << "keyword1" << "mess1");
} else {
metadata->initialize("title", "description", QStringList() << "keyword2" << "mess2");
}
}
filteredItemsModel.setSearchTerm("keyword1 tit");
QCOMPARE(filteredItemsModel.getItemsCount(), 10);
filteredItemsModel.setSearchTerm("!keyword tit");
QCOMPARE(filteredItemsModel.getItemsCount(), 10);
settingsModel.setSearchUsingAnd(true);
filteredItemsModel.setSearchTerm("!keyword tit");
QCOMPARE(filteredItemsModel.getItemsCount(), 0);
filteredItemsModel.setSearchTerm("!keyword2 title");
QCOMPARE(filteredItemsModel.getItemsCount(), 5);
}
void MetadataIOCoordinator::afterImportHandler(const QVector<Models::ArtworkMetadata*> &itemsToRead, bool ignoreBackups) {
Models::SettingsModel *settingsModel = m_CommandManager->getSettingsModel();
const QHash<QString, ImportDataResult> &importResult = m_ReadingWorker->getImportResult();
const QVector<QPair<int, int> > &rangesToUpdate = m_ReadingWorker->getRangesToUpdate();
if (!ignoreBackups && settingsModel->getSaveBackups()) {
LOG_DEBUG << "Restoring the backups...";
int size = itemsToRead.size();
for (int i = 0; i < size; ++i) {
Models::ArtworkMetadata *metadata = itemsToRead.at(i);
const QString &filepath = metadata->getFilepath();
if (importResult.contains(filepath)) {
const ImportDataResult &importResultItem = importResult.value(filepath);
MetadataSavingCopy copy(importResultItem.BackupDict);
copy.saveToMetadata(metadata);
}
}
} else {
LOG_DEBUG << "Skipped restoring the backups";
}
if (!getHasErrors()) {
m_CommandManager->addToLibrary(itemsToRead);
}
m_CommandManager->updateArtworks(rangesToUpdate);
m_CommandManager->submitForSpellCheck(itemsToRead);
m_CommandManager->submitForWarningsCheck(itemsToRead);
}
void FilteredModelTests::filterDescriptionTest() {
DECLARE_MODELS_AND_GENERATE(10);
Models::SettingsModel settingsModel;
settingsModel.setSearchUsingAnd(false);
commandManagerMock.InjectDependency(&settingsModel);
for (int i = 0; i < 10; ++i) {
Models::ArtworkMetadata *metadata = artItemsModelMock.getArtwork(i);
if (i % 2) {
metadata->initialize("title", "description", QStringList() << "keyword1" << "keyword2");
} else {
metadata->initialize("", "", QStringList());
}
}
filteredItemsModel.setSearchTerm("desc");
QCOMPARE(filteredItemsModel.getItemsCount(), 5);
filteredItemsModel.setSearchTerm("!desc");
QCOMPARE(filteredItemsModel.getItemsCount(), 0);
filteredItemsModel.setSearchTerm("description");
QCOMPARE(filteredItemsModel.getItemsCount(), 5);
// strict match does not work for description/title
filteredItemsModel.setSearchTerm("!description");
QCOMPARE(filteredItemsModel.getItemsCount(), 0);
}
void MetadataIOCoordinator::autoDiscoverExiftool() {
LOG_DEBUG << "#";
Models::SettingsModel *settingsModel = m_CommandManager->getSettingsModel();
QString existingExiftoolPath = settingsModel->getExifToolPath();
m_ExiftoolDiscoveryFuture->setFuture(QtConcurrent::run(this,
&MetadataIOCoordinator::tryToLaunchExiftool,
existingExiftoolPath));
}
void MetadataIOCoordinator::exiftoolDiscoveryFinished() {
if (!m_ExiftoolNotFound && !m_RecommendedExiftoolPath.isEmpty()) {
LOG_DEBUG << "Recommended exiftool path is" << m_RecommendedExiftoolPath;
Models::SettingsModel *settingsModel = m_CommandManager->getSettingsModel();
QString existingExiftoolPath = settingsModel->getExifToolPath();
if (existingExiftoolPath != m_RecommendedExiftoolPath) {
LOG_INFO << "Setting exiftool path to recommended";
settingsModel->setExifToolPath(m_RecommendedExiftoolPath);
settingsModel->saveExiftool();
}
}
}
void ArtworkUploader::checkCredentials(const QString &host, const QString &username,
const QString &password, bool disablePassiveMode, bool disableEPSV) const {
Conectivity::UploadContext *context = new Conectivity::UploadContext();
context->m_Host = host;
context->m_Username = username;
context->m_Password = password;
context->m_TimeoutSeconds = 10;
context->m_UsePassiveMode = !disablePassiveMode;
context->m_UseEPSV = !disableEPSV;
Models::SettingsModel *settingsModel = m_CommandManager->getSettingsModel();
context->m_UseProxy = settingsModel->getUseProxy();
context->m_ProxySettings = settingsModel->getProxySettings();
m_TestingCredentialWatcher->setFuture(QtConcurrent::run(Conectivity::isContextValid, context));
}
int main(int argc, char *argv[]) {
const QString runGuardName = getRunGuardName();
Helpers::RunGuard guard(runGuardName);
if (!guard.tryToRun()) {
std::cerr << "Xpiks is already running";
return -1;
}
// will call curl_global_init and cleanup
Conectivity::CurlInitHelper curlInitHelper;
Q_UNUSED(curlInitHelper);
// will init thread-unsafe XMP toolkit
MetadataIO::Exiv2InitHelper exiv2InitHelper;
Q_UNUSED(exiv2InitHelper);
const char *highDpiEnvironmentVariable = setHighDpiEnvironmentVariable();
qRegisterMetaTypeStreamOperators<Models::ProxySettings>("ProxySettings");
qRegisterMetaType<Common::SpellCheckFlags>("Common::SpellCheckFlags");
initQSettings();
Helpers::AppSettings appSettings;
ensureUserIdExists(&appSettings);
Suggestion::LocalLibrary localLibrary;
QString appDataPath = XPIKS_USERDATA_PATH;
if (!appDataPath.isEmpty()) {
QDir appDataDir(appDataPath);
QString libraryFilePath = appDataDir.filePath(Constants::LIBRARY_FILENAME);
localLibrary.setLibraryPath(libraryFilePath);
} else {
std::cerr << "AppDataPath is empty!";
}
#ifdef WITH_LOGS
const QString &logFileDir = QDir::cleanPath(appDataPath + QDir::separator() + "logs");
if (!logFileDir.isEmpty()) {
QDir dir(logFileDir);
if (!dir.exists()) {
bool created = QDir().mkpath(logFileDir);
Q_UNUSED(created);
}
QString time = QDateTime::currentDateTimeUtc().toString("ddMMyyyy-hhmmss-zzz");
QString logFilename = QString("xpiks-qt-%1.log").arg(time);
QString logFilePath = dir.filePath(logFilename);
Helpers::Logger &logger = Helpers::Logger::getInstance();
logger.setLogFilePath(logFilePath);
}
#endif
QMLExtensions::ColorsModel colorsModel;
Models::LogsModel logsModel(&colorsModel);
logsModel.startLogging();
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
qSetMessagePattern("%{time hh:mm:ss.zzz} %{type} T#%{threadid} %{function} - %{message}");
#endif
qInstallMessageHandler(myMessageHandler);
LOG_INFO << "Log started. Today is" << QDateTime::currentDateTimeUtc().toString("dd.MM.yyyy");
LOG_INFO << "Xpiks" << XPIKS_VERSION_STRING << "-" << STRINGIZE(BUILDNUMBER);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
LOG_INFO << QSysInfo::productType() << QSysInfo::productVersion() << QSysInfo::currentCpuArchitecture();
#else
#ifdef Q_OS_WIN
LOG_INFO << QLatin1String("Windows Qt<5.4");
#elsif Q_OS_DARWIN
LOG_INFO << QLatin1String("OS X Qt<5.4");
#else
LOG_INFO << QLatin1String("LINUX Qt<5.4");
#endif
#endif
QApplication app(argc, argv);
LOG_INFO << "Working directory of Xpiks is:" << QDir::currentPath();
LOG_DEBUG << "Extra files search locations:" << QStandardPaths::standardLocations(XPIKS_DATA_LOCATION_TYPE);
if (highDpiEnvironmentVariable) {
qunsetenv(highDpiEnvironmentVariable);
}
localLibrary.loadLibraryAsync();
QString userId = appSettings.value(QLatin1String(Constants::USER_AGENT_ID)).toString();
userId.remove(QRegExp("[{}-]."));
Models::ArtworksRepository artworkRepository;
Models::ArtItemsModel artItemsModel;
Models::CombinedArtworksModel combinedArtworksModel;
Models::UploadInfoRepository uploadInfoRepository;
Warnings::WarningsService warningsService;
Models::SettingsModel settingsModel;
settingsModel.readAllValues();
Encryption::SecretsManager secretsManager;
UndoRedo::UndoRedoManager undoRedoManager;
Models::ZipArchiver zipArchiver;
Suggestion::KeywordsSuggestor keywordsSuggestor(&localLibrary);
Models::FilteredArtItemsProxyModel filteredArtItemsModel;
filteredArtItemsModel.setSourceModel(&artItemsModel);
Models::RecentDirectoriesModel recentDirectorieModel;
Conectivity::FtpCoordinator *ftpCoordinator = new Conectivity::FtpCoordinator(settingsModel.getMaxParallelUploads());
Models::ArtworkUploader artworkUploader(ftpCoordinator);
SpellCheck::SpellCheckerService spellCheckerService;
SpellCheck::SpellCheckSuggestionModel spellCheckSuggestionModel;
MetadataIO::BackupSaverService metadataSaverService;
Warnings::WarningsModel warningsModel;
warningsModel.setSourceModel(&artItemsModel);
warningsModel.setWarningsSettingsModel(warningsService.getWarningsSettingsModel());
Models::LanguagesModel languagesModel;
AutoComplete::AutoCompleteModel autoCompleteModel;
AutoComplete::AutoCompleteService autoCompleteService(&autoCompleteModel);
QMLExtensions::ImageCachingService imageCachingService;
Models::FindAndReplaceModel replaceModel(&colorsModel);
Models::DeleteKeywordsViewModel deleteKeywordsModel;
Conectivity::UpdateService updateService(&settingsModel);
MetadataIO::MetadataIOCoordinator metadataIOCoordinator;
#if defined(QT_NO_DEBUG) && !defined(TELEMETRY_DISABLED)
const bool telemetryEnabled = appSettings.value(Constants::USER_STATISTICS, true).toBool();
#else
const bool telemetryEnabled = false;
#endif
Conectivity::TelemetryService telemetryService(userId, telemetryEnabled);
Plugins::PluginManager pluginManager;
Plugins::PluginsWithActionsModel pluginsWithActions;
pluginsWithActions.setSourceModel(&pluginManager);
Helpers::HelpersQmlWrapper helpersQmlWrapper;
LOG_INFO << "Models created";
Commands::CommandManager commandManager;
commandManager.InjectDependency(&artworkRepository);
commandManager.InjectDependency(&artItemsModel);
commandManager.InjectDependency(&filteredArtItemsModel);
commandManager.InjectDependency(&combinedArtworksModel);
commandManager.InjectDependency(&artworkUploader);
commandManager.InjectDependency(&uploadInfoRepository);
commandManager.InjectDependency(&warningsService);
commandManager.InjectDependency(&secretsManager);
commandManager.InjectDependency(&undoRedoManager);
commandManager.InjectDependency(&zipArchiver);
commandManager.InjectDependency(&keywordsSuggestor);
commandManager.InjectDependency(&settingsModel);
commandManager.InjectDependency(&recentDirectorieModel);
commandManager.InjectDependency(&spellCheckerService);
commandManager.InjectDependency(&spellCheckSuggestionModel);
commandManager.InjectDependency(&metadataSaverService);
commandManager.InjectDependency(&telemetryService);
commandManager.InjectDependency(&updateService);
commandManager.InjectDependency(&logsModel);
commandManager.InjectDependency(&localLibrary);
commandManager.InjectDependency(&metadataIOCoordinator);
commandManager.InjectDependency(&pluginManager);
commandManager.InjectDependency(&languagesModel);
commandManager.InjectDependency(&colorsModel);
commandManager.InjectDependency(&autoCompleteService);
commandManager.InjectDependency(&imageCachingService);
commandManager.InjectDependency(&replaceModel);
commandManager.InjectDependency(&deleteKeywordsModel);
commandManager.InjectDependency(&helpersQmlWrapper);
commandManager.ensureDependenciesInjected();
keywordsSuggestor.initSuggestionEngines();
// other initializations
secretsManager.setMasterPasswordHash(appSettings.value(Constants::MASTER_PASSWORD_HASH, "").toString());
uploadInfoRepository.initFromString(appSettings.value(Constants::UPLOAD_HOSTS, "").toString());
recentDirectorieModel.deserializeFromSettings(appSettings.value(Constants::RECENT_DIRECTORIES, "").toString());
commandManager.connectEntitiesSignalsSlots();
languagesModel.initFirstLanguage();
languagesModel.loadLanguages();
telemetryService.setInterfaceLanguage(languagesModel.getCurrentLanguage());
qmlRegisterType<Helpers::ClipboardHelper>("xpiks", 1, 0, "ClipboardHelper");
qmlRegisterType<QMLExtensions::TriangleElement>("xpiks", 1, 0, "TriangleElement");
QQmlApplicationEngine engine;
Helpers::GlobalImageProvider *globalProvider = new Helpers::GlobalImageProvider(QQmlImageProviderBase::Image);
QMLExtensions::CachingImageProvider *cachingProvider = new QMLExtensions::CachingImageProvider(QQmlImageProviderBase::Image);
cachingProvider->setImageCachingService(&imageCachingService);
QQmlContext *rootContext = engine.rootContext();
rootContext->setContextProperty("artItemsModel", &artItemsModel);
rootContext->setContextProperty("artworkRepository", &artworkRepository);
rootContext->setContextProperty("combinedArtworks", &combinedArtworksModel);
rootContext->setContextProperty("appSettings", &appSettings);
rootContext->setContextProperty("secretsManager", &secretsManager);
rootContext->setContextProperty("undoRedoManager", &undoRedoManager);
rootContext->setContextProperty("keywordsSuggestor", &keywordsSuggestor);
rootContext->setContextProperty("settingsModel", &settingsModel);
rootContext->setContextProperty("filteredArtItemsModel", &filteredArtItemsModel);
rootContext->setContextProperty("helpersWrapper", &helpersQmlWrapper);
rootContext->setContextProperty("recentDirectories", &recentDirectorieModel);
rootContext->setContextProperty("metadataIOCoordinator", &metadataIOCoordinator);
rootContext->setContextProperty("pluginManager", &pluginManager);
rootContext->setContextProperty("pluginsWithActions", &pluginsWithActions);
rootContext->setContextProperty("warningsModel", &warningsModel);
rootContext->setContextProperty("languagesModel", &languagesModel);
rootContext->setContextProperty("i18", &languagesModel);
rootContext->setContextProperty("Colors", &colorsModel);
rootContext->setContextProperty("acSource", &autoCompleteModel);
rootContext->setContextProperty("replaceModel", &replaceModel);
#ifdef QT_DEBUG
QVariant isDebug(true);
#else
QVariant isDebug(false);
#endif
rootContext->setContextProperty("debug", isDebug);
engine.addImageProvider("global", globalProvider);
engine.addImageProvider("cached", cachingProvider);
LOG_DEBUG << "About to load main view...";
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
LOG_DEBUG << "Main view loaded";
pluginManager.getUIProvider()->setQmlEngine(&engine);
QQuickWindow *window = qobject_cast<QQuickWindow *>(engine.rootObjects().at(0));
pluginManager.getUIProvider()->setRoot(window->contentItem());
#ifdef QT_DEBUG
if (argc > 1) {
QList<QUrl> pathes;
for (int i = 1; i < argc; ++i) {
pathes.append(QUrl::fromLocalFile(QString::fromUtf8(argv[i])));
}
commandManager.addInitialArtworks(pathes);
}
#endif
commandManager.afterConstructionCallback();
return app.exec();
}
void AddToUserDictionaryTest::setup() {
Models::SettingsModel *settingsModel = m_CommandManager->getSettingsModel();
settingsModel->setUseSpellCheck(true);
}
void SpellingProducesWarningsTest::setup() {
Models::SettingsModel *settingsModel = m_CommandManager->getSettingsModel();
settingsModel->setUseSpellCheck(true);
}
void SpellCheckUndoTest::setup() {
Models::SettingsModel *settingsModel = m_CommandManager->getSettingsModel();
settingsModel->setUseSpellCheck(true);
}
void ClearMetadataTest::setup() {
Models::SettingsModel *settingsModel = m_CommandManager->getSettingsModel();
settingsModel->setAutoFindVectors(false);
}