(); + Q_UNUSED(argc) Q_UNUSED(argv); + EntityInstanceFactory::registerClass

(); + EntityInstanceFactory::registerClass(); + EntityInstanceFactory::registerClass(); + EntityInstanceFactory::registerClass(); + EntityInstanceFactory::registerClass(); + EntityInstanceFactory::registerClass(); + EntityInstanceFactory::registerClass(); + EntityInstanceFactory::registerClass(); + EntityInstanceFactory::registerClass(); + EntityInstanceFactory::registerClass(); + + + QSharedPointer e = QSharedPointer(new CuteEntityManager::EntityManager("QSQLITE", QDir::currentPath() + "/db.sqlite")); - QStringList inits = QStringList() << "Article"; + qDebug()<startup("0.1", inits); - QSharedPointer

a = QSharedPointer

(new Article(5.0, - "muesli")); - auto ep = a.objectCast(); - qDebug() << e->create(ep, true, true); //INSERT on database - a->setPrice(6.0); //inflation - a->setName("muesli improved"); //1337 muesli upgrade - qDebug() << e->save(ep); //UPDATE on database - qDebug() << e->remove(ep); //REMOVE on database + + + auto entities = DataCreation::createRatingEntities(); + e->save(entities); + +// QSharedPointer pupil = QSharedPointer(new Pupil("Vorname","Nachname","","","Keks")); +// e->save(pupil); + + QSharedPointer pupil = QSharedPointer(new Pupil()); + pupil->setLegalGuardianNote("note"); + e->save(pupil); + +// QSharedPointer person = QSharedPointer(new Person("Vorname","Nachname","","","Keks")); +// e->save(person); + + + + QSharedPointer occasion = QSharedPointer(new Occasion("IrgendeinAnlass")); + QSharedPointer inc = QSharedPointer(new RatingMarkIncident()); + inc->setAdditionalInfo("addInf"); + inc->setBookedAt(QDateTime::currentDateTime()); + inc->setBookedFor(QDateTime::currentDateTime()); + inc->setOccasion(occasion); +// inc->setPupil(pupil); + inc->setRateable(true); +// inc->setRatingMarkSystem(system); + inc->setSymbol("z"); + inc->setValue(23); + + e->save(inc); + + + return 0; } diff --git a/samples/simple/occasion.cpp b/samples/simple/occasion.cpp new file mode 100644 index 0000000..5b2583f --- /dev/null +++ b/samples/simple/occasion.cpp @@ -0,0 +1,22 @@ +#include "occasion.h" + +Occasion::Occasion() : Entity() +{ + m_text.clear(); +} + +Occasion::Occasion(QString text) +{ + m_text=text; +} +QString Occasion::text() +{ + return m_text; +} + +void Occasion::setText(QString &text) +{ + m_text = text; +} + + diff --git a/samples/simple/occasion.h b/samples/simple/occasion.h new file mode 100644 index 0000000..ca3354d --- /dev/null +++ b/samples/simple/occasion.h @@ -0,0 +1,25 @@ +#ifndef OCCASION_H +#define OCCASION_H + +#include "entity.h" +#include + +using namespace CuteEntityManager; +class Occasion : public Entity +{ + Q_OBJECT + EM_MACRO(Occasion) + Q_PROPERTY(QString text READ text WRITE setText) +public: + Q_INVOKABLE explicit Occasion(); + Occasion(QString text); + QString text(); + void setText(QString &text); + +protected: + QString m_text; + +}; + +#endif // OCCASION_H + diff --git a/samples/simple/person.cpp b/samples/simple/person.cpp new file mode 100644 index 0000000..8f42a50 --- /dev/null +++ b/samples/simple/person.cpp @@ -0,0 +1,134 @@ +#include "person.h" +#include "contact.h" +#include "address.h" + +Person::Person(QObject *parent): Entity(parent) { +} +Person::Person(QString firstName, QString familyName, + QString customPictureFileName, QString namePrefix, QString nickName, + QDate birthday, QObject *parent): Entity(parent) { + setFirstName(firstName); + setFamilyName(familyName); + setNamePrefix(namePrefix); + setNickName(nickName); + setBirthday(birthday); + setCustomPictureFileName(customPictureFileName); +} + +const QHash Person::getRelations() const { + auto hash = QHash(); + hash.insert("groups", CuteEntityManager::Relation("groups", + RelationType::MANY_TO_MANY, + QString("persons"))); + hash.insert("maintainedGroups", CuteEntityManager::Relation("maintainedGroups", + RelationType::ONE_TO_MANY, + QString("mainTeacher"))); + hash.insert("contacts", CuteEntityManager::Relation("contacts", + RelationType::MANY_TO_MANY)); + hash.insert("addresses", CuteEntityManager::Relation("addresses", + RelationType::MANY_TO_MANY)); + return hash; +} + +QString Person::fullName(NameOrder nameOrder) const { + QString name = QString(); + if (nameOrder == NameOrder::FAMILY_FIRST_NAME_ORDER) { + name += this->getFamilyName(); + name += ", "; + if (!this->getNamePrefix().isEmpty()) { + name += this->getNamePrefix(); + name += " "; + } + name += this->getFirstName(); + } else { + name += this->getFirstName(); + name += " "; + name += this->getFamilyName(); + if (!this->getNamePrefix().isEmpty()) { + name += ", "; + name += this->getNamePrefix(); + } + } + return name; +} +QString Person::getFirstName() const { + return firstName; +} + +void Person::setFirstName(const QString &value) { + firstName = value; +} +QString Person::getFamilyName() const { + return familyName; +} + +void Person::setFamilyName(const QString &value) { + familyName = value; +} +QString Person::getNamePrefix() const { + return namePrefix; +} + +void Person::setNamePrefix(const QString &value) { + namePrefix = value; +} +QString Person::getNickName() const { + return nickName; +} + +void Person::setNickName(const QString &value) { + nickName = value; +} +QDate Person::getBirthday() const { + return birthday; +} + +void Person::setBirthday(const QDate &value) { + birthday = value; +} +QString Person::getCustomPictureFileName() const { + return customPictureFileName; +} + +void Person::setCustomPictureFileName(const QString &value) { + customPictureFileName = value; +} +QList > Person::getContacts() const { + return contacts; +} + +void Person::setContacts(const QList > &value) { + contacts = value; +} +QList > Person::getAddresses() const { + return addresses; +} + +void Person::setAddresses(const QList > &value) { + addresses = value; +} +QList > Person::getGroups() const { + return groups; +} + +void Person::setGroups(const QList > &value) { + groups = value; +} + +void Person::addContact(Contact *contact) { + this->contacts.append(QSharedPointer(contact)); +} + +void Person::addAddress(Address *address) { + this->addresses.append(QSharedPointer

