beerlog/viewmodels/ordersviewmodel.cpp

#include "ordersviewmodel.h"

#include <QDateTime>

#include "models/basemodel.h"

OrdersViewModel::OrdersViewModel(QObject *parent)
    : QAbstractListModel{parent}
{
    connect(m_ordersModel, &BaseModel::dataChanged, this, &OrdersViewModel::reload);
    connect(m_usersModel, &BaseModel::dataChanged, this, &OrdersViewModel::reload);
    connect(m_productsModel, &BaseModel::dataChanged, this, &OrdersViewModel::reload);
    connect(m_storesModel, &BaseModel::dataChanged, this, &OrdersViewModel::reload);

    reload();
}

int OrdersViewModel::rowCount(const QModelIndex &) const
{
    return m_model.count();
}

QVariant OrdersViewModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid()) {
        return {};
    }

    return m_model.at(index.row()).toMap()[roleNames().value(role)];
}

QHash<int, QByteArray> OrdersViewModel::roleNames() const
{
    return QHash<int, QByteArray> {
        { Roles::UserName, "userName" },
        { Roles::StoreName, "storeName" },
        { Roles::Date, "date" },
        { Roles::Time, "time"},
        { Roles::Amount, "amount" },
        { Roles::Products, "products" }
    };
}

void OrdersViewModel::reload()
{
    beginResetModel();

    m_model.clear();

    for (const QVariant &vOrder : m_ordersModel->items()) {
        QVariantMap order = vOrder.toMap();
        QDateTime orderTime = QDateTime::fromSecsSinceEpoch(order.value("ts", 0).toDouble());
        order["date"] = orderTime.date();
        order["time"] = orderTime.time();
        order["userName"] = m_usersModel->itemProperty(order["userId"].toString(), "name").toString();
        order["storeName"] = m_storesModel->itemProperty(order["storeId"].toString(), "name").toString();

        QVariantList prodModel;
        for (const QVariant &prod : order["products"].toList()) {
            QVariantMap product = prod.toMap();
            product["product"] = m_productsModel->itemProperty(product.value("productId").toString(), "name");
            prodModel << product;
        }
        order["products"] = prodModel;

        m_model << order;
    }

    std::sort(m_model.begin(), m_model.end(), [](const QVariant &l, const QVariant &r) -> bool {
        return l.toMap().value("ts").toDouble() < r.toMap().value("ts").toDouble();
    });

    endResetModel();
}