HistoryViewer.cpp

/*
** Copyright 2017 ViVoka
**
** Made by leroy_v
** Mail <leroy_v@vivoka.com>
**
** vivoka.com
*/

#include "HistoryViewer.hpp"

// Project includes ------------------------------------------------------------
#include "Constants.hpp"
#include "DateTimeItem.hpp"

// Qt includes -----------------------------------------------------------------
#include <QKeyEvent>
#include <QGuiApplication>
#include <QJsonArray>
#include <QJsonDocument>
#include <QWindow>
#include <QMimeData>
#include <QMessageBox>

HistoryViewer::HistoryViewer(QWidget * parent) :
 QWidget(parent)
{
 _requests.reserve(Constants::maxHistorySize);

 _ui.setupUi(this);
 _ui.tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
 _ui.tableWidget->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch);

 QObject::connect(_ui.tableWidget, &QTableWidget::itemSelectionChanged,
 this, &HistoryViewer::_itemSelectionChanged);

 QObject::connect(qApp, &QGuiApplication::focusWindowChanged,
 this, &HistoryViewer::_onWindowFocusChanged);

 auto clipboard = QGuiApplication::clipboard();
 QObject::connect(clipboard, &QClipboard::changed,
 this, &HistoryViewer::_onClipboardChanged);

 // Clear history button
 QObject::connect(_ui.pbClear, &QPushButton::clicked,
 this, &HistoryViewer::_onPbClearClicked);
 // Delete request button
 QObject::connect(_ui.pbDelete, &QPushButton::clicked,
 this, &HistoryViewer::_onPbDeleteClicked);
 // Copy to clipboard button
 QObject::connect(_ui.pbCopyClipboard, &QPushButton::clicked,
 this, &HistoryViewer::_onPbCopyClipboardClicked);
}

bool HistoryViewer::hasRequest(RequestPtr request) const
{
 return _requests.contains(request);
}

void HistoryViewer::updateRequest(RequestPtr request)
{
 const auto row = _getRowForRequest(request.get());
 _fillTableRow(row, request);

 _ui.tableWidget->viewport()->update();
}

void HistoryViewer::addRequest(RequestPtr request)
{
 if (_requests.size() >= Constants::maxHistorySize)
 {
 QObject::disconnect(_ui.tableWidget, &QTableWidget::itemSelectionChanged,
 this, &HistoryViewer::_itemSelectionChanged);
 const auto rowToRemove = _ui.tableWidget->rowCount() - 1;
 const auto requestIdx = _getRequestIdxForItem(_ui.tableWidget->item(rowToRemove, 0));
 _ui.tableWidget->removeRow(rowToRemove);
 _requests.remove(requestIdx);
 QObject::connect(_ui.tableWidget, &QTableWidget::itemSelectionChanged,
 this, &HistoryViewer::_itemSelectionChanged);
 }

 _addRequestToTable(request);
 _requests.push_back(request);

 _ui.tableWidget->selectRow(0);
}

void HistoryViewer::load(QDataStream & in)
{
 in >> _requests;
 for (const auto & request : _requests)
 _addRequestToTable(request);
}

void HistoryViewer::save(QDataStream & out) const
{
 out << _requests;
}

void HistoryViewer::keyPressEvent(QKeyEvent * event)
{
 if (!event->matches(QKeySequence::Delete))
 return ;

 _ui.pbDelete->click();
}

void HistoryViewer::_addRequestToTable(const RequestPtr request)
{
 const int row = _ui.tableWidget->rowCount();
 _ui.tableWidget->setRowCount(row + 1);
 _fillTableRow(row, request);

 _ui.pbClear->setEnabled(true);
 _ui.tableWidget->sortItems(3, Qt::DescendingOrder);
 _ui.tableWidget->viewport()->update();
}

void HistoryViewer::_fillTableRow(int row, const RequestPtr request)
{
 _ui.tableWidget->setItem(row, 0, _createTableItem(request->method.constData()));
 _ui.tableWidget->setItem(row, 1, _createTableItem(request->url().toString()));
 _ui.tableWidget->setItem(row, 2, _createTableItem(QString("%1 %2").arg(request->statusCode)
 .arg(request->reasonPhrase)));
 _ui.tableWidget->setItem(row, 3, _createTableItem(request->date.toString(DateTimeItem::dateFormat), true));
 _ui.tableWidget->setItem(row, 4, _createTableItem(_formatSize(request->responseContent.size())));
 _ui.tableWidget->setItem(row, 5, _createTableItem(QString("%1 ms").arg(request->elapsedTime)));

 _ui.tableWidget->item(row, 0)->setData(Qt::UserRole, QVariant::fromValue(request.get()));
}

int HistoryViewer::_getRequestIdxForItem(const QTableWidgetItem * item) const
{
 const auto request = _getRequestForItem(item);
 for (int i = 0; i < _requests.size(); ++i)
 if (_requests.at(i).get() == request)
 return i;
 return -1;
}

Request * HistoryViewer::_getRequestForItem(const QTableWidgetItem * item) const
{
 const auto firstItem = item->column() == 0 ? item : _ui.tableWidget->item(item->row(), 0);
 return qvariant_cast<Request *>(firstItem->data(Qt::UserRole));
}

int HistoryViewer::_getRowForRequest(const Request * request) const
{
 for (int row = 0; row < _ui.tableWidget->rowCount(); ++row)
 {
 const auto item = _ui.tableWidget->item(row, 0);
 if (qvariant_cast<Request *>(item->data(Qt::UserRole)) == request)
 return row;
 }

 return -1;
}

