path: root/archivemodel.cpp

/*
  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License
  as published by the Free Software Foundation; either version
  2 of the License, or (at your option) any later version.
*/

#include <QSqlQuery>
#include <QSqlError>
#include <QFile>
#include <QSettings>
#include <QMutexLocker>
#include <QSignalMapper>
#include <QFileInfo>
#include <QBrush>
#include <QFont>

#include "smtreeitem.h"
#include "archivemodel.h"
#include "helper.h"

ArchiveModel::ArchiveModel(const QStringList &headers, QObject *parent) : SmTreeModel(headers, parent), mOrder(NoOrder){
    mDb = QSqlDatabase::database("treedb");
    mAvailableOrders.insert("Series Name", SeriesName);
    mAvailableOrders.insert("Actor", Actor);
    mAvailableOrders.insert("Genre", Genre);
    QSignalMapper *collectorMapper = new QSignalMapper(this);
    ArchiveCollector *c1 = new ArchiveCollector(NumFields, SeriesName, this);
    connect(c1, SIGNAL(finished()), collectorMapper, SLOT(map()));
    collectorMapper->setMapping(c1, c1);
    ArchiveCollector *c2 = new ArchiveCollector(NumFields, Actor, this);
    connect(c2, SIGNAL(finished()), collectorMapper, SLOT(map()));
    collectorMapper->setMapping(c2, c2);
    ArchiveCollector *c3 = new ArchiveCollector(NumFields, Genre, this);
    connect(c3, SIGNAL(finished()), collectorMapper, SLOT(map()));
    collectorMapper->setMapping(c3, c3);
    connect(collectorMapper, SIGNAL(mapped(QObject*)), this, SLOT(collectorFinished(QObject*)));
    mCollectors << c1 << c2 << c3;
    connect(this, SIGNAL(needRefresh()), this, SLOT(refresh()));
    refresh();
}

ArchiveModel::~ArchiveModel(){
    /* We need this, otherwise there are random
     * crashes when we exit and a collector is
     * still runnning */
    foreach(ArchiveCollector *c, mCollectors){
        c->cancel();
        c->wait();
    }
}

const QStringList ArchiveModel::availableOrders() const {
    QStringList retval = mAvailableOrders.keys();
    qSort(retval);
    return retval;
}

QVariant ArchiveModel::data(const QModelIndex &index, int role) const{
    SmTreeItem *item = itemAt(index);
    if(role == Qt::DisplayRole && index.column() == 0){
        QString retval;
        int part = item->data(SeriesPart).toInt();
        int childCount = item->data(Count).toInt();
        int nodeType = item->data(Type).toInt();
        if(nodeType == SeriesNode || nodeType == GenreNode || nodeType == ActorNode){
            retval = QString("%1 (%2)").arg(item->data(Name).toString()).arg(QString::number(childCount));
        }else if(nodeType == SeriesPartNode){
            if(part > 0){
                retval = QString("%1 %2").arg(item->data(Name).toString()).arg(QString::number(part));
            }else{
                QString subtitle = item->data(Subtitle).toString();
                if(!subtitle.isEmpty()){
                    retval = QString("%1 - %2").arg(item->data(Name).toString()).arg(item->data(Subtitle).toString());
                }
            }
        }else{
            retval = item->data(Name).toString();
        }
        return retval;
    }
    if(role == Qt::ForegroundRole){
        bool favorite = item->data(Favorite).toBool();
        if(favorite){
            return QColor(Qt::darkGreen);
        }
    }
    if(role == NameRole){
        return item->data(Name);
    }
    if(role == TypeRole){
        return item->data(Type);
    }
    return SmTreeModel::data(index, role);
}

