accountingrecordwidget.cpp

Go to the documentation of this file.

#include "../Data/dataexercise.h"
#include "../Data/dataaccount.h"
#include "../Models/accountmodel.h"
#include "../Widgets/alineedit.h"
#include "../Calculations/dataexercisevalidator.h"
#include <QLineEdit>
#include <QHBoxLayout>
#include <QComboBox>
#include <QVBoxLayout>
#include <QPushButton>
#include <QList>
#include <QPair>
#include <QDebug>
#include <QLabel>

#include "accountingrecordwidget.h"
#include "../Widgets/acombobox.h"
#include "../Widgets/alineedit.h"
#include "../Data/project.h"

AccountingRecordWidget::AccountingRecordWidget(QWidget *parent) : QWidget(parent)
{
    settings = NULL;
    validator = new DataExerciseValidator();
    connect(this, SIGNAL(beginToValidate(DataExercise*,AccountingInformation*,QList<AccountingInformation>*,QList<AccountingInformation>*)), validator, SLOT(exerciseFinished(DataExercise*, AccountingInformation*,QList<AccountingInformation>*,QList<AccountingInformation>*)));
}

void AccountingRecordWidget::setSettings(Settings *settings)
{
    this->settings = settings;
}

void AccountingRecordWidget::makeButtonRow(int type)
{
    if(type != 10)
    {
        QPushButton *buttonAddAccountingRecord = new QPushButton(QIcon(":/misc/Add"), tr("Buchungssatz hinzufügen"), this);
        QPushButton *buttonRemoveAccountingRecord = new QPushButton(QIcon(":/misc/Remove"), tr("Buchungssatz löschen"), this);

        buttonRow->addSpacerItem(new QSpacerItem(60, 0));
        buttonRow->addWidget(buttonAddAccountingRecord);
        buttonRow->addWidget(buttonRemoveAccountingRecord);

        if(type == 0)
        {
            QPushButton *buttonValidate = new QPushButton(QIcon(":/misc/Apply"), tr("Buchungssatz korrigieren"), this);
            QPushButton *buttonShowSolution = new QPushButton(QIcon(":misc/Apply"), tr("Lösung anzeigen"), this);
            buttonRow->addWidget(buttonValidate);
            buttonRow->addWidget(buttonShowSolution);
            connect(buttonValidate, SIGNAL(clicked()), this, SLOT(correctAccountingRecord()));
            connect(buttonShowSolution, SIGNAL(clicked()), this, SIGNAL(finishAccountingRecord()));
        }

        buttonRow->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Expanding));
        connect(buttonAddAccountingRecord, SIGNAL(clicked()), this, SLOT(addNewAccountingRecord()));
        connect(buttonRemoveAccountingRecord, SIGNAL(clicked()), this, SLOT(removeAccountingRecord()));
    }
    else
    {
        QPushButton *buttonBack = new QPushButton(QIcon(":/misc/Cancel"), tr("Zurück"), this);

        buttonRow->addSpacerItem(new QSpacerItem(60, 0));
        buttonRow->addWidget(buttonBack);
        buttonRow->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Expanding));

        connect(buttonBack, SIGNAL(clicked(bool)), this, SIGNAL(backToAccountingRecord()));
    }
}

void AccountingRecordWidget::clearSettings()
{
    if(this->layout())
    {
        deleteWidget();
        delete layout();
    }
    p_layoutForAll = new QVBoxLayout();
    p_accountingRecordLayout = new QVBoxLayout();
    buttonRow = new QHBoxLayout();
    accountingList = new QList<DataAccountingRecord *>();
}

void AccountingRecordWidget::createWidgetRow(bool editable, AccountModel *model, AccountingRecordWidgetType::type type, DataAccountingRecord *record)
{
    AccountingRecord *rec = newAccountingRecord();
    connect(rec, SIGNAL(sendErrorMessage(QString)), this, SIGNAL(forwardErrorMesssage(QString)));
    connect(rec, SIGNAL(actualizeAccounts()), this, SLOT(saveBeforeActualizingAccounts()));
    p_accountingRecordList.append(rec);
    p_accountingRecordLayout->addWidget(rec);

    if(type == AccountingRecordWidgetType::RowWithData)
    {
        rec->createWidgetForExercise(editable, model, showSolution, record);
    }
    else if(type == AccountingRecordWidgetType::RowWithOutData)
    {
        rec->createWidgetForExercise(true, model, showSolution);
    }
}

void AccountingRecordWidget::createWidget(bool editable)
{
    if(accountingList->size() == 0)
    {
        // if there are no data create an empty, editable row
        createWidgetRow(editable, model, AccountingRecordWidgetType::RowWithOutData);
    }
    else
    {
        // create accountingrecordwidgets for every row in the data representation
        for(int i = 0; i < accountingList->size(); i++)
        {
            createWidgetRow(editable, model, AccountingRecordWidgetType::RowWithData, accountingList->value(i));
        }
    }

    p_layoutForAll->addLayout(p_accountingRecordLayout);
    p_layoutForAll->addLayout(buttonRow);
    this->setLayout(p_layoutForAll);
}

