NNTPGrab

#include "WidgetNZBCreator.h"

#include "ui_WidgetNZBCreator.h"

#include "DialogImportNZB.h"

#include 

#include 

#include 

enum {

    FIELD_IMPORT,

    FIELD_PERCENTAGE_COMPLETE,

    FIELD_SUBJECT,

    FIELD_POSTER,

    FIELD_NEWSGROUP,

    FIELD_FILE_SIZE,

    FIELD_STAMP,

    FIELD_FILE_ID,

    FIELD_COLLECTION_NAME_SHORT

};

WidgetNZBCreator::WidgetNZBCreator(QNNTPGrabGlue *glue, QWidget *parent) :

    QWidget(parent),

    ui(new Ui::WidgetNZBCreator)

{

    ui->setupUi(this);

    this->glue = glue;

    connect(ui->entryQuery, SIGNAL(textChanged(QString)), SLOT(entryQuery_textChanged(QString)));

    connect(ui->treeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)), SLOT(treeWidget_itemChanged(QTreeWidgetItem*,int)));

    connect(ui->btnSearch, SIGNAL(clicked()), SLOT(btnSearch_clicked()));

    connect(ui->btnImport, SIGNAL(clicked()), SLOT(btnImport_clicked()));

    connect(ui->btnSelectAll, SIGNAL(clicked()), SLOT(btnSelectAll_clicked()));

    connect(ui->btnSelectNone, SIGNAL(clicked()), SLOT(btnSelectNone_clicked()));

    ui->treeWidget->header()->setResizeMode(QHeaderView::ResizeToContents);

    progressbarDelegate = new ProgressBarDelegate(this);

    ui->treeWidget->setItemDelegateForColumn(FIELD_PERCENTAGE_COMPLETE, progressbarDelegate);

    ui->treeWidget->setColumnHidden(FIELD_FILE_ID, true);

    ui->treeWidget->setColumnHidden(FIELD_COLLECTION_NAME_SHORT, true);

    connect(&watcher_search, SIGNAL(finished()), SLOT(performSearch_finished()));

    connect(&watcher_import, SIGNAL(finished()), SLOT(performImport_finished()));

}

WidgetNZBCreator::~WidgetNZBCreator()

{

    delete ui;

}

void WidgetNZBCreator::changeEvent(QEvent *e)

{

    QWidget::changeEvent(e);

    switch (e->type()) {

    case QEvent::LanguageChange:

        ui->retranslateUi(this);

        break;

    default:

        break;

    }

}

void WidgetNZBCreator::btnSearch_clicked()

{

    QNZBCreator::SearchOpts opts;

    QNZBCreator::SearchResult result;

    QString errmsg;

    opts.query = ui->entryQuery->text();

    opts.username = "guest";

    opts.password = "guest";

    opts.search_only_in = QNZBCreator::SEARCH_ONLY_IN_FILENAMES;

    opts.max_age = 14;

    opts.minimal_file_size = 0;

    opts.maximal_file_size = 0;

    opts.percentage_complete = 0;

    opts.group_to_search = 0;

    opts.file_type = QNZBCreator::FILE_TYPE_UNKNOWN;

    ui->treeWidget->clear();

    ui->btnSearch->setEnabled(false);

    ui->btnSelectAll->setEnabled(false);

    ui->btnSelectNone->setEnabled(false);

    ui->btnImport->setEnabled(false);

    future_search = QtConcurrent::run(this, &WidgetNZBCreator::performSearch, opts);

    watcher_search.setFuture(future_search);

}

WidgetNZBCreator::SearchResult WidgetNZBCreator::performSearch(QNZBCreator::SearchOpts opts)

{

    WidgetNZBCreator::SearchResult ret;

    ret.ret = nzbcreator.performSearch(opts, ret.errmsg, ret.result);

    return ret;

}

void WidgetNZBCreator::performSearch_finished()

{

    WidgetNZBCreator::SearchResult result = future_search.result();

    ui->btnSelectAll->setEnabled(true);

    ui->btnSelectNone->setEnabled(true);

    if (!result.ret) {

        qWarning((tr("Performing Online Search failed: ") + result.errmsg).toUtf8());

        return;

    }

    if (result.result.number_of_results == 0) {

        qWarning((tr("Search query returned no results")).toUtf8());

        return;

    }

    ui->btnImport->setEnabled(true);

    Q_FOREACH(QNZBCreator::Collection collection, result.result.collections) {

        QTreeWidgetItem *collection_item = new QTreeWidgetItem();

        collection_item->setCheckState(FIELD_IMPORT, Qt::Unchecked);

        collection_item->setText(FIELD_SUBJECT, collection.collection_name);

        collection_item->setText(FIELD_COLLECTION_NAME_SHORT, collection.short_collection_name);

        collection_item->setText(FIELD_NEWSGROUP, collection.newsgroup);

        collection_item->setText(FIELD_FILE_SIZE, QNNTPGrabGlue::utilsCalculateFileSize(collection.total_file_size));

        collection_item->setText(FIELD_STAMP, collection.stamp.toString());

        int percentage_total = 0;

        QString poster = "";

        bool unique_poster = true;

        /* Don't show an expander for collections with only one file */

        if (collection.files.count() == 1) {

            collection_item->setText(FIELD_FILE_ID, QString("%1").arg(collection.files.at(0).file_id));

            percentage_total = collection.files.at(0).complete_percentage;

        } else {

            Q_FOREACH(QNZBCreator::File file, collection.files) {

                QTreeWidgetItem *file_item = new QTreeWidgetItem(collection_item);

                file_item->setCheckState(FIELD_IMPORT, Qt::Unchecked);

                file_item->setText(FIELD_PERCENTAGE_COMPLETE, QString("%1").arg(file.complete_percentage));

                file_item->setText(FIELD_SUBJECT, file.subject);

                file_item->setText(FIELD_POSTER, file.poster);

                file_item->setText(FIELD_NEWSGROUP, collection.newsgroup);

                file_item->setText(FIELD_FILE_SIZE, QNNTPGrabGlue::utilsCalculateFileSize(file.file_size));

                file_item->setText(FIELD_STAMP, file.stamp.toString());

                file_item->setText(FIELD_FILE_ID, QString("%1").arg(file.file_id));

                percentage_total += file.complete_percentage;

                if (poster.isEmpty()) {

                    poster = file.poster;

                } else if (poster != file.poster) {

                    unique_poster = false;

                }

            }

        }

        int percentage_avg = percentage_total;

        percentage_avg /= collection.files.count();

        collection_item->setText(FIELD_PERCENTAGE_COMPLETE, QString("%1").arg(percentage_avg));

        if (unique_poster) {

            collection_item->setText(FIELD_POSTER, collection.files.at(0).poster);

        }

        ui->treeWidget->addTopLevelItem(collection_item);

    }

}