bool ArchiveModel::setData(const QModelIndex &idx, const QVariant &value, int role){
    if(role != Qt::EditRole){
        return false;
    }
    // any other column is invisible, hence...
    if(idx.column() != Name){
        return false;
    }
    SmTreeItem *item = itemAt(idx);
    int nodeType = item->data(Type).toInt();
    QSqlQuery updateQuery(mDb);
    if(nodeType == GenreNode){
        updateQuery.prepare("UPDATE genres SET tgenrename = :value WHERE igenres_id = :id");
    }else if(nodeType == ActorNode){
        updateQuery.prepare("UPDATE actors SET tactorname = :value WHERE iactors_id = :id");
    }else if(nodeType == SeriesNode){
        updateQuery.prepare("UPDATE series SET tseries_name = :value WHERE iseries_id = :id");
    }else{
        return false;
    }
    QVariant id = item->data(GenericId);
    updateQuery.bindValue(":value", value);
    updateQuery.bindValue(":id", id);
    mDb.transaction();
    if(updateQuery.exec()){
        mDb.commit();
        item->setData(Name, value);
        emit dataChanged(idx, idx);
        if(nodeType == SeriesNode){
            emit needRefresh();
            return true;
        }
        writeCache(mOrder, root());
    }else{
        mDb.rollback();
        emitDatabaseError(updateQuery.lastError());
    }
    return false;
}

bool ArchiveModel::matchRecursive(const QModelIndex &parent, const QRegExp &regex, int column) const {
    if(!parent.isValid()){
        return false;
    }
    // first try the parent itself
    QString value = parent.data().toString();
    if(value.isEmpty()){
        return false;
    }
    if(value.contains(regex)){
        return true;
    }

    // no match, check for children
    SmTreeItem *item = static_cast<SmTreeItem*>(parent.internalPointer());
    if(!item->childCount()){
        //leaf, chech parents
        return checkParents(item, regex, column);
    }

    // we have children, traverse them
    bool retval = false;
    for(int i = 0; i < item->childCount(); ++i){
        QModelIndex newIdx = createIndex(i, column, item->child(i));
        retval = matchRecursive(newIdx, regex, column);
        if(retval){
            break;
        }
    }
    return retval;
}

bool ArchiveModel::removeNode(const QModelIndex &idx){
    if(!idx.isValid()){
        return false;
    }
    SmTreeItem *item = itemAt(idx);
    if(item->childCount()){
        return false;
    }
    int nodeType = item->data(Type).toInt();
    QSqlQuery removeQuery(mDb);
    if(nodeType == GenreNode){
        removeQuery.prepare("DELETE FROM genres WHERE igenres_id = :id");
    }else if(nodeType == ActorNode){
        removeQuery.prepare("DELETE FROM actors WHERE iactors_id = :id");
    }else if(nodeType == SeriesNode){
        removeQuery.prepare("DELETE FROM series WHERE iseries_id = :id");
    }else{
        return false;
    }
    QVariant id = item->data(GenericId);
    removeQuery.bindValue(":id", id);
    mDb.transaction();
    if(removeQuery.exec()){
        mDb.commit();
        if(nodeType == GenreNode || nodeType == ActorNode){
            removeRows(idx.row(), 1, idx.parent());
        }else if(nodeType == SeriesNode){
            emit needRefresh();
        }
        writeCache(mOrder, root());
        return true;
    }else{
        mDb.rollback();
        emitDatabaseError(removeQuery.lastError());
    }
    return false;
}

QStringList ArchiveModel::indexToPath(const QModelIndex &idx) const {
    QStringList retval;
    SmTreeItem *item = itemAt(idx);
    while (item) {
        retval << item->data(Name).toString();
        item = item->parent();
    }
    std::reverse(retval.begin(), retval.end());
    return retval;
}

QModelIndexList ArchiveModel::pathToIndex(const QStringList &path) const {
    QModelIndexList retval;
    QModelIndex parentIdx = QModelIndex();
    for(int i = 0; i < path.count(); ++i){
        QString curItem = path.at(i);
        QModelIndex found = find(curItem, Name, parentIdx);
        if(found.isValid()){
            retval << found;
            parentIdx = found;
        }
    }
    return retval;
}

