accountingmodel.cpp

Go to the documentation of this file.

#include <QDebug>
#include <QDate>
#include <assert.h>
#include "accountingmodel.h"

AccountingModel::AccountingModel(QObject *parent) : QAbstractTableModel(parent)
{
    addColumn(0, "BelegNr");
    addColumn(1, "Datum");
    addColumn(2, "Text");
    addColumn(3, "Soll");
    addColumn(4, "Haben");
}

int AccountingModel::rowCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    return p_entries.count();
}

int AccountingModel::columnCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    return p_headers.count();
}

QStringList AccountingModel::data(const int row) const
{
    return p_entries.value(row);
}

QVariant AccountingModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if(role != Qt::DisplayRole)
    {
        return QVariant();
    }

    if(orientation == Qt::Horizontal)
    {
        return p_headers.value(section);
    }
    return QVariant();
}

AccountingModel::~AccountingModel()
{
    qDeleteAll(table);
    table.clear();
}

Qt::ItemFlags AccountingModel::flags(const QModelIndex &index) const
{
    if(!index.isValid())
    {
        return 0;
    }

    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}

QVariant AccountingModel::data(const QModelIndex &index, int role) const
{
    if(!index.isValid() || index.row() >= p_entries.size() || index.row() < 0)
    {
        return QVariant();
    }

    if(role == Qt::DisplayRole)
    {
        return p_entries.value(index.row()).value(index.column());
    }
    return QVariant();
}

bool AccountingModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if(index.isValid() && role == Qt::EditRole)
    {
        int row = index.row();
        QStringList p = p_entries.value(row);

        p.replace(index.column(), value.toString());

        p_entries.replace(row, p);

        emit dataChanged(index, index);

        return true;
    }
    return false;
}

bool AccountingModel::insertRows(int position, int rows, const QModelIndex &index)
{
    Q_UNUSED(index);
    beginInsertRows(QModelIndex(), position, position + rows - 1);

    for (int row = 0; row < rows; row++)
    {
        QStringList pair;
        for(int i = 0; i < p_headers.size(); i++)       //add an empty field for each column
        {
            pair << QString();
        }
        p_entries.insert(position, pair);
    }

    endInsertRows();
    return true;
}

bool AccountingModel::removeRows(int position, int rows, const QModelIndex &index)
{
    Q_UNUSED(index);
    beginRemoveRows(QModelIndex(), position, position+rows-1);

    for (int row = 0; row < rows; ++row)
    {
        p_entries.removeAt(position);
    }

    endRemoveRows();
    return true;
}

void AccountingModel::addRow(QString accountingNumber, QString date, QString contraAccount, QString debit, QString credit)
{
    insertRows(rowCount(), 1, QModelIndex());

    int row = rowCount() - 1;
    QModelIndex in = index(row, 0, QModelIndex());
    setData(in, accountingNumber, Qt::EditRole);

    in = index(row, 1, QModelIndex());
    setData(in, date, Qt::EditRole);

    in = index(row, 2, QModelIndex());
    setData(in, contraAccount, Qt::EditRole);

    in = index(row, 3, QModelIndex());
    setData(in, debit, Qt::EditRole);

    in = index(row, 4, QModelIndex());
    setData(in, credit, Qt::EditRole);
}

bool AccountingModel::insertColumns(int position, int columns, const QModelIndex &index)
{
    Q_UNUSED(index);

    beginInsertColumns(QModelIndex(), position, position + columns - 1);
    for(int j = 0; j < p_entries.size(); j++)
    {
        QStringList e = p_entries.value(j);

        // insert a new empty field (column) on every row
        for(int k = 0; k < columns; k++)
        {
            e.insert(position, QString());
        }

        p_entries.replace(j, e);
    }
    endInsertColumns();

    return true;
}

void AccountingModel::addColumn(int position, QString columnName)
{
    insertColumn(position, QModelIndex());
    p_headers.insert(position, columnName);
}

