Merge pull request #41

b1454c6 removed duplicated-by-mistake code (Ilya Kitaev)
be135e3 Processing splash formatting improved (Ilya Kitaev)
54b22d2 Wizard: finish page: restore height hidden if not set (Ilya Kitaev)
d67071a Settings page: layout items vertically (Ilya Kitaev)
4f4cc9c Settings page: small renaming and formatting (Ilya Kitaev)
da552a0 History: Fixed filter collapse (Ilya Kitaev)
7ed623e Basic mode: updating balance properly (Ilya Kitaev)
eafcf71 Minimized aka basic mode (Ilya Kitaev)
a032c84 History: fee color (Ilya Kitaev)
60b2d90 History: display "fee" for sent transactions (Ilya Kitaev)
0ac27e1 History: filter by amount (Ilya Kitaev)
10c2786 added restore height to wizardFinish (Jacob Brydolf)
883762c removed daemon-blockchain-progress rests (Jacob Brydolf)
38d9034 Wizard: added restore-height (Jacob Brydolf)
7f0d6c4 persistentSettings: added restoreHeight (Jacob Brydolf)
9f336a5 libwalletqt: added restore-height parameter to recoveryWallet(); (Jacob Brydolf)
0e0b0be removed moneroComponets dependency (Jacob Brydolf)
38db5a4 Integrate splash counter with restore-height (Jacob Brydolf)
868610c fix conflict (Jacob Brydolf)
4901839 added comma/locale separation to sync counter (Jacob Brydolf)
8b748bf History: filter by amount (Ilya Kitaev)
9b09e83 History: filtering by paymentId and date (Ilya Kitaev)
e3cea85 TransactionHistory: firstDateTime and lastDateTime properties (Ilya Kitaev)
9927182 Fix: unused dummy property removed (Ilya Kitaev)
fd9ed56 Fix: DatePicker component doesn't update the date (Ilya Kitaev)
612c497 TransactionHistory sorting (Ilya Kitaev)
e7e6c58 Adding sort-filter-proxy model (Ilya Kitaev)
0498c3b Transaction history is not crashing and refreshing properly (Ilya Kitaev)
defc2a4 build: get_libwallet_api.sh accepts build type ("Debug" or "Release", release is default); extra build script that skips cmake invocations (Ilya Kitaev)
2966b0d settings page: daemon change + password prompt on seed view (Jacob Brydolf)
9700944 close wallet before reopen (Jacob Brydolf)
522b067 Simple transaction history (Ilya Kitaev)
9cc92bf added onPageCompleted (Jacob Brydolf)
53d3bc4 Receive page: display long address from the beginning in TextField (Ilya Kitaev)
5814c19 Fixed overlapping clipboard icons on recieve page (Jacob Brydolf)
cd1247c Added option to show seed on settings-page (Jacob Brydolf)
af70c81 Added daemon BC sync progress bar depends on https://github.com/monero-project/monero/pull/1173 (Jacob Brydolf)
6a50951 Removed hardcoded height from PasswordDialog (Ilya Kitaev)
819be91 Integrating TransactionHistoryModel (Ilya Kitaev)
56c3579 Replaced Loader with StackView; Fixed payment id generation (Ilya Kitaev)
0ff3fd3 added TransactionHistoryModel; renamings (Ilya Kitaev)
bd8646d UX improvements in wizard - password page styling - tab navigation / focus on load - click language loads next page (Jacob Brydolf)

4 files changed, 482 insertions, 0 deletions