QSet<int> ArchiveModel::seriesPartIds(const QModelIndex &idx) const{
    if(!idx.isValid()){
        return QSet<int>();
    }
    SmTreeItem *cur = itemAt(idx);
    QVector<SmTreeItem*> remaining;
    remaining << cur;
    QSet<int> retval;
    for(int i = 0; i < cur->childCount(); ++i){
        remaining << cur->child(i);
    }
    while(cur){
        cur = remaining.last();
        remaining.pop_back();
        for(int i = 0; i < cur->childCount(); ++i){
            remaining << cur->child(i);
        }
        int curId = cur->data(SeriesPartId).toInt();
        retval << curId;
        if(remaining.isEmpty()){
            break;
        }
    }
    return retval;
}

void ArchiveModel::setOrder(int order) {
    mOrder = order;
    SmTreeItem *rootItem = readCache(mOrder);
    if(rootItem){
        setRoot(rootItem);
    }
}

void ArchiveModel::setOrder(const QString &order){
    int orderNum = mAvailableOrders.value(order);
    setOrder(orderNum);
    setHeaderData(0, Qt::Horizontal, order, Qt::DisplayRole);
}

void ArchiveModel::refresh(){
    emit message(tr("Reading archive data..."));
    foreach(ArchiveCollector *c, mCollectors){
        if(c->isRunning()){
            c->cancel();
        }
        c->start();
    }
}

void ArchiveModel::collectorFinished(QObject *thread){
    ArchiveCollector *t = qobject_cast<ArchiveCollector*>(thread);
    SmTreeItem *rootCopy = t->rootItem();
    int sortOrder = t->sortOrder();
    if(sortOrder == mOrder){
        setRoot(rootCopy);
    }
    writeCache(sortOrder, rootCopy);
    QString sortOrderName = mAvailableOrders.key(sortOrder);
    QString msg = QString("Done reading %1").arg(sortOrderName);
    emit message(msg);
}

bool ArchiveModel::checkParents(const SmTreeItem *item, const QRegExp &regex, int column) const {
    while(item != root()){
        QString value = item->data(column).toString();
        if(value.contains(regex)){
            return true;
        }
        item = item->parent();
    }
    return false;
}

void ArchiveModel::emitDatabaseError(const QSqlError &e){
    QString databaseText = e.databaseText().isEmpty() ? tr("(none)") : e.databaseText();
    QString driverText = e.driverText().isEmpty() ? tr("(none)") : e.driverText();
    QString errormsg = QString(tr("<b>Database error:</b><br/><ul><li>driverText(): %1</li><li>databaseText(): %2</li></ul>")).arg(driverText).arg(databaseText);
    emit databaseError(errormsg);
}

void ArchiveModel::writeCache(int o, SmTreeItem *rItem){
    QFile cache(cacheFile(o));
    cache.open(QIODevice::WriteOnly);
    QDataStream stream(&cache);
    // write root id, no need to write data
    // it's invalid anyway, we just need it as an anchor
    stream << (qint64)rItem;
    for(int i = 0; i < rItem->childCount(); ++i){
        writeRecursive(rItem->child(i), stream);
    }
}

void ArchiveModel::writeRecursive(SmTreeItem *start, QDataStream &stream){
    if(start->childCount()){
        stream << (quint64)start->parent() << (qint64)start;
        writeItem(start, stream);
        for(int i = 0; i < start->childCount(); ++i){
            writeRecursive(start->child(i), stream);
        }
    }else{
        stream << (qint64)start->parent() << (qint64)start;
        writeItem(start, stream);
    }
}

void ArchiveModel::writeItem(SmTreeItem *item, QDataStream &stream){
    for(int i = 0; i < NumFields; ++i){
        stream << item->data(i);
    }
}

