FdItemCoa.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 "FdItemCoa.hpp"

FdItemCoa::FdItemCoa(FdItemCoa_p parent,
                     QString id,
                     QString label,
                     AccountSignature signature,
                     double initial,
                     double balance,
                     double previous) :
    mParent(parent),
    mId(id),
    mLabel(label),
    mSignature(signature),
    mInitialBalance(initial),
    mBalance(balance),
    mPreviousBalance(previous)
{
    if(!parent.isNull() && parent->type() != RootType)
        mOnBalanceSheet = parent->onBalanceSheet();
    else
        mOnBalanceSheet = false;
}

FdItemCoa_p FdItemCoa::pointer(QDomElement item, FdItemCoa_p parent)
{
    FdItemCoa_p myself;
    if(!parent.isNull())
        myself = FdItemCoa_p(new FdItemCoa(parent,
                                           item.attribute("Id"),
                                           item.attribute("Label"),
                                           AccountSignature(item.attribute("Signature", "0").toDouble()),
                                           item.attribute("Initial", "0").toDouble(),
                                           0,
                                           item.attribute("Previous", "0").toDouble()));
    else
        myself = FdItemCoa_p(new FdItemCoa());

    if(!parent.isNull() && parent->type() == RootType)
        myself->setOnBalanceSheet(item.attribute("OnBalanceSheet").toDouble());

    if(item.tagName() != "Account")
    {
        QDomElement child = item.firstChildElement();
        while(!child.isNull())
        {
            myself->appendChild(FdItemCoa::pointer(child, myself));
            child = child.nextSiblingElement();
        }
    }

    return myself;
}

FdItemCoa_p FdItemCoa::pointer(FdItemCoa_p model, FdItemCoa_p parent)
{
    FdItemCoa_p myself = FdItemCoa_p(new FdItemCoa(parent,
                                                   model->id(),
                                                   model->label(),
                                                   model->signature(),
                                                   0,
                                                   0,
                                                   model->balance()));

    if(!parent.isNull() && parent->type() == RootType)
        myself->setOnBalanceSheet(model->onBalanceSheet());

    if(myself->onBalanceSheet())
        myself->setInitialBalance(myself->previousBalance());

    for(int i = 0; i < model->childrenCount(); ++i)
        myself->appendChild(FdItemCoa::pointer(model->child(i), myself));

    return myself;
}

CoaItemType FdItemCoa::type() const
{
    if(mParent.isNull())
        return RootType;
    if(mChildren.size() == 0)
        return AccountType;

    return CategoryType;
}

QString FdItemCoa::id() const
{
    return mId;
}

QString FdItemCoa::label() const
{
    return mLabel;
}

bool FdItemCoa::onBalanceSheet() const
{
    return mOnBalanceSheet;
}

AccountSignature FdItemCoa::signature() const
{
    return mSignature;
}

double FdItemCoa::initialBalance() const
{
    return mInitialBalance;
}

double FdItemCoa::balance() const
{
    return mBalance;
}

double FdItemCoa::previousBalance() const
{
    return mPreviousBalance;
}

void FdItemCoa::setId(QString id)
{
    mId = id;
}

void FdItemCoa::setLabel(QString label)
{
    mLabel = label;
}

void FdItemCoa::setOnBalanceSheet(bool var)
{
    mOnBalanceSheet = var;
    for(int i = 0; i < childrenCount(); ++i)
        mChildren[i]->setOnBalanceSheet(var);
}

void FdItemCoa::setSignature(AccountSignature signature)
{
    mSignature = signature;
}

void FdItemCoa::setInitialBalance(double initial)
{
    mInitialBalance = initial;
}

void FdItemCoa::setPreviousBalance(double previous)
{
    mPreviousBalance = previous;
}

bool FdItemCoa::wasUsed() const
{
    if(mInitialBalance || mPreviousBalance)
        return true;

    return false;
}

QString FdItemCoa::displayLabel() const
{
    return mId+" "+mLabel;
}

FdItemCoa_p FdItemCoa::parent()
{
    return mParent;
}

void FdItemCoa::setParent(FdItemCoa_p parent)
{
    mParent = parent;
}

FdItemCoa_p FdItemCoa::child(int row)
{
    return mChildren.value(row);
}

QList<FdItemCoa_p> FdItemCoa::children()
{
    return mChildren;
}

QList<FdItemCoa_p> FdItemCoa::findChildren(QString text)
{
    QList<FdItemCoa_p> results;
    for(int i = 0; i < mChildren.size(); ++i)
    {
        if(mChildren[i]->id().contains(text, Qt::CaseInsensitive) || mChildren[i]->label().contains(text, Qt::CaseInsensitive))
            results << mChildren[i];
        if(mChildren[i]->type() == CategoryType)
            results << mChildren[i]->findChildren(text);
    }
    return results;
}

