addcostpositionmodel.cpp

Go to the documentation of this file.

#include "addcostpositionmodel.h"
#include <QDebug>

AddCostPositionModel::AddCostPositionModel(CostTypeModel *type, CostCentreModel *centre, int rowid, double sum, QObject *parent) : QAbstractTableModel(parent), costtypemodel(type), costcentremodel(centre), currentSelectedRowId(rowid), p_completeSum(sum)
{
    setHeaders();
    setDefaultFields();
    setCostCentres();
    refreshSums(QModelIndex(), QModelIndex());

    connect(this, SIGNAL(dataChanged(const QModelIndex, const QModelIndex)), this, SLOT(refreshSums(const QModelIndex, const QModelIndex)));
}

void AddCostPositionModel::setHeaders()
{
    p_headers << "";     //for the checkboxes

    QStringList costcentreheaders = costcentremodel->headers();
    for(int i = 0; i < costcentreheaders.count(); i++)
    {
        if(costcentremodel->isCostCentreColumn(i))
        {
            // add costcentre to headers
            p_headers << costcentreheaders.value(i);
        }
    }
    p_headers << tr("Summe");

    p_vert_headers << "Kostenstellenart";
    p_vert_headers << "Prozent";
    p_vert_headers << "Stunden";
    p_vert_headers << "Wert";
    p_vert_headers << "Gemeinkosten";
}

void AddCostPositionModel::setDefaultFields()
{
    for(int row = 0; row < p_vert_headers.count(); row++)
    {
        if(!insertRows(row, 1, QModelIndex()))
        {
            return;
        }
        QModelIndex i = index(row, 0, QModelIndex());

        //enable checkbox for all fields except the first and last (costcentretype and costtype)
        if(row != 0 && row != rowCount(i) - 1)
        {
            setData(i, Qt::Unchecked, Qt::CheckStateRole);
        }
    }

    for(int column = 1; column < p_headers.count() - 1; column++)
    {
        QModelIndex i = index(4, column, QModelIndex());
        setData(i, Qt::Unchecked, Qt::CheckStateRole);
    }
}

void AddCostPositionModel::setCostCentres()
{
    QModelIndex i;
    for(int column = 1; column < columnCount(QModelIndex()) - 1; column++)
    {
        i = index(0, column, QModelIndex());

        QStringList row = costcentremodel->data(0);
        int costCentreColumn = costcentremodel->columnIdIndex(p_headers.value(column));
        QString name = row.value(costCentreColumn);
        setData(i, name, Qt::EditRole);
    }
}

QStringList AddCostPositionModel::currentRow() const
{
    return costtypemodel->data(currentSelectedRowId);
}

int AddCostPositionModel::rowCount(const QModelIndex &parent) const
{
    // type of costcentre
    // percentage
    // hours
    // value
    // type of costs
    return 5;
}

int AddCostPositionModel::columnCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    // 1 (use row) + count of costcentre + 1 (sum)
    int costcentres = costcentremodel->costCentreCount();
    return (1 + costcentres + 1);
}

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

    if(index.row() >= p_entries.size() || index.row() < 0)
    {
        return QVariant();
    }

    if(role == Qt::BackgroundRole)
    {
        if(index.column() == 0)        //select the types to split up your costs
        {
            QColor c;
            c.setNamedColor("#eaeaea");
            return c;
        }
        if(index.column() == columnCount(index) - 1)
        {
            QColor c;
            c.setNamedColor("#f3f3f3");
            return c;
        }
        if(index.row() == rowCount(index) - 1)
        {
            QColor c;
            c.setNamedColor("#AAAAAA");
            return c;
        }
    }
    if(role == Qt::DisplayRole || role == Qt::EditRole)
    {
        QVariantList pair = p_entries.value(index.row());
        if(pair.size() > index.column() && index.column() != 0 && (index.row() != (rowCount(index) - 1)))
        {
            return pair.value(index.column());
        }
    }
    else if(role == Qt::CheckStateRole)
    {
        if(index.column() == 0)
        {
            if(index.row() != 0 && index.row() != rowCount(index) - 1)
            {
                QVariantList pair = p_entries.value(index.row());
                bool firstColumnChecked = pair.value(0).toBool();

                if(firstColumnChecked)
                {
                    return Qt::Checked;
                }
                else
                {
                    return Qt::Unchecked;
                }
            }
        }
        else if(index.row() == 4)
        {
            if(index.column() >= 1 && index.column() < columnCount(index) - 1)
            {
                QVariantList pair = p_entries.value(index.row());
                bool firstColumnChecked = pair.value(index.column()).toBool();

                if(firstColumnChecked)
                {
                    return Qt::Checked;
                }
                else
                {
                    return Qt::Unchecked;
                }
            }
        }
    }
    return QVariant();
}

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

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

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

    if(index.column() == 0)
    {
        if(index.row() == 0)
        {
            return Qt::NoItemFlags;
        }
        if(index.row() == rowCount(index) - 1)
        {
            return Qt::NoItemFlags;
        }
        return Qt::ItemIsEnabled | Qt::ItemIsUserCheckable;
    }
    if(index.column() >= 1 && index.column() < columnCount(index) -1)
    {
        if(index.row() == 0)
        {
            return Qt::NoItemFlags;
        }
        if(index.row() == rowCount(index) - 1)
        {
            return Qt::ItemIsEnabled | Qt::ItemIsUserCheckable;
        }
        return Qt::ItemIsEnabled | Qt::ItemIsEditable;
    }
    if(index.column() == columnCount(index) - 1)
    {
        return Qt::NoItemFlags;
    }
    return Qt::ItemIsEnabled | Qt::ItemIsEditable;
}

