FdModelCoa.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 "FdModelCoa.hpp"
#include "FdItemCoa.hpp"
#include "FdCommandsCoa.hpp"
#include "FdModelJournal.hpp"
#include "../gui/FdSubWindow.hpp"

FdModelCoa::FdModelCoa(FdSubWindow* parent) : QAbstractItemModel(0), mSubwindow(parent)
{
    mRootItem = FdItemCoa_p(new FdItemCoa());
    init();
}

FdModelCoa::FdModelCoa(FdSubWindow* parent, QDomElement& coa) : QAbstractItemModel(0), mSubwindow(parent)
{
    mRootItem = FdItemCoa::pointer(coa);
    init();
}

FdModelCoa::FdModelCoa(FdSubWindow* parent, const FdModelCoa* model) : QAbstractItemModel(0), mSubwindow(parent)
{
    mRootItem = FdItemCoa::pointer(model->getRootItem());  
    init();
}

void FdModelCoa::init()
{
    mStack = new QUndoStack();
    connect(mStack, SIGNAL(cleanChanged(bool)), mSubwindow, SLOT(cleanStateChanged(bool)));
    // Insert items to mIndexes.
    QList<FdItemCoa_p> items = mRootItem->children();
    for(int i = 0; i < items.size(); ++i)
    {
        mIndexes.insert(i, items[i]);
        items << items[i]->children();
    }
}

FdItemCoa_p FdModelCoa::getRootItem() const
{
    return mRootItem;
}

QVariant FdModelCoa::data(FdItemCoa_p item, CoaColumn column) const
{
    switch(column)
    {
    case CoaId: return item->id();
    case CoaLabel: return item->label();
    case CoaSigns:
        if(item->type() == CategoryType)
            return QVariant();
        if(item->signature() == -1)
            return "-+";
        return "+-";
    case CoaBalanceSheet:
        if(item->onBalanceSheet())
            return Qt::Checked;
        return Qt::Unchecked;
    case CoaInitial: return item->initialBalance();
    case CoaBalance: return item->balance();
    }

    return QVariant();
}

QVariant FdModelCoa::data(const QModelIndex &index, int role) const
{
    if(!index.isValid())
        return QVariant();
    if(role == Qt::TextAlignmentRole)
    {
        if(index.column() == CoaBalanceSheet || index.column() == CoaSigns)
            return Qt::AlignCenter;
        if(index.column() == CoaInitial || index.column() == CoaBalance)
            return Qt::AlignRight;
    }
    if(index.column() != CoaBalanceSheet && role != Qt::DisplayRole && role != Qt::EditRole)
        return QVariant();

    FdItemCoa_p item = this->item(index);

    if(index.column() == CoaBalanceSheet && (role != Qt::CheckStateRole || item->parent()->type() != RootType))
        return QVariant();

    return data(item, CoaColumn(index.column()));
}

void FdModelCoa::setData(FdItemCoa_p item, CoaColumn column, const QVariant &value)
{
    switch(column)
    {
    case CoaId:
        item->setId(value.toString());
        break;
    case CoaLabel:
        item->setLabel(value.toString());
        break;
    case CoaBalanceSheet:
        item->setOnBalanceSheet(value.toBool());
        break;
    case CoaSigns:
        item->setSignature(AccountSignature(value.toInt()));
        break;
    case CoaInitial:
        item->setInitialBalance(value.toDouble());
        break;
    }
    QModelIndex index = this->index(item, column);

    emit dataChanged(index, index);
}

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

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

    switch(index.column())
    {
    case CoaId:
        if(idExists(value.toString()))
            return false;
        break;
    case CoaLabel:
        if(labelExists(value.toString()))
            return false;
        break;
    }

    FdItemCoa_p item = this->item(index);
    mStack->push(new FdCoaSetData(this, item, CoaColumn(index.column()), value));
    return true;
}

QVariant FdModelCoa::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
    {
        switch(section)
        {
        case CoaId: return tr("Id", "Chart of accounts column header.");
        case CoaLabel: return tr("Label", "Chart of accounts column header.");
        case CoaSigns: return tr("Signs", "Chart of accounts column header.");
        case CoaBalanceSheet: return tr("On balance sheet", "Chart of accounts column header, a column with tick boxes to decide whether or not the category belongs to the balance sheet.");
        case CoaInitial: return tr("Initial balance", "Chart of accounts column header.");
        case CoaBalance: return tr("Balance", "Chart of accounts column header.");
        }
    }

    return QVariant();
}