int FdItemCoa::childRow(const FdItemCoa* child) const
{
    for(int i = 0; i < mChildren.size(); ++i)
    {
        if(mChildren[i] == child)
            return i;
    }

    return -1;
}

int FdItemCoa::childrenCount() const
{
    return mChildren.count();
}

int FdItemCoa::row() const
{
    if(mParent)
        return mParent->childRow(this);

    return 0;
}

void FdItemCoa::appendChild(FdItemCoa_p item)
{
    mChildren.append(item);
}

bool FdItemCoa::insertChild(FdItemCoa_p item, int row)
{
    if (row < 0 || row > childrenCount())
        return false;

    mChildren.insert(row, item);
    return true;
}

bool FdItemCoa::removeChild(int row)
{
    if(row < 0 || row > mChildren.size())
        return false;

    mChildren.removeAt(row);
    return true;
}

QStringList FdItemCoa::childrenAccountsIds() const
{
    QStringList ids;
    for(int i = 0; i < mChildren.size(); ++i)
    {
        if(mChildren[i]->type() == AccountType)
            ids << mChildren[i]->id();
        else
            ids.append(mChildren[i]->childrenAccountsIds());
    }
    return ids;
}

QStringList FdItemCoa::childrenAccountsLabels() const
{
    QStringList labels;
    for(int i = 0; i < mChildren.size(); ++i)
    {
        if(mChildren[i]->type() == AccountType)
            labels << mChildren[i]->label();
        else
            labels.append(mChildren[i]->childrenAccountsLabels());
    }
    return labels;
}

QList<FdItemCoa_p> FdItemCoa::childrenAccounts() const
{
    QList<FdItemCoa_p> accounts;
    for(int i = 0; i < mChildren.size(); ++i)
    {
        if(mChildren[i]->type() == AccountType)
            accounts << mChildren[i];
        else
            accounts.append(mChildren[i]->childrenAccounts());
    }
    return accounts;
}

FdItemCoa_p FdItemCoa::childById(QString id) const
{
    if(id != QString())
    {
        for(int i = 0; i < mChildren.size(); ++i)
        {
            if(id == mChildren[i]->id())
                return mChildren[i];
            else
            {
                FdItemCoa_p item = mChildren[i]->childById(id);
                if(!item.isNull())
                    return item;
            }
        }
    }
    return FdItemCoa_p();
}

FdItemCoa_p FdItemCoa::childByLabel(QString label) const
{
    if(label != QString())
    {
        for(int i = 0; i < mChildren.size(); ++i)
        {
            if(label == mChildren[i]->label())
                return mChildren[i];
            else
            {
                FdItemCoa_p item = mChildren[i]->childByLabel(label);
                if(!item.isNull())
                    return item;
            }
        }
    }
    return FdItemCoa_p();
}

void FdItemCoa::resetBalance()
{
    if(type() == AccountType)
        mBalance = mInitialBalance;

    for (int i = 0; i < mChildren.size(); ++i)
        mChildren[i]->resetBalance();
}

void FdItemCoa::computeBalances()
{
    double balance = 0;
    for(int i = 0; i < mChildren.size(); ++i)
    {
        if(mChildren[i]->type() == CategoryType)
            mChildren[i]->computeBalances();

        balance += mChildren[i]->balance();
    }
    if(abs(balance) < 1e-2)
        balance = 0;

    mBalance = balance;

    if(type() == CategoryType)
    {
        double initial = 0;
        for(int i = 0; i < mChildren.size(); ++i)
        {
            initial += mChildren[i]->initialBalance();
        }
        if(abs(initial) < 1e-2)
            initial = 0;

        mInitialBalance = initial;
    }
}

void FdItemCoa::debited(double amount)
{
    mBalance += mSignature*amount;
}

void FdItemCoa::credited(double amount)
{
    mBalance -= mSignature*amount;
}

QDomElement FdItemCoa::toXml(QDomDocument &document) const
{
    QDomElement item = document.createElement("Coa");

    if(type() != RootType)
    {
        item.setAttribute("Id", mId);
        item.setAttribute("Label", mLabel);
        if(type() == CategoryType)
            item.setTagName("Category");
        else
        {
            item.setTagName("Account");
            item.setAttribute("Signature", mSignature);
            item.setAttribute("Initial", QString::number(mInitialBalance, 'f', 2));
            item.setAttribute("Previous", QString::number(mPreviousBalance, 'f', 2));
        }
        if(mParent->type() == RootType)
            item.setAttribute("OnBalanceSheet", mOnBalanceSheet);
    }

    if(type() != AccountType)
    {
        for(int i = 0; i < mChildren.size(); ++i)
            item.appendChild(mChildren[i]->toXml(document));
    }

    return item;
}