diff --git a/src/model/TransactionHistoryModel.cpp b/src/model/TransactionHistoryModel.cpp
new file mode 100644
index 00000000..1ad17944
--- /dev/null
+++ b/src/model/TransactionHistoryModel.cpp
@@ -0,0 +1,126 @@
+#include "TransactionHistoryModel.h"
+#include "TransactionHistory.h"
+#include "TransactionInfo.h"
+
+#include <QDateTime>
+
+
+TransactionHistoryModel::TransactionHistoryModel(QObject *parent)
+    : QAbstractListModel(parent), m_transactionHistory(nullptr)
+{
+
+}
+
+void TransactionHistoryModel::setTransactionHistory(TransactionHistory *th)
+{
+    beginResetModel();
+    m_transactionHistory = th;
+    endResetModel();
+
+    connect(m_transactionHistory, &TransactionHistory::refreshStarted,
+            this, &TransactionHistoryModel::beginResetModel);
+    connect(m_transactionHistory, &TransactionHistory::refreshFinished,
+            this, &TransactionHistoryModel::endResetModel);
+
+    emit transactionHistoryChanged();
+}
+
+TransactionHistory *TransactionHistoryModel::transactionHistory() const
+{
+    return m_transactionHistory;
+}
+
+QVariant TransactionHistoryModel::data(const QModelIndex &index, int role) const
+{
+    if (!m_transactionHistory) {
+        return QVariant();
+    }
+
+    if (index.row() < 0 || (unsigned)index.row() >= m_transactionHistory->count()) {
+        return QVariant();
+    }
+
+    TransactionInfo * tInfo = m_transactionHistory->transaction(index.row());
+
+
+    Q_ASSERT(tInfo);
+    if (!tInfo) {
+        qCritical("%s: internal error: no transaction info for index %d", __FUNCTION__, index.row());
+        return QVariant();
+    }
+    QVariant result;
+    switch (role) {
+    case TransactionRole:
+        result = QVariant::fromValue(tInfo);
+        break;
+    case TransactionDirectionRole:
+        result = QVariant::fromValue(tInfo->direction());
+        break;
+    case TransactionPendingRole:
+        result = tInfo->isPending();
+        break;
+    case TransactionFailedRole:
+        result = tInfo->isFailed();
+        break;
+    case TransactionAmountRole:
+        result = tInfo->amount();
+        break;
+    case TransactionDisplayAmountRole:
+        result = tInfo->displayAmount();
+        break;
+    case TransactionFeeRole:
+        result = tInfo->fee();
+        break;
+    case TransactionBlockHeightRole:
+        result = tInfo->blockHeight();
+        break;
+    case TransactionHashRole:
+        result = tInfo->hash();
+        break;
+    case TransactionTimeStampRole:
+        result = tInfo->timestamp();
+        break;
+    case TransactionPaymentIdRole:
+        result = tInfo->paymentId();
+        break;
+    case TransactionIsOutRole:
+        result = tInfo->direction() == TransactionInfo::Direction_Out;
+        break;
+    case TransactionDateRole:
+        result = tInfo->date();
+        break;
+    case TransactionTimeRole:
+        result = tInfo->time();
+        break;
+    }
+
+    return result;
+}
+
+int TransactionHistoryModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent)
+    return m_transactionHistory ? m_transactionHistory->count() : 0;
+}
+
+QHash<int, QByteArray> TransactionHistoryModel::roleNames() const
+{
+    QHash<int, QByteArray> roleNames = QAbstractListModel::roleNames();
+    roleNames.insert(TransactionRole, "transaction");
+    roleNames.insert(TransactionDirectionRole, "direction");
+    roleNames.insert(TransactionPendingRole, "isPending");
+    roleNames.insert(TransactionFailedRole, "isFailed");
+    roleNames.insert(TransactionAmountRole, "amount");
+    roleNames.insert(TransactionDisplayAmountRole, "displayAmount");
+    roleNames.insert(TransactionFeeRole, "fee");
+    roleNames.insert(TransactionBlockHeightRole, "blockHeight");
+    roleNames.insert(TransactionHashRole, "hash");
+    roleNames.insert(TransactionTimeStampRole, "timeStamp");
+    roleNames.insert(TransactionPaymentIdRole, "paymentId");
+    roleNames.insert(TransactionIsOutRole, "isOut");
+    roleNames.insert(TransactionDateRole, "date");
+    roleNames.insert(TransactionTimeRole, "time");
+    return roleNames;
+}
+
+
diff --git a/src/model/TransactionHistoryModel.h b/src/model/TransactionHistoryModel.h
new file mode 100644
index 00000000..0960ceae
--- /dev/null
+++ b/src/model/TransactionHistoryModel.h
@@ -0,0 +1,68 @@
+#ifndef TRANSACTIONHISTORYMODEL_H
+#define TRANSACTIONHISTORYMODEL_H
+
+#include <QAbstractListModel>
+
+class TransactionHistory;
+class TransactionInfo;
+
+/**
+ * @brief The TransactionHistoryModel class - read-only list model for Transaction History
+ */
+
+class TransactionHistoryModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(TransactionHistory * transactionHistory READ transactionHistory WRITE setTransactionHistory NOTIFY transactionHistoryChanged)
+
+public:
+    enum TransactionInfoRole {
+        TransactionRole = Qt::UserRole + 1, // for the TransactionInfo object;
+        TransactionDirectionRole,
+        TransactionPendingRole,
+        TransactionFailedRole,
+        TransactionAmountRole,
+        TransactionDisplayAmountRole,
+        TransactionFeeRole,
+        TransactionBlockHeightRole,
+        TransactionHashRole,
+        TransactionTimeStampRole,
+        TransactionPaymentIdRole,
+        // extra role (alias) for TransactionDirectionRole (as UI currently wants just boolean "out")
+        TransactionIsOutRole,
+        // extra roles for date and time (as UI wants date and time separately)
+        TransactionDateRole,
+        TransactionTimeRole
+    };
+    Q_ENUM(TransactionInfoRole)
+
+    TransactionHistoryModel(QObject * parent = 0);
+    void setTransactionHistory(TransactionHistory * th);
+    TransactionHistory * transactionHistory() const;
+    /**
+     * @brief dateFrom - returns firstmost transaction datetime
+     * @return
+     */
+    QDateTime firstDateTime() const;
+
+    /**
+     * @brief dateTo - returns lastmost transaction datetime
+     * @return
+     */
+    QDateTime lastDateTime() const;
+
+
+
+    /// QAbstractListModel
+    virtual QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const override;
+    virtual int rowCount(const QModelIndex & parent = QModelIndex()) const override;
+    virtual QHash<int, QByteArray> roleNames() const  override;
+
+signals:
+    void transactionHistoryChanged();
+
+private:
+    TransactionHistory * m_transactionHistory;
+};
+
+#endif // TRANSACTIONHISTORYMODEL_H
diff --git a/src/model/TransactionHistorySortFilterModel.cpp b/src/model/TransactionHistorySortFilterModel.cpp
new file mode 100644
index 00000000..6d6a2b44
--- /dev/null
+++ b/src/model/TransactionHistorySortFilterModel.cpp
@@ -0,0 +1,209 @@
+#include "TransactionHistorySortFilterModel.h"
+#include "TransactionHistoryModel.h"
+
+#include <QDebug>
+
+namespace {
+    /**
+     * helper to extract scope value from filter
+     */
+    template <typename T>
+    T scopeFilterValue(const QMap<int, QVariant> &filters, int role, int scopeIndex)
+    {
+        if (!filters.contains(role)) {
+            return T();
+        }
+        return filters.value(role).toList().at(scopeIndex).value<T>();
+    }
+
+    /**
+     * helper to setup scope value to filter
+     */
+    template <typename T>
+    void setScopeFilterValue(QMap<int, QVariant> &filters, int role, int scopeIndex, const T &value)
+    {
+        QVariantList scopeFilter;
+
+        if (filters.contains(role)) {
+            scopeFilter = filters.value(role).toList();
+        }
+        while (scopeFilter.size() < 2) {
+            scopeFilter.append(T());
+        }
+        scopeFilter[scopeIndex] = QVariant::fromValue(value);
+        filters[role] = scopeFilter;
+    }
+}
+
+
+TransactionHistorySortFilterModel::TransactionHistorySortFilterModel(QObject *parent)
+    : QSortFilterProxyModel(parent)
+{
+    setDynamicSortFilter(true);
+}
+
+QString TransactionHistorySortFilterModel::paymentIdFilter() const
+{
+    return m_filterValues.value(TransactionHistoryModel::TransactionPaymentIdRole).toString();
+}
+
+void TransactionHistorySortFilterModel::setPaymentIdFilter(const QString &arg)
+{
+    if (paymentIdFilter() != arg) {
+        m_filterValues[TransactionHistoryModel::TransactionPaymentIdRole] = arg;
+        emit paymentIdFilterChanged();
+        invalidateFilter();
+    }
+}
+
+QDate TransactionHistorySortFilterModel::dateFromFilter() const
+{
+    return scopeFilterValue<QDate>(m_filterValues, TransactionHistoryModel::TransactionTimeStampRole, ScopeIndex::From);
+}
+
+void TransactionHistorySortFilterModel::setDateFromFilter(const QDate &date)
+{
+    if (date != dateFromFilter()) {
+        setScopeFilterValue(m_filterValues, TransactionHistoryModel::TransactionTimeStampRole, ScopeIndex::From, date);
+        emit dateFromFilterChanged();
+        invalidateFilter();
+    }
+}
+
+QDate TransactionHistorySortFilterModel::dateToFilter() const
+{
+    return scopeFilterValue<QDate>(m_filterValues, TransactionHistoryModel::TransactionTimeStampRole, ScopeIndex::To);
+}
+
+void TransactionHistorySortFilterModel::setDateToFilter(const QDate &date)
+{
+    if (date != dateToFilter()) {
+        setScopeFilterValue(m_filterValues, TransactionHistoryModel::TransactionTimeStampRole, ScopeIndex::To, date);
+        emit dateToFilterChanged();
+        invalidateFilter();
+    }
+}
+
+double TransactionHistorySortFilterModel::amountFromFilter() const
+{
+    return scopeFilterValue<double>(m_filterValues, TransactionHistoryModel::TransactionAmountRole, ScopeIndex::From);
+}
+
+void TransactionHistorySortFilterModel::setAmountFromFilter(double value)
+{
+    if (value != amountFromFilter()) {
+        setScopeFilterValue(m_filterValues, TransactionHistoryModel::TransactionAmountRole, ScopeIndex::From, value);
+        emit amountFromFilterChanged();
+        invalidateFilter();
+    }
+}
+
+double TransactionHistorySortFilterModel::amountToFilter() const
+{
+    return scopeFilterValue<double>(m_filterValues, TransactionHistoryModel::TransactionAmountRole, ScopeIndex::To);
+}
+
+void TransactionHistorySortFilterModel::setAmountToFilter(double value)
+{
+    if (value != amountToFilter()) {
+        setScopeFilterValue(m_filterValues, TransactionHistoryModel::TransactionAmountRole, ScopeIndex::To, value);
+        emit amountToFilterChanged();
+        invalidateFilter();
+    }
+}
+
+int TransactionHistorySortFilterModel::directionFilter() const
+{
+    return m_filterValues.value(TransactionHistoryModel::TransactionDirectionRole).value<TransactionInfo::Direction>();
+}
+
+void TransactionHistorySortFilterModel::setDirectionFilter(int value)
+{
+    if (value != directionFilter()) {
+        m_filterValues[TransactionHistoryModel::TransactionDirectionRole] = QVariant::fromValue(value);
+        emit directionFilterChanged();
+        invalidateFilter();
+    }
+}
+
+
+void TransactionHistorySortFilterModel::sort(int column, Qt::SortOrder order)
+{
+    QSortFilterProxyModel::sort(column, order);
+}
+
+TransactionHistory *TransactionHistorySortFilterModel::transactionHistory() const
+{
+    const TransactionHistoryModel * model = static_cast<const TransactionHistoryModel*> (sourceModel());
+    return model->transactionHistory();
+}
+
+bool TransactionHistorySortFilterModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+{
+
+    if (source_row < 0 || source_row >= sourceModel()->rowCount()) {
+        return false;
+    }
+
+    QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
+    if (!index.isValid()) {
+        return false;
+    }
+
+    bool result = true;
+
+    // iterating through filters
+    for (int role : m_filterValues.keys()) {
+        if (m_filterValues.contains(role)) {
+            QVariant data = sourceModel()->data(index, role);
+            switch (role) {
+            case TransactionHistoryModel::TransactionPaymentIdRole:
+                result = data.toString().contains(paymentIdFilter());
+                break;
+            case TransactionHistoryModel::TransactionTimeStampRole:
+            {
+                QDateTime from = QDateTime(dateFromFilter());
+                QDateTime to   = QDateTime(dateToFilter());
+                to = to.addDays(1); // including upperbound
+                QDateTime timestamp = data.toDateTime();
+                bool matchFrom = from.isNull() || timestamp.isNull() || timestamp >= from;
+                bool matchTo = to.isNull() || timestamp.isNull() || timestamp <= to;
+                result = matchFrom && matchTo;
+            }
+                break;
+            case TransactionHistoryModel::TransactionAmountRole:
+            {
+                double from = amountFromFilter();
+                double to = amountToFilter();
+                double amount = data.toDouble();
+
+                bool matchFrom = from <= 0 || amount  >= from;
+                bool matchTo = to <= 0 || amount <= to;
+                result = matchFrom && matchTo;
+            }
+                break;
+            case TransactionHistoryModel::TransactionDirectionRole:
+                result = directionFilter() == TransactionInfo::Direction_Both ? true
+                                                  : data.toInt() == directionFilter();
+
+
+                break;
+
+            default:
+                break;
+            }
+
+
+            if (!result) { // stop the loop once filter doesn't match
+                break;
+            }
+        }
+    }
+
+    return result;
+}
+
+bool TransactionHistorySortFilterModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
+{
+    return QSortFilterProxyModel::lessThan(source_left, source_right);
+}
diff --git a/src/model/TransactionHistorySortFilterModel.h b/src/model/TransactionHistorySortFilterModel.h
new file mode 100644
index 00000000..1b5c2fce
--- /dev/null
+++ b/src/model/TransactionHistorySortFilterModel.h
@@ -0,0 +1,79 @@
+#ifndef TRANSACTIONHISTORYSORTFILTERMODEL_H
+#define TRANSACTIONHISTORYSORTFILTERMODEL_H
+
+#include "TransactionInfo.h"
+
+#include <QSortFilterProxyModel>
+#include <QMap>
+#include <QVariant>
+#include <QDate>
+
+
+class TransactionHistory;
+
+class TransactionHistorySortFilterModel: public QSortFilterProxyModel
+{
+    Q_OBJECT
+    Q_PROPERTY(QString paymentIdFilter READ paymentIdFilter WRITE setPaymentIdFilter NOTIFY paymentIdFilterChanged)
+    Q_PROPERTY(QDate dateFromFilter READ dateFromFilter WRITE setDateFromFilter NOTIFY dateFromFilterChanged)
+    Q_PROPERTY(QDate dateToFilter READ dateToFilter WRITE setDateToFilter NOTIFY dateToFilterChanged)
+    Q_PROPERTY(double amountFromFilter READ amountFromFilter WRITE setAmountFromFilter NOTIFY amountFromFilterChanged)
+    Q_PROPERTY(double amountToFilter READ amountToFilter WRITE setAmountToFilter NOTIFY amountToFilterChanged)
+    Q_PROPERTY(int directionFilter READ directionFilter WRITE setDirectionFilter NOTIFY directionFilterChanged)
+
+    Q_PROPERTY(TransactionHistory * transactionHistory READ transactionHistory)
+
+public:
+    TransactionHistorySortFilterModel(QObject * parent = nullptr);
+    //! filtering by payment id
+    QString paymentIdFilter() const;
+    void setPaymentIdFilter(const QString &arg);
+
+    //! filtering by date (lower bound)
+    QDate dateFromFilter() const;
+    void setDateFromFilter(const QDate &date);
+
+    //! filtering by to date (upper bound)
+    QDate dateToFilter() const;
+    void setDateToFilter(const QDate &date);
+
+    //! filtering by amount (lower bound)
+    double amountFromFilter() const;
+    void setAmountFromFilter(double value);
+
+    //! filtering by amount (upper bound)
+    double amountToFilter() const;
+    void setAmountToFilter(double value);
+
+    //! filtering by direction
+    int directionFilter() const;
+    void setDirectionFilter(int value);
+
+    Q_INVOKABLE void sort(int column, Qt::SortOrder order);
+    TransactionHistory * transactionHistory() const;
+
+signals:
+    void paymentIdFilterChanged();
+    void dateFromFilterChanged();
+    void dateToFilterChanged();
+    void amountFromFilterChanged();
+    void amountToFilterChanged();
+    void directionFilterChanged();
+
+protected:
+    // QSortFilterProxyModel overrides
+    virtual bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const;
+    virtual bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const;
+
+
+private:
+    enum ScopeIndex {
+        From = 0,
+        To   = 1
+    };
+
+private:
+    QMap<int, QVariant> m_filterValues;
+};
+
+#endif // TRANSACTIONHISTORYSORTFILTERMODEL_H