Merge branch 'persistence' into 'development'

merge persistence to development See merge request !1

Merge branch 'persistence' into 'development'
merge persistence to development See merge request !1
Stephan Hausdörfer
2 parents aa62787f 896a9c92
Showing 28 changed files with 1118 additions and 4 deletions
.gitignore
docker/docker-compose.yml
docker/postgres/volumes/logs/README.md
docker/wildfly/Dockerfile
docker/wildfly/standalone.xml
docker/wildfly/volumes/modules/org/postgres/main/module.xml
docker/wildfly/volumes/modules/org/postgres/main/postgresql-42.1.4.jar
services/Common/build.gradle
services/Common/src/main/java/de/bht/beuthbot/daos/AppUserDAO.java
services/Common/src/main/java/de/bht/beuthbot/daos/AppUserDAOImpl.java
services/Common/src/main/java/de/bht/beuthbot/daos/GenericDAO.java
services/Common/src/main/java/de/bht/beuthbot/daos/GenericHibernateDAO.java
services/Common/src/main/java/de/bht/beuthbot/model/entities/AppUser.java
services/Common/src/main/java/de/bht/beuthbot/model/entities/AppUserImpl.java
services/Common/src/main/java/de/bht/beuthbot/model/entities/EntityBase.java
services/Common/src/main/java/de/bht/beuthbot/model/entities/EntityBaseImpl.java
services/Common/src/main/java/de/bht/beuthbot/model/entities/GenericEntity.java
services/Common/src/main/java/de/bht/beuthbot/model/entities/GenericEntityAttribute.java
services/Common/src/main/java/de/bht/beuthbot/model/entities/GenericEntityAttributeValue.java
services/Common/src/main/java/de/bht/beuthbot/persistence/ExtendedPostgreSQLDialect.java
@@ -14,10 +14,13 @@ hs_err_pid*
 # Logfiles
 **.log
 **.log.*
+docker/wildfly/volumes/logs/
  
 **/.DS_Store
 .idea
 .gradle
 bht-chatbot.iml
+BeuthBot.iml
 target/
 build
+out
@@ -9,13 +9,20 @@ services:
       - "8080:8080"
       - "8787:8787"
       - "9990:9990"
+    environment:
+          POSTGRES_USER: beuthbot_app
+          POSTGRES_PASSWORD: VhS7WPVpdYEHYLpf
+          POSTGRES_DB: beuthbot
     volumes:
       - ./wildfly/volumes/deployments/:/opt/jboss/wildfly/standalone/deployments/
       - ./wildfly/volumes/logs/:/opt/jboss/wildfly/standalone/log/
       - ./wildfly/volumes/conf/:/opt/jboss/wildfly/standalone/conf/
+      - ./wildfly/volumes/modules/org/postgres/main/:/opt/jboss/wildfly/modules/org/postgres/main/
     links:
       - rasa-server
+      - postgres-db
     command: /opt/jboss/wildfly/bin/standalone.sh -b 0.0.0.0 -bmanagement 0.0.0.0 --debug
+
   rasa-server:
     build: ./rasa_nlu
     container_name: rasa_nlu
@@ -25,4 +32,22 @@ services:
     volumes:
       - ./rasa_nlu/volumes/data/api/:/app/data/api
       - ./rasa_nlu/volumes/logs/:/app/logs/
-    command: python -m rasa_nlu.server -c config/chatbot_config.json --server_model_dirs=default
 \ No newline at end of file
+    command: python -m rasa_nlu.server -c config/chatbot_config.json --server_model_dirs=default
+
+  postgres-db:
+    image: postgres
+    ports:
+      - "5432:5432"
+    command: postgres -c logging_collector=on -c log_destination=stderr -c log_directory=/logs
+    environment:
+      POSTGRES_USER: beuthbot_app
+      POSTGRES_PASSWORD: VhS7WPVpdYEHYLpf
+      POSTGRES_DB: beuthbot
+    volumes:
+      - ./postgres/volumes/logs:/logs
+
+  adminer:
+    container_name: adminer_dbmanagement
+    image: adminer
+    ports:
+      - "8081:8080"
 \ No newline at end of file
+## Log Directory
+This is the log directory which will be mounted into the docker postgres container.
 \ No newline at end of file
 FROM jboss/wildfly:10.1.0.Final
 RUN /opt/jboss/wildfly/bin/add-user.sh admin Admin
-COPY standalone.xml /opt/jboss/wildfly/standalone/configuration/standalone.xml
 \ No newline at end of file
+COPY standalone.xml /opt/jboss/wildfly/standalone/configuration/standalone.xml
+
+
+#USER root
+
+#ADD modules/org/postgres/main/postgresql-42.1.4.jar /opt/jboss/wildfly/modules/org/postgres/main/postgresql-42.1.4.jar
+#ADD modules/org/postgres/main/module.xml /opt/jboss/wildfly/modules/org/postgres/main/module.xml
 \ No newline at end of file
@@ -161,7 +161,7 @@
                     <managed-scheduled-executor-service name="default" jndi-name="java:jboss/ee/concurrency/scheduler/default" context-service="default" hung-task-threshold="60000" keepalive-time="3000"/>
                 </managed-scheduled-executor-services>
             </concurrent>