Qt::ItemFlags FdModelCoa::flags(const QModelIndex &index) const
{
    FdItemCoa_p item = this->item(index);

    Qt::ItemFlags flags;
    if(!(item->type() == CategoryType && (index.column() == CoaInitial || index.column() == CoaSigns)) && index.column() != CoaBalanceSheet && index.column() != CoaBalance)
        flags |=  Qt::ItemIsEditable;

    if(!(item->type() == AccountType && mSubwindow->journal()->isUsed(item)))
        flags |= Qt::ItemIsDropEnabled;

    if(index.column() == CoaBalanceSheet && item->parent()->type() == RootType)
        flags |= Qt::ItemIsUserCheckable;

    flags |= Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
    return flags;
}

Qt::DropActions FdModelCoa::supportedDragActions() const
{
    return Qt::MoveAction;
}

Qt::DropActions FdModelCoa::supportedDropActions() const
{
    return Qt::MoveAction;
}

QModelIndex FdModelCoa::index(int row, int column, const QModelIndex &parent) const
{
    if (parent.isValid() && parent.column() != 0)
        return QModelIndex();

    FdItemCoa_p parentItem = item(parent);
    if(FdItemCoa_p childItem = parentItem->child(row))
        return createIndex(row, column, mIndexes.key(childItem));
    else
        return QModelIndex();
}

QModelIndex FdModelCoa::index(FdItemCoa_p item) const
{
    return index(item, CoaId);
}

QModelIndex FdModelCoa::index(FdItemCoa_p item, CoaColumn column) const
{
    QList<FdItemCoa_p> items;
    while(item != mRootItem)
    {
        items.prepend(item);
        item = item->parent();
    }

    QModelIndex index = QModelIndex();
    for(int i = 0; i < items.size(); ++i)
        index = this->index(items[i]->row(),column,index);

    return index;
}

QModelIndex FdModelCoa::parent(const QModelIndex &index) const
{
    if (!index.isValid())
        return QModelIndex();

    FdItemCoa_p parentItem = item(index)->parent();

    if (parentItem == mRootItem)
        return QModelIndex();

    return createIndex(parentItem->row(), 0, mIndexes.key(parentItem));
}

QStringList FdModelCoa::mimeTypes() const
{
    return QStringList() << "application/freedebks";
}

QMimeData* FdModelCoa::mimeData(const QModelIndexList &indexes) const
{
    QMimeData* mimeData = new QMimeData();
    QByteArray encodedData;
    QDataStream stream(&encodedData, QIODevice::WriteOnly);

    qint32 index;
    for(int i = 0; i < indexes.size(); ++i)
    {
        if(indexes[i].column() == 0)
        {
            index = indexes[i].internalId();
            stream << index;
        }
    }

    mimeData->setData("application/freedebks", encodedData);
    return mimeData;
}

bool FdModelCoa::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
{
    if(action != Qt::MoveAction)
        return false;

    // Retrieves a list of items identifiers, see mIndexes.
    QByteArray encodedData = data->data("application/freedebks");
    QDataStream stream(&encodedData, QIODevice::ReadOnly);
    QList<FdItemCoa_p> items;

    FdItemCoa_p newParent = this->item(parent);

    if(row == -1)
    {
        if(parent.isValid())
            row = 0;
        else
            row = newParent->childrenCount();
    }

    while(!stream.atEnd())
    {
        qint32 index;
        stream >> index;
        FdItemCoa_p item = mIndexes.value(index);
        items << item;
    }

    mStack->push(new FdCoaDragDrop(this, items, newParent, row));
    return true;
}

int FdModelCoa::rowCount(const QModelIndex &parent) const
{
    return item(parent)->childrenCount();
}

int FdModelCoa::columnCount(const QModelIndex &parent) const
{
    return CoaColumnCount;
}

bool FdModelCoa::insertItem(FdItemCoa_p item, int row, FdItemCoa_p parent)
{
    return insertItems(QList<FdItemCoa_p>() << item, row, parent);
}

bool FdModelCoa::insertItems(QList<FdItemCoa_p> items, int row, FdItemCoa_p parent)
{
    QModelIndex parentIndex = index(parent);
    int count = items.size();
    beginInsertRows(parentIndex, row, row + count - 1);
    qint32 key = 0;
    for(int i = 0; i < count; ++i)
    {
        if(!parent->insertChild(items[i],row+i))
            return false;
        items[i]->setParent(parent);
        while(mIndexes.contains(key))
            ++key;
        mIndexes.insert(key, items[i]);
    }
    endInsertRows();
    return true;
}

bool FdModelCoa::removeItem(FdItemCoa_p item, FdItemCoa_p parent)
{
    QModelIndex parentIndex = index(parent);
    int row = item->row();
    beginRemoveRows(parentIndex, row, row);
    if(!parent->removeChild(row))
        return false;
    mIndexes.remove(mIndexes.key(item));
    item->setParent(FdItemCoa_p(0));
    endRemoveRows();
    return true;
}

void FdModelCoa::moveItem(FdItemCoa_p item, FdItemCoa_p parent, int row)
{
    removeItem(item, parent);
    insertItem(item, row, parent);
}

