rsyncui/mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "downloadfile.h"
#include "tools.h"
#include <iostream>
#include <KTreeWidgetSearchLineWidget>
#include <pstreams/pstream.h>
#include <sstream>
#include <string>
#include <cstring>
#include <iostream>
#include <stdio.h>
#include <cstdio>
#include <QMessageBox>
#include <vector>
#include <boost/algorithm/string/replace.hpp>
#include <QFuture>
#include <QtConcurrent>
#include <qtconcurrentrun.h>
#include <QFileDialog>
#include <QThread>
#include <QProgressDialog>
#include <QCheckBox>
#include <sys/wait.h>
#include <QGuiApplication>

using namespace std;

bool display = false;

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    connect(&downloadO, &downloadFile::progressSignal, ui->progressBar, &QProgressBar::setValue);
    connect(&downloadO, &downloadFile::finishedSignal, this, &MainWindow::downloadFinished);
    connect(this, &MainWindow::stopDownloading, &downloadO, &downloadFile::cancelled);

    ui->ktreewidgetsearchline->setTreeWidget(ui->treeWidget);
    ui->ktreewidgetsearchline->setCaseSensitivity(Qt::CaseInsensitive);
    ui->treeWidget->setHeaderLabels({tr("Path"), tr("Size")} );
    ui->progressBar->hide();

    loadSettings();

    populateList();

}

MainWindow::~MainWindow()
{
    QMessageBox::StandardButton reply;

    if (ui->listDownload->count() != 0)
    {
       reply = QMessageBox::question(
                this,
                "RsyncUI",
                tr("Exiting will stop downloading, and will clear the download queue.\n Do you want to exit ?"),
                QMessageBox::Yes|QMessageBox::No,
                QMessageBox::No);
        if (reply == QMessageBox::Yes)
        {
            emit (stopDownloading(this->downloading.pid));
        }
    }
    saveSettings();
    if (this->downloading.pid != 0)
    {
        waitpid(this->downloading.pid, NULL, WUNTRACED);
    }
    delete ui;
}

void MainWindow::populateTree()
{
    stringstream ss;
    vector<string> path;

    if (!this->connexion.server.empty() and this->connexion.port > 0 and this->connexion.port < 65536)
    {
        QGuiApplication::setOverrideCursor(Qt::WaitCursor);
        if (validateServer(this->connexion.server))
        {
            path = explode(ui->listWidget->currentItem()->text().toStdString(), '\n', 2);
            scanDir(this->connexion.server, this->connexion.port, NULL, path[0].append("/") );
        }
        QGuiApplication::setOverrideCursor(Qt::ArrowCursor);
    }
}

void MainWindow::populateList()
{
    stringstream ss;
    QString str;
    QString server;
    QString port;

    server = ui->khistorycombobox->currentText();
    this->connexion.server.assign(server.toStdString());
    ss << ui->portEdit->text().toStdString();
    ss >> this->connexion.port;
    QGuiApplication::setOverrideCursor(Qt::WaitCursor);

    this->settings.beginGroup("connexion/server");
    if (this->settings.contains(server))
    {
        port = this->settings.value(server).toString();
        ui->portEdit->setText(port);
        this->connexion.port = this->settings.value(server).toInt();
    }

    if (!server.isEmpty() and this->connexion.port > 0 and this->connexion.port < 65536)
    {
        if (validateServer(server.toStdString()))
        {
            //this->settings.beginGroup("connexion/server");
            if (!this->settings.contains(server))
            {
                cout << server.toStdString() << endl;
                // storing serverURL and port in settings
                this->settings.setValue(server, this->connexion.port);
                this->settings.sync();

                // storing in history of combobox
                ui->khistorycombobox->addToHistory(server);
            }
            // "waiting" cursor
            // load and display rsync services of the rsync server
            listServices();
        }
    }
    this->settings.endGroup();
    QGuiApplication::setOverrideCursor(Qt::ArrowCursor);
}

void MainWindow::listServices()
{
    char cmd[4096];
    string line;
    string errorRsync;
    vector<string> v;
    char service[4096];

    ui->listWidget->clear();
    sprintf(cmd, "rsync --contimeout=10 -P \"%s::\" --port %d ", this->connexion.server.c_str(), this->connexion.port );
    redi::ipstream in(cmd, redi::pstreams::pstdout | redi::pstreams::pstderr);
    while (getline(in.out(), line))
    {
        //cout << "stdout: " << line << endl;
        boost::replace_all(line," ","");
        boost::replace_all(line, "\t", " - ");
        v = explode(line, ' ', 3 );
        sprintf(service, "%s\n\t%s", v[0].c_str(), v[2].c_str());
        ui->listWidget->addItem(service);
    }
}