SmTreeItem *ArchiveModel::readCache(int o){
    QFile cache(cacheFile(o));
    if(!cache.exists() || !cache.size()){
        return 0;
    }
    cache.open(QIODevice::ReadOnly);
    QDataStream stream(&cache);
    QHash<qint64, SmTreeItem*> idHash;
    qint64 rootId;
    stream >> rootId;
    SmTreeItem *rootItem = new SmTreeItem(NumFields);
    idHash.insert(rootId, rootItem);
    qint64 parentId = 0;
    qint64 myId = 0;
    while(!stream.atEnd()){
        stream >> parentId >> myId;
        SmTreeItem *curItem = readItem(stream);
        SmTreeItem *parentItem = idHash.value(parentId, 0);
        Q_ASSERT(parentItem);
        curItem->setParent(parentItem);
        parentItem->appendChild(curItem);
        idHash.insert(myId, curItem);
    }
    return rootItem;
}

SmTreeItem *ArchiveModel::readItem(QDataStream &stream) const{
    QList<QVariant> data;
    QVariant cur;
    for(int i = 0; i < NumFields; ++i){
        stream >> cur;
        data << cur;
    }
    SmTreeItem *retval = new SmTreeItem(data);
    return retval;
}

const QString ArchiveModel::cacheFile(int o) const{
    QSettings s;
    QString archive = s.value("paths/archivedir").toString();
    QString cacheFile = QString("%1/.archivecache/").arg(archive);
    switch(o){
        case Actor:
            cacheFile.append("actors.cache");
            break;
        case Genre:
            cacheFile.append("genre.cache");
            break;
        case SeriesName:
            cacheFile.append("seriesname.cache");
            break;
        default:
            return QString();
    }
    return cacheFile;
}

/*
 * ArchiveFilesModel BEGIN */

ArchiveFilesModel::ArchiveFilesModel(const QStringList &headers, QObject *parent) : SmTreeModel(headers, parent) {
    mDb = QSqlDatabase::database("treedb");
    mRoleDbColumnMap.insert(FilenameRole, "tfilename");
    mRoleDbColumnMap.insert(DvdNoRole, "idvd");
    mRoleDbColumnMap.insert(FileTypeRole, "sifiletype");
    mRoleDbColumnMap.insert(FileNumberRole, "sifileno");
    mRoleDbColumnMap.insert(QualityRole, "siquality");
}

QVariant ArchiveFilesModel::data(const QModelIndex &index, int role) const {
    if(!index.isValid()){
        return QVariant();
    }
    SmTreeItem *item = itemAt(index);
    int col = index.column();
    if(role == ExpansionRole){
        return item->data(Expansion);
    }
    if(role == SeriesPartIdRole){
        return item->data(SeriesPartId);
    }
    if(role == FilenameRole){
        return item->data(Filename);
    }
    if(role == Md5SumRole){
        return item->data(Md5Sum);
    }
    if(role == SizeRole){
        return item->data(Size);
    }
    if(role == DvdNoRole){
        return item->data(DvdNo);
    }
    if(role == FileTypeRole){
        return item->data(FileType);
    }
    if(role == FileNumberRole){
        return item->data(FileNumber);
    }
    if(role == QualityRole){
        return item->data(Quality);
    }
    if(role == FileIdRole){
        return item->data(FileId);
    }
    if(role == SizeDurRole){
        return item->data(SizeDur);
    }
    if(role == SizeDurRole){
        return item->data(SizeDur);
    }
    if(role == FullPathRole){
        return item->data(FullPath);
    }
    if(role == Qt::ForegroundRole){
        if(col == DvdNo){
            if(item->data(DvdNo).toInt() < 0){
                return QBrush(Qt::blue);
            }else{
                return QBrush(Qt::red);
            }
        }
        if(col == Size){
            qint64 size = item->data(Size).toInt();
            qint64 fMax = Q_INT64_C(1024 * 1024 * 1024 * 4);
            if(size < fMax){
                return QBrush(Qt::green);
            }else{
                return QBrush(Qt::red);
            }
        }
    }
    if(role == Qt::TextAlignmentRole){
        switch(col){
            case Size:
            case FileId:
            case Quality:
            case FileNumber:
            case SizeDur:
                return Qt::AlignRight;

        }
    }
    if(role == Qt::FontRole){
        switch(col){
            case Md5Sum:
            case FullPath:
            case SizeDur:
                return QFont("courier new");
        }
    }
    return SmTreeModel::data(index, role);
}