-            <default-bindings context-service="java:jboss/ee/concurrency/context/default" datasource="java:jboss/datasources/ExampleDS" jms-connection-factory="java:jboss/DefaultJMSConnectionFactory" managed-executor-service="java:jboss/ee/concurrency/executor/default" managed-scheduled-executor-service="java:jboss/ee/concurrency/scheduler/default" managed-thread-factory="java:jboss/ee/concurrency/factory/default"/>
+            <default-bindings context-service="java:jboss/ee/concurrency/context/default" datasource="java:jboss/datasources/PostgreSQLDS" jms-connection-factory="java:jboss/DefaultJMSConnectionFactory" managed-executor-service="java:jboss/ee/concurrency/executor/default" managed-scheduled-executor-service="java:jboss/ee/concurrency/scheduler/default" managed-thread-factory="java:jboss/ee/concurrency/factory/default"/>
         </subsystem>
         <subsystem xmlns="urn:jboss:domain:ejb3:4.0">
             <session-bean>
@@ -417,6 +417,40 @@
             <client-config name="Standard-Client-Config"/>
         </subsystem>
         <subsystem xmlns="urn:jboss:domain:weld:3.0"/>
+
+        <subsystem xmlns="urn:jboss:domain:datasources:2.0">
+            <datasources>
+                <datasource jta="true" jndi-name="java:jboss/datasources/PostgreSQLDS" pool-name="PostgreSQLDS" enabled="true" use-java-context="true">
+                    <connection-url>jdbc:postgresql://postgres-db:5432/beuthbot</connection-url>
+                    <connection-property name="url">jdbc:postgresql://postgres-db:5432/beuthbot</connection-property>
+                    <connection-property name="databaseName">beuthbot</connection-property>
+                    <driver>postgresql</driver>
+                    <security>
+                        <user-name>beuthbot_app</user-name>
+                        <password>VhS7WPVpdYEHYLpf</password>
+                    </security>
+                    <pool>
+                        <min-pool-size>5</min-pool-size>
+                        <initial-pool-size>5</initial-pool-size>
+                        <max-pool-size>100</max-pool-size>
+                        <prefill>true</prefill>
+                    </pool>
+                    <validation>
+                        <valid-connection-checker class-name="org.jboss.jca.adapters.jdbc.extensions.postgres.PostgreSQLValidConnectionChecker"/>
+                        <exception-sorter class-name="org.jboss.jca.adapters.jdbc.extensions.postgres.PostgreSQLExceptionSorter"/>
+                    </validation>
+                </datasource>
+
+                <drivers>
+                    <driver name="postgresql" module="org.postgres">
+                        <driver-class>org.postgresql.Driver</driver-class>
+                        <xa-datasource-class>org.postgresql.xa.PGXADataSource</xa-datasource-class>
+                        <datasource-class>org.postgresql.ds.PGSimpleDataSource</datasource-class>
+                    </driver>
+                </drivers>
+            </datasources>
+        </subsystem>
+
     </profile>
  
     <interfaces>
+<?xml version="1.0" encoding="UTF-8"?>
+<module xmlns="urn:jboss:module:1.1" name="org.postgres">
+    <resources>
+        <!--https://jdbc.postgresql.org/download.html-->
+        <resource-root path="postgresql-42.1.4.jar"/>
+    </resources>
+    <dependencies>
+        <module name="javax.api"/>
+        <module name="javax.transaction.api"/>
+        <module name="javax.servlet.api" optional="true"/>
+    </dependencies>
+</module>
 \ No newline at end of file
@@ -9,6 +9,12 @@ dependencies {
     compile "org.jboss.spec:jboss-javaee-7.0:1.1.0.Final",
             "com.google.code.gson:gson:2.8.1",
             "org.slf4j:slf4j-api:1.7.25"
+
+    compile group: 'org.postgresql', name: 'postgresql', version: '9.3-1100-jdbc4'
+    compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.0.1'
+
+    compileOnly group: 'org.hibernate', name: 'hibernate-core', version: '5.2.12.Final'
+    compileOnly group: 'org.hibernate', name: 'hibernate-entitymanager', version: '4.3.6.Final'
 }
  
 sourceCompatibility = 1.8
 \ No newline at end of file
