commit e2ee17bffaa48eb8775fe4a88dede9c836509a38
Author: Christian Ehringfeld <c.ehringfeld@t-online.de>
Date:   Sat Aug 8 23:07:30 2015 +0200

    validators

diff --git a/EntityManager.pro b/EntityManager.pro
index 15dfe15..9a0bf1b 100644
--- a/EntityManager.pro
+++ b/EntityManager.pro
@@ -30,7 +30,12 @@ src/entity.h \
     src/queryinterpreter.h \
     src/expression.h \
     src/orderby.h \
-    src/sqlitebackupprocessor.h
+    src/sqlitebackupprocessor.h \
+    src/validators/validator.h \
+    src/validators/param.h \
+    src/validators/errormsg.h \
+    src/validators/defaultvalidator.h \
+    src/validators/validatorfactory.h
 
 SOURCES += \
 src/entity.cpp \
@@ -54,7 +59,12 @@ src/entity.cpp \
     src/queryinterpreter.cpp \
     src/expression.cpp \
     src/orderby.cpp \
-    src/sqlitebackupprocessor.cpp
+    src/sqlitebackupprocessor.cpp \
+    src/validators/validator.cpp \
+    src/validators/param.cpp \
+    src/validators/errormsg.cpp \
+    src/validators/defaultvalidator.cpp \
+    src/validators/validatorfactory.cpp
 
 CONFIG += c++14
 QMAKE_CXXFLAGS += -std=c++14
diff --git a/src/entityinstancefactory.cpp b/src/entityinstancefactory.cpp
index dd5da82..350dba8 100644
--- a/src/entityinstancefactory.cpp
+++ b/src/entityinstancefactory.cpp
@@ -83,7 +83,7 @@ Entity *EntityInstanceFactory::setAttributes(Entity *&e,
                     }
                 } else {
                     qWarning() << prop.name() << "on Entity" << EntityHelper::getClassname(
-                                 e) << "not writeable!";
+                                   e) << "not writeable!";
                 }
             }
             ++iterator;