bool AddCostPositionModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if(index.isValid())
    {
        if(role == Qt::EditRole || role == Qt::CheckStateRole)
        {
            int row = index.row();
            QVariantList p = p_entries.value(row);
            for(int i = 0; i < p_headers.size(); i++)
            {
                if(index.column() == i)
                {
                    p.replace(i, value.toString());
                }
            }
            p_entries.replace(row, p);
        }
        emit dataChanged(index, index);
        return true;
    }
    return false;
}

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

    int columncount = columnCount(index);
    for (int row = 0; row < rows; row++)
    {
        QVariantList pair;
        for(int i = 0; i < columncount; i++)
        {
            if(row >= 1 && i >=1 && row <= rowCount(index) - 1 && i <= columnCount(index) -1)
            {
                //costcentre field
                pair << "0";
            }
            else
            {
                pair << "";
            }
        }
        p_entries.insert(position, pair);
    }

    endInsertRows();
    return true;
}

bool AddCostPositionModel::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 AddCostPositionModel::refreshSums(const QModelIndex left, const QModelIndex right)
{
    p_currentSum = 0;
    // calculate the sum of all rows -- display an error in the sum column if wrong input has been entered

    if(left == right) //one cell changed -- e.g. a comboBox
    {
        qDebug()<<"left equals right";
        qDebug()<<"index: " << left;
        int row = left.row();
        qDebug()<<"row: " << row;
        switch(row)
        {
            case 1:
            {
                // percentage row
                if(p_entries.value(row).value(0) == Qt::Checked)
                {
                    // disable hours row
                    QVariantList secondrow = p_entries.value(2);
                    secondrow.replace(0, Qt::Unchecked);
                    p_entries.replace(2, secondrow);
                }
                break;
            }
            case 2:
            {
                // hours row
                if(p_entries.value(row).value(0) == Qt::Checked)
                {
                    // disable the other rows
                    QVariantList firstrow = p_entries.value(1);
                    firstrow.replace(0, Qt::Unchecked);
                    p_entries.replace(1, firstrow);

                    QVariantList thirdrow = p_entries.value(3);
                    thirdrow.replace(0, Qt::Unchecked);
                    p_entries.replace(3, thirdrow);
                }
                break;
            }
            case 3:
            {
                if(p_entries.value(row).value(0) == Qt::Checked)
                {
                    // disable hours row
                    QVariantList secondrow = p_entries.value(2);
                    secondrow.replace(0, Qt::Unchecked);
                    p_entries.replace(2, secondrow);
                    break;
                }
            }
        }
    }
    else
    {
        qDebug()<<"left doesn't match right";
    }

    for(int row = 1; row < rowCount(QModelIndex()) - 1; row++)
    {
        double sum = 0;

        if(p_entries.value(row).value(0) == Qt::Checked)
        {
            sum = 0;
            bool rowOk = true;
            switch(row)
            {
                case 1:
                {
                    rowOk = checkPercentageOfRow(p_entries.value(row));
                    if(rowOk)
                    {
                        sum += calculatedRowValuePercentage(p_entries.value(row));
                    }
                    else
                    {
                        qDebug()<<"checkPercentageOfRow returned false";
                        sum = -1;
                    }
                    break;
                }
                case 2:
                {
                    rowOk = checkWorkTimeOfRow(p_entries.value(row));
                    if(rowOk)
                    {
                        sum += calculatedRowValueHours(p_entries.value(row));
                    }
                    else
                    {
                        qDebug()<<"checkWorkTimeOfRow returned false";
                        sum = -1;
                    }
                    break;
                }
                case 3:
                {
                    rowOk = checkValuesOfRow(p_entries.value(row));
                    if(rowOk)
                    {
                        sum += calculatedRowValueBased(p_entries.value(row));
                    }
                    else
                    {
                        qDebug()<<"checkValuesOfRow returned false";
                        sum = -1;
                    }
                    break;
                }
            }
        }

        QModelIndex i = index(row, columnCount(QModelIndex()) - 1, QModelIndex());
        //can't use setData method here because it would end up in an infinite loop -- need to replace the data by hand
        if(i.isValid())
        {
            QVariantList p = p_entries.value(row);
            for(int header = 0; header < p_headers.size(); header++)
            {
                if(i.column() == header)
                {
                    if(sum == -1)
                    {
                        p.replace(header, "Fehler");
                    }
                    else
                    {
                        p.replace(header, QString::number(sum));
                    }
                }
            }
            p_entries.replace(row, p);
        }

        if(sum != -1)
        {
            p_currentSum += sum;
        }
    }
    emit updateView();
    emit currentSumChanged(p_currentSum);
}