void AccountingModel::buildTable()
{
    double amount, total = 0;
    int i, j;
    DataAccountingRecord *currentAccountingRecord;

    qDeleteAll(table);
    table.clear();

    /***************** opening stock *****************/
    for(i = 0; i < exercise->accounts()->size(); i++)
    {
        if(exercise->accounts()->at(i)->accountNumber() == accountNumber)
        {
            QList<QVariant> *row = new QList<QVariant>();

            // negative opening stock means credit
            amount = 0;//exercise->accounts()->at(i)->openingStock();
            total += amount;

            // assumption: fiscal year from 01/01 (kein abweichendes Wirtschaftsjahr) -David
            // TODO: date? (year?)
            (*row) << QVariant() << ("01.01." + QString::number(QDate::currentDate().year())) << "9800" << (amount > 0 ? amount : QVariant()) << (amount < 0 ? -amount : QVariant());
            table.append(row);
            break;
        }
    }
    /*************** End opening stock ***************/

    /***************** accounting records *****************/
    for(i = 0; i < exercise->accountingRecords()->size(); i++)
    {
        currentAccountingRecord = exercise->accountingRecords()->at(i);

        // iterate over debits
        for(j = 0; j < currentAccountingRecord->debits()->size(); j++)
        {
            // assumption: an account may appear only once on one side of an accounting record -David
            // assumption: no negative amounts in accounting record
            if(currentAccountingRecord->debits()->at(j)->first == accountNumber)
            {
                // assumption: no negative amounts in accounting record
                assert(currentAccountingRecord->debits()->at(j)->second > 0);

                total += currentAccountingRecord->debits()->at(j)->second;
                appendRecord(currentAccountingRecord, currentAccountingRecord->debits()->at(j)->second);
                break; // we really should go below the next loop, but I don't like goto hacks -David
            }
        }

        // iterate over credits (TODO: this is very similar to the code above. We should think about managing these 2 together)
        // (e.g. negative numbers for credit-sided stuff stored in dataaccountingrecord)
        for(j = 0; j < currentAccountingRecord->credits()->size(); j++)
        {
            // assumption: an account may appear only once on one side of an accounting record -David
            if(currentAccountingRecord->credits()->at(j)->first == accountNumber)
            {
                // assumption: no negative amounts in accounting record
                assert(currentAccountingRecord->credits()->at(j)->second > 0);

                total -= currentAccountingRecord->debits()->at(j)->second;
                appendRecord(currentAccountingRecord, -currentAccountingRecord->credits()->at(j)->second);
                break;
            }
        }
    }
    /*************** End accounting records ***************/

    QList<QVariant> *row = new QList<QVariant>();
    // TODO: instead of "Saldo", write "31.12." - "9850 SBK" if appropriate
    (*row) << QVariant() << QVariant() << "Saldo" << (total < 0 ? -total : QVariant()) << (total > 0 ? total : QVariant());
    table.append(row);

    // column order: documentNumber, date, text, debit, credit
}

void AccountingModel::appendRecord(DataAccountingRecord *currentAccountingRecord, double amount)
{
    QList<QVariant> *row = new QList<QVariant>();
    QList<QPair<int, double> *> *otherSide;
    QString text, s;
    int i;

    (*row) << currentAccountingRecord->documentNumber() << currentAccountingRecord->date().toString("dd.MM.yyyy");

    if(amount > 0) // account is on debit side of the record
    {
        otherSide = currentAccountingRecord->credits();
    }
    else // credit side
    {
        otherSide = currentAccountingRecord->debits();
    }

    // collecting text
    for(i = 0; i < otherSide->size(); i++)
    {
        s.sprintf("%4d", otherSide->at(i)->first);
        text += (text.length() ? ", " : "") + s;
    }
    // negative opening stock means credit
    (*row) << text << (amount > 0 ? amount : QVariant()) << (amount < 0 ? -amount : QVariant());

    table.append(row);
}

double AccountingModel::debitSum()
{
    double sum = 0;
    for(int i = 0; i < p_entries.count(); i++)
    {
        sum += p_entries.value(i).value(3).toDouble();
    }
    return sum;
}

double AccountingModel::creditSum()
{
    double sum = 0;
    for(int i = 0; i < p_entries.count(); i++)
    {
        sum += p_entries.value(i).value(4).toDouble();
    }
    return sum;
}

---