void FdModelCoa::orderItems(FdItemCoa_p parent)
{
    if(parent.isNull())
        parent = mRootItem;

    int count = parent->childrenCount()-1;
    int j;
    for(int i = 0; i < count; ++i)
    {
        j = i-1;
        if(parent->child(i+1)->id() < parent->child(i)->id())
        {
            // We search where to place the item

            while(j >= 0 && parent->child(i+1)->id() < parent->child(j)->id())
                --j;

            moveItem(parent->child(i+1), parent, j+1);
        }

        j += 1;
        if(parent->child(j)->type() == CategoryType)
            orderItems(parent->child(j));
    }

    if(count > 0 && parent->child(count)->type() == CategoryType)
        orderItems(parent->child(count));
}

FdItemCoa_p FdModelCoa::item(const QModelIndex &index) const
{
    if(index.isValid())
    {
        if(FdItemCoa_p item = mIndexes.value(index.internalId()))
            return item;
    }
    return mRootItem;
}

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

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

bool FdModelCoa::idExists(QString id) const
{
    if(itemById(id).isNull())
        return false;

    return true;
}

bool FdModelCoa::labelExists(QString label) const
{
    if(itemByLabel(label).isNull())
        return false;

    return true;
}

bool FdModelCoa::isAccountId(QString id) const
{
    FdItemCoa_p item = itemById(id);
    if(item.isNull() || item->type() != AccountType)
        return false;

    return true;
}

bool FdModelCoa::isAccountLabel(QString label) const
{
    FdItemCoa_p item = itemByLabel(label);
    if(item.isNull() || item->type() != AccountType)
        return false;

    return true;
}

bool FdModelCoa::isRemovable(FdItemCoa_p item) const
{
    if(item->type() == AccountType)
    {
        if(mSubwindow->journal()->isUsed(item) || item->wasUsed())
            return false;
    }
    else if(item->type() == CategoryType)
    {
        QList<FdItemCoa_p> children = item->children();
        for(int i = 0; i < children.size(); ++i)
        {
            if(!isRemovable(children[i]))
                return false;
        }
    }
    return true;
}

bool FdModelCoa::isRemovable(const QModelIndex &index) const
{
    if(index.isValid())
        return isRemovable(item(index));
    return false;
}

QStringList FdModelCoa::accountsIds() const
{
    return mRootItem->childrenAccountsIds();
}

QStringList FdModelCoa::accountsLabels() const
{
    return mRootItem->childrenAccountsLabels();
}

QList<FdItemCoa_p> FdModelCoa::accounts() const
{
    return mRootItem->childrenAccounts();
}

FdItemCoa_p FdModelCoa::itemById(QString id) const
{
    return mRootItem->childById(id);
}

FdItemCoa_p FdModelCoa::itemByLabel(QString label) const
{
    return mRootItem->childByLabel(label);
}


QModelIndexList FdModelCoa::itemByPartialText(QString text) const
{
    QList<FdItemCoa_p> items = mRootItem->findChildren(text);
    QModelIndexList results;
    for(int i = 0; i < items.size(); ++i)
        results << index(items[i]);

    return results;
}

QDomElement FdModelCoa::toXml(QDomDocument &document) const
{
    mStack->setClean();
    return mRootItem->toXml(document);
}

QModelIndex FdModelCoa::addItem(const QModelIndex &selected)
{
    FdItemCoa_p parentItem = item(selected);
    int row;
    if(parentItem->type() == AccountType && (mSubwindow->journal()->isUsed(parentItem) || parentItem->wasUsed()))
    {
        parentItem = parentItem->parent();
        row = selected.row()+1;
    }
    else
        row = parentItem->childrenCount();

    // Automatically chooses an id depending on parent's id.
    int i = 0;
    QString id;
    do
    {
        id = parentItem->id()+QString::number(i);
        ++i;
    }
    while(idExists(id));

    // Automatically defines an unused name
    i = 0;
    QString label;
    do
    {
        label = "Empty"+QString::number(i);
        ++i;
    }
    while(labelExists(label));

    FdItemCoa_p item = FdItemCoa_p(new FdItemCoa(parentItem, id, label));
    mStack->push(new FdCoaAddItem(this, parentItem, item, row));
    return index(item);
}

void FdModelCoa::removeSelected(QModelIndexList selected)
{
    FdItemCoa_p item;
    QList<FdItemCoa_p> items;
    for(int i = 0; i < selected.size(); ++i)
    {
        item = this->item(selected[i]);
        if(isRemovable(item))
            items << item;
    }

    if(items.size())
        mStack->push(new FdCoaRemove(this, items));
}

void FdModelCoa::recomputeBalances()
{
    mRootItem->resetBalance();
    if(mSubwindow->journal()->recomputeAccounts())
        mRootItem->computeBalances();
    emit(dataChanged(index(0,0),index(rowCount()-1,columnCount()-1)));
}