bool AddCostPositionModel::checkPercentageOfRow(QVariantList row)
{
    double percentage = 0;
    for(int column = 1; column < row.count() - 1; column++)
    {
        bool ok = true;
        double value = 0;
        if(row.value(column) != "")
        {
            value = row.value(column).toDouble(&ok);
        }
        if(!ok)
        {
            qDebug()<<"there's an error in the percentage field: " << row.value(column);
            return false;
        }
        percentage += value;
    }
    return (percentage >= 0 && percentage <= 100);
}

double AddCostPositionModel::calculatedRowValuePercentage(QVariantList row)
{
    double wholeCosts = 0;
    for(int column = 1; column < row.count() - 1; column++)
    {
        double value = 0;
        if(row.value(column) != "")
        {
            value = row.value(column).toDouble();
        }
        double newvalue = (p_completeSum / 100) * value;
        qDebug()<<"p_completeSum: " << p_completeSum;
        qDebug()<<"value: " << value;
        qDebug()<<"p_completeSum / 100) * value: " << (p_completeSum / 100) * value;
        wholeCosts += newvalue;
    }
    qDebug()<<"wholecosts of percentage: " << wholeCosts;
    return wholeCosts;
}

double AddCostPositionModel::calculateCostCentreSum(int column)
{
    double costs = 0;

    double percentage = p_entries.value(1).value(column).toDouble();
    costs += (p_completeSum / 100 * percentage);

    costs += workTimePerCostCentre(p_entries.value(2), column);

    costs += p_entries.value(3).value(column).toDouble();

    return costs;
}

double AddCostPositionModel::workTimePerCostCentre(QVariantList row, int columnWanted)
{
    double worktime = 0;
    for(int column = 1; column < columnCount(QModelIndex()) - 1; column++)
    {
        bool ok = true;
        double value = 0;
        if(row.value(column) != QVariant())
        {
            value = row.value(column).toDouble(&ok);
        }
        if(!ok)
        {
            return 0;
        }
        qDebug()<<"worktime value costcentre: " << column << " " << value;
        worktime += value;
    }
    qDebug() << "worktime: " << worktime;

    double hourlyRate = (p_completeSum / worktime);
    qDebug()<<"hourlyRate: " << hourlyRate;

    double value = 0;
    if(row.value(columnWanted) != QVariant())
    {
        value = row.value(columnWanted).toDouble();
    }
    return hourlyRate * value;
}

bool AddCostPositionModel::checkWorkTimeOfRow(QVariantList row)
{
    double worktime = 0;
    for(int column = 1; column < row.count() - 1; column++)
    {
        bool ok = true;
        double value = 0;
        if(row.value(column) != "")
        {
            value = row.value(column).toDouble(&ok);
        }
        if(!ok)
        {
            return false;
        }
        worktime += value;
    }

    double hourlyRate = (p_completeSum / worktime);
    double wholePrice = 0;
    for(int column = 1; column < row.count() - 1; column++)
    {
        double value = 0;
        if(row.value(column) != "")
        {
            value = row.value(column).toDouble();
        }
        double valuePerCostCentre = hourlyRate * value;
        wholePrice += valuePerCostCentre;
    }
    return (wholePrice >= 0 || wholePrice <= p_completeSum);
}