void AccountingRecordWidget::makeWidgetForExercise(bool editable, AccountModel *model, DataExercise *exercise)
{
    clearSettings();
    this->exercise = exercise;
    this->model = model;
    this->showSolution = false;

    if(editable)
    {
        makeButtonRow(0);
        accountingList = exercise->accountingRecords();
    }
    else
    {
        makeButtonRow(10);
        accountingList = exercise->solutionRecords();
    }

    createWidget(editable);
}

AccountingRecord *AccountingRecordWidget::newAccountingRecord()
{
    return new AccountingRecord(this, Project::dateCalendar());
}

void AccountingRecordWidget::makeWidgetForTask(bool editable, AccountModel *model, DataExercise *exercise, bool showSolution)
{
    clearSettings();
    this->exercise = exercise;
    this->model = model;
    this->showSolution = showSolution;

    if(editable)
    {
        if(showSolution)
        {
            accountingList = exercise->solutionRecords();
        }
        else
        {
            accountingList = exercise->accountingRecords();
        }
        makeButtonRow(1);
    }

    createWidget(editable);
}

void AccountingRecordWidget::makeWidgetForPrinter(AccountModel *model, DataExercise *exercise, bool editable)
{
    clearSettings();
    if(editable)
    {
        accountingList = exercise->accountingRecords();
    }
    else
    {
        accountingList = exercise->solutionRecords();
    }
    for(int i = 0; i < accountingList->size(); i++)
    {
        AccountingRecord *record = newAccountingRecord();
        record->createWidgetForPrinter(model, accountingList->value(i));
        p_accountingRecordList.append(record);
        p_accountingRecordLayout->addWidget(record);
    }
    p_layoutForAll->addLayout(p_accountingRecordLayout);
    this->setLayout(p_layoutForAll);
}

void AccountingRecordWidget::removeAccountingRecord()
{
    AccountingRecord *record = p_accountingRecordList.takeLast();
    p_accountingRecordLayout->removeWidget(record);
    record->deleteWidget();
    delete record;
    if(p_accountingRecordList.size() == 0)
    {
        AccountingRecord *rec = newAccountingRecord();
        rec->createWidgetForExercise(true, model);
        p_accountingRecordLayout->addWidget(record);
        p_accountingRecordList.append(record);
    }
    saveBeforeActualizingAccounts();
}

void AccountingRecordWidget::addNewAccountingRecord()
{
    // only used for adding new accountingrecords on user interaction (button click)
    AccountingRecord *record = newAccountingRecord();
    connect(record, SIGNAL(sendErrorMessage(QString)), this, SIGNAL(forwardErrorMesssage(QString)));
    connect(record, SIGNAL(actualizeAccounts()), this, SLOT(saveBeforeActualizingAccounts()));
    if(settings->teacher())
    {
        record->createWidgetForExercise(true, model, true);
    }
    else
    {
        record->createWidgetForExercise(true, model, false);
    }

    p_accountingRecordLayout->addWidget(record);
    p_accountingRecordList.append(record);
    saveBeforeActualizingAccounts();
}

void AccountingRecordWidget::saveBeforeActualizingAccounts()
{
    qDebug()<<"saveBeforeActualizingAccounts";
    exercise->dataChanged();

    if(showSolution)
    {
        exercise->solutionRecords()->clear();
    }
    else
    {
        exercise->accountingRecords()->clear();
    }

    // transfer data from widget into data classes
    for(int i = 0; i < p_accountingRecordList.size(); i++)
    {
        AccountingRecord *current = p_accountingRecordList.value(i);
        current->saveIntoData(exercise);
    }
    emit actualizeAccountsAfterSaving();
}

void AccountingRecordWidget::correctAccountingRecord()
{
    exercise->dataChanged();
    exercise->accountingRecords()->clear();
    validator->resetOk();
    resetAllStylesForValidator();
    for(int i = 0; i < p_accountingRecordList.size(); i++)
    {
        AccountingRecord *current = p_accountingRecordList.value(i);
        current->saveIntoData(exercise);

        emit beginToValidate(exercise, current->accountingRowInfos(), current->creditList(), current->debitList());
    }
    if(validator->everythingOk())
    {
        emit changeState(exercise->name(), exercise->id(), Correct);
    }
    else
    {
        emit changeState(exercise->name(), exercise->id(), Wrong);
    }
}

void AccountingRecordWidget::deleteWidget()
{
    QLayoutItem *item;
    while(item = p_layoutForAll->takeAt(0))
    {
        if((item->widget()) != 0)
        {
           qobject_cast<AccountingRecord *>(item->widget())->deleteWidget();
           p_accountingRecordList.clear();
        }
        else
        {
            QLayout *layout = item->layout();
            while(item = layout->takeAt(0))
            {
                if((item->widget()) != 0)
                {
                    layout->removeWidget(item->widget());
                    delete item->widget();
                }
            }
            delete layout;
        }
    }
    p_accountingRecordList.clear();
}

void AccountingRecordWidget::resetAllStylesForValidator()
{
    for(int i = 0; i < p_accountingRecordList.count(); i++)
    {
        AccountingRecord *record = p_accountingRecordList.value(i);
        record->resetStyle();
    }
}

---