kget/core/transferhistorystore.cpp

   1 /* This file is part of the KDE project
   2
   3    Copyright (C) 2007 by Lukas Appelhans <l.appelhans@gmx.de>
   4    Copyright (C) 2008 by Javier Goday <jgoday@gmail.com>
   5
   6    This program is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU General Public
   8    License as published by the Free Software Foundation; either
   9    version 2 of the License, or (at your option) any later version.
  10 */
  11 #include "core/transferhistorystore.h"
  12 #include "core/transferhistorystore_xml_p.h"
  13 #include "core/transfer.h"
  14 #include "settings.h"
  15
  16 #include <QDateTime>
  17 #include <QDomDocument>
  18 #include <QFile>
  19 #include <QList>
  20 #include <QThread>
  21 #include <QTimer>
  22
  23 #ifdef HAVE_SQLITE
  24     #include "core/transferhistorystore_sqlite_p.h"
  25     #include <QSqlDatabase>
  26     #include <QSqlError>
  27     #include <QSqlQuery>
  28     #include <QSqlRecord>
  29 #endif
  30
  31 #include <KDebug>
  32 #include <kio/global.h>
  33 #include <KLocale>
  34 #include <KMessageBox>
  35 #include <KStandardDirs>
  36
  37 TransferHistoryItem::TransferHistoryItem() : QObject()
  38 {}
  39
  40 TransferHistoryItem::TransferHistoryItem(const Transfer &transfer) : QObject()
  41 {
  42     setDest(transfer.dest().url());
  43     setSource(transfer.source().url());
  44     setSize(transfer.totalSize());
  45     setDateTime(QDateTime::currentDateTime());
  46
  47     setState(transfer.status());
  48 }
  49
  50 TransferHistoryItem::TransferHistoryItem(const TransferHistoryItem &item) : QObject()
  51 {
  52     setDest(item.dest());
  53     setSource(item.source());
  54     setState(item.state());
  55     setSize(item.size());
  56     setDateTime(item.dateTime());
  57 }
  58
  59 void TransferHistoryItem::setDest(const QString &dest)
  60 {
  61     m_dest = dest;
  62 }
  63
  64 void TransferHistoryItem::setSource(const QString &source)
  65 {
  66     m_source = source;
  67 }
  68
  69 void TransferHistoryItem::setState(int state)
  70 {
  71     m_state = state;
  72 }
  73
  74 void TransferHistoryItem::setSize(int size)
  75 {
  76     m_size = size;
  77 }
  78
  79 void TransferHistoryItem::setDateTime(const QDateTime &dateTime)
  80 {
  81     m_dateTime = dateTime;
  82 }
  83
  84 QString TransferHistoryItem::dest() const
  85 {
  86     return m_dest;
  87 }
  88
  89 QString TransferHistoryItem::source() const
  90 {
  91     return m_source;
  92 }
  93
  94 int TransferHistoryItem::state() const
  95 {
  96     return m_state;
  97 }
  98
  99 int TransferHistoryItem::size() const
 100 {
 101     return m_size;
 102 }
 103
 104 QDateTime TransferHistoryItem::dateTime() const
 105 {
 106     return m_dateTime;
 107 }
 108
 109 TransferHistoryItem& TransferHistoryItem::operator=(const TransferHistoryItem &item)
 110 {
 111     setDest(item.dest());
 112     setSource(item.source());
 113     setState(item.state());
 114     setSize(item.size());
 115     setDateTime(item.dateTime());
 116
 117     return *this;
 118 }
 119
 120 bool TransferHistoryItem::operator==(const TransferHistoryItem& item)
 121 {
 122     return dest() == item.dest() && source() == item.source();
 123 }
 124
 125 TransferHistoryStore::TransferHistoryStore() : QObject(),
 126     m_items()
 127 {
 128 }
 129
 130 TransferHistoryStore::~TransferHistoryStore()
 131 {
 132 }
 133
 134 QList <TransferHistoryItem> TransferHistoryStore::items() const
 135 {
 136     return m_items;
 137 }
 138
 139 TransferHistoryStore *TransferHistoryStore::getStore()
 140 {
 141     switch(Settings::historyBackend())
 142     {
 143         case TransferHistoryStore::SQLite:
 144 #ifdef HAVE_SQLITE
 145             return new SQLiteStore(KStandardDirs::locateLocal("appdata", "transferhistory.db"));
 146             break;
 147 #endif
 148         case TransferHistoryStore::Xml:
 149         default:
 150             return new XmlStore(KStandardDirs::locateLocal("appdata", "transferhistory.kgt"));
 151     }
 152 }
 153
 154 XmlStore::SaveThread::SaveThread(QObject *parent, const QString &url, const QList<TransferHistoryItem> &list) : QThread(parent),
 155     m_url(url),
 156     m_items(list),
 157     m_item()
 158 {
 159 }
 160
 161 XmlStore::SaveThread::SaveThread(QObject *parent, const QString &url, const TransferHistoryItem &item) : QThread(parent),
 162     m_url(url),
 163     m_items(),
 164     m_item(item)
 165 {
 166 }
 167
 168 void XmlStore::SaveThread::run()
 169 {
 170     QFile file(m_url);
 171     QDomDocument *doc;
 172     QDomElement root;
 173
 174     if (!file.exists())
 175     {
 176         doc = new QDomDocument("Transfers");
 177         root = doc->createElement("Transfers");
 178         doc->appendChild(root);
 179     }
 180     else
 181     {
 182         doc = new QDomDocument();
 183         doc->setContent(&file);
 184         file.close();
 185         root = doc->documentElement();
 186         doc->appendChild(root);
 187     }
 188
 189     QDomElement e = doc->createElement("Transfer");
 190     root.appendChild(e);
 191
 192     e.setAttribute("Source", m_item.source());
 193     e.setAttribute("Dest", m_item.dest());
 194     e.setAttribute("Time", QDateTime::currentDateTime().toTime_t());
 195     e.setAttribute("Size", QString::number(m_item.size()));
 196     e.setAttribute("State", QString::number(m_item.state()));
 197
 198     if (file.open(QFile::WriteOnly | QFile::Truncate)) {
 199         QTextStream stream( &file );
 200         doc->save( stream, 0 );
 201         file.close();
 202     }
 203     delete doc;
 204 }
 205
 206 XmlStore::DeleteThread::DeleteThread(QObject *parent, const QString &url, const TransferHistoryItem &item) : QThread(parent),
 207     m_url(url),
 208     m_item(item),
 209     m_items()
 210 {
 211 }
 212
 213 void XmlStore::DeleteThread::run()
 214 {
 215     QDomDocument doc("tempHistory");
 216     QFile file(m_url);
 217
 218     QString error;
 219     int line;
 220     int column;
 221     int total;
 222
 223     if (!doc.setContent(&file, &error, &line, &column))
 224     {
 225         kDebug(5001) << "Error1" << error << line << column;
 226         return;
 227     }
 228     file.close();
 229
 230     QDomElement root = doc.documentElement();
 231     total = root.childNodes().size();
 232
 233     QDomNodeList list = root.elementsByTagName("Transfer");
 234
 235     int nItems = list.length();
 236
 237     for (int i = 0 ; i < nItems ; i++) {
 238         QDomElement element = list.item(i).toElement();
 239
 240         if(QString::compare(element.attribute("Source"), m_item.source()) == 0) {
 241             root.removeChild(element);
 242         }
 243         else {
 244             TransferHistoryItem item;
 245             item.setDest(element.attribute("Dest"));
 246             item.setSource(element.attribute("Source"));
 247             item.setSize(element.attribute("Size").toInt());
 248             item.setDateTime(QDateTime::fromTime_t(element.attribute("Time").toUInt()));
 249             item.setState(element.attribute("State").toInt());
 250             m_items << item;
 251         }
 252     }
 253
 254     if (file.open(QFile::WriteOnly | QFile::Truncate)) {
 255         QTextStream stream( &file );
 256         doc.save(stream, 0);
 257         file.close();
 258         doc.clear();
 259     }
 260 }
 261
 262 XmlStore::LoadThread::LoadThread(QObject *parent, const QString &url) : QThread(parent),
 263     m_url(url)
 264 {
 265 }
 266
 267 void XmlStore::LoadThread::run()
 268 {
 269     qRegisterMetaType<TransferHistoryItem>("TransferHistoryItem");
 270     QDomDocument doc("tempHistory");
 271     QFile file(m_url);
 272
 273     QString error;
 274     int line;
 275     int column;
 276     int total;
 277
 278     if (!doc.setContent(&file, &error, &line, &column))
 279     {
 280         kDebug(5001) << "Error1" << error << line << column;
 281         file.close();
 282         return;
 283     }
 284
 285     QDomElement root = doc.documentElement();
 286     total = root.childNodes().size();
 287
 288     QDomNodeList list = root.elementsByTagName("Transfer");
 289
 290     int nItems = list.length();
 291
 292     for (int i = 0 ; i < nItems ; i++)
 293     {
 294         QDomElement dom = list.item(i).toElement();
 295         TransferHistoryItem item;
 296         item.setDest(dom.attribute("Dest"));
 297         item.setSource(dom.attribute("Source"));
 298         item.setSize(dom.attribute("Size").toInt());
 299         item.setDateTime(QDateTime::fromTime_t(dom.attribute("Time").toUInt()));
 300         item.setState(dom.attribute("State").toInt());
 301
 302         emit elementLoaded(i, total, item);
 303     }
 304     doc.clear();
 305     file.close();
 306     TransferHistoryItem item;
 307
 308     emit elementLoaded(total, total, item);
 309     kDebug(5001) << "Load file" << m_url;
 310 }
 311
 312 XmlStore::XmlStore(const QString &url) : TransferHistoryStore(),
 313     m_storeUrl(url),
 314     m_loadThread(0),
 315     m_saveThread(0),
 316     m_deleteThread(0)
 317 {
 318 }
 319
 320 XmlStore::~XmlStore()
 321 {
 322     if(m_loadThread && m_loadThread->isRunning()) {
 323         m_loadThread->terminate();
 324     }
 325
 326     if(m_saveThread && m_saveThread->isRunning()) {
 327         m_saveThread->terminate();
 328     }
 329
 330     if(m_deleteThread && m_deleteThread->isRunning()) {
 331         m_deleteThread->terminate();
 332     }
 333
 334     delete m_loadThread;
 335     delete m_saveThread;
 336     delete m_deleteThread;
 337 }
 338
 339 void XmlStore::load()
 340 {
 341     m_items.clear();
 342     // TODO: only load if necessary
 343     m_loadThread = new XmlStore::LoadThread(this, m_storeUrl);
 344
 345     connect(m_loadThread, SIGNAL(finished()), SIGNAL(loadFinished()));
 346     connect(m_loadThread, SIGNAL(elementLoaded(int, int, const TransferHistoryItem &)),
 347                         SIGNAL(elementLoaded(int, int, const TransferHistoryItem &)));
 348     connect(m_loadThread, SIGNAL(elementLoaded(int, int, const TransferHistoryItem &)),
 349                         SLOT(slotLoadElement(int, int, const TransferHistoryItem &)));
 350     m_loadThread->start();
 351 }
 352
 353 void XmlStore::clear()
 354 {
 355     QFile::remove(m_storeUrl);
 356 }
 357
 358 void XmlStore::saveItem(const TransferHistoryItem &item)
 359 {
 360     m_saveThread = new XmlStore::SaveThread(this, m_storeUrl, item);
 361
 362     connect(m_saveThread, SIGNAL(finished()), SIGNAL(saveFinished()));
 363     connect(m_saveThread, SIGNAL(elementLoaded(int, int, const TransferHistoryItem &)),
 364                         SIGNAL(elementLoaded(int, int, const TransferHistoryItem &)));
 365     m_saveThread->start();
 366 }
 367
 368 void XmlStore::deleteItem(const TransferHistoryItem &item)
 369 {
 370     Q_UNUSED(item)
 371
 372     m_deleteThread = new XmlStore::DeleteThread(this, m_storeUrl, item);
 373
 374     connect(m_deleteThread, SIGNAL(finished()), SLOT(slotDeleteElement()));
 375
 376     m_deleteThread->start();
 377 }
 378
 379 void XmlStore::slotLoadElement(int number, int total, const TransferHistoryItem &item)
 380 {
 381     Q_UNUSED(number)
 382     Q_UNUSED(total)
 383     m_items.append(item);
 384 }
 385
 386 void XmlStore::slotDeleteElement()
 387 {
 388     m_items.clear();
 389     m_items << m_deleteThread->items();
 390
 391     emit loadFinished();
 392 }
 393
 394 #ifdef HAVE_SQLITE
 395 SQLiteStore::SQLiteStore(const QString &database) : TransferHistoryStore(),
 396     m_dbName(database),
 397     m_sql()
 398 {
 399 }
 400
 401 SQLiteStore::~SQLiteStore()
 402 {
 403     if (m_sql.isOpen()) {
 404         m_sql.close();
 405     }
 406 }
 407
 408 void SQLiteStore::load()
 409 {
 410     m_items.clear();
 411     if (sql().open()) {
 412         if (!sql().tables().contains("transfer_history_item")) {
 413             createTables();
 414         }
 415
 416         QSqlQuery query = sql().exec("SELECT * FROM transfer_history_item");
 417
 418         if (query.lastError().isValid()) {
 419             kDebug() << query.lastError().text();
 420         }
 421         else {
 422             QSqlRecord rec = query.record();
 423
 424             while (query.next()) {
 425                 TransferHistoryItem item;
 426                 item.setDest(query.value(rec.indexOf("dest")).toString());
 427                 item.setSource(query.value(rec.indexOf("source")).toString());
 428                 item.setState(query.value(rec.indexOf("state")).toInt());
 429                 item.setDateTime(QDateTime::fromTime_t(query.value(rec.indexOf("time")).toUInt()));
 430                 item.setSize(query.value(rec.indexOf("size")).toInt());
 431
 432                 m_items << item;
 433                 emit elementLoaded(query.at(), query.size(), item);
 434             }
 435         }
 436     }
 437
 438     sql().close();
 439
 440     emit loadFinished();
 441 }
 442
 443 void SQLiteStore::clear()
 444 {
 445     QFile::remove(m_dbName);
 446 }
 447
 448 void SQLiteStore::saveItem(const TransferHistoryItem &item)
 449 {
 450     if (sql().open()) {
 451         if (!sql().tables().contains("transfer_history_item")) {
 452             createTables();
 453         }
 454
 455        QSqlQuery query = sql().exec("insert into transfer_history_item(source, dest, size, time, state)"
 456                                 "values ('"+item.source()+"', '"+item.dest()+"', "
 457                                 + QString::number(item.size()) + ", "
 458                                 + QString::number(item.dateTime().toTime_t()) + ", '"
 459                                 + QString::number(item.state())+"')");
 460
 461         if (query.lastError().isValid()) {
 462             kDebug() << query.lastError().text();
 463         }
 464
 465         sql().commit();
 466         m_items << item;
 467     }
 468     sql().close();
 469
 470     emit saveFinished();
 471 }
 472
 473 void SQLiteStore::deleteItem(const TransferHistoryItem &item)
 474 {
 475     if (sql().open()) {
 476         if (!sql().tables().contains("transfer_history_item")) {
 477             createTables();
 478         }
 479
 480         QSqlQuery query = sql().exec("delete from transfer_history_item where "
 481                                             " source = '" + item.source() + "';");
 482
 483         if (query.lastError().isValid()) {
 484             kDebug() << query.lastError().text();
 485         }
 486
 487         sql().commit();
 488         m_items.removeAll(item);
 489     }
 490     sql().close();
 491
 492     emit deleteFinished();
 493 }
 494
 495 QSqlDatabase SQLiteStore::sql()
 496 {
 497     if (!m_sql.isValid()) {
 498         m_sql = QSqlDatabase::addDatabase("QSQLITE");
 499         m_sql.setDatabaseName(m_dbName);
 500     }
 501
 502     return m_sql;
 503 }
 504
 505 void SQLiteStore::createTables()
 506 {
 507     QSqlQuery query = sql().exec("CREATE TABLE transfer_history_item(dest VARCHAR NOT NULL, "
 508                                 "source VARCHAR NOT NULL, size int NOT NULL, time int not null, "
 509                                 "state int, PRIMARY KEY(dest, source));");
 510
 511     if (query.lastError().isValid()) {
 512         kDebug() << query.lastError().text();
 513     }
 514 }
 515 #endif
 516
 517 #include "transferhistorystore.moc"
 518 #include "transferhistorystore_xml_p.moc"
 519 #ifdef HAVE_SQLITE
 520     #include "transferhistorystore_sqlite_p.moc"
 521 #endif