FdModelJournal.cpp

Go to the documentation of this file.

// --------------------------------------------------------------------
// Copyright © 2011-2013 Mathieu Schopfer
//
// This file is part of FreeDebks.
//
// FreeDebks is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// FreeDebks is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with FreeDebks.  If not, see <http://www.gnu.org/licenses/>.
// --------------------------------------------------------------------

#include "FdModelJournal.hpp"
#include "FdItemJournal.hpp"
#include "FdCommandsJournal.hpp"
#include "FdModelCoa.hpp"
#include "FdItemCoa.hpp"
#include "../gui/FdSubWindow.hpp"

FdModelJournal::FdModelJournal(FdSubWindow *parent) :
        QAbstractTableModel(0), mSubwindow(parent)
{
    init();
}

FdModelJournal::FdModelJournal(FdSubWindow *parent, QDomElement &journal) :
    QAbstractTableModel(0), mSubwindow(parent)
{
    mEntries = QList<FdItemJournal_p>();
    QDomElement entry = journal.firstChildElement();
    while(!entry.isNull())
    {
        mEntries << FdItemJournal::pointer(mSubwindow, entry);
        entry = entry.nextSiblingElement();
    }

    init();
}

void FdModelJournal::init()
{
    mStack = new QUndoStack();
    connect(mStack, SIGNAL(cleanChanged(bool)), mSubwindow, SLOT(cleanStateChanged(bool)));
}

QVariant FdModelJournal::data(FdItemJournal_p entry, JournalColumn column) const
{
    switch(column)
    {
    case JournalDate: return entry->date();
    case JournalObject: return entry->object();
    case JournalLabel: return entry->label();
    case JournalDebitId:
        if(!entry->debit().isNull())
            return entry->debit()->id();
        break;
    case JournalDebitLabel:
        if(!entry->debit().isNull())
            return entry->debit()->label();
        break;
    case JournalCreditId:
        if(!entry->credit().isNull())
            return entry->credit()->id();
        break;
    case JournalCreditLabel:
        if(!entry->credit().isNull())
            return entry->credit()->label();
        break;
    case JournalAmount: return entry->amount();
    }

    return QVariant();
}

QVariant FdModelJournal::data(const QModelIndex &index, int role) const
{
    if(!index.isValid())
        return QVariant();
    if(role == ValidityRole)
        return mEntries[index.row()]->isValid();
    if(role == Qt::TextAlignmentRole && index.column() == JournalAmount)
        return Qt::AlignRight;
    if (role != Qt::DisplayRole && role != Qt::EditRole)
        return QVariant();

    return data(mEntries[index.row()], JournalColumn(index.column()));

}

void FdModelJournal::setData(FdItemJournal_p entry, JournalColumn column, const QVariant &value)
{
    int row = mEntries.indexOf(entry);
    int columnEnd = column;
    switch(column)
    {
    case JournalDate:
        entry->setDate(value.toDate());
        break;
    case JournalObject:
        entry->setObject(value.toString());
        break;
    case JournalLabel:
        entry->setLabel(value.toString());
        break;
    case JournalDebitId:
        entry->setDebit(mSubwindow->coa()->itemById(value.toString()));
        columnEnd = JournalDebitLabel;
        break;
    case JournalDebitLabel:
        entry->setDebit(mSubwindow->coa()->itemByLabel(value.toString()));
        column = JournalDebitId;
        break;
    case JournalCreditId:
        entry->setCredit(mSubwindow->coa()->itemById(value.toString()));
        columnEnd = JournalCreditLabel;
        break;
    case JournalCreditLabel:
        entry->setCredit(mSubwindow->coa()->itemByLabel(value.toString()));
        column = JournalCreditId;
        break;
    case JournalAmount:
        entry->setAmount(value.toDouble());
        break;
    }

    emit(dataChanged(index(row, column), index(row, columnEnd)));
}