bool ArchiveFilesModel::setData(const QModelIndex &idx, const QVariant &value, int role){
    const QString dbColumn = mRoleDbColumnMap.value(role);
    if(dbColumn.isEmpty()){
        return SmTreeModel::setData(idx, value, role);
    }
    QString queryString = QString("UPDATE files SET %1 = :value WHERE ifiles_id = :id").arg(dbColumn);
    QSqlQuery q(mDb);
    q.prepare(queryString);
    q.bindValue(":value", value);
    q.bindValue(":id", idx.data(FileIdRole));
    mDb.transaction();
    bool success = q.exec();
    if(success){
        if(role == FilenameRole){
            QFile f(idx.data(FullPathRole).toString());
            QFileInfo fi(f);
            QString dir = fi.absolutePath();
            QString newName = QString("%1/%2").arg(dir).arg(value.toString());
            success = f.rename(newName);
        }
        // check rename, too!
        if(success){
            mDb.commit();
            SmTreeItem *item = itemAt(idx);
            item->setData(idx.column(), value);
            emit dataChanged(idx, idx);
            return true;
        }
    }
    mDb.rollback();
    return false;
}

Qt::ItemFlags ArchiveFilesModel::flags(const QModelIndex &index) const{
    if(index.isValid()){
        QVariant v = index.data(ExpansionRole);
        if(!v.isNull()){
            return Qt::ItemIsEnabled;
        }
    }
    return SmTreeModel::flags(index);
}

int ArchiveFilesModel::nextDvd() const{
    int retval;
    QSqlQuery q("SELECT max(idvd) FROM files", mDb);
    while(q.next()){
        retval = q.value(0).toInt();
    }
    return retval + 1;
}

bool ArchiveFilesModel::isMovie(const QModelIndex &idx) const{
    return idx.data(FileTypeRole).toInt() == Movie;
}

void ArchiveFilesModel::populate(const QSet<int> &seriesPartIds){
    if(seriesPartIds.isEmpty()){
        return;
    }
    mSeriesPartIds = seriesPartIds;
    SmTreeItem *root = new SmTreeItem(NumFields);
    SmTreeItem *movies = new SmTreeItem(NumFields, root);
    movies->setData(Expansion, QChar(0x2642));
    root->appendChild(movies);
    SmTreeItem *pictures = new SmTreeItem(NumFields, root);
    pictures->setData(Expansion, QChar(0x2640));
    QStringList ids;
    foreach(int i, seriesPartIds){
        ids << QString::number(i);
    }
    QString queryString = QString("SELECT iseriespart_id, tfilename, cmd5sum, bisize, idvd, sifiletype, sifileno, siquality, ifiles_id, cpicsize, iduration FROM files WHERE iseriespart_id IN (%1) ORDER BY tfilename ASC").arg(ids.join(","));
    QSqlQuery q(queryString, mDb);
    while(q.next()){
        QList<QVariant> data;
        data << QVariant(); //expansion (empty)
        data << q.value(0) << q.value(1) << q.value(2) << q.value(3) << q.value(4) << q.value(5) << q.value(6) << q.value(7) << q.value(8); // << q.value(9);
        if(!q.value(9).isNull()){
            data << q.value(9);
        }else if(!q.value(10).isNull()){
            data << q.value(10);
        }else{
            data << 0x0;
        }
        QString fullPath = Helper::createArchivePath(data.at(Filename).toString(), data.at(Md5Sum).toString());
        data << fullPath;
        if(data.at(FileType).toInt() == Movie){
            SmTreeItem *newItem = new SmTreeItem(data, movies);
            movies->appendChild(newItem);
        }else{
            SmTreeItem *newItem = new SmTreeItem(data, pictures);
            pictures->appendChild(newItem);
        }
    }
    if(pictures->childCount()){
        root->appendChild(pictures);
    }else{
        delete pictures;
    }
    setRoot(root);
}