void MainWindow::scanDir(string server, int portN, QTreeWidgetItem *parent, string path)
{
    char cmd[4096];
    string line;
    string errorRsync;
    vector<string> v;
    QTreeWidgetItem * item;
    char npath[4096];

    sprintf(cmd, "rsync --contimeout=10 -P \"%s::%s\" --port %d ", server.c_str(), path.c_str(), portN );
    redi::ipstream in(cmd, redi::pstreams::pstdout | redi::pstreams::pstderr);

    while (getline(in.out(), line))
    {

        v = explode(line, ' ', 5);
        if (v.size() == 5)
        {
            if (v[4].at(0) != '.' and (v[0].at(0) == '-' or v[0].at(0) == 'd'))
            {
                if (parent != NULL)
                {
                    item = addTreeChild(parent,QString::fromStdString(v[4]), QString::fromStdString(v[1]));
                }else
                {
                    item = addTreeRoot(QString::fromStdString(v[4]), QString::fromStdString(v[1]));
                }
                if (v[0].at(0) == 'd')
                {
                   sprintf(npath, "%s%s/", path.c_str(), v[4].c_str());
                   scanDir(server, portN, item, npath);
                }
            }
        }
    }
    // if reading stdout stopped at EOF then reset the state:
    if (in.eof() && in.fail())
        in.clear();
    // read child's stderr
    while (getline(in.err(), line))
    {
        cout << "stderr: " << line << endl;
        errorRsync.append(line);
        errorRsync.append("\n");
    }
    if ( !errorRsync.empty())
    {
        QMessageBox::warning(
            this,
            "RsyncUI",
            errorRsync.c_str());
    }

}

bool MainWindow::isIpAddress(string server)
{
    vector<string> r;
    int elementN;
    QString qr;
    bool ok;

    r = explode(server, '.', 5);
    if (r.size() == 4)
    {
        for (auto element : r)
        {
            elementN = QString::fromStdString(element).toInt(&ok);
            if (elementN < 0 or elementN > 255 or ok == false)
            {
                return false;
            }
        }
    }
    return true;
}

bool MainWindow::validateServer(string server)
{
    char cmd[512];
    string line;
    string errorDig;
    bool flag = false;

    sprintf(cmd, "dig %s", server.c_str());
    redi::ipstream in(cmd, redi::pstreams::pstdout | redi::pstreams::pstderr);

    while (getline(in.out(), line))
    {
        //cout << "stdout: " << line << '\n';
        if (line.find(";; ANSWER SECTION:") != string::npos)
        {
            flag = true;
        }
    }
    // if reading stdout stopped at EOF then reset the state:
    if (in.eof() && in.fail())
        in.clear();
    // read child's stderr
    while (std::getline(in.err(), line))
    {
        cout << "stderr: " << line << '\n';
        errorDig.append(line);
        errorDig.append("\n");
    }
    if ( !errorDig.empty())
    {
        QMessageBox::warning(
            this,
            "RsyncUI",
            errorDig.c_str()
        );
    }
    if ( flag == false)
    {
        flag = isIpAddress(server);
    }
    if ( flag == false)
    {
        QMessageBox::warning(
            this,
            "RsyncUI",
            tr("server does not exists" )
        );
    }
    return flag;
}

void MainWindow::displayTree()
{
  populateTree();

}

void MainWindow::on_khistorycombobox_returnPressed()
{
    //populateList();
}

void MainWindow::on_khistorycombobox_currentIndexChanged(int i)
{
    /*QString server = ui->khistorycombobox->currentText();
    this->settings.beginGroup("connexion/server");
    ui->portEdit->setText(this->settings.value(server).toString());
    this->settings.endGroup();*/
    this->populateList();
}

void MainWindow::on_portEdit_returnPressed()
{
    populateList();
}

void MainWindow::on_actionDownload_triggered()
{

}

QTreeWidgetItem * MainWindow::addTreeRoot(QString name, QString fileSize)
{
    // QTreeWidgetItem(QTreeWidget * parent, int type = Type)
    QTreeWidgetItem *treeItem = new QTreeWidgetItem(ui->treeWidget);

    // QTreeWidgetItem::setText(int column, const QString & text)
    treeItem->setText(0, name);
    treeItem->setText(1, fileSize);
    return treeItem;
}