bool FdModelJournal::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if(!index.isValid() || role != Qt::EditRole)
        return false;

    if(value == data(index, Qt::DisplayRole))
        return true;

    int column = index.column();
    switch(column)
    {
    case JournalDate:
        if(value.toDate() < mSubwindow->initialDate() || mSubwindow->finalDate() < value.toDate())
            return false;
        break;
    case JournalDebitId:
    case JournalCreditId:
        if(!mSubwindow->coa()->isAccountId(value.toString()))
            return false;
        break;
    case JournalDebitLabel:
        if(mSubwindow->coa()->isAccountId(value.toString()))
        {
            column = JournalDebitId;
            break;
        }
    case JournalCreditLabel:
        if(mSubwindow->coa()->isAccountId(value.toString()))
        {
            column = JournalCreditId;
            break;
        }
        if(!mSubwindow->coa()->isAccountLabel(value.toString()))
            return false;
        break;
    }

    FdItemJournal_p entry = mEntries.at(index.row());

    if(column == JournalLabel)
    {
        FdItemJournal_p lastEntry = lastEntryByLabel(value.toString(), index.row()-1);
        if(!lastEntry.isNull())
        {
            QUndoCommand* copyEntry = new QUndoCommand();
            copyEntry->setText(QObject::tr("copy entry", "Will appear like this : Undo/Redo copy entry."));
            new FdJournalSetData(this, entry, JournalDebitId, lastEntry->debit()->id(), copyEntry);
            new FdJournalSetData(this, entry, JournalCreditId, lastEntry->credit()->id(), copyEntry);
            new FdJournalSetData(this, entry, JournalLabel, value, copyEntry);
            mStack->push(copyEntry);
            return true;
        }
    }

    mStack->push(new FdJournalSetData(this, entry, JournalColumn(column), value));
    return true;
}

QVariant FdModelJournal::headerData(int section, Qt::Orientation orientation, int role) const
{
    if(role == Qt::DisplayRole)
    {
        if (orientation == Qt::Horizontal)
        {
            switch(section)
            {
            case JournalDate: return tr("Date", "Journal column header.");
            case JournalObject: return tr("Object", "Journal column header.");
            case JournalLabel: return tr("Label", "Journal column header.");
            case JournalDebitId: return tr("Debit", "Journal column header.");
            case JournalDebitLabel: return tr("Debit account", "Journal column header.");
            case JournalCreditId: return tr("Credit", "Journal column header.");
            case JournalCreditLabel: return tr("Credit account", "Journal column header.");
            case JournalAmount: return tr("Amount", "Journal column header.");
            }
        }
        else
            return section+1;
    }

    return QVariant();
}

Qt::ItemFlags FdModelJournal::flags(const QModelIndex &index) const
{
    if(index.isValid())
        return Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled;
    else
        return QAbstractTableModel::flags(index);
}

bool FdModelJournal::removeRows(int row, int count, const QModelIndex &parent)
{
    beginRemoveRows(parent, row, row+count-1);
    for(int i = 0; i < count; ++i)
    {
        mEntries.removeAt(row);
    }
    endRemoveRows();
    return true;
}

int FdModelJournal::rowCount(const QModelIndex &parent) const
{
    return mEntries.size();
}

int FdModelJournal::columnCount(const QModelIndex &parent) const
{
    return JournalColumnCount;
}

void FdModelJournal::insertEntry(FdItemJournal_p entry, int row)
{
    insertEntries(QList<FdItemJournal_p>() << entry, row);
}

void FdModelJournal::insertEntries(QList<FdItemJournal_p> entries, int row)
{
    int count = entries.size();
    beginInsertRows(QModelIndex(), row, row+count-1);
    FdItemCoa_p account;
    for(int i = 0; i < count; ++i)
    {
        account = entries[i]->debit();
        if(!account.isNull() && !mSubwindow->coa()->idExists(account->id()))
            entries[i]->setDebit(FdItemCoa_p(0));

        account = entries[i]->credit();
        if(!account.isNull() && !mSubwindow->coa()->idExists(account->id()))
            entries[i]->setCredit(FdItemCoa_p(0));

        mEntries.insert(row+i, entries[i]);
    }
    endInsertRows();
}

void FdModelJournal::removeEntries(QList<FdItemJournal_p> entries)
{
    for(int i = 0; i < entries.size(); ++i)
        removeRow(mEntries.indexOf(entries[i]));
}

QModelIndex FdModelJournal::itemIndex(FdItemJournal_p entry)
{
    for(int i = 0; i < mEntries.size(); ++i)
    {
        if(entry == mEntries[i])
            return index(i, 0);
    }

    return QModelIndex();
}

QAction* FdModelJournal::redo()
{
    return mStack->createRedoAction(this);
}

QAction* FdModelJournal::undo()
{
    return mStack->createUndoAction(this);
}

QStringList FdModelJournal::labels() const
{
    QStringList labels;
    for(int i = 0; i < rowCount(); ++i)
    {
        QString label = mEntries[i]->label();
        if(!labels.contains(label))
            labels << label;
    }
    return labels;
}