void ArchiveFilesModel::refresh(){
    populate(mSeriesPartIds);
}

/*
 * ArchiveCollector BEGIN */

ArchiveCollector::ArchiveCollector(int numFields, int order, QObject *parent) : QThread(parent), mRootItem(0), mNumFields(numFields), mSortOrder(order) {
    QString dbName = QString("%1").arg((qint64(this)));
    mDb = QSqlDatabase::cloneDatabase(QSqlDatabase::database("treedb"), dbName);
    mDb.open();
}

SmTreeItem *ArchiveCollector::rootItem(){
    mAccessMx.lock();
    SmTreeItem *retval = new SmTreeItem(*mRootItem);
    mAccessMx.unlock();
    return retval;
}

void ArchiveCollector::cancel(){
    QMutexLocker l(&mCancelledMx);
    mCancelled = true;
}

void ArchiveCollector::run(){
    mAccessMx.lock();
    delete mRootItem;
    mRootItem = new SmTreeItem(mNumFields);
    switch (mSortOrder){
        case ArchiveModel::SeriesName:
            populateBySeriesName();
            break;
        case ArchiveModel::Genre:
            populateByGenre();
            break;
        case ArchiveModel::Actor:
            populateByActor();
            break;
        default:
            return;
    }
    mAccessMx.unlock();
}

void ArchiveCollector::populateBySeriesName() {
    fetchSeries(QVariant(), mRootItem);
    for(int i = 0; i < mRootItem->childCount(); ++i){
        checkCancelled();
        fetchParts(QVariant(), mRootItem->child(i));
    }
}

void ArchiveCollector::populateByGenre(){
    QSqlQuery genreIdQuery = QSqlQuery("SELECT igenres_id, tgenrename FROM genres ORDER BY tgenrename", mDb);
    while(genreIdQuery.next()){
        checkCancelled();
        QList<QVariant> genreIdData;
        genreIdData << genreIdQuery.value(1) << genreIdQuery.value(0) << QVariant() << QVariant() << ArchiveModel::GenreNode << false << QVariant() << QVariant();
        SmTreeItem *genreIdItem = new SmTreeItem(genreIdData, mRootItem);
        mRootItem->appendChild(genreIdItem);
    }
    fetchChildren(mRootItem);
}

void ArchiveCollector::populateByActor(){
    QSqlQuery actorIdQuery = QSqlQuery("SELECT iactors_id, tactorname FROM actors ORDER BY tactorname", mDb);
    while(actorIdQuery.next()){
        checkCancelled();
        QList<QVariant> actorIdData;
        actorIdData << actorIdQuery.value(1) << actorIdQuery.value(0) << QVariant() << QVariant() << ArchiveModel::ActorNode << false << QVariant() << QVariant();
        SmTreeItem *actorIdItem = new SmTreeItem(actorIdData, mRootItem);
        mRootItem->appendChild(actorIdItem);
    }
    fetchChildren(mRootItem);
}

void ArchiveCollector::fetchChildren(SmTreeItem *parent){
    for(int i = 0; i < parent->childCount(); ++i){
        checkCancelled();
        fetchSeries(parent->child(i)->data(ArchiveModel::GenericId), parent->child(i));
        for(int j = 0; j < parent->child(i)->childCount(); ++j){
            checkCancelled();
            SmTreeItem *seriesItem = parent->child(i)->child(j);
            fetchParts(parent->child(i)->data(ArchiveModel::GenericId), seriesItem);
        }
    }
}