void WidgetNZBCreator::btnImport_clicked()

{

    bool multiple_collections = FALSE;

    QList<int> file_ids;

    collection_name = "";

    for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++) {

        QTreeWidgetItem *collection_item = ui->treeWidget->topLevelItem(i);

        /* Does this collection have any children? */

        if (collection_item->childCount() == 0) {

            if (collection_item->checkState(FIELD_IMPORT) == Qt::Checked) {

                file_ids.append(collection_item->text(FIELD_FILE_ID).toInt());

                if (collection_name.isEmpty()) {

                    collection_name = collection_item->text(FIELD_COLLECTION_NAME_SHORT);

                } else if (collection_name != collection_item->text(FIELD_COLLECTION_NAME_SHORT)) {

                    multiple_collections = TRUE;

                }

            }

            continue;

        }

        for (int j = 0; j < collection_item->childCount(); j++) {

            QTreeWidgetItem *file_item = collection_item->child(j);

            if (file_item->checkState(FIELD_IMPORT) == Qt::Checked) {

                file_ids.append(file_item->text(FIELD_FILE_ID).toInt());

                if (collection_name.isEmpty()) {

                    collection_name = collection_item->text(FIELD_COLLECTION_NAME_SHORT);

                } else if (collection_name != collection_item->text(FIELD_COLLECTION_NAME_SHORT)) {

                    multiple_collections = TRUE;

                }

            }

        }

    }

    if (collection_name.isEmpty()) {

        qWarning(tr("Please select one or more files which you want to import").toUtf8());

        return;

    }

    if (multiple_collections) {

        collection_name = ui->entryQuery->text();

    }

    ui->btnImport->setEnabled(false);

    ui->treeWidget->setEnabled(false);

    future_import = QtConcurrent::run(this, &WidgetNZBCreator::performImport, file_ids);

    watcher_import.setFuture(future_import);

}

WidgetNZBCreator::ImportResult WidgetNZBCreator::performImport(QList<int> file_ids)

{

    WidgetNZBCreator::ImportResult res;

    res.nzb_data = nzbcreator.generateNZB(file_ids, res.errmsg);

    return res;

}

void WidgetNZBCreator::performImport_finished()

{

    WidgetNZBCreator::ImportResult res = future_import.result();

    if (res.nzb_data.isEmpty()) {

        qWarning((tr("Unable to import files: ") + res.errmsg).toUtf8());

        return;

    }

    DialogImportNZB d(glue);

    d.quickImport(collection_name, res.nzb_data, true);

    ui->btnImport->setEnabled(true);

    ui->treeWidget->setEnabled(true);

}

void WidgetNZBCreator::btnSelectAll_clicked()

{

    for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++) {

        ui->treeWidget->topLevelItem(i)->setCheckState(FIELD_IMPORT, Qt::Checked);

    }

}

void WidgetNZBCreator::btnSelectNone_clicked()

{

    for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++) {

        ui->treeWidget->topLevelItem(i)->setCheckState(FIELD_IMPORT, Qt::Unchecked);

    }

}

void WidgetNZBCreator::entryQuery_textChanged(QString text)

{

    if (text.isEmpty()) {

        ui->btnSearch->setEnabled(false);

    } else {

        ui->btnSearch->setEnabled(true);

    }

}

void WidgetNZBCreator::treeWidget_itemChanged(QTreeWidgetItem *item, int column)

{

    /* Automatically check files when the collection item is checked */

    if (column != FIELD_IMPORT || item->childCount() == 0) {

        return;

    }

    if (item->checkState(column) == Qt::Checked) {

        for (int i = 0; i < item->childCount(); i++) {

            item->child(i)->setCheckState(FIELD_IMPORT, Qt::Checked);

        }

    } else {

        for (int i = 0; i < item->childCount(); i++) {

            item->child(i)->setCheckState(FIELD_IMPORT, Qt::Unchecked);

        }

    }

}