+package de.bht.beuthbot.daos;
+
+import de.bht.beuthbot.model.entities.AppUser;
+
+import javax.ejb.Remote;
+
+/**
+ * Created by Benjamin Rühl on 19.12.2017.
+ */
+@Remote
+public interface AppUserDAO extends GenericDAO<AppUser, Long> {
+
+    AppUser createUser();
+}
+package de.bht.beuthbot.daos;
+
+import de.bht.beuthbot.model.entities.AppUserImpl;
+import de.bht.beuthbot.model.entities.AppUser;
+
+import javax.ejb.Stateless;
+
+/**
+ * Created by Benjamin Rühl on 19.12.2017.
+ */
+@Stateless
+public class AppUserDAOImpl extends GenericHibernateDAO<AppUser, AppUserImpl, Long> implements AppUserDAO {
+
+    @Override
+    public AppUser createUser() {
+        return new AppUserImpl();
+    }
+}
+package de.bht.beuthbot.daos;
+
+import de.bht.beuthbot.model.entities.EntityBase;
+
+import javax.ejb.Remote;
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * Created by Benjamin Rühl on 19.12.2017.
+ */
+@Remote
+public interface GenericDAO<T extends EntityBase, ID extends Serializable> {
+
+    T findById(ID id);
+
+    List<T> findAll();
+
+    T saveOrUpdate(T entity);
+
+    void delete(T entity);
+}
+package de.bht.beuthbot.daos;
+
+import de.bht.beuthbot.model.entities.EntityBase;
+
+import javax.annotation.PostConstruct;
+import javax.ejb.Stateless;
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.PersistenceContext;
+import javax.persistence.PersistenceUnit;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+import java.io.Serializable;
+import java.lang.reflect.ParameterizedType;
+import java.util.List;
+
+/**
+ * Created by Benjamin Rühl on 19.12.2017.
+ * Base class for DAO implementations using hibernate for persistence.
+ * Provides generic functionality for interaction with entities.
+ * @param <I>  Interface type of entity class
+ * @param <T>  Implementation type of entity class
+ * @param <ID> Type of entity's primary id
+ */
+@Stateless
+public class GenericHibernateDAO<I extends EntityBase, T extends I, ID extends Serializable> implements GenericDAO<I, ID> {
+
+    private Class<T> entityClass;
+
+    @PersistenceUnit(unitName = "PostgresPU")
+    private EntityManagerFactory entityManagerFactory;
+
+    @PersistenceContext(unitName = "PostgresPU")
+    private EntityManager entityManager;
+
+    @SuppressWarnings("unchecked cast")
+    @PostConstruct
+    public void init() {
+        if (entityManager == null)
+            throw new RuntimeException("EntityManager must not be null");
+
+        entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[1];
+    }
+
+    public Class<T> getEntityClass() {
+        return entityClass;
+    }
+
+    @Override
+    public I findById(ID id) {
+        return entityManager.find(getEntityClass(), id);
+    }
+
+    @Override
+    public List<I> findAll() {
+        return findByCriteria();
+    }
+
+    @Override
+    public I saveOrUpdate(I entity) {
+        entityManager.merge(entity);
+        return entity;
+    }
+
+    @Override
+    public void delete(I entity) {
+        entityManager.remove(entity);
+    }
+
+    /**
+     * Use this inside subclasses as a convenience method.
+     */
+    protected List<I> findByCriteria(Predicate... restrictions) {
+        CriteriaBuilder builder = entityManager.getCriteriaBuilder();
+        CriteriaQuery<T> criteria = builder.createQuery(getEntityClass());
+        Root<T> criteriaRoot = criteria.from(getEntityClass());
+
+        criteria.select(criteriaRoot);
+        criteria.where(restrictions);
+
+        List<T> elements = entityManager.createQuery(criteria).getResultList();
+        return (List<I>) elements;
+    }
+
+    protected EntityManager getEntityManager() {
+        return entityManager;
+    }
+}
+package de.bht.beuthbot.model.entities;
+
+/**
+ * Created by Benjamin Rühl on 19.11.2017.
+ */
+public interface AppUser extends EntityBase {
+
+    void setFacebookUserId(String facebookUserId);
+    String getFacebookUserId();
+    void setTelegramUserId(String telegramUserId);
+    String getTelegramUserId();
+    <T extends Object> T getProperty(String propertyName, Class<T> propertyType);
+    void setProperty(String propertyName, Object propertyValue);
+}
+package de.bht.beuthbot.model.entities;
+
+import de.bht.beuthbot.persistence.GenericEntityAccessFacade;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+
+/**
+ * Created by Benjamin Rühl on 19.11.2017.
+ * Note: This class must not be named "User" except a different table name is provided.
+ * Postgres does not support creating a table named "user".
+ */
+@Entity
+@Table
+public class AppUserImpl extends EntityBaseImpl implements AppUser {
+
+    private String facebookUserId;
+
+    private String telegramUserId;
+
+    @OneToOne(cascade = CascadeType.ALL)
+    private GenericEntity additionalData;
+
+    //@Type(type = "JsonMapType")
+    //private Map<String, String> additionalData = new HashMap<>();
+
+    public AppUserImpl() {
+        additionalData = new GenericEntity();
+        additionalData.setName("User");
+    }
+
+    @Override
+    public String getFacebookUserId() {
+        return facebookUserId;
+    }
+
+    @Override
+    public String getTelegramUserId() {
+        return telegramUserId;
+    }
+
+    @Override
+    public <T> T getProperty(String propertyName, Class<T> propertyType) {
+        return GenericEntityAccessFacade.getAttribute(additionalData, propertyName, propertyType);
+    }
+
+    @Override
+    public void setProperty(String propertyName, Object propertyValue) {
+        GenericEntityAccessFacade.setAttribute(additionalData, propertyName, propertyValue);
+    }
+
+    //@Override
+    /*public <T extends Object> T getProperty(String propertyName, Class<T> propertyType) {
+        String propertyValue = additionalData.getOrDefault(propertyName, null);
+
+        if (propertyValue == null)
+            return null;
+
+        return (T) JsonHelper.fromJson(propertyValue, propertyType);
+    }*/
+
+    //@Override
+    /*public void setProperty(String propertyName, Object propertyValue) {
+        String valueAsJson = JsonHelper.toJson(propertyValue, propertyValue.getClass());
+        additionalData.put(propertyName, valueAsJson);
+    }*/
+
+    public void setFacebookUserId(String facebookUserId) {
+        this.facebookUserId = facebookUserId;
+    }
+
+    public void setTelegramUserId(String telegramUserId) {
+        this.telegramUserId = telegramUserId;
+    }
+}
+package de.bht.beuthbot.model.entities;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * Created by Benjamin Rühl on 19.11.2017.
+ */
+public interface EntityBase extends Serializable {
+
+    Long getId();
+
+    Date getCreationDate();
+
+    Date getUpdateDate();
+}
+package de.bht.beuthbot.model.entities;
+
+import de.bht.beuthbot.persistence.JsonMapUserType;
+
+import org.hibernate.annotations.TypeDef;
+
+import javax.persistence.*;
+import java.util.Date;
+import java.util.Objects;
+
+/**
+ * Created by Benjamin Rühl on 19.11.2017.
+ */
+@MappedSuperclass
+@Access(AccessType.FIELD)
+@TypeDef(name = "JsonMapType", typeClass = JsonMapUserType.class)
+public class EntityBaseImpl implements EntityBase {
+
+    @Id
+    @GeneratedValue
+    protected long id;
+
+    @Temporal(TemporalType.TIMESTAMP)
+    protected Date creationDate;
+
+    @Temporal(TemporalType.TIMESTAMP)
+    protected Date updateDate;
+
+    @PrePersist
+    protected void onCreate() {
+        creationDate = new Date();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        this.updateDate = new Date();
+    }
+
+    @Override
+    public Long getId() {
+        return null;
+    }
+
+    @Override
+    public Date getCreationDate() {
+        return creationDate;
+    }
+
+    @Override
+    public Date getUpdateDate() {
+        return updateDate;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+
+        if (obj == null)
+            return false;
+
+        if (obj.getClass() != getClass())
+            return false;
+
+        EntityBaseImpl other = (EntityBaseImpl)obj;
+
+        if (other.getId() == 0 && getId() == 0)
+            return super.equals(obj);
+
+        return Objects.equals(other.getId(), getId());
+    }
+
+    @Override
+    public int hashCode(){
+        return Objects.hash(id);
+    }
+}
+package de.bht.beuthbot.model.entities;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ * A generic container entity that holds references to a set of generic attributes which can be specified at runtime.
+ * Follows the Entity-Attribute-Value model of database design.
+ */
+@Entity
+@Table
+public class GenericEntity extends EntityBaseImpl {
+
+    /**
+     * name is not mandatory, but can help to identify the entity's purpose for the developer
+     */
+    private String name;
+
+    @OneToMany(cascade = CascadeType.ALL)
+    private List<GenericEntityAttribute> attributes = new ArrayList<>();
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<GenericEntityAttribute> getAttributes() {
+        return attributes;
+    }
+
+    public void setAttribute(GenericEntityAttribute attribute) {
+        List<GenericEntityAttribute> existingAttributesForName = this.attributes.stream().filter(a -> a.getName().equals(attribute.getName())).collect(Collectors.toList());
+
+        if (!existingAttributesForName.isEmpty())
+            getAttributes().removeAll(existingAttributesForName);
+
+        this.attributes.add(attribute);
+    }
+}
+package de.bht.beuthbot.model.entities;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.OneToMany;
+import javax.persistence.Table;
+import java.util.List;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ * An attribute of a generic entity that can be specified at runtime.
+ * Holds a collection of generic values.
+ */
+@Entity
+@Table
+public class GenericEntityAttribute extends EntityBaseImpl {
+
+    private String name;
+
+    @OneToMany(cascade = CascadeType.ALL)
+    private List<GenericEntityAttributeValue> values;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<GenericEntityAttributeValue> getValues() {
+        return values;
+    }
+
+    public void addValue(GenericEntityAttributeValue value) {
+        this.values.add(value);
+    }
+}
+package de.bht.beuthbot.model.entities;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ * The value of a generic attribute in supported data formats.
+ * Supports complex nested types using a reference to a generic sub entity.
+ */
+@Entity
+@Table
+public class GenericEntityAttributeValue extends EntityBaseImpl {
+
+    private Boolean valueAsBool;
+
+    private Long valueAsLong;
+
+    private Double valueAsDouble;
+
+    private String valueAsString;
+
+    @OneToOne(cascade = CascadeType.ALL)
+    private GenericEntity valueAsEntity;
+
+    public Boolean getValueAsBool() {
+        return valueAsBool;
+    }
+
+    public void setValueAsBool(boolean valueAsBool) {
+        this.valueAsBool = valueAsBool;
+    }
+
+    public Long getValueAsLong() {
+        return valueAsLong;
+    }
+
+    public void setValueAsLong(long valueAsLong) {
+        this.valueAsLong = valueAsLong;
+    }
+
+    public Double getValueAsDouble() {
+        return valueAsDouble;
+    }
+
+    public void setValueAsDouble(double valueAsDouble) {
+        this.valueAsDouble = valueAsDouble;
+    }
+
+    public String getValueAsString() {
+        return valueAsString;
+    }
+
+    public void setValueAsString(String valueAsString) {
+        this.valueAsString = valueAsString;
+    }
+
+    public GenericEntity getValueAsEntity() {
+        return valueAsEntity;
+    }
+
+    public void setValueAsEntity(GenericEntity valueAsEntity) {
+        this.valueAsEntity = valueAsEntity;
+    }
+}
+package de.bht.beuthbot.persistence;
+
+import org.hibernate.dialect.PostgreSQLDialect;
+
+import java.sql.Types;
+
+public class ExtendedPostgreSQLDialect extends PostgreSQLDialect {
+
+    public ExtendedPostgreSQLDialect(){
+        super();
+        registerHibernateType(Types.JAVA_OBJECT, "json");
+
+    }
+}
 \ No newline at end of file
