dataexercise.cpp

Go to the documentation of this file.

#include <QDomElement>
#include <QDebug>
#include <QtAlgorithms>
#include "dataexercise.h"
#include "datahash.h"

bool DataExercise::loadDataNode(const QDomNode data)
{
    exerciseName = data.toElement().attribute("name");
    exerciseId = data.toElement().attribute("exerciseId").toUInt();
    exerciseStatus = NotCompleted;

    //qDebug()<<"exerciseName: " << exerciseName;
    //qDebug()<<"exerciseId: " << exerciseId;

    QDomNode node = data.firstChild();
    while(!node.isNull())
    {
        if(node.nodeName() == "description")
        {
            m_description = node.firstChild().nodeValue().simplified();
        }
        else if(node.nodeName() == "records")
        {
            if(!loadRecords(node, &accountingRecordList))
            {
                qDebug()<<"loading records failed";
                return false;
            }
            //qDebug()<<"accountingrecordList: " << accountingRecordList;
        }
        else if(node.nodeName() == "solution")
        {
            if(!loadRecords(node, &solutionAccountingRecordList))
            {
                qDebug()<<"loading solution failed";
                return false;
            }
        }
        else if(node.nodeName() == "accounts")
        {
            QDomNode nodeAcc = node.firstChild();
            while(!nodeAcc.isNull())
            {
                if(nodeAcc.nodeName() == "account")
                {
                    DataAccount *acc = new DataAccount();
                    if(!acc->loadDataNode(nodeAcc))
                    {
                        qDebug()<<"loading account failed";
                        delete acc;
                        return false;
                    }
                    connect(acc, SIGNAL(changed()), this, SLOT(dataChanged()));
                    accountList.append(acc);
                }
                else if(nodeAcc.nodeName() != "#comment")
                {
                    qDebug() << "Unknown element in accounts tag:" << nodeAcc.nodeName();
                }
                nodeAcc = nodeAcc.nextSibling();
            }
        }
        else if(node.nodeName() == "exerciseStatus")
        {
            QString str = node.firstChild().nodeValue().simplified();
            if(str == "Correct")
                exerciseStatus = Correct;
            else if(str == "Wrong")
                exerciseStatus = Wrong;
            else if(str == "NotCompleted")
                exerciseStatus = NotCompleted;
            else
            {
                exerciseStatus = NotCompleted;
                qDebug() << "wrong value in exerciseStatus: " << str;
            }
        }
        else if(node.nodeName() != "#comment")
        {
            qDebug() << "Unknown element in exercise tag:" << node.nodeName();
        }
        node = node.nextSibling();
    }
    return true;
}

bool DataExercise::loadRecords(const QDomNode data, QList<DataAccountingRecord *> *targetList)
{
    QDomNode node = data.firstChild();
    while(!node.isNull())
    {
        if(node.nodeName() == "record")
        {
            DataAccountingRecord *dar = new DataAccountingRecord();
            if(!dar->loadDataNode(node))
            {
                qDebug()<<"loading datanode accounting record failed";
                delete dar;
                return false;
            }
            if(!dar->isEmpty())
            {
//                qDebug()<<"non empty accounting record";
                targetList->append(dar);
                connect(dar, SIGNAL(changed()), this, SLOT(dataChanged()));
            }
            else
            {
//                qDebug()<<"empty accounting record -- deleting";
                delete dar;
            }
        }
        else if(node.nodeName() != "#comment")
        {
            qDebug() << "Unknown element in records:" << node.nodeName();
        }
        node = node.nextSibling();
    }
    return true;
}

QString DataExercise::statusToString(DataExerciseStatus status)
{
    switch(status)
    {
    case Correct: return "Correct";
    case Wrong: return "Wrong";
    case NotCompleted: return "NotCompleted";
    default:
        qDebug() << "DataExercise: can't convert DataExerciseStatus to string, please add to the switch statement";
    }
    return "NotCompleted";
}

QDomElement DataExercise::saveDataNode(QDomDocument *xml)
{
    QDomElement exercise = xml->createElement("exercise");
    exercise.setAttribute("name", exerciseName);
    exercise.setAttribute("exerciseId", QString::number(exerciseId));

    QDomElement eDescription = xml->createElement("description");
    eDescription.appendChild(xml->createTextNode(m_description));
    exercise.appendChild(eDescription);

    QDomElement eStatus = xml->createElement("exerciseStatus");
    eStatus.appendChild(xml->createTextNode(statusToString(exerciseStatus)));
    exercise.appendChild(eStatus);

    QDomElement records = xml->createElement("records");
    saveRecords(xml, &records, &accountingRecordList);
    exercise.appendChild(records);

    QDomElement solution = xml->createElement("solution");
    saveRecords(xml, &solution, &solutionAccountingRecordList);
    exercise.appendChild(solution);

    QDomElement eAccounts = xml->createElement("accounts");
    for(int i = 0; i < accountList.size(); i++)
    {
        eAccounts.appendChild(accountList[i]->saveDataNode(xml));
    }
    exercise.appendChild(eAccounts);

    return exercise;
}

void DataExercise::saveRecords(QDomDocument *xml, QDomElement *parent, QList<DataAccountingRecord *> *records)
{
    qDebug() << "saveRecords(): list size:" << records->size();
    for(int i = 0; i < records->size(); i++)
    {
        parent->appendChild((*records)[i]->saveDataNode(xml));
    }
}

void DataExercise::hash(unsigned int &startValue)
{
    // Note: After we release, it is important to keep the order of these. If we really need to add something, the file version
    //       should be used to determine how to hash.
    DataHash::hash(exerciseName, startValue);
    DataHash::hash(&exerciseId, sizeof(exerciseId), startValue);
    DataHash::hash(m_description, startValue);
    DataHash::hash(&exerciseStatus, sizeof(exerciseStatus), startValue);

    for(int i = 0; i < accountingRecordList.size(); i++)
    {
        accountingRecordList[i]->hash(startValue);
    }
    for(int i = 0; i < solutionAccountingRecordList.size(); i++)
    {
        solutionAccountingRecordList[i]->hash(startValue);
    }
    for(int i = 0; i < accountList.size(); i++)
    {
        accountList[i]->hash(startValue);
    }
}

DataExercise::DataExercise()
{
}

DataExercise::DataExercise(DataExercise &exercise)
{
    this->exerciseName = exercise.name();
    this->exerciseId = exercise.id();
    this->exerciseStatus = exercise.status();
    this->m_description = exercise.description();
    this->accountingRecordList = QList<DataAccountingRecord *> (*(exercise.accountingRecords()));
    this->solutionAccountingRecordList = QList<DataAccountingRecord *> (*(exercise.solutionRecords()));
    this->accountList = QList<DataAccount *> (*(exercise.accounts()));
}

DataExercise::~DataExercise()
{
    qDeleteAll(accountingRecordList);
    accountingRecordList.clear();

    qDeleteAll(solutionAccountingRecordList);
    solutionAccountingRecordList.clear();

    qDeleteAll(accountList);
    accountList.clear();
}

---