FdItemJournal_p FdModelJournal::lastEntryByLabel(QString label) const
{
    return lastEntryByLabel(label, rowCount()-1);
}

FdItemJournal_p FdModelJournal::lastEntryByLabel(QString label, int row) const
{
    for(int i = row; i >= 0; --i)
    {
        if(mEntries[i]->label() == label)
            return mEntries[i];
    }

    return FdItemJournal_p(0);
}

QModelIndexList FdModelJournal::entryByPartialText(QString text) const
{
    QModelIndexList results;
    for(int i = 0; i < rowCount(); ++i)
    {
        if(mEntries[i]->label().contains(text, Qt::CaseInsensitive) || mEntries[i]->amount() == text.toDouble())
            results << index(i, 0);
    }
    return results;
}

FdItemCoa_p FdModelJournal::selectedAccount(const QModelIndex &index) const
{
    FdItemJournal_p entry = mEntries[index.row()];
    if(index.column() == JournalDebitId || index.column() == JournalDebitLabel)
        return entry->debit();
    else if (index.column() == JournalCreditId || index.column() == JournalCreditLabel)
        return entry->credit();

    return FdItemCoa_p(0);
}

QList<FdItemJournal_p> FdModelJournal::accountEntries(FdItemCoa_p account) const
{
    QList<FdItemJournal_p> entries;
    for(int i = 0; i < mEntries.size(); ++i)
    {
        if(account == mEntries[i]->debit() || account == mEntries[i]->credit())
            entries << mEntries[i];
    }

    return entries;
}

QDate FdModelJournal::getMinDate()
{
    orderByDate();
    return mEntries[0]->date();
}

QDate FdModelJournal::getMaxDate()
{
    orderByDate();
    return mEntries[rowCount()-1]->date();
}

bool FdModelJournal::isUsed(FdItemCoa_p account) const
{
    for(int i = 0; i < mEntries.size(); ++i)
    {
        if(mEntries[i]->debit() == account || mEntries[i]->credit() == account)
            return true;
    }

    return false;
}

QDomElement FdModelJournal::toXml(QDomDocument &document) const
{
    QDomElement journal = document.createElement("Journal");
    for(int i = 0; i < mEntries.size(); ++i)
    {
        if(!mEntries[i]->isEmpty())
        {
            QDomElement entry = mEntries[i]->toXml(document);
            journal.appendChild(entry);
        }
    }

    mStack->setClean();
    return journal;
}

QModelIndex FdModelJournal::addEntry(const QModelIndex &selected)
{
    int row;
    if(selected.isValid())
        row = selected.row()+1;
    else
        row = rowCount();

    QDate date;
    if(row == 0)
        date = mSubwindow->initialDate();
    else
        date = mEntries[row-1]->date();

    FdItemJournal_p item = FdItemJournal_p(new FdItemJournal(date));
    insertEntry(item, row);
    return index(row, JournalDate);
}

void FdModelJournal::removeSelected(const QList<int> &rows)
{
    QList<FdItemJournal_p> entries;
    QList<FdItemJournal_p> toDelete;
    for(int i = 0; i < rows.size(); ++i)
    {
        if(mEntries[rows[i]]->isEmpty())
            toDelete << mEntries[rows[i]];
        else
            entries << mEntries[rows[i]];
    }

    removeEntries(toDelete);

    if(entries.size())
        mStack->push(new FdJournalRemove(this, entries));
}

void FdModelJournal::orderByDate()
{
    for(int i = 0; i < rowCount(); ++i)
    {
        if(mEntries[i]->isEmpty())
        {
            removeEntries(QList<FdItemJournal_p>() << mEntries[i]);
            --i;
        }
    }

    for(int i = 0; i < rowCount()-1; ++i)
    {
        if(mEntries[i+1]->date() < mEntries[i]->date())
        {
            int j = i-1;
            while(j >= 0 && mEntries[i+1]->date() < mEntries[j]->date())
                --j;

            mEntries.move(i+1,j+1);
        }
    }
    emit(dataChanged(index(0,0), index(rowCount()-1, columnCount()-1)));
}

void FdModelJournal::copyFromPreviousLine(const QModelIndex& selected)
{
    int row = selected.row();
    if(selected.row() != 0)
        setData(selected, data(mEntries[row-1], JournalColumn(selected.column())));
}

bool FdModelJournal::recomputeAccounts()
{
    for(int i = 0; i < mEntries.size(); ++i)
    {
        if(!mEntries[i]->breakDown())
        {
            emit(error(index(i,0)));
            return false;
        }
    }

    return true;
}