+package de.bht.beuthbot.persistence;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+
+import de.bht.beuthbot.model.entities.GenericEntity;
+import de.bht.beuthbot.model.entities.GenericEntityAttribute;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ * Provides convenience methods for accessing GenericEntity structures
+ */
+public class GenericEntityAccessFacade {
+
+    public static <T> T getAttribute(GenericEntity contextEntity, String attributeName, Class<T> attributeType) {
+        List<GenericEntityAttribute> propertiesWithName = contextEntity.getAttributes().stream().filter(a -> a.getName().equals(attributeName)).limit(1).collect(Collectors.toList());
+
+        if (propertiesWithName == null || propertiesWithName.isEmpty())
+            return null;
+
+        GenericEntityAttribute property = propertiesWithName.get(0);
+
+        try {
+            String propertyAsJson = GenericEntityJsonConverter.toJson(property);
+            return (T) JsonHelper.fromJson(propertyAsJson, attributeType);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public static void setAttribute(GenericEntity contextEntity, String attributeName, Object attributeValue) {
+        String attributeValueAsJson = JsonHelper.toJson(attributeValue, attributeValue.getClass());
+
+        GenericEntityAttribute deserializedGenericAttribute = null;
+
+        try {
+            deserializedGenericAttribute = createGenericEntityAttributeFromJson(attributeValueAsJson);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        if (deserializedGenericAttribute == null)
+            return;
+
+        deserializedGenericAttribute.setName(attributeName);
+
+        contextEntity.setAttribute(deserializedGenericAttribute);
+    }
+
+    private static GenericEntityAttribute createGenericEntityAttributeFromJson(String json) throws IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        SimpleModule module = new SimpleModule();
+        module.addDeserializer(GenericEntity.class, new GenericEntityDeserializer());
+        module.addDeserializer(GenericEntityAttribute.class, new GenericEntityAttributeDeserializer());
+        mapper.registerModule(module);
+
+        return mapper.readValue(json, GenericEntityAttribute.class);
+    }
+}
+package de.bht.beuthbot.persistence;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+
+import de.bht.beuthbot.model.entities.GenericEntity;
+import de.bht.beuthbot.model.entities.GenericEntityAttribute;
+import de.bht.beuthbot.model.entities.GenericEntityAttributeValue;
+
+import javax.naming.OperationNotSupportedException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ */
+public class GenericEntityAttributeDeserializer extends StdDeserializer<GenericEntityAttribute> {
+
+    public GenericEntityAttributeDeserializer() {
+        this(GenericEntityAttribute.class);
+    }
+
+    public GenericEntityAttributeDeserializer(Class<? extends GenericEntityAttribute> t) {
+        super(t);
+    }
+
+    @Override
+    public GenericEntityAttribute deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
+        if (jp.isClosed())
+            return null;
+
+        GenericEntityAttribute deserializedAttribute = new GenericEntityAttribute();
+
+        JsonToken jsonToken = jp.getCurrentToken();
+
+        if (jsonToken.equals(JsonToken.FIELD_NAME)) {
+            String fieldName = jp.getCurrentName();
+            deserializedAttribute.setName(fieldName);
+
+            jsonToken = jp.nextToken();
+
+            if (jsonToken.equals(JsonToken.START_ARRAY)) {
+                try {
+                    for (GenericEntityAttributeValue attributeValue : readAttributeValuesUntilArrayEndToken(jp, ctxt)) {
+                        deserializedAttribute.addValue(attributeValue);
+                    }
+                } catch (OperationNotSupportedException e) {
+                    e.printStackTrace();
+                }
+            } else {
+                deserializedAttribute.addValue(readAttributeValueFromCurrentToken(jp, ctxt));
+            }
+        }
+
+        return deserializedAttribute;
+    }
+
+    private List<GenericEntityAttributeValue> readAttributeValuesUntilArrayEndToken(JsonParser jp, DeserializationContext ctxt) throws IOException, OperationNotSupportedException {
+        List<GenericEntityAttributeValue> attributes = new ArrayList<>();
+        JsonToken jsonToken = jp.getCurrentToken();
+
+        if (!jsonToken.equals(JsonToken.START_ARRAY))
+            throw new OperationNotSupportedException("Method should not be called if current token is not START_ARRAY");
+
+        while (!jp.isClosed() || jsonToken.equals(JsonToken.END_ARRAY)) {
+            jsonToken = jp.nextToken();
+            attributes.add(readAttributeValueFromCurrentToken(jp, ctxt));
+        }
+
+        return attributes;
+    }
+
+    private GenericEntityAttributeValue readAttributeValueFromCurrentToken(JsonParser jp, DeserializationContext ctxt) throws IOException {
+        GenericEntityAttributeValue attributeValue = new GenericEntityAttributeValue();
+        JsonToken jsonToken = jp.getCurrentToken();
+
+        if (jsonToken.equals(JsonToken.VALUE_FALSE) || jsonToken.equals(JsonToken.VALUE_TRUE)) {
+            attributeValue.setValueAsBool(jp.getBooleanValue());
+        } else if (jsonToken.equals(JsonToken.VALUE_NUMBER_INT)) {
+            attributeValue.setValueAsLong(jp.getLongValue());
+        } else if (jsonToken.equals(JsonToken.VALUE_NUMBER_FLOAT)) {
+            attributeValue.setValueAsDouble(jp.getFloatValue());
+        } else if (jsonToken.equals(JsonToken.VALUE_STRING)) {
+            attributeValue.setValueAsString(jp.getText());
+        } else if (jsonToken.equals(JsonToken.START_OBJECT)) {
+            GenericEntity embeddedEntity = new GenericEntityDeserializer().deserialize(jp, ctxt);
+            attributeValue.setValueAsEntity(embeddedEntity);
+        }
+
+        return attributeValue;
+    }
+}
+package de.bht.beuthbot.persistence;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+
+import de.bht.beuthbot.model.entities.GenericEntity;
+import de.bht.beuthbot.model.entities.GenericEntityAttribute;
+
+import java.io.IOException;
+
+/**
+ * Created by Benjamin Rühl on 23.12.2017.
+ */
+public class GenericEntityDeserializer extends StdDeserializer<GenericEntity> {
+
+    public GenericEntityDeserializer() {
+        this(GenericEntity.class);
+    }
+
+    public GenericEntityDeserializer(Class<? extends GenericEntity> t) {
+        super(t);
+    }
+
+    @Override
+    public GenericEntity deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
+        GenericEntity deserializedEntity = new GenericEntity();
+        GenericEntityAttributeDeserializer attributeDeserializer = new GenericEntityAttributeDeserializer();
+
+        while (!jp.isClosed()) {
+            JsonToken jsonToken = jp.nextToken();
+
+            if (jsonToken.equals(JsonToken.FIELD_NAME)) {
+                GenericEntityAttribute attribute = attributeDeserializer.deserialize(jp, ctxt);
+                deserializedEntity.setAttribute(attribute);
+            }
+        }
+
+        return deserializedEntity;
+    }
+}
 \ No newline at end of file
