void ITunesFeature::onRightClick(const QPoint& globalPos) {
BaseExternalLibraryFeature::onRightClick(globalPos);
QMenu menu;
QAction useDefault(tr("Use Default Library"), &menu);
QAction chooseNew(tr("Choose Library..."), &menu);
menu.addAction(&useDefault);
menu.addAction(&chooseNew);
QAction *chosen(menu.exec(globalPos));
if (chosen == &useDefault) {
SettingsDAO settings(m_database);
settings.setValue(ITDB_PATH_KEY, QString());
activate(true); // clears tables before parsing
} else if (chosen == &chooseNew) {
SettingsDAO settings(m_database);
QString dbfile = QFileDialog::getOpenFileName(
NULL, tr("Select your iTunes library"), QDir::homePath(), "*.xml");
QFileInfo dbFileInfo(dbfile);
if (dbfile.isEmpty() || !dbFileInfo.exists()) {
return;
}
// The user has picked a new directory via a file dialog. This means the
// system sandboxer (if we are sandboxed) has granted us permission to
// this folder. Create a security bookmark while we have permission so
// that we can access the folder on future runs. We need to canonicalize
// the path so we first wrap the directory string with a QDir.
Sandbox::createSecurityToken(dbFileInfo);
settings.setValue(ITDB_PATH_KEY, dbfile);
activate(true); // clears tables before parsing
}
}
bool DataCache::save() const
{
qDebug() << Q_FUNC_INFO << this->name()
<< "Serializing item database to" << m_fileName;
QFileInfo dbFileInfo(m_fileName);
if (!QDir().mkpath(dbFileInfo.path())) {
qWarning() << Q_FUNC_INFO << this->name()
<< "Error creating path" << dbFileInfo.path();
return false;
}
std::ofstream dbFile(m_fileName.toStdString().c_str());
if (!dbFile) {
qWarning() << Q_FUNC_INFO << this->name()
<< "Error opening file" << m_fileName << "for writing.";
return false;
}
Json::Value json;
if (!this->exportData(json)) {
qWarning() << Q_FUNC_INFO << this->name()
<< "Error exporting data to JSON.";
return false;
}
Json::StyledStreamWriter writer(" ");
writer.write(dbFile, json);
if (!dbFile) {
qWarning() << "Error writing to" << m_fileName;
return false;
}
return true;
}
QDateTime LocalCookieStore::lastUpdateTimeStamp() const
{
QFileInfo dbFileInfo(m_dbPath);
return dbFileInfo.lastModified();
}
//----------------------------------------------------------------------------
void ctkPluginStorageSQL::open()
{
if (m_isDatabaseOpen)
return;
QString path;
//Create full path to database
if(m_databasePath.isEmpty ())
m_databasePath = getDatabasePath();
path = m_databasePath;
QFileInfo dbFileInfo(path);
if (!dbFileInfo.dir().exists())
{
if(!QDir::root().mkpath(dbFileInfo.path()))
{
close();
QString errorText("Could not create database directory: %1");
throw ctkPluginDatabaseException(errorText.arg(dbFileInfo.path()), ctkPluginDatabaseException::DB_CREATE_DIR_ERROR);
}
}
m_connectionName = dbFileInfo.completeBaseName();
QSqlDatabase database;
if (QSqlDatabase::contains(m_connectionName))
{
database = QSqlDatabase::database(m_connectionName);
}
else
{
database = QSqlDatabase::addDatabase("QSQLITE", m_connectionName);
database.setDatabaseName(path);
}
if (!database.isValid())
{
close();
throw ctkPluginDatabaseException(QString("Invalid database connection: %1").arg(m_connectionName),
ctkPluginDatabaseException::DB_CONNECTION_INVALID);
}
//Create or open database
if (!database.isOpen())
{
if (!database.open())
{
close();
throw ctkPluginDatabaseException(QString("Could not open database. ") + database.lastError().text(),
ctkPluginDatabaseException::DB_SQL_ERROR);
}
}
m_isDatabaseOpen = true;
//Check if the sqlite version supports foreign key constraints
QSqlQuery query(database);
if (!query.exec("PRAGMA foreign_keys"))
{
close();
throw ctkPluginDatabaseException(QString("Check for foreign key support failed."),
ctkPluginDatabaseException::DB_SQL_ERROR);
}
if (!query.next())
{
close();
throw ctkPluginDatabaseException(QString("SQLite db does not support foreign keys. It is either older than 3.6.19 or was compiled with SQLITE_OMIT_FOREIGN_KEY or SQLITE_OMIT_TRIGGER"),
ctkPluginDatabaseException::DB_SQL_ERROR);
}
query.finish();
query.clear();
//Enable foreign key support
if (!query.exec("PRAGMA foreign_keys = ON"))
{
close();
throw ctkPluginDatabaseException(QString("Enabling foreign key support failed."),
ctkPluginDatabaseException::DB_SQL_ERROR);
}
query.finish();
//Check database structure (tables) and recreate tables if neccessary
//If one of the tables is missing remove all tables and recreate them
//This operation is required in order to avoid data coruption
if (!checkTables())
{
if (dropTables())
{
createTables();
}
else
{
//dropTables() should've handled error message
//and warning
close();
}
}
// silently remove any plugin marked as uninstalled
cleanupDB();
//Update database based on the recorded timestamps
updateDB();
initNextFreeIds();
}
bool PersistentStore::init()
{
QMutexLocker locker(&_mutex);
// Get application data directory and database filename.
QSettings settings;
QString appdata = settings.value("app/app_data").toString();
if(appdata.isEmpty())
{
DEBUG << "Error creating the PersistentStore: app.appdata not set.";
return false;
}
bool create = false;
QString dbUrl(appdata + QDir::separator() + DEFAULT_DBNAME);
QFileInfo dbFileInfo(dbUrl);
// Initialize database object.
_db = _db.addDatabase("QSQLITE", "tarsnap");
_db.setConnectOptions("QSQLITE_OPEN_URI");
_db.setDatabaseName(dbUrl);
// Determine whether to try to open the database.
if(!dbFileInfo.exists())
{
create = true;
}
else if(!dbFileInfo.isFile() || !dbFileInfo.isReadable())
{
DEBUG
<< "Error creating the PersistentStore: DB file is not accessible "
<< dbUrl;
return false;
} // Database file exists and is readable; attempt to open.
else if(!_db.open())
{
DEBUG << "Error opening the PersistentStore DB: "
<< _db.lastError().text();
return false;
}
else
{
// Successfully opened database.
QStringList tables = _db.tables();
// Is the database valid?
if(!tables.contains("archives", Qt::CaseInsensitive))
{
_db.close();
DEBUG << "Invalid PersistentStore DB found. Attempting to recover.";
QString newName(dbUrl + "." +
QString::number(QDateTime::currentMSecsSinceEpoch()));
if(!QFile::rename(dbUrl, newName))
{
DEBUG << "Failed to rename current invalid PersistentStore DB. "
"Please manually clean up the DB directory "
<< appdata;
return false;
}
create = true;
}
else
{
// Check the database version, and upgrade if necessary.
if(!tables.contains("version", Qt::CaseInsensitive))
{
if(!upgradeVersion0())
{
DEBUG << "Failed to upgrade PersistentStore DB. It's best "
"to start from scratch by purging the existing DB "
"in "
<< appdata;
return false;
}
}
int version = -1;
QSqlQuery query(_db);
if(query.exec("SELECT version FROM version"))
{
query.next();
version = query.value(0).toInt();
}
else
{
DEBUG << "Failed to get current DB version: "
<< query.lastError().text();
return false;
}
if((version == 0) && upgradeVersion1())
{
DEBUG << "DB upgraded to version 1.";
version = 1;
}
if((version == 1) && upgradeVersion2())
{
DEBUG << "DB upgraded to version 2.";
version = 2;
}
if((version == 2) && upgradeVersion3())
{
DEBUG << "DB upgraded to version 3.";
version = 3;
}
if((version == 3) && upgradeVersion4())
{
DEBUG << "DB upgraded to version 4.";
version = 4;
}
}
}
// Create new database (if needed).
if(create)
{
QFile dbTemplate(":/dbtemplate.db");
if(!dbTemplate.copy(dbUrl))
{
DEBUG << "Failed to create the PersistentStore DB.";
return false;
}
// Work around the fact that QFile::copy from the resource system does
// not set u+w on the resulted file
QFile dbFile(dbUrl);
dbFile.setPermissions(dbFile.permissions() | QFileDevice::WriteOwner);
dbFile.close();
if(!_db.open())
{
DEBUG << "Error opening the PersistentStore DB: "
<< _db.lastError().text();
return false;
}
}
return _initialized = true;
}