(address)); +} + +QList > Person::getMaintainedGroups() const { + return maintainedGroups; +} + +void Person::setMaintainedGroups(const QList > &value) { + maintainedGroups = value; + +} + diff --git a/samples/simple/person.h b/samples/simple/person.h new file mode 100644 index 0000000..a5a7ac1 --- /dev/null +++ b/samples/simple/person.h @@ -0,0 +1,96 @@ +#ifndef PERSON_H +#define PERSON_H + +#include +#include +#include +#include +#include +#include +#include "entity.h" + +using namespace CuteEntityManager; +class Group; +class Contact; +class Address; + +class Person: public Entity { + Q_OBJECT + EM_MACRO(Person) + Q_PROPERTY(QString firstName READ getFirstName WRITE setFirstName) + Q_PROPERTY(QString familyName READ getFamilyName WRITE setFamilyName) + Q_PROPERTY(QString namePrefix READ getNamePrefix WRITE setNamePrefix) + Q_PROPERTY(QString nickName READ getNickName WRITE setNickName) + Q_PROPERTY(QString customPictureFileName READ getCustomPictureFileName WRITE + setCustomPictureFileName) + Q_PROPERTY(QDate birthday READ getBirthday WRITE setBirthday) + Q_PROPERTY(QList> groups READ getGroups WRITE setGroups) + Q_PROPERTY(QList> maintainedGroups READ + getMaintainedGroups WRITE setMaintainedGroups) + Q_PROPERTY(QList> contacts READ getContacts WRITE + setContacts) + Q_PROPERTY(QList> addresses READ + getAddresses WRITE setAddresses) + + public: + enum class NameOrder {FIRST_FAMILY_NAME_ORDER, FAMILY_FIRST_NAME_ORDER}; + Q_INVOKABLE explicit Person(QObject *parent = 0); + Person(QString firstName, QString familyName, + QString customPictureFileName = QString(), QString namePrefix = QString(), + QString nickName = QString(), QDate birthday = QDate(), QObject *parent = 0); + + virtual const QHash getRelations() const override; + + bool isPresent(QDateTime date = QDateTime::currentDateTime()); + QString fullName(NameOrder nameOrder = NameOrder::FAMILY_FIRST_NAME_ORDER) + const; + + QString getFirstName() const; + void setFirstName(const QString &value); + + QString getFamilyName() const; + void setFamilyName(const QString &value); + + QString getNamePrefix() const; + void setNamePrefix(const QString &value); + + QString getNickName() const; + void setNickName(const QString &value); + + QDate getBirthday() const; + void setBirthday(const QDate &value); + + QString getCustomPictureFileName() const; + void setCustomPictureFileName(const QString &value); + + QList > getContacts() const; + void setContacts(const QList > &value); + + QList > getAddresses() const; + void setAddresses(const QList > &value); + + QList > getGroups() const; + void setGroups(const QList > &value); + + void addContact(Contact *contact); + void addAddress(Address *address); + + QList > getMaintainedGroups() const; + void setMaintainedGroups(const QList > &value); + + protected: + QString firstName; + QString familyName; + QString namePrefix; + QString nickName; + QDate birthday; + QString customPictureFileName; + QList > contacts; + QList > addresses; + QList > groups; + QList > maintainedGroups; + +}; + + +#endif // PERSON_H diff --git a/samples/simple/pupil.cpp b/samples/simple/pupil.cpp new file mode 100644 index 0000000..2532914 --- /dev/null +++ b/samples/simple/pupil.cpp @@ -0,0 +1,34 @@ +#include "pupil.h" + +Pupil::Pupil() : Person() { + +} + +Pupil::Pupil(QString firstName, QString familyName, + QString customPictureFileName, QString namePrefix, QString nickName, + QDate birthday, QString legalGuardianNote, QObject *parent) + : Person(firstName, familyName, customPictureFileName, namePrefix, + nickName, birthday, parent) { + setFirstName(firstName); + setFamilyName(familyName); + setNamePrefix(namePrefix); + setNickName(nickName); + setBirthday(birthday); + setCustomPictureFileName(customPictureFileName); + this->setLegalGuardianNote(legalGuardianNote); +} + +QString Pupil::getLegalGuardianNote() const { + return legalGuardianNote; +} + +void Pupil::setLegalGuardianNote(const QString &value) { + legalGuardianNote = value; +} + +const QHash Pupil::getRelations() const { + auto hash = Person::getRelations(); + hash.insert("groups", CuteEntityManager::Relation("groups", + RelationType::MANY_TO_MANY)); + return hash; +} diff --git a/samples/simple/pupil.h b/samples/simple/pupil.h new file mode 100644 index 0000000..ecff139 --- /dev/null +++ b/samples/simple/pupil.h @@ -0,0 +1,28 @@ +#ifndef PUPIL_H +#define PUPIL_H +#include "person.h" + +class Pupil : public Person { + Q_OBJECT + EM_MACRO(Pupil) + Q_PROPERTY(QString legalGuardianNote READ getLegalGuardianNote WRITE + setLegalGuardianNote) + public: + Q_INVOKABLE Pupil(); + Pupil(QString firstName, QString familyName, + QString customPictureFileName = QString(), QString namePrefix = QString(), + QString nickName = QString(), QDate birthday = QDate(), QString legalGuardianNote = "", QObject *parent = 0); + + QString getLegalGuardianNote() const; + void setLegalGuardianNote(const QString &value); + virtual const QHash getRelations() const override; + + QString getForm() const; + void setForm(const QString &value); + + protected: + QString legalGuardianNote; + +}; + +#endif // PUPIL_H diff --git a/samples/simple/ratingmarkdefinition.cpp b/samples/simple/ratingmarkdefinition.cpp new file mode 100644 index 0000000..9e6611c --- /dev/null +++ b/samples/simple/ratingmarkdefinition.cpp @@ -0,0 +1,118 @@ +#include "ratingmarkdefinition.h" + +RatingMarkDefinition::RatingMarkDefinition() + :Incident() +{ + m_ratingMarkSystem = QSharedPointer(); + m_symbol = QString(); + m_valueEquivalent = -999; + m_minValue = -999; + m_percentEquivalent = -999; + m_minPercent = -999; + m_rateable = true; + m_panelColumn = -1; + m_panelRow = -1; +} + +QSharedPointer RatingMarkDefinition::ratingMarkSystem() const +{ + return m_ratingMarkSystem; +} + +void RatingMarkDefinition::setRatingMarkSystem(const QSharedPointer &ratingMarkSystem) +{ + m_ratingMarkSystem = ratingMarkSystem; +} + +QString RatingMarkDefinition::symbol() const +{ + return m_symbol; +} + +void RatingMarkDefinition::setSymbol(const QString &symbol) +{ + m_symbol = symbol; +} + +qreal RatingMarkDefinition::valueEquivalent() const +{ + return m_valueEquivalent; +} + +void RatingMarkDefinition::setValueEquivalent(const qreal &valueEquivalent) +{ + m_valueEquivalent = valueEquivalent; +} + +qreal RatingMarkDefinition::minValue() const +{ + return m_minValue; +} + +void RatingMarkDefinition::setMinValue(const qreal &minValue) +{ + m_minValue = minValue; +} + +qreal RatingMarkDefinition::percentEquivalent() const +{ + return m_percentEquivalent; +} + +void RatingMarkDefinition::setPercentEquivalent(const qreal &percentEquivalent) +{ + m_percentEquivalent = percentEquivalent; +} + +qreal RatingMarkDefinition::minPercent() const +{ + return m_minPercent; +} + +void RatingMarkDefinition::setMinPercent(const qreal &minimumPercent) +{ + m_minPercent = minimumPercent; +} + +bool RatingMarkDefinition::rateable() const +{ + return m_rateable; +} + +void RatingMarkDefinition::setRateable(bool rateable) +{ + m_rateable = rateable; +} + +int RatingMarkDefinition::panelColumn() const +{ + return m_panelColumn; +} + +void RatingMarkDefinition::setPanelColumn(int panelColumn) +{ + m_panelColumn = panelColumn; +} + +int RatingMarkDefinition::panelRow() const +{ + return m_panelRow; +} + +void RatingMarkDefinition::setPanelRow(int panelRow) +{ + m_panelRow = panelRow; +} + +const QHash RatingMarkDefinition::getRelations() const +{ + auto hash = Incident::getRelations(); + hash.insert("ratingMarkSystem",Relation("ratingMarkSystem",CuteEntityManager::RelationType::MANY_TO_ONE)); + + return hash; +} + +bool RatingMarkDefinition::lessThanPercent(const QSharedPointer &a, const QSharedPointer &b) +{ + return a->percentEquivalent() < b->percentEquivalent(); +} diff --git a/samples/simple/ratingmarkdefinition.h b/samples/simple/ratingmarkdefinition.h new file mode 100644 index 0000000..c65eabb --- /dev/null +++ b/samples/simple/ratingmarkdefinition.h @@ -0,0 +1,80 @@ +#ifndef RATINGMARKDEFINITION_H +#define RATINGMARKDEFINITION_H + +#include + +#include "entity.h" +#include "incident.h" +#include "enums.h" + +class RatingMarkSystem; + +using namespace CuteEntityManager; + +/** + * @brief The RatingMarkDefinition class + * + */ +class RatingMarkDefinition : public Incident +{ + Q_OBJECT + EM_MACRO(RatingMarkDefinition) + Q_PROPERTY(QSharedPointer ratingMarkSystem READ ratingMarkSystem WRITE setRatingMarkSystem) + Q_PROPERTY(QString symbol READ symbol WRITE setSymbol) + Q_PROPERTY(qreal valueEquivalent READ valueEquivalent WRITE setValueEquivalent) + Q_PROPERTY(qreal minValue READ minValue WRITE setMinValue) + Q_PROPERTY(qreal percentEquivalent READ percentEquivalent WRITE setPercentEquivalent) + Q_PROPERTY(qreal minPercent READ minPercent WRITE setMinPercent) + Q_PROPERTY(bool rateable READ rateable WRITE setRateable) + Q_PROPERTY(int panelColumn READ panelColumn WRITE setPanelColumn) + Q_PROPERTY(int panelRow READ panelRow WRITE setPanelRow) + +public: + Q_INVOKABLE RatingMarkDefinition(); + + QSharedPointer ratingMarkSystem() const; + void setRatingMarkSystem(const QSharedPointer &ratingMarkSystem); + + QString symbol() const; + void setSymbol(const QString &symbol); + + qreal valueEquivalent() const; + void setValueEquivalent(const qreal &valueEquivalent); + + qreal minValue() const; + void setMinValue(const qreal &minValue); + + qreal percentEquivalent() const; + void setPercentEquivalent(const qreal &percentEquivalent); + + qreal minPercent() const; + void setMinPercent(const qreal &minPercent); + + bool rateable() const; + void setRateable(bool rateable); + + int panelColumn() const; + void setPanelColumn(int panelColumn); + + int panelRow() const; + void setPanelRow(int panelRow); + + virtual const QHash getRelations() const override; + virtual InheritanceStrategy getInheritanceStrategy() const override { return InheritanceStrategy::PER_CLASS_TABLE; } + + + static bool lessThanPercent(const QSharedPointer &a, const QSharedPointer &b); + +protected: + QSharedPointer m_ratingMarkSystem; + QString m_symbol; + qreal m_valueEquivalent; + qreal m_minValue; + qreal m_percentEquivalent; + qreal m_minPercent; + bool m_rateable; + int m_panelColumn; + int m_panelRow; +}; + +#endif // RATINGMARKDEFINITION_H diff --git a/samples/simple/ratingmarkincident.cpp b/samples/simple/ratingmarkincident.cpp new file mode 100644 index 0000000..21b132c --- /dev/null +++ b/samples/simple/ratingmarkincident.cpp @@ -0,0 +1,94 @@ +#include "ratingmarkincident.h" + +RatingMarkIncident::RatingMarkIncident() +{ + +} + +QString RatingMarkIncident::symbol() const +{ + return m_symbol; +} + +void RatingMarkIncident::setSymbol(const QString &symbol) +{ + m_symbol = symbol; +} + +qreal RatingMarkIncident::value() const +{ + return m_value; +} + +void RatingMarkIncident::setValue(const qreal &value) +{ + m_value = value; +} + +qreal RatingMarkIncident::percentValue() const +{ + return m_percentValue; +} + +void RatingMarkIncident::setPercentValue(const qreal &percentValue) +{ + m_percentValue = percentValue; +} + +qreal RatingMarkIncident::weight() const +{ + return m_weight; +} + +void RatingMarkIncident::setWeight(const qreal &weight) +{ + m_weight = weight; +} + +bool RatingMarkIncident::rateable() const +{ + return m_rateable; +} + +void RatingMarkIncident::setRateable(bool rateable) +{ + m_rateable = rateable; +} + +QSharedPointer RatingMarkIncident::occasion() const +{ + return m_occasion; +} + +void RatingMarkIncident::setOccasion(const QSharedPointer &occasion) +{ + m_occasion = occasion; +} + +const QHash RatingMarkIncident::getRelations() const +{ + auto hash = Incident::getRelations(); + hash.insert("occasion",Relation("occasion",CuteEntityManager::RelationType::MANY_TO_ONE)); + hash.insert("ratingMarkSystem", Relation("ratingMarkSystem",RelationType::MANY_TO_ONE)); + return hash; +} + +QSharedPointer RatingMarkIncident::ratingMarkSystem() const +{ + return m_ratingMarkSystem; +} + +void RatingMarkIncident::setRatingMarkSystem(const QSharedPointer &ratingMarkSystem) +{ + m_ratingMarkSystem = ratingMarkSystem; +} + +bool RatingMarkIncident::signatureNeeded() const +{ + return m_signatureNeeded; +} + +void RatingMarkIncident::setSignatureNeeded(bool signatureNeeded) +{ + m_signatureNeeded = signatureNeeded; +} diff --git a/samples/simple/ratingmarkincident.h b/samples/simple/ratingmarkincident.h new file mode 100644 index 0000000..b649a0f --- /dev/null +++ b/samples/simple/ratingmarkincident.h @@ -0,0 +1,69 @@ +#ifndef RATINGMARKINCIDENT_H +#define RATINGMARKINCIDENT_H + +#include + +#include "incident.h" +#include "occasion.h" +#include "ratingmarksystem.h" + +class AppData; +class RatingMarkIncident : public Incident +{ + Q_OBJECT + EM_MACRO(RatingMarkIncident) + Q_PROPERTY(QString symbol READ symbol WRITE setSymbol) + Q_PROPERTY(qreal value READ value WRITE setValue) + Q_PROPERTY(qreal percentValue READ percentValue WRITE setPercentValue) + Q_PROPERTY(qreal weight READ weight WRITE setWeight) + Q_PROPERTY(bool rateable READ rateable WRITE setRateable) + Q_PROPERTY(bool signatureNeeded READ signatureNeeded WRITE setSignatureNeeded) + Q_PROPERTY(QSharedPointer occasion READ occasion WRITE setOccasion) + // ratingMarkSystem scheint auf den ersten Blick ein Duplikat zu sein, da man es aus AppData + // (zu AppRatingData gecastet) ermitteln könnte. In der TimeMachine ist es jedoch wichtig, dass + // bei einem für die App geänderten RatingMarkSystem ein alter RatingMarkIncident noch sein + // ursprüngliches RatingMarkSystem kennt. + Q_PROPERTY(QSharedPointer ratingMarkSystem READ ratingMarkSystem WRITE setRatingMarkSystem) +public: + Q_INVOKABLE RatingMarkIncident(); + + QString symbol() const; + void setSymbol(const QString &symbol); + + qreal value() const; + void setValue(const qreal &value); + + qreal percentValue() const; + void setPercentValue(const qreal &percentValue); + + qreal weight() const; + void setWeight(const qreal &weight); + + bool rateable() const; + void setRateable(bool rateable); + + QSharedPointer occasion() const; + void setOccasion(const QSharedPointer &occasion); + + virtual const QHash getRelations() const override; + virtual InheritanceStrategy getInheritanceStrategy() const override { return InheritanceStrategy::PER_CLASS_TABLE; } + + + QSharedPointer ratingMarkSystem() const; + void setRatingMarkSystem(const QSharedPointer &ratingMarkSystem); + + bool signatureNeeded() const; + void setSignatureNeeded(bool signatureNeeded); + +protected: + QString m_symbol = QString(); + qreal m_value = 0; + qreal m_percentValue = 0; + qreal m_weight = 1; + bool m_rateable = true; + bool m_signatureNeeded = false; + QSharedPointer m_occasion = QSharedPointer(); + QSharedPointer m_ratingMarkSystem = QSharedPointer(); +}; + +#endif // RATINGMARK_H diff --git a/samples/simple/ratingmarksystem.cpp b/samples/simple/ratingmarksystem.cpp new file mode 100644 index 0000000..6a82dc0 --- /dev/null +++ b/samples/simple/ratingmarksystem.cpp @@ -0,0 +1,273 @@ +#include "ratingmarksystem.h" +#include "ratingmarkincident.h" +#include "occasion.h" + +#include +#include + +RatingMarkSystem::RatingMarkSystem() +{ + +} + +QString RatingMarkSystem::name() const +{ + return m_name; +} + +void RatingMarkSystem::setName(const QString &name) +{ + m_name = name; +} + +QList > RatingMarkSystem::ratingMarkDefinitions() const +{ + return m_ratingMarkDefinitions; +} + +void RatingMarkSystem::setRatingMarkDefinitions(const QList > &ratingMarkDefinitions) +{ + m_ratingMarkDefinitions = ratingMarkDefinitions; +} + +bool RatingMarkSystem::valuesComputable() const +{ + return m_valuesComputable; +} + +void RatingMarkSystem::setValuesComputable(bool valuesComputable) +{ + m_valuesComputable = valuesComputable; +} + +bool RatingMarkSystem::higherValueBetter() const +{ + return m_higherValueBetter; +} + +void RatingMarkSystem::setHigherValueBetter(bool value) +{ + m_higherValueBetter = value; +} + +int RatingMarkSystem::digits() const +{ + return m_digits; +} + +void RatingMarkSystem::setDigits(int value) +{ + m_digits = value; +} + +const QHash RatingMarkSystem::getRelations() const +{ + auto hash = Incident::getRelations(); + hash.insert("ratingMarkDefinitions",Relation("ratingMarkDefinitions",CuteEntityManager::RelationType::ONE_TO_MANY,QString("ratingMarkSystem"))); + + return hash; +} + +QSharedPointer RatingMarkSystem::ratingMarkDefinitionAtPanelPosition(int col, int row) +{ + for (int i = 0; i < this->ratingMarkDefinitions().count(); i++) { + QSharedPointer rmd = this->ratingMarkDefinitions().at(i); + if (rmd->panelColumn() == col) { + if (rmd->panelRow() == row) { + return rmd; + } + } + } + return QSharedPointer(); +} + +int RatingMarkSystem::panelColumns() const +{ + return m_panelColumns; +} + +void RatingMarkSystem::setPanelColumns(int panelColumns) +{ + m_panelColumns = panelColumns; +} + +int RatingMarkSystem::panelRows() const +{ + return m_panelRows; +} + +void RatingMarkSystem::setPanelRows(int panelRows) +{ + m_panelRows = panelRows; +} + +bool RatingMarkSystem::lessThanPercent(const QSharedPointer &a, const QSharedPointer &b) +{ + return a->percentValue() < b->percentValue(); +} +bool RatingMarkSystem::moreThanPercent(const QSharedPointer &a, const QSharedPointer &b) +{ + return a->percentValue() > b->percentValue(); +} +bool RatingMarkSystem::lessThanValue(const QSharedPointer &a, const QSharedPointer &b) +{ + return a->value() < b->value(); +} +bool RatingMarkSystem::moreThanValue(const QSharedPointer &a, const QSharedPointer &b) +{ + return a->value() > b->value(); +} +QList > RatingMarkSystem::sortPercent(QList > list, Qt::SortOrder sortOrder) +{ + if (sortOrder == Qt::AscendingOrder) { + std::sort(list.begin(),list.end(),RatingMarkSystem::lessThanPercent); + } else { + std::sort(list.begin(),list.end(),RatingMarkSystem::moreThanPercent); + } + return list; +} + +QList > RatingMarkSystem::sortValue(QList > list, Qt::SortOrder sortOrder) +{ + if (sortOrder == Qt::AscendingOrder) { + std::sort(list.begin(),list.end(),RatingMarkSystem::lessThanValue); + } else { + std::sort(list.begin(),list.end(),RatingMarkSystem::moreThanValue); + } + return list; +} + +bool RatingMarkSystem::shallBeCalculated(QSharedPointer inc, QSharedPointer occasion, bool respectRateabilityProperty) { + if (!occasion.isNull() && (occasion != inc->occasion())) { + return false; + } + if (respectRateabilityProperty && !inc->rateable()) { + return false; + } + return true; + +} + +qreal RatingMarkSystem::averageSomeFloatProperty(QList > list, + QString propertyName, + QSharedPointer occasion, + int digits, + Enums::RoundingOption rounding, + bool respectWeight, + bool respectRateabilityProperty) +{ + qreal sum = 0; + qreal weightSum = 0; + QListIterator > iter(list); + bool ok = true; + + while (ok && iter.hasNext()) { + QSharedPointer inc = iter.next(); + qreal addValue; + QVariant var = inc->getProperty(propertyName); + if (var.isValid() && !var.isNull()) { + addValue = var.toFloat(&ok); + if (!ok) { + qDebug()<<"RatingMarkSystem::averageSomeFloatProperty: Float conversion of "<shallBeCalculated(inc, occasion, respectRateabilityProperty)) { + qreal weight = respectWeight ? inc->weight() : 1; + if (weight < -Enums::EPSILON_CALCULATION) { + ok = true; + } + sum += weight * addValue; + weightSum += weight; + } + } + Q_ASSERT(ok); + return !ok? -1 : ((qAbs(weightSum) < Enums::EPSILON_CALCULATION)? -1 : this->shortenNumber(sum / weightSum, digits, rounding)); +} + +qreal RatingMarkSystem::averagePercent(const QList > list, + QSharedPointer occasion, + int digits, + Enums::RoundingOption rounding, + bool respectWeight, + bool respectRateabilityProperty) +{ + return this->averageSomeFloatProperty(list,"percentValue", occasion, digits, rounding, respectWeight, respectRateabilityProperty); +} + +qreal RatingMarkSystem::averageValueSimple(QList > list, + QSharedPointer occasion, + int digits, + Enums::RoundingOption rounding, + bool respectWeight, + bool respectRateabilityProperty) +{ + return this->averageSomeFloatProperty(list,"value", occasion, digits, rounding, respectWeight, respectRateabilityProperty); +} + +qreal RatingMarkSystem::symbolToPercent(QString symbol) +{ + QListIterator>iter (this->ratingMarkDefinitions()); + bool found = false; + QSharedPointer def; + while (!found && iter.hasNext()) { + def = iter.next(); + if (def->symbol() == symbol) { + found = true; + } + } + return found? def->percentEquivalent() : -1; +} + +QString RatingMarkSystem::percentToSymbol(qreal percent) +{ + QListIterator>iter (this->ratingMarkDefinitions()); + QSharedPointer candidate; + while (iter.hasNext()) { + QSharedPointer def; + def = iter.next(); + if (def->minPercent() <= percent){ + if (candidate.isNull()) { + candidate = def; + } else { + if (def->minPercent() > candidate->minPercent()) { + candidate = def; + } + } + } + + } + return candidate.isNull()? QString() : candidate->symbol(); +} + +qreal RatingMarkSystem::shortenNumber(qreal nr, int digits, Enums::RoundingOption rounding) +{ + if (digits >= 0) { + int factor = 1; + if (digits > 0) { + factor = qPow(10, digits); + nr *= factor; + } + qDebug()<<"Factor: "< 0) { + nr /= factor; + } + } + return nr; +} + + + diff --git a/samples/simple/ratingmarksystem.h b/samples/simple/ratingmarksystem.h new file mode 100644 index 0000000..e20b98e --- /dev/null +++ b/samples/simple/ratingmarksystem.h @@ -0,0 +1,117 @@ +#ifndef RATINGMARKSYSTEM_H +#define RATINGMARKSYSTEM_H + +#include "ratingmarkdefinition.h" + +class RatingMarkIncident; +class Occasion; +//////////////////////////////////////////////// +/// \brief The RatingMarkSystem class +/// +/// A rating mark system defines a set of rating marks that are able +/// to evaluate the achievement of pupils. +/// Rating marks can base on numbers or plain symbols, they not have to +/// be equidistant, not even ordinal. +/// +/// "ratingMarkDefinitions" keeps the actual symbols, values and boundaries +/// +/// "valuesComputable" means that intermediate values can be calculated, +/// e.g. 1.3 and 1.0 could be averaged to a value of 1.15. +/// +/// "digits" states, how many digits after the decimal point are to be +/// kept and taken into calculation +/// +/// "higherValueBetter" is true for a system, where a higher value means +/// a better mark (greater achievement). +/// +/// "panelColumns" and "panelRows" give QML information about the layout of the input panel for this system + +class RatingMarkSystem : public Incident +{ + Q_OBJECT + EM_MACRO(RatingMarkSystem) + Q_PROPERTY(QList> ratingMarkDefinitions READ ratingMarkDefinitions WRITE setRatingMarkDefinitions) + Q_PROPERTY(QString name READ name WRITE setName) + Q_PROPERTY(bool valuesComputable READ valuesComputable WRITE setValuesComputable) + Q_PROPERTY(int digits READ digits WRITE setDigits) + Q_PROPERTY(bool higherValueBetter READ higherValueBetter WRITE setHigherValueBetter) + Q_PROPERTY(int panelColumns READ panelColumns WRITE setPanelColumns) + Q_PROPERTY(int panelRows READ panelRows WRITE setPanelRows) +public: + Q_INVOKABLE RatingMarkSystem(); + + + QString name() const; + void setName(const QString &name); + + QList > ratingMarkDefinitions() const; + void setRatingMarkDefinitions(const QList > &ratingMarkDefinitions); + + bool valuesComputable() const; + void setValuesComputable(bool valuesComputable); + + bool higherValueBetter() const; + void setHigherValueBetter(bool value); + + int digits() const; + void setDigits(int value); + + virtual const QHash getRelations() const override; + virtual InheritanceStrategy getInheritanceStrategy() const override { return InheritanceStrategy::PER_CLASS_TABLE; } + + + QSharedPointerratingMarkDefinitionAtPanelPosition(int col, int row); + + int panelColumns() const; + void setPanelColumns(int panelColumns); + + int panelRows() const; + void setPanelRows(int panelRows); + + static bool lessThanPercent(const QSharedPointer &a, const QSharedPointer &b); + static bool moreThanPercent(const QSharedPointer &a, const QSharedPointer &b); + static bool lessThanValue(const QSharedPointer &a, const QSharedPointer &b); + static bool moreThanValue(const QSharedPointer &a, const QSharedPointer &b); + virtual QList> sortPercent(QList> list, Qt::SortOrder sortOrder); + virtual QList> sortValue(QList> list, Qt::SortOrder sortOrder); + + + virtual qreal averagePercent(QList> list, + QSharedPointer occasion, + int digits = -1, + Enums::RoundingOption rounding = Enums::RoundingOption::ROUND, + bool respectWeight = true, + bool respectRateabilityProperty = true); + virtual qreal averageValueSimple(QList> list, + QSharedPointer occasion, + int digits = -1, + Enums::RoundingOption rounding = Enums::RoundingOption::ROUND, + bool respectWeight = true, + bool respectRateabilityProperty = true); + virtual bool shallBeCalculated(QSharedPointer inc, + QSharedPointer occasion, + bool respectRateabilityProperty = true); + + + qreal symbolToPercent(QString symbol); + QString percentToSymbol(qreal percent); + qreal shortenNumber(qreal nr, int digits, Enums::RoundingOption rounding); +protected: + qreal averageSomeFloatProperty(QList> list, + QString propertyName, + QSharedPointer occasion, + int digits = -1, + Enums::RoundingOption rounding = Enums::RoundingOption::ROUND, + bool respectWeight = true, + bool respectRateabilityProperty = true); + + QString m_name; + QList> m_ratingMarkDefinitions; + bool m_valuesComputable = false; + bool m_higherValueBetter = true; + int m_digits = -1; + int m_panelColumns = -1; + int m_panelRows = -1; +}; + +#endif // RATINGMARKSYSTEM_H diff --git a/samples/simple/simple.pro b/samples/simple/simple.pro index 4ea8f88..4414fdc 100644 --- a/samples/simple/simple.pro +++ b/samples/simple/simple.pro @@ -15,8 +15,29 @@ CONFIG -= app_bundle TEMPLATE = app HEADERS += \ - article.h + ratingmarkincident.h \ + incident.h \ + ratingmarksystem.h \ + ratingmarkdefinition.h \ + enums.h \ + occasion.h \ + datacreation.h \ + address.h \ + contact.h \ + group.h \ + person.h \ + pupil.h SOURCES += \ main.cpp \ - article.cpp + ratingmarkincident.cpp \ + incident.cpp \ + ratingmarksystem.cpp \ + ratingmarkdefinition.cpp \ + occasion.cpp \ + datacreation.cpp \ + address.cpp \ + contact.cpp \ + group.cpp \ + person.cpp \ + pupil.cpp