+package de.bht.beuthbot.persistence;
+
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonGenerator;
+
+import de.bht.beuthbot.model.entities.GenericEntity;
+import de.bht.beuthbot.model.entities.GenericEntityAttribute;
+import de.bht.beuthbot.model.entities.GenericEntityAttributeValue;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.lang.reflect.Field;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by Benjamin Rühl on 22.12.2017.
+ * Helper class to serialize GenericEntity as if its generic attributes were normal fields
+ */
+public class GenericEntityJsonConverter {
+
+    /**
+     * Serializes a GenericEntity to json as if its generic attributes were normal fields.
+     * Other normal fields are serialized as well.
+     * @param genericEntity the context entity to be serialized with all its sub structure
+     * @return a serialized string in json format
+     * @throws IOException
+     */
+    public static String toJson(GenericEntity genericEntity) throws IOException {
+        JsonFactory jFactory = new JsonFactory();
+        StringWriter writer = new StringWriter();
+        JsonGenerator jsonGenerator = jFactory.createJsonGenerator(writer);
+
+        jsonGenerator.writeStartObject();
+        writeGenericEntityWithoutStart(jsonGenerator, genericEntity);
+
+        jsonGenerator.close();
+        return writer.toString();
+    }
+
+    /**
+     * Serializes a GenericEntityAttribute to json as if it would be a normal field.
+     * @param genericAttribute the context attribute to be serialized with all its sub structure
+     * @return a serialized string in json format
+     * @throws IOException
+     */
+    public static String toJson(GenericEntityAttribute genericAttribute) throws IOException {
+        JsonFactory jFactory = new JsonFactory();
+        StringWriter writer = new StringWriter();
+        JsonGenerator jsonGenerator = jFactory.createJsonGenerator(writer);
+
+        writeGenericAttribute(jsonGenerator, genericAttribute);
+
+        jsonGenerator.close();
+        return writer.toString();
+    }
+
+    /**
+     * Uses a JsonGenerator to append a GenericEntity and its content to json.
+     * Does not open the json object because this part depends on whether the object stands for itself or is the value of a field.
+     * However it does close the object.
+     * @param jsonGenerator the generator used for building the json
+     * @param genericEntity the context entity that is serialized
+     * @throws IOException
+     */
+    private static void writeGenericEntityWithoutStart(JsonGenerator jsonGenerator, GenericEntity genericEntity) throws IOException {
+        writeClassFieldsWithoutGenericEntityHierarchy(jsonGenerator, genericEntity);
+
+        for (GenericEntityAttribute genericAttribute : genericEntity.getAttributes()) {
+            writeGenericAttribute(jsonGenerator, genericAttribute);
+        }
+
+        jsonGenerator.writeEndObject();
+    }
+
+    private static void writeGenericAttribute(JsonGenerator jsonGenerator, GenericEntityAttribute genericAttribute) throws IOException {
+        List<GenericEntityAttributeValue> attributeValues = genericAttribute.getValues();
+
+        if (attributeValues == null || attributeValues.isEmpty()) {
+            jsonGenerator.writeNullField(genericAttribute.getName());
+        } else if (attributeValues.size() == 1) {
+            writeGenericAttributeValue(jsonGenerator, genericAttribute.getValues().get(0), genericAttribute.getName());
+        } else {
+            writeGenericAttributeMultiValue(jsonGenerator, genericAttribute);
+        }
+    }
+
+    private static void writeGenericAttributeMultiValue(JsonGenerator jsonGenerator, GenericEntityAttribute genericAttribute) throws IOException {
+        jsonGenerator.writeArrayFieldStart(genericAttribute.getName());
+
+        for (GenericEntityAttributeValue genericValue : genericAttribute.getValues()) {
+            writeGenericAttributeValueInArray(jsonGenerator, genericValue);
+        }
+
+        jsonGenerator.writeEndArray();
+    }
+
+    private static void writeGenericAttributeValue(JsonGenerator jsonGenerator, GenericEntityAttributeValue genericAttributeValue, String attributeName) throws IOException {
+        if (genericAttributeValue.getValueAsBool() != null) {
+            jsonGenerator.writeBooleanField(attributeName, genericAttributeValue.getValueAsBool());
+        } else if (genericAttributeValue.getValueAsLong() != null) {
+            jsonGenerator.writeNumberField(attributeName, genericAttributeValue.getValueAsLong());
+        } else if (genericAttributeValue.getValueAsDouble() != null) {
+            jsonGenerator.writeNumberField(attributeName, genericAttributeValue.getValueAsDouble());
+        } else if (genericAttributeValue.getValueAsString() != null) {
+            jsonGenerator.writeStringField(attributeName, genericAttributeValue.getValueAsString());
+        } else if (genericAttributeValue.getValueAsEntity() != null) {
+            jsonGenerator.writeObjectFieldStart(attributeName);
+            writeGenericEntityWithoutStart(jsonGenerator, genericAttributeValue.getValueAsEntity());
+        }
+    }
+
+    private static void writeGenericAttributeValueInArray(JsonGenerator jsonGenerator, GenericEntityAttributeValue genericAttributeValue) throws IOException {
+        if (genericAttributeValue.getValueAsBool() != null) {
+            jsonGenerator.writeBoolean(genericAttributeValue.getValueAsBool());
+        } else if (genericAttributeValue.getValueAsLong() != null) {
+            jsonGenerator.writeNumber(genericAttributeValue.getValueAsLong());
+        } else if (genericAttributeValue.getValueAsDouble() != null) {
+            jsonGenerator.writeNumber(genericAttributeValue.getValueAsDouble());
+        } else if (genericAttributeValue.getValueAsString() != null) {
+            jsonGenerator.writeString(genericAttributeValue.getValueAsString());
+        } else if (genericAttributeValue.getValueAsEntity() != null) {
+            jsonGenerator.writeStartObject();
+            writeGenericEntityWithoutStart(jsonGenerator, genericAttributeValue.getValueAsEntity());
+        }
+    }
+
+    /**
+     * Uses a JsonGenerator to append all fields and their values of the targetObject to json.
+     * Ignores fields that have GenericEntity, GenericEntityAttribute or GenericEntityAttributeValue as type or generic list parameter.
+     * @throws IOException
+     */
+    private static void writeClassFieldsWithoutGenericEntityHierarchy(JsonGenerator jsonGenerator, Object targetObject) throws IOException {
+        for (Field field : targetObject.getClass().getFields()) {
+            if (isGenericEntityHierarchyType(field))
+                continue;
+
+            try {
+                jsonGenerator.writeObjectField(field.getName(), field.get(targetObject));
+            } catch (Exception e) {
+                jsonGenerator.writeStringField(field.getName(), e.getClass().getName());
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Determines whether the field's type is GenericEntity, GenericEntityAttribute or GenericEntityAttributeValue
+     * or a list type with one of those types as generic type parameter.
+     */
+    private static boolean isGenericEntityHierarchyType(Field field) {
+        List<Class> typesOfGenericEntityHierarchy = Arrays.asList(GenericEntity.class, GenericEntityAttribute.class, GenericEntityAttributeValue.class);
+
+        // check for list types
+        try {
+            if (Iterable.class.isAssignableFrom(field.getType())) {
+                Type fieldFirstGenericType = ((ParameterizedType)field.getGenericType()).getActualTypeArguments()[0];
+                if (typesOfGenericEntityHierarchy.contains(fieldFirstGenericType.getClass()))
+                    return true;
+            }
+        } catch (Exception e) {
+            // not a list or not generic
+        }
+
+        return typesOfGenericEntityHierarchy.contains(field.getType());
+    }
+}
+package de.bht.beuthbot.persistence;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+/**
+ * Created by Benjamin Rühl on 03.12.2017.
+ * A simple wrapper around the json serializer to make sure the same serializer is used across different classes
+ */
+public class JsonHelper {
+
+    private static final Gson gson = new GsonBuilder().serializeNulls().create();
+
+    public static Object fromJson(String json, Class sourceClass) {
+        return gson.fromJson(json, sourceClass);
+    }
+
+    public static String toJson(Object source, Class sourceClass) {
+        return gson.toJson(source, sourceClass);
+    }
+}
+package de.bht.beuthbot.persistence;
+
+import org.hibernate.HibernateException;
+import org.hibernate.engine.spi.SharedSessionContractImplementor;
+import org.hibernate.internal.util.compare.EqualsHelper;
+import org.hibernate.type.SerializationException;
+import org.hibernate.usertype.UserType;
+import org.postgresql.util.PGobject;
+
+import java.io.Serializable;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Created by Benjamin Rühl on 03.12.2017.
+ * Custom Hibernate UserType for mapping json typed columns in postgres to java maps
+ * @see <a href="http://vojtechruzicka.com/postgresqls-jsonb-type-mapping-using-hibernate/">vojtechruzicka.com</a>
+ */
+public class JsonMapUserType implements UserType {
+
+    @Override
+    public void nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session) throws HibernateException, SQLException {
+        if (value == null) {
+            st.setNull(index, Types.OTHER);
+        } else {
+            st.setObject(index, JsonHelper.toJson(value, Map.class), Types.OTHER);
+        }
+    }
+
+    @Override
+    public Object nullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws HibernateException, SQLException {
+        PGobject o = (PGobject) rs.getObject(names[0]);
+        if (o.getValue() != null) {
+            return JsonHelper.fromJson(o.getValue(), Map.class);
+        }
+
+        return new HashMap<String, String>();
+    }
+
+    @Override
+    public Object deepCopy(Object originalValue) throws HibernateException {
+        if (originalValue == null) {
+            return null;
+        }
+
+        if (!(originalValue instanceof Map)) {
+            return null;
+        }
+
+        Map<String, String> resultMap = new HashMap<>();
+
+        Map<?, ?> tempMap = (Map<?, ?>) originalValue;
+        tempMap.forEach((key, value) -> resultMap.put((String) key, (String) value));
+
+        return resultMap;
+    }
+
+    @Override
+    public Serializable disassemble(Object value) throws HibernateException {
+        Object copy = deepCopy(value);
+
+        if (copy instanceof Serializable) {
+            return (Serializable) copy;
+        }
+
+        throw new SerializationException(String.format("Cannot serialize '%s', %s is not Serializable.", value, value.getClass()), null);
+    }
+
+    @Override
+    public Object assemble(Serializable cached, Object owner) throws HibernateException {
+        return deepCopy(cached);
+    }
+
+    @Override
+    public Object replace(Object original, Object target, Object owner) throws HibernateException {
+        return deepCopy(original);
+    }
+
+    @Override
+    public boolean isMutable() {
+        return true;
+    }
+
+    @Override
+    public int hashCode(Object x) throws HibernateException {
+        if (x == null) {
+            return 0;
+        }
+
+        return x.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object x, Object y) throws HibernateException {
+        return EqualsHelper.equals(x, y);
+    }
+
+    @Override
+    public Class<?> returnedClass() {
+        return Map.class;
+    }
+
+    @Override
+    public int[] sqlTypes() {
+        return new int[]{Types.JAVA_OBJECT};
+    }
+}
+<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
+             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
+             http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
+             version="2.1">
+
+    <persistence-unit name="PostgresPU" transaction-type="JTA">
+
+        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+
+        <jta-data-source>java:jboss/datasources/PostgreSQLDS</jta-data-source>
+
+        <properties>
+
+            <!--<property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect"/>--> <!-- DB Dialect -->
+            <property name="hibernate.dialect" value="de.bht.beuthbot.persistence.ExtendedPostgreSQLDialect"/>
+            <!--<property name="hibernate.ejb.naming_strategy" value="org.hibernate.cfg.ImprovedNamingStrategy"/>-->
+            <property name="hibernate.hbm2ddl.auto" value="create-drop" /> <!-- create / create-drop / update / none -->
+            <property name="hibernate.archive.autodetection" value="class"/>
+
+            <property name="hibernate.show_sql" value="true" /> <!-- Show SQL in console -->
+            <property name="hibernate.format_sql" value="true" /> <!-- Show SQL formatted -->
+        </properties>
+
+    </persistence-unit>
+
+</persistence>
 \ No newline at end of file
@@ -13,7 +13,6 @@ dependencies {
             "org.apache.httpcomponents:httpclient:4.5.3",
             "commons-io:commons-io:2.5"
  
-
     providedCompile "org.slf4j:slf4j-api:1.7.25"
  
     testCompile "org.jboss.arquillian.junit:arquillian-junit-container:1.1.13.Final",