double AddCostPositionModel::calculatedRowValueHours(QVariantList row)
{
    double worktime = 0;
    for(int column = 1; column < row.count() - 1; column++)
    {
        double value = 0;
        if(row.value(column) != "")
        {
            value = row.value(column).toDouble();
        }
        worktime += value;
    }

    double hourlyRate = (p_completeSum / worktime);
    double wholePrice = 0;
    for(int column = 1; column < row.count() - 1; column++)
    {
        double value = 0;
        if(row.value(column) != "")
        {
            value = row.value(column).toDouble();
        }
        double valuePerCostCentre = hourlyRate * value;
        wholePrice += valuePerCostCentre;
    }
    return wholePrice;
}

bool AddCostPositionModel::checkValuesOfRow(QVariantList row)
{
    double rowCosts = 0;
    for(int column = 1; column < row.count() - 1; column++)
    {
        bool ok = true;
        double value = 0;
        if(row.value(column) != "")
        {
            value = row.value(column).toDouble(&ok);
        }
        if(!ok)
        {
            return false;
        }
        rowCosts += value;
    }
    qDebug()<<"checkValuesOfRow rowCosts: " << rowCosts;
    qDebug()<<"checkValuesOfRow completeCosts: " << p_completeSum;
    qDebug()<<"checkValuesOfRow expression: " << (rowCosts <= p_completeSum && rowCosts >= 0);
    return (rowCosts <= p_completeSum || rowCosts >= 0);
}

double AddCostPositionModel::calculatedRowValueBased(QVariantList row)
{
    double rowCosts = 0;
    for(int column = 1; column < row.count() - 1; column++)
    {
        double value = 0;
        if(row.value(column) != "")
        {
            value = row.value(column).toDouble();
        }
        rowCosts += value;
    }
    return rowCosts;
}

void AddCostPositionModel::clear()
{
    qDebug() << "TODO: clear everything after last row has been added";
}

bool AddCostPositionModel::isCorrectSpreaded()
{
    return p_currentSum == p_completeSum;
}

QString AddCostPositionModel::costTypesRow()
{
    QString types;
    for(int column = 1; column < columnCount(QModelIndex()) - 1; column++)
    {
        bool fixedCosts = p_entries.value(4).value(column).toBool();
        if(!fixedCosts)
        {
            types += "E";
        }
        else
        {
            types += "G";
        }

        if(column <= columnCount(QModelIndex()) - 3)
        {
            types += "/";
        }
    }
    return types;
}

QString AddCostPositionModel::costSpreadingRow()
{
    // example:
    // complete costs: 1000
    // first costcentre:
    //    percent: 50
    //    value: 100
    // second costcentre:
    //    value: 400

    // results in:
    // p:50;v:100/;v:400

    QString spreading;
    for(int column = 1; column < columnCount(QModelIndex()) - 1; column++)
    {
        for(int row = 1; row < rowCount(QModelIndex()); row++)
        {
            if(p_entries.value(row).value(0) == Qt::Checked)
            {
                switch(row)
                {
                    case 1:
                    {
                        if(p_entries.value(row).value(column) != "" && p_entries.value(row).value(column) != 0)
                        {
                            spreading += "p:";
                            spreading += p_entries.value(row).value(column).toString();
                        }
                        break;
                    }
                    case 2:
                    {
                        if(p_entries.value(row).value(column) != "" && p_entries.value(row).value(column) != 0)
                        {
                            spreading += "h:";
                            spreading += p_entries.value(row).value(column).toString();
                        }
                        break;
                    }
                    case 3:
                    {
                        if(p_entries.value(row).value(column) != "" && p_entries.value(row).value(column) != 0)
                        {
                            spreading += "v:";
                            spreading += p_entries.value(row).value(column).toString();
                        }
                        break;
                    }
                }
            }
            if(row < rowCount(QModelIndex()) - 2)
            {
                spreading += ";";
            }
        }
        if(column < columnCount(QModelIndex()) - 2)
        {
            spreading += "/";
        }
    }
    return spreading;
}

---