void ArchiveCollector::fetchSeries(const QVariant &id, SmTreeItem *parent){
    QSqlQuery seriesIdQuery(mDb);
    switch (mSortOrder) {
        case ArchiveModel::SeriesName:
            seriesIdQuery.prepare("SELECT iseries_id, tseries_name FROM series ORDER BY tseries_name");
            break;
        case ArchiveModel::Genre:
            seriesIdQuery.prepare("SELECT distinct(series.iseries_id), tseries_name FROM series, seriesparts, seriesparts_genremap WHERE seriesparts_genremap.igenres_id = :genreid AND seriesparts_genremap.iseriesparts_id = seriesparts.iseriesparts_id AND seriesparts.iseries_id = series.iseries_id ORDER BY tseries_name");
            seriesIdQuery.bindValue(":genreid", id);
            break;
        case ArchiveModel::Actor:
            seriesIdQuery.prepare("SELECT distinct(series.iseries_id), tseries_name FROM series, seriesparts, seriesparts_actormap WHERE seriesparts_actormap.iactors_id = :actorid AND seriesparts_actormap.iseriesparts_id = seriesparts.iseriesparts_id AND seriesparts.iseries_id = series.iseries_id ORDER BY tseries_name");
            seriesIdQuery.bindValue(":actorid", id);
            break;
        default:
            qFatal("ArchiveTreeModel::fetchSeries: invalid order!");
            return;
    }
    if(!seriesIdQuery.exec()){
        qWarning("ArchiveTreeModel::fetchSeries: failed to exectue query!");
        return;
    }
    while(seriesIdQuery.next()){
        checkCancelled();
        QList<QVariant> seriesData;
        seriesData << seriesIdQuery.value(1) << seriesIdQuery.value(0) << QVariant() << QVariant() << ArchiveModel::SeriesNode << false << QVariant() << QVariant();
        SmTreeItem *seriesItem = new SmTreeItem(seriesData, parent);
        parent->appendChild(seriesItem);
    }
    parent->setData(ArchiveModel::Count, parent->childCount());
}


void ArchiveCollector::fetchParts(const QVariant &id, SmTreeItem *parent){
    QSqlQuery partsQuery(mDb);
    if(mSortOrder == ArchiveModel::SeriesName){
        partsQuery.prepare("SELECT iseriesparts_id, iseriespart, bfavorite, tsubtitle FROM seriesparts WHERE iseries_id = :id ORDER BY iseriespart");
        partsQuery.bindValue(":id", parent->data(ArchiveModel::GenericId));
    }else if(mSortOrder == ArchiveModel::Genre){
        partsQuery.prepare("SELECT seriesparts.iseriesparts_id, iseriespart, bfavorite, tsubtitle FROM seriesparts, seriesparts_genremap WHERE iseries_id = :id AND seriesparts.iseriesparts_id = seriesparts_genremap.iseriesparts_id AND seriesparts_genremap.igenres_id = :genreid ORDER BY iseriespart");
        partsQuery.bindValue(":id", parent->data(ArchiveModel::GenericId));
        partsQuery.bindValue(":genreid", id);
    }else if(mSortOrder == ArchiveModel::Actor){
        partsQuery.prepare("SELECT seriesparts.iseriesparts_id, iseriespart, bfavorite, tsubtitle FROM seriesparts, seriesparts_actormap WHERE iseries_id = :id AND seriesparts.iseriesparts_id = seriesparts_actormap.iseriesparts_id AND seriesparts_actormap.iactors_id = :actorid ORDER BY iseriespart");
        partsQuery.bindValue(":id", parent->data(ArchiveModel::GenericId));
        partsQuery.bindValue(":actorid", id);
    }
    partsQuery.exec();
    while(partsQuery.next()){
        checkCancelled();
        QList<QVariant> partData;
        partData << parent->data(ArchiveModel::Name) << parent->data(ArchiveModel::GenericId) << partsQuery.value(0) << partsQuery.value(1) << ArchiveModel::SeriesPartNode << partsQuery.value(2) << partsQuery.value(3) << QVariant();
        SmTreeItem *partItem = new SmTreeItem(partData, parent);
        parent->appendChild(partItem);
    }
    parent->setData(ArchiveModel::Count, parent->childCount());
}

void ArchiveCollector::checkCancelled(){
    QMutexLocker l(&mCancelledMx);
    if(mCancelled){
        mCancelled = false;
        quit();
    }
}