diff --git a/src/entityinstancefactory.h b/src/entityinstancefactory.h
index bf83f97..2ab6ea0 100644
--- a/src/entityinstancefactory.h
+++ b/src/entityinstancefactory.h
@@ -47,16 +47,19 @@ class EntityInstanceFactory {
     //http://www.mimec.org/node/350
     template<typename T>
     static void registerClass() {
-        EntityInstanceFactory::instance.insert( T::staticMetaObject.className(),
-                                                &constructorHelper<T> );
-        QString lName = "QList<QSharedPointer<";
-        lName.append(T::staticMetaObject.className());
-        lName.append(">>");
-        /**
-         * @brief qRegisterMetaType<QList<QSharedPointer<T> > >
-         * @todo would be great if we could remove this shit
-         */
-        qRegisterMetaType<QList<QSharedPointer<T>>>(lName.toLatin1().constData());
+        if (!EntityInstanceFactory::instance.contains(
+                    T::staticMetaObject.className())) {
+            EntityInstanceFactory::instance.insert( T::staticMetaObject.className(),
+                                                    &constructorHelper<T> );
+            QString lName = "QList<QSharedPointer<";
+            lName.append(T::staticMetaObject.className());
+            lName.append(">>");
+            /**
+             * @brief qRegisterMetaType<QList<QSharedPointer<T> > >
+             * @todo would be great if we could remove this shit
+             */
+            qRegisterMetaType<QList<QSharedPointer<T>>>(lName.toLatin1().constData());
+        }
     }
 
     static Entity *createObject( const QByteArray &className) {
diff --git a/src/validators/defaultvalidator.cpp b/src/validators/defaultvalidator.cpp
new file mode 100644
index 0000000..e4bbc7d
--- /dev/null
+++ b/src/validators/defaultvalidator.cpp
@@ -0,0 +1,13 @@
+#include "defaultvalidator.h"
+#include "validator.h"
+using namespace CuteEntityManager;
+DefaultValidator::DefaultValidator() : Validator() {
+}
+
+ErrorMsg DefaultValidator::validateParam(QVariant value, Param param) const {
+    if (value != param.getValue()) {
+        return ErrorMsg(param.getName(), "Default value not set");
+    }
+    return ErrorMsg();
+}
+
diff --git a/src/validators/defaultvalidator.h b/src/validators/defaultvalidator.h
new file mode 100644
index 0000000..0cf3707
--- /dev/null
+++ b/src/validators/defaultvalidator.h
@@ -0,0 +1,14 @@
+#ifndef DEFAULTVALIDATOR_H
+#define DEFAULTVALIDATOR_H
+#include "validator.h"
+namespace CuteEntityManager {
+class ErrorMsg;
+class DefaultValidator : public Validator {
+    Q_OBJECT
+  public:
+    DefaultValidator();
+    ErrorMsg validateParam(QVariant value, Param param) const final override;
+};
+}
+
+#endif // DEFAULTVALIDATOR_H
diff --git a/src/validators/errormsg.cpp b/src/validators/errormsg.cpp
new file mode 100644
index 0000000..1245020
--- /dev/null
+++ b/src/validators/errormsg.cpp
@@ -0,0 +1,37 @@
+#include "errormsg.h"
+using namespace CuteEntityManager;
+ErrorMsg::ErrorMsg() {
+}
+
+ErrorMsg::~ErrorMsg() {
+}
+
+ErrorMsg::ErrorMsg(QString param, QString errorMsg, QString propertyName) {
+    this->param = param;
+    this->errorMsg = errorMsg;
+    this->propertyName = propertyName;
+}
+
+QString ErrorMsg::getParam() const {
+    return param;
+}
+
+void ErrorMsg::setParam(const QString &value) {
+    param = value;
+}
+
+QString ErrorMsg::getPropertyName() const {
+    return propertyName;
+}
+
+void ErrorMsg::setPropertyName(const QString &value) {
+    propertyName = value;
+}
+
+QString ErrorMsg::getErrorMsg() const {
+    return errorMsg;
+}
+
+void ErrorMsg::setErrorMsg(const QString &value) {
+    errorMsg = value;
+}
diff --git a/src/validators/errormsg.h b/src/validators/errormsg.h
new file mode 100644
index 0000000..d5347ab
--- /dev/null
+++ b/src/validators/errormsg.h
@@ -0,0 +1,26 @@
+#ifndef ERRORMSG_H
+#define ERRORMSG_H
+#include <QString>
+namespace CuteEntityManager {
+class ErrorMsg {
+public:
+    ErrorMsg();
+    ~ErrorMsg();
+    ErrorMsg(QString param, QString errorMsg, QString propertyName = "");
+
+    QString getParam() const;
+    void setParam(const QString &value);
+
+    QString getPropertyName() const;
+    void setPropertyName(const QString &value);
+
+    QString getErrorMsg() const;
+    void setErrorMsg(const QString &value);
+
+private:
+    QString param;
+    QString propertyName;
+    QString errorMsg;
+};
+}
+#endif // ERRORMSG_H
diff --git a/src/validators/param.cpp b/src/validators/param.cpp
new file mode 100644
index 0000000..177f187
--- /dev/null
+++ b/src/validators/param.cpp
@@ -0,0 +1,31 @@
+#include "param.h"
+using namespace CuteEntityManager;
+
+Param::Param() {
+}
+
+Param::~Param() {
+}
+
+Param::Param(QString name, QVariant value) {
+    this->value = value;
+    this->name = name;
+}
+
+QVariant Param::getValue() const {
+    return value;
+}
+
+void Param::setValue(QVariant value) {
+    value = value;
+}
+
+QString Param::getName() const {
+    return name;
+}
+
+void Param::setName(const QString &value) {
+    name = value;
+}
+
+
diff --git a/src/validators/param.h b/src/validators/param.h
new file mode 100644
index 0000000..716112d
--- /dev/null
+++ b/src/validators/param.h
@@ -0,0 +1,24 @@
+#ifndef PARAM_H
+#define PARAM_H
+
+#include <QString>
+#include <QVariant>
+namespace CuteEntityManager {
+class Param {
+  public:
+    Param();
+    ~Param();
+    Param(QString name, QVariant value = QVariant());
+    QVariant getValue() const;
+    void setValue(QVariant value);
+
+    QString getName() const;
+    void setName(const QString &value);
+
+  private:
+    QVariant value;
+    QString name;
+};
+}
+
+#endif // PARAM_H
diff --git a/src/validators/validator.cpp b/src/validators/validator.cpp
new file mode 100644
index 0000000..c9a0d3f
--- /dev/null
+++ b/src/validators/validator.cpp
@@ -0,0 +1,45 @@
+#include "validator.h"
+#include "validatorfactory.h"
+using namespace CuteEntityManager;
+Validator::Validator() : QObject() {
+    ValidatorFactory::registerClasses();
+}
+
+Validator::~Validator() {
+}
+
+const QHash<QString, QString> Validator::builtInValidators() {
+    QHash<QString, QString> hash = QHash<QString, QString>();
+//    hash.insert("compare", "CompareValidator");
+    hash.insert("default", "DefaultValidator");
+//    hash.insert("email", "EmailValidator");
+//    hash.insert("exist", "ExistValidator");
+//    hash.insert("image", "ImageValidator");
+//    hash.insert("size", "SizeValidator");
+//    hash.insert("number", "NumberValidator");
+//    hash.insert("date", "DateValidator");
+//    hash.insert("required", "RequiredValidator");
+//    hash.insert("unique", "UniqueValidator");
+//    hash.insert("url", "UrlValidator");
+    return hash;
+}
+
+QList<ErrorMsg> Validator::validate(QVariant value, QList<Param> params) const {
+    QList<ErrorMsg> msgs = QList<ErrorMsg>();
+    for (int i = 0; i < params.size(); ++i) {
+        ErrorMsg msg = this->validateParam(value, params.at(i));
+        if (!msg.getErrorMsg().isEmpty()) {
+            msgs.append(msg);
+        }
+    }
+    return msgs;
+}
+
+QString Validator::generateErrorMsg(ErrorMsg msg) {
+    if (msg.getPropertyName().isEmpty()) {
+        //return tr(msg.getErrorMsg());
+        return msg.getErrorMsg();
+    }
+    //return tr(msg.getErrorMsg()).replace("<property>", msg.getPropertyName());
+    return msg.getErrorMsg().replace("<property>", msg.getPropertyName());
+}
diff --git a/src/validators/validator.h b/src/validators/validator.h
new file mode 100644
index 0000000..18e5c6e
--- /dev/null
+++ b/src/validators/validator.h
@@ -0,0 +1,22 @@
+#ifndef VALIDATOR_H
+#define VALIDATOR_H
+
+#include <QObject>
+#include <QHash>
+#include "param.h"
+#include "errormsg.h"
+namespace CuteEntityManager {
+class Validator : public QObject {
+    Q_OBJECT
+  public:
+    Validator();
+    virtual ~Validator();
+    static const QHash<QString, QString> builtInValidators();
+    virtual QList<ErrorMsg> validate(QVariant value, QList<Param> params) const;
+    QString generateErrorMsg(ErrorMsg msg);
+
+  protected:
+    virtual ErrorMsg validateParam(QVariant value, Param param) const = 0;
+};
+}
+#endif // VALIDATOR_H
diff --git a/src/validators/validatorfactory.cpp b/src/validators/validatorfactory.cpp
new file mode 100644
index 0000000..c742ec7
--- /dev/null
+++ b/src/validators/validatorfactory.cpp
@@ -0,0 +1,33 @@
+#include "validatorfactory.h"
+#include "defaultvalidator.h"
+using namespace CuteEntityManager;
+ValidatorFactory::ValidatorFactory() {
+}
+
+
+QHash<QByteArray, ValidatorFactory::Constructor> ValidatorFactory::instance =
+    QHash<QByteArray, ValidatorFactory::Constructor>();
+
+
+Validator *ValidatorFactory::createValidator(QString shortname) {
+    if (Validator::builtInValidators().contains(shortname)) {
+        return ValidatorFactory::createObject(shortname.toLatin1());
+    }
+    return nullptr;
+}
+
+void ValidatorFactory::registerClasses() {
+    if (ValidatorFactory::instance.isEmpty()) {
+//        Validator::registerClass<CompareValidator>();
+        ValidatorFactory::registerClass<DefaultValidator>();
+//        Validator::registerClass<EmailValidator>();
+//        Validator::registerClass<ExistValidator>();
+//        Validator::registerClass<ImageValidator>();
+//        Validator::registerClass<SizeValidator>();
+//        Validator::registerClass<NumberValidator>();
+//        Validator::registerClass<DateValidator>();
+//        Validator::registerClass<RequiredValidator>();
+//        Validator::registerClass<UniqueValidator>();
+//        Validator::registerClass<UrlValidator>();
+    }
+}
diff --git a/src/validators/validatorfactory.h b/src/validators/validatorfactory.h
new file mode 100644
index 0000000..bda0cd6
--- /dev/null
+++ b/src/validators/validatorfactory.h
@@ -0,0 +1,39 @@
+#ifndef VALIDATORFACTORY_H
+#define VALIDATORFACTORY_H
+#include <QString>
+#include <QHash>
+namespace CuteEntityManager {
+class Validator;
+class ValidatorFactory {
+  public:
+    static void registerClasses();
+    static Validator *createValidator(QString shortname);
+    template<typename T>
+    static void registerClass() {
+        if (!ValidatorFactory::instance.contains(
+                    T::staticMetaObject.className())) {
+            ValidatorFactory::instance.insert( T::staticMetaObject.className(),
+                                               &constructorHelper<T> );
+        }
+    }
+
+    static Validator *createObject( const QByteArray &className) {
+        Constructor constructor = ValidatorFactory::instance.value(className);
+        if ( constructor == nullptr ) {
+            return nullptr;
+        }
+        return (*constructor)();
+    }
+    typedef Validator *(*Constructor)();
+    template<typename T>
+    static Validator *constructorHelper() {
+        return new T();
+    }
+    static QHash<QByteArray, Constructor> instance;
+
+  protected:
+    ValidatorFactory();
+};
+}
+
+#endif // VALIDATORFACTORY_H