//! ----------------------- PlaylistWriter::run --------------------------------
void PlaylistWriter::run()
{
if (m_fileToSave.isEmpty()) return;
m_isRunning = true;
if(MEDIA::isPlaylistFile(m_fileToSave))
{
//! save to file
MEDIA::PlaylistToFile( m_fileToSave, m_model->tracks() );
//! check if we need to update database
QString path = QFileInfo(m_fileToSave).absolutePath();
QStringList listDir = QStringList() << DatabaseManager::instance()->DB_PARAM().sourcePathList;
bool dbChange = false;
foreach(const QString& s, listDir) {
if(s.contains(path)) {
dbChange = true;
break;
}
}
//! playlist is in collection directory --> add or update into database
if(dbChange) {
updateDatabase(m_model->tracks());
emit playlistSaved();
}
} // fin Media is playlist
m_isRunning = false;
}
void Task::skip( const std::string & message, RenderContainer * renders, MonitorContainer * monitoring)
{
if( progress->state & AFJOB::STATE_DONE_MASK) return;
if( run ) run->skip( message, renders, monitoring);
else
{
progress->state = AFJOB::STATE_DONE_MASK | AFJOB::STATE_SKIPPED_MASK;
progress->errors_count = 0;
updateDatabase();
monitor( monitoring);
appendLog( message);
}
}
void Task::refresh( time_t currentTime, RenderContainer * renders, MonitorContainer * monitoring, int & errorHostId)
{
//printf("Task::refresh:\n");
bool changed = false;
// forgive error hosts
if(( false == errorHosts.empty() ) && ( block->getErrorsForgiveTime() > 0 ))
{
std::list<std::string>::iterator hIt = errorHosts.begin();
std::list<int>::iterator cIt = errorHostsCounts.begin();
std::list<time_t>::iterator tIt = errorHostsTime.begin();
while( hIt != errorHosts.end() )
if( currentTime - *tIt > block->getErrorsForgiveTime())
{
appendLog( std::string("Forgived error host \"") + *hIt + "\" since " + af::time2str(*tIt) + ".");
hIt = errorHosts.erase( hIt);
cIt = errorHostsCounts.erase( cIt);
tIt = errorHostsTime.erase( tIt);
}
else
{
hIt++;
cIt++;
tIt++;
}
}
if( renders != NULL )
{
if( run ) changed = run->refresh( currentTime, renders, monitoring, errorHostId);
else
{
// Retry errors:
if((progress->state & AFJOB::STATE_ERROR_MASK) && (progress->errors_count <= block->getErrorsRetries()))
{
progress->state = progress->state | AFJOB::STATE_READY_MASK;
progress->state = progress->state & (~AFJOB::STATE_ERROR_MASK);
appendLog( std::string("Automatically retrying error task") + af::itos( progress->errors_count) + " of " + af::itos( block->getErrorsRetries()) + ".");
if( changed == false) changed = true;
}
}
}
if( changed)
{
monitor( monitoring);
updateDatabase();
}
deleteRunningZombie();
}
void Task::restartError( const std::string & message, RenderContainer * renders, MonitorContainer * monitoring)
{
if( false == ( progress->state & AFJOB::STATE_ERROR_MASK )) return;
if( run )
{
AFERRAR("Task::restartError: task is runnning: %s[%d][%d]", block->m_job->getName().c_str(), block->m_data->getBlockNum(), number)
return;
}
progress->state = AFJOB::STATE_READY_MASK;
progress->errors_count = 0;
updateDatabase();
monitor( monitoring);
appendLog( message);
}
void Task::restart( bool onlyRunning, const std::string & message, RenderContainer * renders, MonitorContainer * monitoring)
{
if( run )
{
run->restart( message, renders, monitoring);
return;
}
if( onlyRunning ) return;
progress->state = AFJOB::STATE_READY_MASK;
progress->errors_count = 0;
updateDatabase();
monitor( monitoring);
appendLog( message);
}
bool DatabasePrivate::open(bool update)
{
Q_Q(Database);
// if (update)
bool isNew = getCurrectScheema();
connectionName = q->metaObject()->className()
+ QString::number(DatabasePrivate::lastId);
db = QSqlDatabase::addDatabase(driver, connectionName);
db.setHostName(hostName);
db.setDatabaseName(databaseName);
db.setUserName(userName);
db.setPassword(password);
bool ok = db.open();
if (!ok) {
qWarning("Could not connect to database, error = %s",
db.lastError().text().toLocal8Bit().data());
if (db.lastError().text().contains("database \"" + databaseName
+ "\" does not exist")
|| db.lastError().text().contains("Cannot open database")
|| db.lastError().text().contains("Unknown database '"
+ databaseName + "'")) {
db.setDatabaseName(sqlGenertor->masterDatabaseName(databaseName));
ok = db.open();
qDebug("Creating database");
if (ok) {
db.exec("CREATE DATABASE " + databaseName);
db.close();
if (db.lastError().type() != QSqlError::NoError)
qWarning("Creating database error: %s",
db.lastError().text().toLatin1().data());
return open(update);
} else {
qWarning("Unknown error detecting change logs, %s",
db.lastError().text().toLatin1().data());
}
}
return false;
}
if(isNew)
return updateDatabase();
else
return true;
}
LibraryDB::LibraryDB(Proxy *pr) :QObject(0)
{
proxy = pr;
QMutexLocker locker(&lock);
db = QSqlDatabase::addDatabase("QSQLITE", "LibraryDB");
db.setDatabaseName(QDir::homePath()+"/.cuberok/library.db");
if(QFile::exists(db.databaseName())) {
if(!db.open()) {
qDebug("Can not open library database");
proxy->error("Can not open library database");
open = false;
} else {
open = true;
QSqlQuery q1("select value from Version", db);
int ver = 0;
if(q1.next()) ver = q1.value(0).toString().toInt();
if(ver < DB_VERSION) {
open = updateDatabase(ver);
if(!open) db.close();
} else if(ver > DB_VERSION) {
open = false;
db.close();
qDebug("Wrong database version (%d)", ver);
proxy->error("Wrong database version -" + QString::number(ver));
}
}
} else {
if(!QDir().mkpath(QDir::homePath()+"/.cuberok") || !db.open()) {
qDebug("Can not create database");
proxy->error("Can not create database");
open = false;
} else {
QSqlQuery q0("create table Version (value integer)", db);
QSqlQuery q1("insert into Version (value) values ("+QString::number(DB_VERSION)+")", db);
QSqlQuery q2("create table Playlist (ID integer primary key autoincrement, value varchar(200), refs integer, rating integer, art varchar(250), list varchar(250))", db);
FillFromCollection();
open = true;
}
}
if(open) proxy->message("LibraryDB ready");
}
LocalOsmSearchPlugin::LocalOsmSearchPlugin( QObject *parent ) :
SearchRunnerPlugin( parent ),
m_databaseFiles()
{
setSupportedCelestialBodies(QStringList(QStringLiteral("earth")));
setCanWorkOffline( true );
QString const path = MarbleDirs::localPath() + QLatin1String("/maps/earth/placemarks/");
QFileInfo pathInfo( path );
if ( !pathInfo.exists() ) {
QDir("/").mkpath( pathInfo.absolutePath() );
pathInfo.refresh();
}
if ( pathInfo.exists() ) {
m_watcher.addPath( path );
}
connect( &m_watcher, SIGNAL(directoryChanged(QString)), this, SLOT(updateDirectory(QString)) );
connect( &m_watcher, SIGNAL(fileChanged(QString)), this, SLOT(updateFile(QString)) );
updateDatabase();
}
Database::Database() :QObject(0), subset(false), ssAlbum(0), fillingProgress(0), filling(false)
{
QMutexLocker locker(&lock);
db = QSqlDatabase::addDatabase("QSQLITE", "CollectionDB");
db.setDatabaseName(QDir::homePath()+"/.cuberok/collection.db");
// db.setConnectOptions("QSQLITE_ENABLE_SHARED_CACHE=1");
if(QFile::exists(db.databaseName())) {
if(!db.open()) {
qDebug("Can not open database");
proxy->error("Can not open database");
open = false;
} else {
open = true;
QSqlQuery q1("select value from Version", db);
int ver = -1;
if(q1.next()) ver = q1.value(0).toString().toInt();
if(ver == -1) {
open = createDatabase();
} else if(ver < DB_VERSION) {
open = updateDatabase(ver);
if(!open) db.close();
} else if(ver > DB_VERSION) {
open = false;
db.close();
qDebug("Wrong database version (%d)", ver);
proxy->error("Wrong database version -" + QString::number(ver));
}
}
} else {
if(!QDir().mkpath(QDir::homePath()+"/.cuberok") || !db.open()) {
qDebug("Can not create database");
proxy->error("Can not create database");
open = false;
} else {
open = createDatabase();
}
}
if(open) proxy->message("Database ready");
}
//***** Quantity should be checked when inputing it
void transaction(unsigned char type,unsigned char msg[]){
int status;
int quantity;
item msg_item;
// A-upc,name,price,stock,description,imagelink,category
if (type == 'A'){
status = checkItem(msg,-1);
if (status == 0){
msg_item = getItemFromMsg(msg);
sendMsg(concat("A,",msg));
//status = receiveMsg(0);
status = 1;
if (status == 1){
addItem(msg_item);
updateDatabase();
}
else{
printMsg("Transaction failed!",0,30);
printf("Transaction failed!\n\n");
}
}
else{
printMsg("Cannot add the item!",0,30);
printf("Cannot add the item!\n\n");
}
wait(30000000);
}
// B-upc,quantity
else if (type == 'B'){
quantity = getQuantityFromMsg(msg);
status = checkItem(msg,quantity);
if (status == 1){
sendMsg(concat("B,",msg));
//status = receiveMsg(0);
status = 1;
if (status == 1){
buyItem(msg_item,quantity);
updateDatabase();
}
else{
printMsg("Transaction failed!",0,30);
printf("Transaction failed!\n\n");
}
}
else{
printMsg("Cannot buy the item!",0,30);
printf("Cannot buy the item!\n\n");
}
wait(30000000);
}
// C-upc,name,price,stock,description,imagelink
else if (type == 'C'){
status = checkItem(msg,-1);
if (status == 1){
msg_item = getItemFromMsg(msg);
sendMsg(concat("C,",msg));
//status = receiveMsg(0);
status = 1;
if (status == 1){
changeItem(msg_item);
msg_item = scan(msg_item.upc);
printf("Price after:%.2f\n",msg_item.price);
updateDatabase();
}
else{
printMsg("Transaction failed!",0,30);
printf("Transaction failed!\n\n");
}
}
else{
printMsg("Cannot change the item's information!",0,30);
printf("Cannot change the item's information!\n\n");
}
wait(30000000);
}
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* MAIN
*/
int
main(int argc, char ** argv)
{
FILE* outFp;
optionProcess(&getdefsOptions, argc, argv);
validateOptions();
outFp = startAutogen();
doPreamble(outFp);
/*
* Process each input file
*/
{
int ct = STACKCT_OPT(INPUT);
char const ** ppz = STACKLST_OPT(INPUT);
do {
processFile(*ppz++);
} while (--ct > 0);
}
/*
* IF we don't have an ordering file, but we do have a "first index",
* THEN alphabetize by definition name.
*/
if ((pzIndexText == NULL) && HAVE_OPT(FIRST_INDEX)) {
qsort((void*)papzBlocks, blkUseCt, sizeof(char*), compar_defname);
set_first_idx();
}
else if (ENABLED_OPT(ORDERING) && (blkUseCt > 1))
qsort((void*)papzBlocks, blkUseCt, sizeof(char*), &compar_text);
printEntries(outFp);
fclose(outFp);
/*
* IF output is to a file
* THEN set the permissions and modification times
*/
if ( (WHICH_IDX_AUTOGEN == INDEX_OPT_OUTPUT)
&& (outFp != stdout) ) {
struct utimbuf tbuf;
tbuf.actime = time((time_t*)NULL);
tbuf.modtime = modtime + 1;
utime(OPT_ARG(OUTPUT), &tbuf);
chmod(OPT_ARG(OUTPUT), S_IRUSR|S_IRGRP|S_IROTH);
}
/*
* IF we are keeping a database of indexes
* AND we have augmented the contents,
* THEN append the new entries to the file.
*/
if ((pzIndexText != NULL) && (pzEndIndex != pzIndexEOF))
updateDatabase();
if (agPid != -1)
return awaitAutogen();
return EXIT_SUCCESS;
}