QVector<QTableWidgetItem *> HistoryViewer::_getUniqueItemPerSelectedRow() const
{
 auto selectedItems = QVector<QTableWidgetItem *>::fromList(_ui.tableWidget->selectedItems());
 std::sort(selectedItems.begin(), selectedItems.end(),
 [](const QTableWidgetItem * v1, const QTableWidgetItem * v2)
 { return v1->row() < v2->row(); });

 selectedItems.erase(std::unique(selectedItems.begin(), selectedItems.end(),
 [](const QTableWidgetItem * v1, const QTableWidgetItem * v2)
 { return v1->row() == v2->row(); }), selectedItems.end());
 return selectedItems;
}

void HistoryViewer::_tryLoadRequestFromClipboard(QClipboard::Mode mode)
{
 // Check clipboard info
 auto clipboard = QGuiApplication::clipboard();
 if (clipboard->mimeData(mode) == nullptr || !clipboard->mimeData(mode)->hasText())
 return ;

 const auto json = QJsonDocument::fromJson(clipboard->text(mode).toUtf8()).object();
 if (json.isEmpty())
 return ;

 // Convert clipboard info into requests
 std::vector<RequestPtr> requests;
 const auto jsonRequests = json.value(Keys::requests).toArray();
 requests.reserve(static_cast<std::size_t>(jsonRequests.size()));
 for (const auto jsonRequest : jsonRequests)
 {
 requests.emplace_back(std::make_shared<Request>());
 auto & request = requests.back();
 request->fromJson(jsonRequest.toObject());

 if (request->isNull())
 requests.pop_back();
 }

 if (requests.empty())
 return ;

 // Ask the user if he want to import
 const auto button = QMessageBox::question(this, "Import request?",
 QString("Would you like to import %1 HTTP request%2 from your clipboard?")
 .arg(requests.size()).arg(requests.size() > 1 ? "s" : ""));
 if (button != QMessageBox::Yes)
 return ;

 // Add request to the table widget
 for (const auto & request : requests)
 addRequest(request);

 // Select new row
 std::vector<int> newRequestRows;
 for (const auto & request : requests)
 newRequestRows.push_back(_getRowForRequest(request.get()));

 _ui.tableWidget->clearSelection();
 for (const auto & row : newRequestRows)
 _ui.tableWidget->setRangeSelected({row, 0, row, _ui.tableWidget->columnCount() - 1}, true);
}

QTableWidgetItem * HistoryViewer::_createTableItem(const QString & text, bool dateTime)
{
 auto item = dateTime ? new DateTimeItem(text) : new QTableWidgetItem(text);
 item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 return item;
}

QString HistoryViewer::_formatSize(qint32 size)
{
 static const auto f = [](const int value, const int factor)
 {
 const auto val = (value % factor) / (factor / 10);
 if (val == 0)
 return QString::number(value / factor);
 else
 return QString("%1.%2").arg(value / factor).arg(val);
 };

 if (size < 1024)
 return QString("%1 B").arg(size);
 else if (size < 1024 * 1024)
 return QString("%1 kB").arg(f(size, 1024));
 else if (size < 1024 * 1024 * 1024)
 return QString("%1 MB").arg(f(size , 1024 * 1024));
 else
 return QString("%1 GB").arg(f(size , 1024 * 1024 * 1024));
}

void HistoryViewer::_itemSelectionChanged()
{
 const auto areItemSelected = !_ui.tableWidget->selectedItems().isEmpty();
 _ui.pbDelete->setEnabled(areItemSelected);
 _ui.pbCopyClipboard->setEnabled(areItemSelected);

 if (!areItemSelected)
 return ;

 const auto idx = _getRequestIdxForItem(_ui.tableWidget->currentItem());
 emit currentChanged(_requests.at(idx));
}

void HistoryViewer::_onPbClearClicked()
{
 _ui.tableWidget->clearContents();
 _ui.tableWidget->setRowCount(0);
 _requests.clear();
 _ui.pbClear->setEnabled(false);
}

void HistoryViewer::_onPbDeleteClicked()
{
 const auto selectedItems = _getUniqueItemPerSelectedRow();
 for (const auto & item : selectedItems)
 {
 const auto idx = _getRequestIdxForItem(item);
 _requests.removeAt(idx);

 QObject::disconnect(_ui.tableWidget, &QTableWidget::itemSelectionChanged,
 this, &HistoryViewer::_itemSelectionChanged);
 _ui.tableWidget->removeRow(item->row());
 QObject::connect(_ui.tableWidget, &QTableWidget::itemSelectionChanged,
 this, &HistoryViewer::_itemSelectionChanged);
 }

 if (_ui.tableWidget->rowCount() == 0)
 _ui.pbClear->setEnabled(false);

 _itemSelectionChanged();
}

void HistoryViewer::_onPbCopyClipboardClicked()
{
 const auto selectedItems = _getUniqueItemPerSelectedRow();
 QJsonArray jsonRequests;
 for (const auto & item : selectedItems)
 {
 const auto request = _getRequestForItem(item);
 jsonRequests.append(request->toJson());
 }

 _dataCameFromOwnCopy = true;
 const auto json = QJsonObject{{Keys::requests, jsonRequests}};
 auto clipboard = QGuiApplication::clipboard();
 clipboard->setText(QJsonDocument(json).toJson());
}

void HistoryViewer::_onWindowFocusChanged(const QWindow * window)
{
 if (window == nullptr || !_hasNewDataInClipboard)
 return ; // Lost window focus

 _hasNewDataInClipboard = false;
 _tryLoadRequestFromClipboard(_clipboardModeChanged);
}

void HistoryViewer::_onClipboardChanged(QClipboard::Mode mode)
{
 if (_dataCameFromOwnCopy)
 {
 _dataCameFromOwnCopy = false;
 return ;
 }

 _hasNewDataInClipboard = true;
 _clipboardModeChanged = mode;
 _onWindowFocusChanged(qApp->focusWindow());
}