QTreeWidgetItem * MainWindow::addTreeChild(QTreeWidgetItem *parent, QString name, QString fileSize)
{
    // QTreeWidgetItem(QTreeWidget * parent, int type = Type)
    QTreeWidgetItem *treeItem = new QTreeWidgetItem();

    // QTreeWidgetItem::setText(int column, const QString & text)
    treeItem->setText(0, name);
    treeItem->setText(1, fileSize);

    // QTreeWidgetItem::addChild(QTreeWidgetItem * child)
    parent->addChild(treeItem);
    return treeItem;
}

void MainWindow::on_listWidget_clicked(const QModelIndex &index)
{
    vector<string> v;
    v = explode(ui->listWidget->currentItem()->text().toStdString(), '\n', 2);
    this->downloading.service = v[0];
    populateTree();
}

void MainWindow::on_treeWidget_itemDoubleClicked(QTreeWidgetItem *item, int column)
{
    QFuture<void> future;
    QFileDialog dialog;
    QCheckBox *cb = new QCheckBox("Okay I understand");

    item = ui->treeWidget->currentItem();
    this->downloading.path = item->text(0).toStdString();
    while(item->parent() != NULL)
    {
        item = item->parent();
        this->downloading.path = item->text(0).toStdString() + "/" + this->downloading.path;

    };

    //dirPath.append("/Vidéos/");
    if (this->downloading.savePath.empty())
    {
        if (this->downloading.dirPath.toStdString().empty())
        {
            this->downloading.dirPath = getenv("HOME");
        }

        this->downloading.savePath = dialog.getExistingDirectory(this, tr("Choose directory to save file"), this->downloading.dirPath, QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks).toStdString();
        if (!this->downloading.savePath.empty() && this->downloading.pid == 0)
        {
            startDownloading();
        }
    }
    ui->listDownload->addItem(QString::fromStdString(this->downloading.path));
}

void MainWindow::startDownloading()
{
    ui->progressBar->setValue(0);
    ui->progressBar->show();

    QtConcurrent::run(&this->downloadO, &downloadFile::download, this);

}

void MainWindow::stoppingDownload()
{
    emit (stopDownloading(this->downloading.pid));
}

void MainWindow::downloadFinished()
{
    ui->progressBar->hide();
    delete ui->listDownload->takeItem(0);
    this->downloading.pid = 0;
    if (ui->listDownload->count() != 0)
    {
        this->downloading.path = ui->listDownload->item(0)->text().toStdString();
        startDownloading();
    }
}

void MainWindow::on_listDownload_itemClicked(QListWidgetItem *item)
{
    QFileDialog dialog;
    QMessageBox::StandardButton reply;

    //cout << item->text().toStdString() << endl;
    if (item->listWidget()->row(item) == 0)
    {
       reply = QMessageBox::question(
                this,
                "RsyncUI",
                tr("Do you want to stop downloading and delete this file from download queue ?"),
                QMessageBox::Yes|QMessageBox::No,
                QMessageBox::No);
        if (reply == QMessageBox::Yes)
        {
            emit (stopDownloading(this->downloading.pid));
        }
    }else
    {
        reply = QMessageBox::question(
                this,
                "RsyncUI",
                tr("Do you want to delete this file from download queue ?"),
                QMessageBox::Yes|QMessageBox::No,
                QMessageBox::No);
        if (reply == QMessageBox::Yes)
        {
            ui->listDownload->removeItemWidget(item);
            delete item;
        }
    }
}

void MainWindow::loadSettings()
{
    this->restoreGeometry(settings.value("window/geometry").toByteArray());
    this->settings.beginGroup("connexion/server");

    QStringList servers = this->settings.allKeys();
    this->settings.endGroup();

    for( const QString &server : servers )
    {
        ui->khistorycombobox->addToHistory(server);
    }
}


void MainWindow::saveSettings()
{
    this->settings.setValue("window/geometry", saveGeometry());
    this->settings.sync();
}

void MainWindow::on_actionAbout_triggered()
{
    QString text =  this->about.description + "\n\n" +
                    "Licence:     " + this->about.licence + "\n" +
                    "Author:      " + this->about.author + "\n" +
                    "EMail :      " + this->about.email + "\n" +
                    "Source code: " + this->about.git;
    QMessageBox::about(this, this->about.title, text);
}

void MainWindow::on_actionAbout_Qt_triggered()
{
    QMessageBox::aboutQt(this);
}