diff --git a/gemeinsamforschen/README.md b/gemeinsamforschen/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cc994934ffe760469d6db752161c9434d37dcf19
--- /dev/null
+++ b/gemeinsamforschen/README.md
@@ -0,0 +1,13 @@
+# Rocket Chat Configuration
+
+## Admin Account
+In `GFRocketChatConfig.java` add admin user account data.
+
+## Personal Access Token for API
+### Create non expiring access token
+Go to `Administration -> Allgemeines -> REST API -> Enable Personal Access Tokens to REST API` 
+
+### Manual Personal Access Token
+1. Click on your profile picture -> `Mein Konto` -> `Personal Access Token`
+1. add a new personal access token
+1. add it to configuration class `GFRocketChatConfig`
\ No newline at end of file
diff --git a/gemeinsamforschen/pom.xml b/gemeinsamforschen/pom.xml
index 4941332d713933926882edf406d6139722a8ee21..5b2bd52a6a6a796f086ffb07f3dfdb57a86ebab2 100644
--- a/gemeinsamforschen/pom.xml
+++ b/gemeinsamforschen/pom.xml
@@ -24,6 +24,7 @@
     <properties>
         <org.springframework.version>3.2.4.RELEASE</org.springframework.version>
         <jersey.version>2.6</jersey.version>
+        <jackson.version>2.9.4</jackson.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
@@ -106,25 +107,25 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
-            <version>2.4.5</version>
+            <version>${jackson.version}</version>
         </dependency>
 
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>2.4.5</version>
+            <version>${jackson.version}</version>
         </dependency>
 
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
-            <version>2.4.5</version>
+            <version>${jackson.version}</version>
         </dependency>
 
         <dependency>
             <groupId>com.fasterxml.jackson.jaxrs</groupId>
             <artifactId>jackson-jaxrs-json-provider</artifactId>
-            <version>2.4.5</version>
+            <version>${jackson.version}</version>
         </dependency>
 
         <dependency>
@@ -226,6 +227,21 @@
             <artifactId>commons-dbutils</artifactId>
             <version>1.7</version>
         </dependency>
+        <dependency>
+            <groupId>io.github.openunirest</groupId>
+            <artifactId>unirest-java</artifactId>
+            <version>2.4.02</version>
+        </dependency>
+        <dependency>
+            <groupId>io.github.openunirest</groupId>
+            <artifactId>object-mappers-jackson</artifactId>
+            <version>1.0.01</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.mail</groupId>
+            <artifactId>mail</artifactId>
+            <version>1.5.0-b01</version>
+        </dependency>
 
         <dependency>
             <groupId>eu.de-swaef.pdf</groupId>
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/config/Constants.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/Constants.java
deleted file mode 100644
index 125862780cbc50f02a1a8978b49f87eaacdeef3c..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/config/Constants.java
+++ /dev/null
@@ -1,6 +0,0 @@
-package unipotsdam.gf.config;
-
-public interface Constants {
-
-    String ROCKET_CHAT_URL = "http://rocketchat.westeurope.cloudapp.azure.com";
-}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFApplicationBinder.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFApplicationBinder.java
index f0307c3b2d614be8e8d11cd0b7dd7bb2678e9d50..21150f06a74b124c21b0ff9a3c827f60f2467a4a 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFApplicationBinder.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFApplicationBinder.java
@@ -31,10 +31,12 @@ import unipotsdam.gf.session.GFContexts;
 
 public class GFApplicationBinder extends AbstractBinder {
 
-
+    /**
+     * TODO replace DummyImplementation
+     */
     @Override
     protected void configure() {
-        bind(CommunicationDummyService.class).to(ICommunication.class);
+        bind(CommunicationService.class).to(ICommunication.class);
         bind(ManagementImpl.class).to(Management.class);
         bind(PeerAssessment.class).to(IPeerAssessment.class);
         bind(PhasesImpl.class).to(IPhases.class);
@@ -57,11 +59,15 @@ public class GFApplicationBinder extends AbstractBinder {
         bind(GroupDAO.class).to(GroupDAO.class);
         bind(TaskDAO.class).to(TaskDAO.class);
         bind(FeedbackImpl.class).to(Feedback.class);
+        bind(UnirestService.class).to(UnirestService.class);
 
         bindMore();
     }
 
     protected void bindMore() {
         bind(MysqlConnectImpl.class).to(MysqlConnect.class);
+        bind(MysqlConnect.class).to(MysqlConnect.class);
+        bind(GroupfindingImpl.class).to(IGroupFinding.class);
+        bind(UnirestService.class).to(UnirestService.class);
     }
 }
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFMailConfig.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFMailConfig.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b4665ac02639d461684f6369a9546d8ddf7c965
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFMailConfig.java
@@ -0,0 +1,9 @@
+package unipotsdam.gf.config;
+
+public class GFMailConfig {
+
+    public final static String SMTP_HOST = "";
+    public final static String SMTP_PORT = "";
+    public final static String SMTP_USERNAME = "";
+    public final static String SMTP_PASSWORD = "";
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFRocketChatConfig.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFRocketChatConfig.java
index feac0c4e9926ffabdf27fad4ff2c1620d8b0b680..2397889ea1002864cb3e5970773ad4d368aa8deb 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFRocketChatConfig.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFRocketChatConfig.java
@@ -1,8 +1,20 @@
 package unipotsdam.gf.config;
 
+import unipotsdam.gf.core.management.user.User;
+
 public class GFRocketChatConfig {
 
-    public static final String ROCKET_CHAT_LINK = "https://rocket.farm.uni-potsdam.de/";
-    public static final String ADMIN_USERNAME = "";
-    public static final String ADMIN_PASSWORD = "";
+    private static final String ROCKET_CHAT_LINK = "http://rocketchat.westeurope.cloudapp.azure.com/";
+
+    public static final String ROCKET_CHAT_ROOM_LINK = ROCKET_CHAT_LINK + "group/";
+
+    public static final String ROCKET_CHAT_API_LINK = ROCKET_CHAT_LINK + "api/v1/";
+
+    public static final User ADMIN_USER = new User("admin nachname", "passwort",
+            "email", "token", "rocketChatUsername", "rocketChatAuthToken",
+            "rocketChatPersonalAccessToken", "rocketChatUserId", false);
+
+    public static final User TEST_USER = new User("test nachname", "passwort",
+            "email", "token", "rocketChatUsername", "rocketChatAuthToken",
+            "rocketChatPersonalAccessToken", "rocketChatUserId", false);
 }
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/ICommunication.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/ICommunication.java
index ece710bea944cf6039ef9aa659244b169757e9f1..f470ceaccea4f7aa49e1118b82b59ae73c5f8a9a 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/ICommunication.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/ICommunication.java
@@ -1,12 +1,12 @@
 package unipotsdam.gf.interfaces;
 
-import unipotsdam.gf.modules.project.Project;
-import unipotsdam.gf.modules.user.User;
-import unipotsdam.gf.process.constraints.ConstraintsMessages;
+import unipotsdam.gf.core.management.group.Group;
+import unipotsdam.gf.core.management.project.Project;
+import unipotsdam.gf.core.management.user.User;
+import unipotsdam.gf.core.states.model.ConstraintsMessages;
 import unipotsdam.gf.modules.assessment.controller.model.StudentIdentifier;
-import unipotsdam.gf.modules.communication.model.Message;
+import unipotsdam.gf.modules.communication.model.EMailMessage;
 import unipotsdam.gf.modules.communication.model.chat.ChatMessage;
-import unipotsdam.gf.modules.communication.model.chat.ChatRoom;
 
 import java.util.List;
 import java.util.Map;
@@ -23,21 +23,32 @@ public interface ICommunication {
      * @param roomId ID of room of user
      * @return List of Chat Messages
      */
+    @Deprecated
     List<ChatMessage> getChatHistory(String roomId);
 
-
-    boolean sendMessageToChat(Message message, String roomId) ;
+    @Deprecated
+    boolean sendMessageToChat(EMailMessage EMailMessage, String roomId);
 
     /**
      * endpoint: https://rocket.chat/docs/developer-guides/rest-api/groups/create/
      * creates chatroom
      *
-     * @param name                  chat room name
-     * @param userList member of chat by id
+     * @param name chat room name
      * @return chat room id
      */
-    String createChatRoom(String name, List<User> userList);
+    String createChatRoom(String name, boolean readOnly, List<User> users);
+
+    /**
+     * creates chatRoom with name "group.projectId - group.id" and set chatRoomId for group
+     *
+     * @param group Object for information
+     * @return true if chatRoom was created, otherwise false
+     */
+    boolean createChatRoom(Group group, boolean readOnly);
 
+    String createEmptyChatRoom(String name, boolean readOnly);
+
+    boolean deleteChatRoom(String roomId);
 
     /**
      * endpoint: https://rocket.chat/docs/developer-guides/rest-api/groups/invite/
@@ -46,9 +57,9 @@ public interface ICommunication {
      * @param user   information about user
      * @return if user was added successfully
      */
-    boolean addUserToChatRoom(String roomId, User user);
+    boolean addUserToChatRoom(User user, String roomId);
 
-    boolean removeUserFromChatRoom(User user, String roomId) ;
+    boolean removeUserFromChatRoom(User user, String roomId);
 
     /**
      * endpoint: https://rocket.chat/docs/developer-guides/rest-api/groups/settopic/
@@ -57,6 +68,7 @@ public interface ICommunication {
      * @param topic  topic of chat room
      * @return true, if topic was set correctly
      */
+    @Deprecated
     boolean setChatRoomTopic(String roomId, String topic);
 
 
@@ -67,7 +79,9 @@ public interface ICommunication {
      * @param roomId chat room id
      * @return chat room information
      */
-    ChatRoom getChatRoomInfo(String roomId);
+    String getChatRoomName(String roomId);
+
+    boolean exists(String roomId);
 
     /**
      * api: https://rocket.chat/docs/developer-guides/rest-api/authentication/login/
@@ -78,6 +92,10 @@ public interface ICommunication {
     boolean loginUser(User user);
 
     /**
+     * api 1: https://rocket.chat/docs/developer-guides/rest-api/users/register/
+     * api 2: https://rocket.chat/docs/developer-guides/rest-api/users/generatepersonalaccesstoken/
+     * api 3: https://rocket.chat/docs/developer-guides/rest-api/users/getpersonalaccesstokens/
+     *
      * registers new user to rocket chat
      *
      * @param user registers user to rocket.chat
@@ -85,16 +103,13 @@ public interface ICommunication {
      */
     boolean registerUser(User user);
 
-    boolean registerAndLoginUser(User user);
-
-    String getChatRoomLink(String userEmail, String projectToken, String groupToken);
+    String getChatRoomLink(String userToken, String projectId);
 
     // TODO implement as Email or whatever
-    void sendSingleMessage(Message message, User user);
+    boolean sendSingleMessage(EMailMessage EMailMessage, User user);
 
     //added by Axel.
-    void informAboutMissingTasks(Map<StudentIdentifier, ConstraintsMessages> tasks, Project project);
+    boolean informAboutMissingTasks(Map<StudentIdentifier, ConstraintsMessages> tasks, Project project);
 
-    // TODO implement as Email or whatever
-    void sendMessageToUsers(Project project, String message);
+    boolean sendMessageToUsers(Project project, EMailMessage eMailMessage);
 }
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/ChatWindow.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/ChatWindow.java
index 1a0d657baba3b66527714bd71550de846525ce0a..573e38ebd52c7658455df3c3b00ff58d2e446e6c 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/ChatWindow.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/ChatWindow.java
@@ -1,7 +1,13 @@
 package unipotsdam.gf.modules.communication;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import unipotsdam.gf.core.database.mysql.MysqlConnect;
+import unipotsdam.gf.core.management.user.UserDAO;
 import unipotsdam.gf.interfaces.ICommunication;
-import unipotsdam.gf.modules.communication.service.CommunicationDummyService;
+import unipotsdam.gf.modules.communication.service.CommunicationService;
+import unipotsdam.gf.modules.communication.service.UnirestService;
+import unipotsdam.gf.modules.groupfinding.service.GroupDAO;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.jsp.JspWriter;
@@ -11,21 +17,24 @@ import java.io.IOException;
 
 public class ChatWindow extends SimpleTagSupport {
 
+    private static final Logger log = LoggerFactory.getLogger(ChatWindow.class);
+
     private String orientation;
 
     public void doTag() throws IOException {
+
+        // TODO refactor
         PageContext pageContext = (PageContext) getJspContext();
         HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
         String token = request.getParameter("token");
-        //User user = management.getUserByEmail(token);
-        String groupToken = request.getParameter("groupToken");
-        String projectToken = request.getParameter("projectName");
-        //get ProjetbyToken
-        ICommunication communicationService = new CommunicationDummyService();
-        String chatRoomLink = communicationService.getChatRoomLink(token, projectToken, groupToken);
-
+        String projectId = request.getParameter("projectId");
+        UserDAO userDAO = new UserDAO(new MysqlConnect());
+        GroupDAO groupDAO = new GroupDAO(new MysqlConnect());
+        ICommunication communicationService = new CommunicationService(new UnirestService(), userDAO, groupDAO);
+        String chatRoomLink = communicationService.getChatRoomLink(token, projectId);
+        log.debug("ChatRoomLink for ChatWindow: {}", chatRoomLink);
         JspWriter out = getJspContext().getOut();
-        out.println("<iframe width=\"30%\" height=\"100%\" src=\"" + chatRoomLink + "\"/>");
+        out.println("<iframe height=\"400px\" src=\"" + chatRoomLink + "\"/>");
     }
 
     public void setOrientation(String orientation) {
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/Messages.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/Messages.java
index cb24bd6725cf2397565210fb53c8618b2d6b9050..68d7366ae37d07534d21ee288eecb97636321fbb 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/Messages.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/Messages.java
@@ -1,25 +1,38 @@
-package unipotsdam.gf.modules.communication;
+package unipotsdam.gf.view;
 
-import unipotsdam.gf.modules.project.Project;
+import unipotsdam.gf.core.management.project.Project;
+import unipotsdam.gf.modules.communication.model.EMailMessage;
 
 public class Messages {
-    public static String GroupFormation(Project project){
+    public static EMailMessage GroupFormation(Project project) {
         // TODO add link to site + markup
-        return "Die Gruppen wurden für den Kurs "+ project.getName() + " erstellt";
+        EMailMessage eMailMessage = new EMailMessage();
+        eMailMessage.setSubject(project.getId() + ": Gruppenerstellung abgeschlossen");
+        eMailMessage.setBody("Die Gruppen wurden für den Kurs " + project.getId() + " erstellt");
+        return eMailMessage;
     }
 
-    public static String NewFeedbackTask(Project project) {
+    public static EMailMessage NewFeedbackTask(Project project) {
         // TODO add link to site + markup
-        return "Eine neue Feedbackaufgabe wurde für den Kurs "+ project.getName() + " erstellt";
+        EMailMessage eMailMessage = new EMailMessage();
+        eMailMessage.setSubject(project.getId() + ": Feedbackaufgabe erstellt");
+        eMailMessage.setBody("Eine neue Feedbackaufgabe wurde für den Kurs " + project.getId() + " erstellt");
+        return eMailMessage;
     }
 
-    public static String AssessmentPhaseStarted(Project project) {
+    public static EMailMessage AssessmentPhaseStarted(Project project) {
         // TODO add link to site + markup
-        return "Die Bewertungsphase hat begonnen. Bitte geht auf ... und macht ....";
+        EMailMessage eMailMessage = new EMailMessage();
+        eMailMessage.setSubject(project.getId() + ": Beginn der Bewertungsphase");
+        eMailMessage.setBody("Die Bewertungsphase hat begonnen. Bitte geht auf ... und macht ....");
+        return eMailMessage;
     }
 
-    public static String CourseEnds(Project project) {
+    public static EMailMessage CourseEnds(Project project) {
         // TODO add link to site + markup
-        return "Die Bewertung ist abgeschlossen. Sie erhalten ihre Bewertung in Kürze.";
+        EMailMessage eMailMessage = new EMailMessage();
+        eMailMessage.setSubject(project.getId() + ": Bewertungsphase abgeschlossen");
+        eMailMessage.setBody("Die Bewertung ist abgeschlossen. Sie erhalten ihre Bewertung in Kürze.");
+        return eMailMessage;
     }
 }
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/EMailMessage.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/EMailMessage.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b76df20de6bf2c90a4be77e229936ddba14fe19
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/EMailMessage.java
@@ -0,0 +1,34 @@
+package unipotsdam.gf.modules.communication.model;
+
+public class EMailMessage {
+
+    private String subject;
+    private String body;
+
+
+    public EMailMessage() {
+    }
+
+    public EMailMessage(String subject, String body) {
+        this.subject = subject;
+        this.body = body;
+    }
+
+    public String getSubject() {
+        return subject;
+    }
+
+    public void setSubject(String subject) {
+        this.subject = subject;
+    }
+
+    public String getBody() {
+        return body;
+    }
+
+    public void setBody(String body) {
+        this.body = body;
+    }
+
+
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/Message.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/Message.java
deleted file mode 100644
index d01a32710be40c2ac13b7203ea9dd9f9f6e2cab1..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/Message.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package unipotsdam.gf.modules.communication.model;
-
-public class Message {
-
-    private String roomIdOrChannel;
-    private String message;
-
-    public Message() {}
-
-    public Message(String roomIdOrChannel, String message) {
-        this.roomIdOrChannel = roomIdOrChannel;
-        this.message = message;
-    }
-
-    public String getRoomIdOrChannel() {
-        return roomIdOrChannel;
-    }
-
-    public void setRoomIdOrChannel(String roomIdOrChannel) {
-        this.roomIdOrChannel = roomIdOrChannel;
-    }
-
-    public String getMessage() {
-        return message;
-    }
-
-    public void setMessage(String message) {
-        this.message = message;
-    }
-
-    @Override
-    public String toString() {
-        return "Message{" +
-                "roomIdOrChannel='" + roomIdOrChannel + '\'' +
-                ", message='" + message + '\'' +
-                '}';
-    }
-}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/SampleAnswer.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/SampleAnswer.java
deleted file mode 100644
index 6a34b213584abfc5fd149c488184250dfacf0303..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/SampleAnswer.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package unipotsdam.gf.modules.communication.model;
-
-
-public class SampleAnswer {
-
-    private String answer;
-
-    public SampleAnswer() {
-    }
-
-    public String getAnswer() {
-        return answer;
-    }
-
-    public void setAnswer(String answer) {
-        this.answer = answer;
-    }
-
-    @Override
-    public String toString() {
-        return "SampleAnswer{" +
-                "answer='" + answer + '\'' +
-                '}';
-    }
-}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/chat/ChatRoom.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/chat/ChatRoom.java
index 0a97bfcaa8956ee862866c8cb1df48335a9301ed..1dfa856184657b7aad7c7ff6ca4012adc0dbca03 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/chat/ChatRoom.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/chat/ChatRoom.java
@@ -1,5 +1,6 @@
 package unipotsdam.gf.modules.communication.model.chat;
 
+// TODO: never used at the moment by ICommunication, just context, maybe remove
 public class ChatRoom {
 
     String id;
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/rocketChat/RocketChatLoginResponse.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/rocketChat/RocketChatLoginResponse.java
new file mode 100644
index 0000000000000000000000000000000000000000..408e236d5b6f3de10281567a5bf010abb4333e51
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/rocketChat/RocketChatLoginResponse.java
@@ -0,0 +1,78 @@
+package unipotsdam.gf.modules.communication.model.rocketChat;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+import java.util.Map;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class RocketChatLoginResponse {
+
+    private String status;
+
+    // for success data
+    private Map data;
+
+    // for error data
+    private String error;
+    private String message;
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    public Map getData() {
+        return data;
+    }
+
+    public void setData(Map data) {
+        this.data = data;
+    }
+
+    public String getError() {
+        return error;
+    }
+
+    public void setError(String error) {
+        this.error = error;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    @Override
+    public String toString() {
+        return "RocketChatLoginResponse{" +
+                "status='" + status + '\'' +
+                ", data=" + data +
+                ", error='" + error + '\'' +
+                ", message='" + message + '\'' +
+                '}';
+    }
+
+    public boolean isSuccessful() {
+        return status.equals("success");
+    }
+
+    public boolean hasError() {
+        return status.equals("error");
+    }
+
+    public String getAuthToken() {
+        // TODO: throw exception for error
+        return isSuccessful() ? data.get("authToken").toString() : "";
+    }
+
+    public String getUserId() {
+        // TODO: throw exception for error
+        return isSuccessful() ? data.get("userId").toString() : "";
+    }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/rocketChat/RocketChatRegisterResponse.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/rocketChat/RocketChatRegisterResponse.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd24a152b4c56f55c880d29cbd99e196b1a1592e
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/rocketChat/RocketChatRegisterResponse.java
@@ -0,0 +1,57 @@
+package unipotsdam.gf.modules.communication.model.rocketChat;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.apache.logging.log4j.util.Strings;
+
+import java.util.Map;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class RocketChatRegisterResponse {
+
+    private Map user;
+    private String error;
+
+    private boolean successful;
+
+    public Map getUser() {
+        return user;
+    }
+
+    public void setUser(Map user) {
+        this.user = user;
+    }
+
+    public String getError() {
+        return error;
+    }
+
+    public void setError(String error) {
+        this.error = error;
+    }
+
+    @JsonProperty("success")
+    public boolean isSuccessful() {
+        return successful;
+    }
+
+    public void setSuccessful(boolean successful) {
+        this.successful = successful;
+    }
+
+    public String getUserId() {
+        if (!isSuccessful()) {
+            // TODO: throw error
+            return Strings.EMPTY;
+        }
+        return user.get("_id").toString();
+    }
+
+    public boolean isEmailExistError() {
+        boolean emailError = false;
+        if (!isSuccessful()) {
+            emailError = error.contains("Email already exists.");
+        }
+        return emailError;
+    }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/CommunicationDummyService.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/CommunicationDummyService.java
deleted file mode 100644
index a932c327f53f53e8d7b91c7ca8ed5860ac393746..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/CommunicationDummyService.java
+++ /dev/null
@@ -1,138 +0,0 @@
-package unipotsdam.gf.modules.communication.service;
-
-import unipotsdam.gf.assignments.Assignee;
-import unipotsdam.gf.assignments.NotImplementedLogger;
-import unipotsdam.gf.config.Constants;
-import unipotsdam.gf.modules.project.Management;
-import unipotsdam.gf.modules.project.Project;
-import unipotsdam.gf.modules.user.User;
-import unipotsdam.gf.process.constraints.ConstraintsMessages;
-import unipotsdam.gf.interfaces.ICommunication;
-import unipotsdam.gf.modules.assessment.controller.model.StudentIdentifier;
-import unipotsdam.gf.modules.communication.model.Message;
-import unipotsdam.gf.modules.communication.model.chat.ChatMessage;
-import unipotsdam.gf.modules.communication.model.chat.ChatRoom;
-
-import javax.annotation.ManagedBean;
-import javax.annotation.Resource;
-import javax.inject.Inject;
-import javax.inject.Singleton;
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-
-@Resource
-@ManagedBean
-@Singleton
-public class CommunicationDummyService implements ICommunication {
-
-    @Inject
-    Management managementService;
-
-    @Override
-    public List<ChatMessage> getChatHistory(String roomId) {
-        ArrayList<ChatMessage> chatMessages = new ArrayList<>();
-        int maxValue = 6;
-        for (int i = 1; i <= maxValue; i++) {
-            chatMessages.add(new ChatMessage(String.valueOf(i), "Dies ist ein Test " + i + ".",
-                    Instant.now().minusSeconds(maxValue * 10 - i * 10), "testUser" + i));
-        }
-        return chatMessages;
-    }
-
-    @Override
-    public boolean sendMessageToChat(Message message, String roomId) {
-        NotImplementedLogger.logAssignment(Assignee.MARTIN, CommunicationDummyService.class);
-        return false;
-    }
-
-    @Override
-    public String createChatRoom(String name, List<User> userList) {
-        if (Objects.isNull(userList)) {
-            return "2";
-        }
-
-        return "1";
-    }
-
-    @Override
-    public boolean addUserToChatRoom(String roomId, User user)  {
-        NotImplementedLogger.logAssignment(Assignee.MARTIN, CommunicationDummyService.class, "addUserToChatRoom");
-        return false;
-    }
-
-    @Override
-    public boolean removeUserFromChatRoom(User user, String roomId)  {
-        NotImplementedLogger.logAssignment(Assignee.MARTIN, CommunicationDummyService.class, "removing user from chat " +
-                "room");
-        return false;
-    }
-
-    @Override
-    public boolean setChatRoomTopic(String roomId, String topic) {
-        NotImplementedLogger.logAssignment(Assignee.MARTIN, CommunicationDummyService.class, "setting chat room topic");
-        return false;
-    }
-
-    @Override
-    public ChatRoom getChatRoomInfo(String roomId) {
-        return new ChatRoom("1", "test");
-    }
-
-    @Override
-    public boolean loginUser(User user) {
-        user.setRocketChatAuthToken("abc");
-        return true;
-    }
-
-    @Override
-    public boolean registerUser(User user) {
-        user.setRocketChatId("1");
-        return true;
-    }
-
-    @Override
-    public boolean registerAndLoginUser(User user) {
-        // TODO: try to login user first --> if it fails there is no user, register afterwards or add exists function
-        if (!registerUser(user)) {
-            return false;
-        }
-        return loginUser(user);
-
-    }
-
-    public String getChatRoomLink(String userEmail, String projectToken, String groupToken) {
-        //User user = managementService.getUserByEmail(userEmail);
-        // TODO: Implement getProjectbyToken and getGroupByToken
-        //Project project = managementService.getProject(projectName
-        String channelName = "general";
-        return Constants.ROCKET_CHAT_URL + "/channel/" + channelName + "?layout=embedded";
-    }
-
-    @Override
-    public void sendSingleMessage(Message message, User user)  {
-        // TODO implement as email or directed message, popup after login or whatever
-        String message2 = "sending email with message: "+ message.getMessage() + " to: "+ user.getEmail();
-        NotImplementedLogger.logAssignment(Assignee.MARTIN, CommunicationDummyService.class, message2);
-    }
-
-    @Override
-    public void informAboutMissingTasks(Map<StudentIdentifier, ConstraintsMessages> tasks, Project project) {
-
-    }
-
-    @Override
-    public void sendMessageToUsers(Project project, String message) {
-        // TODO implement as email or directed message, popup after login or whatever
-        String message2 = "sending email with message: "+ message + " to: "+ project.getName();
-        NotImplementedLogger.logAssignment(Assignee.MARTIN, CommunicationDummyService.class, message2);
-    }
-
-    // TODO: remove after done implementing
-    // just for postman testing
-    public User getUser() {
-        return new User("Martin Stähr", "test", "test@test.com", true);
-    }
-}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/CommunicationService.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/CommunicationService.java
new file mode 100644
index 0000000000000000000000000000000000000000..eeeabc0b5e35e132e7587bf944907722e6ae2772
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/CommunicationService.java
@@ -0,0 +1,413 @@
+package unipotsdam.gf.modules.communication.service;
+
+import io.github.openunirest.http.HttpResponse;
+import org.apache.logging.log4j.util.Strings;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import unipotsdam.gf.config.GFRocketChatConfig;
+import unipotsdam.gf.core.management.group.Group;
+import unipotsdam.gf.core.management.project.Project;
+import unipotsdam.gf.core.management.user.User;
+import unipotsdam.gf.core.management.user.UserDAO;
+import unipotsdam.gf.core.states.model.ConstraintsMessages;
+import unipotsdam.gf.interfaces.ICommunication;
+import unipotsdam.gf.modules.assessment.controller.model.StudentIdentifier;
+import unipotsdam.gf.modules.communication.model.EMailMessage;
+import unipotsdam.gf.modules.communication.model.chat.ChatMessage;
+import unipotsdam.gf.modules.communication.model.rocketChat.RocketChatLoginResponse;
+import unipotsdam.gf.modules.communication.model.rocketChat.RocketChatRegisterResponse;
+import unipotsdam.gf.modules.communication.util.RocketChatHeaderMapBuilder;
+import unipotsdam.gf.modules.groupfinding.service.GroupDAO;
+
+import javax.annotation.ManagedBean;
+import javax.annotation.Resource;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.mail.Authenticator;
+import javax.mail.Message;
+import javax.mail.MessagingException;
+import javax.mail.PasswordAuthentication;
+import javax.mail.Session;
+import javax.mail.Transport;
+import javax.mail.internet.InternetAddress;
+import javax.mail.internet.MimeMessage;
+import javax.ws.rs.core.Response;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.stream.Collectors;
+
+import static unipotsdam.gf.config.GFMailConfig.SMTP_HOST;
+import static unipotsdam.gf.config.GFMailConfig.SMTP_PASSWORD;
+import static unipotsdam.gf.config.GFMailConfig.SMTP_PORT;
+import static unipotsdam.gf.config.GFMailConfig.SMTP_USERNAME;
+import static unipotsdam.gf.config.GFRocketChatConfig.ROCKET_CHAT_API_LINK;
+import static unipotsdam.gf.config.GFRocketChatConfig.ROCKET_CHAT_ROOM_LINK;
+
+@Resource
+@ManagedBean
+@Singleton
+public class CommunicationService implements ICommunication {
+
+    private final static Logger log = LoggerFactory.getLogger(CommunicationService.class);
+
+    private UnirestService unirestService;
+    private UserDAO userDAO;
+    private GroupDAO groupDAO;
+
+    // TODO: refactor error handling and add maybe some descriptions
+
+    @Inject
+    public CommunicationService(UnirestService unirestService, UserDAO userDAO, GroupDAO groupDAO) {
+        this.unirestService = unirestService;
+        this.userDAO = userDAO;
+        this.groupDAO = groupDAO;
+    }
+
+    @Override
+    public List<ChatMessage> getChatHistory(String roomId) {
+        //TODO : not needed at the moment, possibly remove
+        return null;
+    }
+
+    @Override
+    public boolean sendMessageToChat(EMailMessage EMailMessage, String roomId) {
+        // TODO: not needed at the moment, possibly remove
+        return false;
+    }
+
+    @Override
+    public String createEmptyChatRoom(String name, boolean readOnly) {
+        return createChatRoom(name, readOnly, new ArrayList<>());
+    }
+
+    @Override
+    public String createChatRoom(String name, boolean readOnly, List<User> member) {
+        Map<String, String> headerMap = new RocketChatHeaderMapBuilder().withRocketChatAdminAuth().build();
+
+        List<String> usernameList = member.stream().map(User::getRocketChatUsername).collect(Collectors.toList());
+        HashMap<String, Object> bodyMap = new HashMap<>();
+        bodyMap.put("name", name);
+        bodyMap.put("readOnly", readOnly);
+        bodyMap.put("members", usernameList);
+
+        HttpResponse<Map> response =
+                unirestService
+                        .post(ROCKET_CHAT_API_LINK + "groups.create")
+                        .headers(headerMap)
+                        .body(bodyMap)
+                        .asObject(Map.class);
+
+        if (response.getStatus() == Response.Status.BAD_REQUEST.getStatusCode()) {
+            return Strings.EMPTY;
+        }
+
+        Map responseMap = response.getBody();
+        log.debug("responseMap: {}", responseMap);
+        if (responseMap.containsKey("error")) {
+            return Strings.EMPTY;
+        }
+
+        Map groupMap = (Map) responseMap.get("group");
+        return groupMap.get("_id").toString();
+    }
+
+    @Override
+    public boolean createChatRoom(Group group, boolean readOnly) {
+        // chatRoom name: projectId - GroupId
+        String chatRoomName = String.join("-", group.getProjectId(), String.valueOf(group.getId()));
+        String chatRoomId = createChatRoom(chatRoomName, readOnly, group.getMembers());
+        if (chatRoomId.isEmpty()) {
+            return false;
+        }
+        group.setChatRoomId(chatRoomId);
+        groupDAO.update(group);
+        return true;
+    }
+
+    @Override
+    public boolean deleteChatRoom(String roomId) {
+        // TODO: maybe add lock for getChatRoomName, so synchronized access doesn't create errors while deleting
+        Map<String, String> headerMap = new RocketChatHeaderMapBuilder().withRocketChatAdminAuth().build();
+        HashMap<String, String> bodyMap = new HashMap<>();
+        bodyMap.put("roomId", roomId);
+
+        HttpResponse<Map> response =
+                unirestService
+                        .post(ROCKET_CHAT_API_LINK + "groups.delete")
+                        .headers(headerMap)
+                        .body(bodyMap)
+                        .asObject(Map.class);
+
+        if (isBadRequest(response)) {
+            return false;
+        }
+        Map responseMap = response.getBody();
+        if (responseMap.get("success").equals("false") || responseMap.containsKey("error")) {
+            return false;
+        }
+        groupDAO.clearChatRoomIdOfGroup(roomId);
+
+        return true;
+    }
+
+    @Override
+    public boolean addUserToChatRoom(User user, String roomId) {
+        return modifyChatRoom(user, roomId, true);
+    }
+
+    @Override
+    public boolean removeUserFromChatRoom(User user, String roomId) {
+        return modifyChatRoom(user, roomId, false);
+    }
+
+    private boolean modifyChatRoom(User user, String roomId, boolean addUser) {
+        if (hasEmptyParameter(user.getRocketChatUserId(), user.getRocketChatPersonalAccessToken(), roomId)) {
+            return false;
+        }
+        Map<String, String> headerMap = new RocketChatHeaderMapBuilder().withRocketChatAdminAuth().build();
+        Map<String, String> bodyMap = new HashMap<>();
+        bodyMap.put("roomId", roomId);
+        bodyMap.put("userId", user.getRocketChatUserId());
+
+        String groupUrl = addUser ? "groups.invite" : "groups.kick";
+
+        HttpResponse<Map> response = unirestService
+                .post(GFRocketChatConfig.ROCKET_CHAT_API_LINK + groupUrl)
+                .headers(headerMap)
+                .body(bodyMap)
+                .asObject(Map.class);
+
+        if (isBadRequest(response)) {
+            return false;
+        }
+
+        Map responseMap = response.getBody();
+        return !responseMap.containsKey("error") && !responseMap.get("success").equals("false");
+    }
+
+    @Override
+    public boolean setChatRoomTopic(String roomId, String topic) {
+        // TODO: not needed at the moment, possibly remove
+        return false;
+    }
+
+    @Override
+    public String getChatRoomName(String roomId) {
+        Map<String, String> headerMap = new RocketChatHeaderMapBuilder().withRocketChatAdminAuth().build();
+
+        HttpResponse<Map> response =
+                unirestService
+                        .get(ROCKET_CHAT_API_LINK + "groups.info")
+                        .headers(headerMap)
+                        .queryString("roomId", roomId).asObject(Map.class);
+
+        if (isBadRequest(response)) {
+            return Strings.EMPTY;
+        }
+
+        Map responseMap = response.getBody();
+        if (responseMap.containsKey("error")) {
+            return Strings.EMPTY;
+        }
+
+        Map groupMap = (Map) responseMap.get("group");
+        return groupMap.get("name").toString();
+    }
+
+    @Override
+    public boolean loginUser(User user) {
+        if (hasEmptyParameter(user.getEmail(), user.getPassword())) {
+            return false;
+        }
+
+        HashMap<String, String> rocketChatAuth = new HashMap<>();
+        rocketChatAuth.put("user", user.getEmail());
+        rocketChatAuth.put("password", user.getPassword());
+
+        HttpResponse<RocketChatLoginResponse> response =
+                unirestService
+                        .post(ROCKET_CHAT_API_LINK + "login")
+                        .body(rocketChatAuth)
+                        .asObject(RocketChatLoginResponse.class);
+
+        if (isBadRequest(response)) {
+            return false;
+        }
+
+        RocketChatLoginResponse rocketChatLoginResponse = response.getBody();
+        user.setRocketChatUserId(rocketChatLoginResponse.getUserId());
+        user.setRocketChatAuthToken(rocketChatLoginResponse.getAuthToken());
+        return true;
+    }
+
+    @Override
+    public boolean registerUser(User user) {
+
+        if (hasEmptyParameter(user.getEmail(), user.getName(), user.getPassword())) {
+            return false;
+        }
+
+        HashMap<String, String> rocketChatRegister = new HashMap<>();
+        String rocketChatUsername = createRocketChatUsername(user);
+        rocketChatRegister.put("username", rocketChatUsername);
+        rocketChatRegister.put("email", user.getEmail());
+        rocketChatRegister.put("pass", user.getPassword());
+        rocketChatRegister.put("name", user.getName());
+
+        HttpResponse<RocketChatRegisterResponse> response =
+                unirestService
+                        .post(ROCKET_CHAT_API_LINK + "users.register")
+                        .body(rocketChatRegister)
+                        .asObject(RocketChatRegisterResponse.class);
+
+        if (isBadRequest(response)) {
+            return false;
+        }
+
+        RocketChatRegisterResponse registerResponse = response.getBody();
+        if (!registerResponse.isSuccessful()) {
+            return false;
+        }
+
+        user.setRocketChatUsername(rocketChatUsername);
+        user.setRocketChatUserId(registerResponse.getUserId());
+
+        return createCustomAccessToken(user);
+    }
+
+    public String getChatRoomLink(String userToken, String projectId) {
+        User user = userDAO.getUserByToken(userToken);
+        StudentIdentifier studentIdentifier = new StudentIdentifier(projectId, user.getId());
+        String chatRoomId = groupDAO.getGroupChatRoomIdByStudentIdentifier(studentIdentifier);
+        if (chatRoomId.isEmpty()) {
+            return Strings.EMPTY;
+        }
+
+        String chatRoomName = getChatRoomName(chatRoomId);
+        if (chatRoomName.isEmpty()) {
+            return Strings.EMPTY;
+        }
+
+        return ROCKET_CHAT_ROOM_LINK + chatRoomName + "?layout=embedded";
+    }
+
+    // TODO: Think about splitting email and chat communication into different
+    @Override
+    public boolean sendSingleMessage(EMailMessage eMailMessage, User user) {
+        Properties properties = new Properties();
+        properties.put("mail.smtp.auth", true);
+        properties.put("mail.smtp.starttls.enable", "true");
+        properties.put("mail.smtp.host", SMTP_HOST);
+        properties.put("mail.smtp.port", SMTP_PORT);
+
+        Session session = Session.getInstance(properties, new Authenticator() {
+            @Override
+            protected PasswordAuthentication getPasswordAuthentication() {
+                return new PasswordAuthentication(SMTP_USERNAME, SMTP_PASSWORD);
+            }
+        });
+
+        try {
+            Message message = new MimeMessage(session);
+            message.setFrom(new InternetAddress(SMTP_USERNAME, "FLTrail Messagebot"));
+            message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(user.getEmail()));
+            message.setSubject(eMailMessage.getSubject());
+            message.setText(eMailMessage.getBody());
+
+            Transport.send(message);
+            return true;
+        } catch (MessagingException | UnsupportedEncodingException e) {
+            log.error("Exception while sending an email: {}", e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean informAboutMissingTasks(Map<StudentIdentifier, ConstraintsMessages> tasks, Project project) {
+        HashMap<StudentIdentifier, ConstraintsMessages> notSentEMailMap = new HashMap<>();
+        tasks.entrySet().stream().filter(entry -> {
+            User user = new User();
+            user.setEmail(entry.getKey().getStudentId());
+            EMailMessage eMailMessage = new EMailMessage();
+            eMailMessage.setSubject("Benachrichtigung über nicht erledigte Aufgaben im Projekt " + project.getId());
+            eMailMessage.setBody(entry.getValue().toString());
+            return !sendSingleMessage(eMailMessage, user);
+        }).forEach(entry -> notSentEMailMap.put(entry.getKey(), entry.getValue()));
+        return notSentEMailMap.isEmpty();
+    }
+
+    @Override
+    public boolean sendMessageToUsers(Project project, EMailMessage eMailMessage) {
+        List<User> users = userDAO.getUsersByProjectId(project.getId());
+        List<User> userEmailProblemList = users
+                .stream()
+                .filter(user -> !sendSingleMessage(eMailMessage, user))
+                .collect(Collectors.toList());
+        return userEmailProblemList.isEmpty();
+    }
+
+    private boolean hasEmptyParameter(String... parameters) {
+        return Arrays.stream(parameters).anyMatch(String::isEmpty);
+    }
+
+    private String createRocketChatUsername(User user) {
+        // TODO: eventually add username to normal registration
+        String possibleUsername = user.getName().replaceAll(" ", "");
+        int counter = 1;
+        while (userDAO.existsByRocketChatUsername(possibleUsername)) {
+            possibleUsername = user.getName().replaceAll(" ", "") + counter;
+            counter++;
+        }
+        return possibleUsername;
+    }
+
+    private boolean createCustomAccessToken(User user) {
+        if (hasEmptyParameter(user.getRocketChatUserId())) {
+            return false;
+        }
+
+        if (!loginUser(user)) {
+            return false;
+        }
+
+        HashMap<String, String> bodyMap = new HashMap<>();
+        bodyMap.put("tokenName", "fltrailToken");
+        Map<String, String> headerMap = new RocketChatHeaderMapBuilder()
+                .withAuthTokenHeader(user.getRocketChatAuthToken())
+                .withRocketChatUserId(user.getRocketChatUserId()).build();
+
+        HttpResponse<Map> response = unirestService
+                .post(ROCKET_CHAT_API_LINK + "users.generatePersonalAccessToken")
+                .headers(headerMap)
+                .body(bodyMap)
+                .asObject(Map.class);
+
+        if (isBadRequest(response)) {
+            return false;
+        }
+
+        Map responseBody = response.getBody();
+        if (responseBody.containsKey("status")) {
+            return false;
+        }
+        user.setRocketChatPersonalAccessToken(responseBody.get("token").toString());
+        return true;
+    }
+
+    private boolean isBadRequest(HttpResponse response) {
+        int status = response.getStatus();
+        return status == Response.Status.BAD_REQUEST.getStatusCode() ||
+                status == Response.Status.UNAUTHORIZED.getStatusCode();
+    }
+
+
+    @Override
+    public boolean exists(String roomId) {
+        return !getChatRoomName(roomId).isEmpty();
+    }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/SampleService.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/SampleService.java
deleted file mode 100644
index 870b49db98d0a0b8434fc627ea23a9022c13d52b..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/SampleService.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package unipotsdam.gf.modules.communication.service;
-
-import unipotsdam.gf.modules.communication.model.SampleAnswer;
-
-public class SampleService {
-
-    public SampleAnswer provideSampleAnswer(String name) {
-        SampleAnswer sampleAnswer = new SampleAnswer();
-        sampleAnswer.setAnswer("Hello " + name);
-        return sampleAnswer;
-    }
-}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/UnirestService.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/UnirestService.java
new file mode 100644
index 0000000000000000000000000000000000000000..9930d0297939a1e9770948d8b4da0468aa63001d
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/UnirestService.java
@@ -0,0 +1,43 @@
+package unipotsdam.gf.modules.communication.service;
+
+import io.github.openunirest.http.Unirest;
+import io.github.openunirest.mappers.JacksonObjectMapper;
+import io.github.openunirest.request.GetRequest;
+import io.github.openunirest.request.HttpRequestWithBody;
+
+import javax.annotation.ManagedBean;
+import javax.annotation.Resource;
+import javax.inject.Singleton;
+
+@ManagedBean
+@Resource
+@Singleton
+public class UnirestService {
+
+    private static boolean isInitialized = false;
+
+    public UnirestService() {
+        // has to be set for application
+        if (!isInitialized) {
+            Unirest.setObjectMapper(new JacksonObjectMapper());
+            Unirest.setDefaultHeader("Content-Type", "application/json");
+            isInitialized = true;
+        }
+    }
+
+    public GetRequest get(String url) {
+        return Unirest.get(url);
+    }
+
+    public HttpRequestWithBody post(String url) {
+        return Unirest.post(url);
+    }
+
+    public HttpRequestWithBody delete(String url) {
+        return Unirest.delete(url);
+    }
+
+    public HttpRequestWithBody put(String url) {
+        return Unirest.put(url);
+    }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/util/RocketChatHeaderMapBuilder.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/util/RocketChatHeaderMapBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f351b3aa895043d4ff690a82c9a99e1df2e6806
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/util/RocketChatHeaderMapBuilder.java
@@ -0,0 +1,34 @@
+package unipotsdam.gf.modules.communication.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static unipotsdam.gf.config.GFRocketChatConfig.ADMIN_USER;
+
+public class RocketChatHeaderMapBuilder {
+
+    private Map<String, String> headerMap;
+
+    public RocketChatHeaderMapBuilder() {
+        headerMap = new HashMap<>();
+    }
+
+    public RocketChatHeaderMapBuilder withAuthTokenHeader(String authToken) {
+        headerMap.put("X-Auth-Token", authToken);
+        return this;
+    }
+
+    public RocketChatHeaderMapBuilder withRocketChatUserId(String userId) {
+        headerMap.put("X-User-Id", userId);
+        return this;
+    }
+
+    public RocketChatHeaderMapBuilder withRocketChatAdminAuth() {
+        RocketChatHeaderMapBuilder rocketChatHeaderMapBuilder = withAuthTokenHeader(ADMIN_USER.getRocketChatPersonalAccessToken());
+        return rocketChatHeaderMapBuilder.withRocketChatUserId(ADMIN_USER.getRocketChatUserId());
+    }
+
+    public Map<String, String> build() {
+        return headerMap;
+    }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/view/CommunicationView.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/view/CommunicationView.java
index cfb141f320c5d74d9b7e97dbd12b13213df28de5..d1178369f086dab8ef56177949db28aad8dc9c62 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/view/CommunicationView.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/view/CommunicationView.java
@@ -4,10 +4,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import unipotsdam.gf.modules.user.User;
 import unipotsdam.gf.interfaces.ICommunication;
-import unipotsdam.gf.modules.communication.model.Message;
-import unipotsdam.gf.modules.communication.model.chat.ChatMessage;
-import unipotsdam.gf.modules.communication.model.chat.ChatRoom;
-import unipotsdam.gf.modules.communication.service.CommunicationDummyService;
 
 import javax.annotation.ManagedBean;
 import javax.inject.Inject;
@@ -37,47 +33,13 @@ public class CommunicationView {
     @Produces(MediaType.APPLICATION_JSON)
     @Path("/info/{roomId}")
     public Response getChatRoomInformation(@PathParam("roomId") String roomId) {
-        ChatRoom chatRoom = communicationService.getChatRoomInfo(roomId);
-        if (isNull(chatRoom)) {
+        String chatRoomName = communicationService.getChatRoomName(roomId);
+        if (chatRoomName.isEmpty()) {
             log.error("chatRoom not found for roomId: {}", roomId);
             return Response.status(Response.Status.NOT_FOUND).build();
         }
-        log.trace("getChatRoomInformationResponse: {}", chatRoom);
-        return Response.ok(chatRoom).build();
-    }
-
-    @GET
-    @Produces(MediaType.APPLICATION_JSON)
-    @Path("/history/{roomId}")
-    public Response getChatHistory(@PathParam("roomId") String roomId) {
-        List<ChatMessage> chatMessages = communicationService.getChatHistory(roomId);
-        if (isNull(chatMessages)) {
-            log.error("getChatHistory: chatRoom not found for roomId: {}", roomId);
-            return Response.status(Response.Status.NOT_FOUND).build();
-        }
-        log.trace("response for getChatHistory: {}", chatMessages);
-        return Response.ok(chatMessages).build();
-    }
-
-    @POST
-    @Consumes(MediaType.APPLICATION_JSON)
-    @Produces(MediaType.APPLICATION_JSON)
-    @Path("/send/{roomId}")
-    public Response sendMessage(Message message, @PathParam("roomId") String roomId) {
-        if (isNull(message)) {
-            log.trace("sendMessage message object was null");
-            return Response.status(Response.Status.BAD_REQUEST).entity("must provide message").build();
-        }
-        boolean wasSend = communicationService.sendMessageToChat(message, roomId);
-        Response response;
-        if (wasSend) {
-            log.trace("response for sendMessage: {}", wasSend);
-            response = Response.ok(wasSend).build();
-        } else {
-            log.error("error while sending message for message: {}", message);
-            response = Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("error while sending message").build();
-        }
-        return response;
+        log.trace("getChatRoomInformationResponse: {}", chatRoomName);
+        return Response.ok(chatRoomName).build();
     }
 
     @POST
@@ -89,7 +51,7 @@ public class CommunicationView {
             log.trace("addUser user object was null");
             return Response.status(Response.Status.BAD_REQUEST).entity("must provide user").build();
         }
-        boolean wasAdded = communicationService.addUserToChatRoom(roomId, user);
+        boolean wasAdded = communicationService.addUserToChatRoom(user, roomId);
         if (isNull(wasAdded)) {
             log.error("addUserToChatRoom: chatRoom not found for roomId: {}, user: {}", roomId, user);
             return Response.status(Response.Status.NOT_FOUND).build();
@@ -131,56 +93,20 @@ public class CommunicationView {
         return response;
     }
 
-    @POST
-    @Produces(MediaType.APPLICATION_JSON)
-    @Path("/setTopic/{roomId}")
-    public Response setChatRoomTopic(@PathParam("roomId") String roomId, @QueryParam("topic") String topic) {
-        if (isNull(topic)) {
-            log.trace("setTopic param not given");
-            return Response.status(Response.Status.BAD_REQUEST).entity("topic must be not empty").build();
-        }
-        boolean wasSet = communicationService.setChatRoomTopic(roomId, topic);
-        if (isNull(wasSet)) {
-            log.error("addChatRoomTopic: chatRoom not found for roomId: {}, topic: {}", roomId, topic);
-            return Response.status(Response.Status.NOT_FOUND).build();
-        }
-        Response response;
-        if (wasSet) {
-            log.trace("response for setTopic: {}", wasSet);
-            response = Response.ok(wasSet).build();
-        } else {
-            log.error("error while setting topic to chat room");
-            response = Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("error while setting topic to chat room").build();
-        }
-        return response;
-    }
-
     @POST
     @Consumes(MediaType.APPLICATION_JSON)
     @Produces(MediaType.APPLICATION_JSON)
-    @Path("/create")
-    public Response createChatRoom(@QueryParam("name") String name, List<User> users) {
+    @Path("/room/create/{name}")
+    public Response createChatRoom(@PathParam("name") String name, List<User> users, @QueryParam("readOnly") boolean readOnly) {
         if (isNull(name)) {
             return Response.status(Response.Status.BAD_REQUEST).entity("must provide name as queryParam").build();
         }
-        String chatId = communicationService.createChatRoom(name, users);
-        if (isNull(chatId)) {
+        String chatId = communicationService.createChatRoom(name, readOnly, users);
+        if (chatId.isEmpty()) {
             log.error("error while creating chatRoom for: name: {}, users: {}", name, users);
             return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
         }
         log.trace("response for createChatRoom: {}", chatId);
         return Response.status(Response.Status.CREATED).entity(chatId).build();
     }
-
-    // Temp: just get user as json
-    // TODO: remove after done implementing
-    @GET
-    @Path("/user")
-    @Produces(MediaType.APPLICATION_JSON)
-    public Response getUser() {
-        User user = ((CommunicationDummyService) communicationService).getUser();
-        return Response.ok(user).build();
-    }
-
-
 }
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/view/SampleView.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/view/SampleView.java
deleted file mode 100644
index e54f664db4177cdd62bb3aa58c6853c1a933ed13..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/view/SampleView.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package unipotsdam.gf.modules.communication.view;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import unipotsdam.gf.modules.communication.model.SampleAnswer;
-import unipotsdam.gf.modules.communication.service.SampleService;
-
-import javax.ws.rs.GET;
-import javax.ws.rs.Path;
-import javax.ws.rs.PathParam;
-import javax.ws.rs.Produces;
-import javax.ws.rs.core.MediaType;
-
-@Path("/example")
-public class SampleView {
-
-    Logger log = LoggerFactory.getLogger(SampleView.class);
-
-    @GET
-    @Produces(MediaType.APPLICATION_JSON)
-    @Path("{name}")
-    public SampleAnswer helloWorld(@PathParam("name") String name) {
-        SampleService sampleService = new SampleService();
-        SampleAnswer sampleAnswer = sampleService.provideSampleAnswer(name);
-        log.info("HelloWorldview helloWorld Method answered: {}",sampleAnswer);
-        return sampleAnswer;
-    }
-}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/groupfinding/service/GroupDAO.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/groupfinding/service/GroupDAO.java
new file mode 100644
index 0000000000000000000000000000000000000000..579fb0bb637de31b6d157396401d5f2b60cca13f
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/groupfinding/service/GroupDAO.java
@@ -0,0 +1,167 @@
+package unipotsdam.gf.modules.groupfinding.service;
+
+import org.apache.logging.log4j.util.Strings;
+import unipotsdam.gf.core.database.mysql.MysqlConnect;
+import unipotsdam.gf.core.database.mysql.VereinfachtesResultSet;
+import unipotsdam.gf.core.management.group.Group;
+import unipotsdam.gf.core.management.user.User;
+import unipotsdam.gf.core.management.util.ResultSetUtil;
+import unipotsdam.gf.modules.assessment.controller.model.StudentIdentifier;
+
+import javax.annotation.ManagedBean;
+import javax.annotation.Resource;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Objects;
+
+@ManagedBean
+@Resource
+@Singleton
+public class GroupDAO {
+
+    private MysqlConnect connect;
+
+    @Inject
+    public GroupDAO(MysqlConnect connect) {
+        this.connect = connect;
+    }
+
+    public ArrayList<String> getStudentsInSameGroupAs(StudentIdentifier student) {
+        connect.connect();
+        ArrayList<String> result = new ArrayList<>();
+        Integer groupId;
+        String mysqlRequest1 = "SELECT groupId FROM `groupuser` WHERE `projectId`=? AND `studentId`=?";
+        VereinfachtesResultSet vereinfachtesResultSet1 =
+                connect.issueSelectStatement(mysqlRequest1, student.getProjectId(), student.getStudentId());
+        vereinfachtesResultSet1.next();
+        groupId = vereinfachtesResultSet1.getInt("groupId");
+        String mysqlRequest2 = "SELECT * FROM `groupuser` WHERE `groupId`=?";
+        VereinfachtesResultSet vereinfachtesResultSet2 =
+                connect.issueSelectStatement(mysqlRequest2, groupId);
+        boolean next2 = vereinfachtesResultSet2.next();
+        while (next2) {
+            String peer = vereinfachtesResultSet2.getString("studentId");
+            if (!peer.equals(student.getStudentId()))
+                result.add(peer);
+            next2 = vereinfachtesResultSet2.next();
+        }
+        connect.close();
+        return result;
+    }
+
+    public void persist(Group group) {
+        connect.connect();
+        List<Group> existingGroups = getExistingEntriesOfGroups(group.getProjectId());
+        if (Objects.isNull(group.getChatRoomId())) {
+            group.setChatRoomId("");
+        }
+        String mysqlRequestGroup = "INSERT INTO groups (`projectId`,`chatRoomId`) values (?,?)";
+        connect.issueInsertOrDeleteStatement(mysqlRequestGroup, group.getProjectId(), group.getChatRoomId());
+
+        List<Group> existingGroupsWithNewEntry = getExistingEntriesOfGroups(group.getProjectId());
+        existingGroupsWithNewEntry.removeAll(existingGroups);
+        group.setId(existingGroupsWithNewEntry.get(0).getId());
+        for (User groupMember : group.getMembers()) {
+            String mysqlRequest2 = "INSERT INTO groupuser (`studentId`, `projectId`, `groupId`) values (?,?,?)";
+            connect.issueInsertOrDeleteStatement(mysqlRequest2, groupMember.getEmail(), group.getProjectId(), group.getId());
+        }
+        connect.close();
+
+    }
+
+    public void update(Group group) {
+        connect.connect();
+        String mysqlRequest = "UPDATE groups SET projectId = ?, chatRoomId = ? where id = ?";
+        connect.issueUpdateStatement(mysqlRequest, group.getProjectId(), group.getChatRoomId(), group.getId());
+        connect.close();
+        // TODO: implement update of groupuser if needed later (if member list need to be updated)
+    }
+
+    public void clearChatRoomIdOfGroup(String chatRoomId) {
+        connect.connect();
+        String mysqlRequest = "update groups SET chatRoomId = ? where chatRoomId = ?";
+        connect.issueUpdateStatement(mysqlRequest, "", chatRoomId);
+        connect.close();
+    }
+
+    public Boolean exists(Group group) {
+        List<Group> existingGroups = getGroupsByProjectId(group.getProjectId());
+        return existingGroups.contains(group);
+    }
+
+    public void addGroupMember(User groupMember, int groupId) {
+        // TODO: implement
+    }
+
+    public void deleteGroupMember(User groupMember, int groupId) {
+        // TODO: implement
+    }
+
+    public List<Group> getGroupsByProjectId(String projectId) {
+        connect.connect();
+        String mysqlRequest = "SELECT * FROM groups g " +
+                "JOIN groupuser gu ON g.id=gu.groupId " + "JOIN users u ON gu.studentId=u.email " +
+                "where g.projectId = ?";
+        VereinfachtesResultSet vereinfachtesResultSet =
+                connect.issueSelectStatement(mysqlRequest, projectId);
+        if (Objects.isNull(vereinfachtesResultSet)) {
+            connect.close();
+            return Collections.emptyList();
+        }
+        HashMap<Integer, Group> groupHashMap = new HashMap<>();
+        while (vereinfachtesResultSet.next()) {
+            fillGroupFromResultSet(vereinfachtesResultSet, groupHashMap);
+        }
+        ArrayList<Group> groups = new ArrayList<>();
+        groupHashMap.forEach((key, group) -> groups.add(group));
+        connect.close();
+        return groups;
+    }
+
+    public String getGroupChatRoomIdByStudentIdentifier(StudentIdentifier studentIdentifier) {
+        connect.connect();
+        String mysqlRequest = "SELECT g.chatRoomId FROM groups g join groupuser gu on g.id=gu.groupId where gu.projectId=? and gu.studentId=?";
+        VereinfachtesResultSet resultSet = connect.issueSelectStatement(mysqlRequest, studentIdentifier.getProjectId(), studentIdentifier.getStudentId());
+        if (Objects.isNull(resultSet)) {
+            connect.close();
+            return Strings.EMPTY;
+        }
+        String chatRoomId = Strings.EMPTY;
+        if (resultSet.next()) {
+            chatRoomId = resultSet.getString("chatRoomId");
+        }
+        connect.close();
+        return chatRoomId;
+    }
+
+    private void fillGroupFromResultSet(VereinfachtesResultSet vereinfachtesResultSet, HashMap<Integer, Group> existingGroups) {
+        int id = vereinfachtesResultSet.getInt("id");
+        if (existingGroups.containsKey(id)) {
+            existingGroups.get(id).addMember(ResultSetUtil.getUserFromResultSet(vereinfachtesResultSet));
+        } else {
+            String projectId = vereinfachtesResultSet.getString("projectId");
+            User user = ResultSetUtil.getUserFromResultSet(vereinfachtesResultSet);
+            String chatRoomId = vereinfachtesResultSet.getString("chatRoomId");
+            ArrayList<User> userList = new ArrayList<>(Collections.singletonList(user));
+            Group group = new Group(id, userList, projectId, chatRoomId);
+            existingGroups.put(id, group);
+        }
+    }
+
+    private List<Group> getExistingEntriesOfGroups(String projectId) {
+        String mysqlExistingGroup = "SELECT * FROM groups WHERE projectId = ?";
+        VereinfachtesResultSet resultSet = connect.issueSelectStatement(mysqlExistingGroup, projectId);
+        ArrayList<Group> existingGroups = new ArrayList<>();
+        while (resultSet.next()) {
+            int id = resultSet.getInt("id");
+            Group existingGroup = new Group(id, projectId);
+            existingGroups.add(existingGroup);
+        }
+        return existingGroups;
+    }
+
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/User.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/User.java
index fbacc36332744862c9a6a117014a34ce36b0375b..d2fe95f1d20ba2ecf98c4cb28d0856c464afbede 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/User.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/User.java
@@ -13,23 +13,41 @@ public class User {
     private String name;
     private String password;
     private String email;
+    private String token;
+    private String rocketChatUsername;
     private String rocketChatAuthToken;
-    private String rocketChatId;
+    private String rocketChatPersonalAccessToken;
+    private String rocketChatUserId;
     private Boolean isStudent;
 
     public User() {
     }
 
     public User(String name, String password, String email, Boolean isStudent) {
-        this(name, password, email, "", "", isStudent);
+        this(name, password, email, "", "", "",
+                "", "", isStudent);
+    }
+
+    public User(String name, String password, String email, String rocketChatUsername, Boolean isStudent) {
+        this(name, password, email, "", rocketChatUsername, "",
+                "", "", isStudent);
     }
 
     public User(String name, String password, String email,  String rocketChatAuthToken, String rocketChatId, Boolean isStudent) {
+    public User(String name, String password, String email, String rocketChatUsername, String rocketChatPersonalAccessToken, String rocketChatUserId) {
+        this(name, password, email, "", rocketChatUsername, "", rocketChatPersonalAccessToken, rocketChatUserId, false);
+    }
+
+    public User(String name, String password, String email, String rocketChatUsername,
+                String rocketChatAuthToken, String rocketChatPersonalAccessToken, String rocketChatUserId,
+                Boolean isStudent) {
         this.name = name;
         this.password = password;
         this.email = email;
+        this.rocketChatUsername = rocketChatUsername;
         this.rocketChatAuthToken = rocketChatAuthToken;
-        this.rocketChatId = rocketChatId;
+        this.rocketChatPersonalAccessToken = rocketChatPersonalAccessToken;
+        this.rocketChatUserId = rocketChatUserId;
         this.isStudent = isStudent;
     }
 
@@ -69,12 +87,12 @@ public class User {
         isStudent = student;
     }
 
-    public String getRocketChatId() {
-        return rocketChatId;
+    public String getRocketChatUserId() {
+        return rocketChatUserId;
     }
 
-    public void setRocketChatId(String rocketChatId) {
-        this.rocketChatId = rocketChatId;
+    public void setRocketChatUserId(String rocketChatUserId) {
+        this.rocketChatUserId = rocketChatUserId;
     }
 
     public String getRocketChatAuthToken() {
@@ -85,14 +103,32 @@ public class User {
         this.rocketChatAuthToken = rocketChatAuthToken;
     }
 
+    public String getRocketChatUsername() {
+        return rocketChatUsername;
+    }
+
+    public void setRocketChatUsername(String rocketChatUsername) {
+        this.rocketChatUsername = rocketChatUsername;
+    }
+
+    public String getRocketChatPersonalAccessToken() {
+        return rocketChatPersonalAccessToken;
+    }
+
+    public void setRocketChatPersonalAccessToken(String rocketChatPersonalAccessToken) {
+        this.rocketChatPersonalAccessToken = rocketChatPersonalAccessToken;
+    }
+
     @Override
     public String toString() {
         return "User{" +
                 "name='" + name + '\'' +
                 ", password='" + password + '\'' +
                 ", email='" + email + '\'' +
+                ", rocketChatUsername='" + rocketChatUsername + '\'' +
                 ", rocketChatAuthToken='" + rocketChatAuthToken + '\'' +
-                ", rocketChatId='" + rocketChatId + '\'' +
+                ", rocketChatPersonalAccessToken='" + rocketChatPersonalAccessToken + '\'' +
+                ", rocketChatUserId='" + rocketChatUserId + '\'' +
                 ", isStudent=" + isStudent +
                 '}';
     }
@@ -106,7 +142,7 @@ public class User {
                 Objects.equals(password, user.password) &&
                 Objects.equals(email, user.email) &&
                 Objects.equals(rocketChatAuthToken, user.rocketChatAuthToken) &&
-                Objects.equals(rocketChatId, user.rocketChatId) &&
+                Objects.equals(rocketChatUserId, user.rocketChatUserId) &&
                 Objects.equals(isStudent, user.isStudent);
     }
 }
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserDAO.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserDAO.java
index 24f786511fb094bded2e5415682466d4cdc1f7f0..740354d13099420448b8c358355bcf0d4eb652ab 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserDAO.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserDAO.java
@@ -29,9 +29,11 @@ public class UserDAO {
     public void persist(User user, UserProfile profile) {
         connect.connect();
         String mysqlRequest = "INSERT INTO users (`name`, `password`, `email`, `isStudent`," +
-                "`rocketChatId`,`rocketChatAuthToken`) values (?,?,?,?,?,?)";
+                "`rocketChatUserId`,`rocketChatUsername`,`rocketChatAuthToken`,`rocketChatPersonalAccessToken`) " +
+                "values (?,?,?,?,?,?,?,?,?)";
         connect.issueInsertOrDeleteStatement(mysqlRequest, user.getName(), user.getPassword(), user.getEmail(),
-                 user.getStudent(), user.getRocketChatId(), user.getRocketChatAuthToken());
+                user.getStudent(), user.getRocketChatUserId(), user.getRocketChatUsername(), user.getRocketChatAuthToken(),
+                user.getRocketChatPersonalAccessToken());
         connect.close();
         // TODO implmement UserProfile @Mar
     }
@@ -47,10 +49,10 @@ public class UserDAO {
         String mysqlRequest = "UPDATE `users` SET `name`=?,`password`=?,`email`=?,`isStudent`=?," +
                 "`rocketChatId`=?,`rocketChatAuthToken`=? WHERE email=? LIMIT 1";
         //TODO: maybe add handling if a line is actually updated
-        //TODO: if user is updated, it also must updateForUser all other tables which includes some information about the user, for example project user
+        //TODO: if user is updated, it also must update all other tables which includes some information about the user, for example project user
         connect.connect();
-        connect.issueUpdateStatement(mysqlRequest, user.getName(), user.getPassword(), user.getEmail(), user
-                .getStudent(), user.getRocketChatId(), user.getRocketChatAuthToken(), user.getEmail());
+        connect.issueUpdateStatement(mysqlRequest, user.getName(), user.getPassword(), user.getEmail(),
+                user.getStudent(), user.getRocketChatUserId(), user.getRocketChatAuthToken(), user.getEmail());
         connect.close();
     }
 
@@ -65,6 +67,15 @@ public class UserDAO {
         return result;
     }
 
+    public boolean existsByRocketChatUsername(String rocketChatUsername) {
+        connect.connect();
+        String mysqlRequest = "SELECT * FROM users where rocketChatUsername = ?";
+        VereinfachtesResultSet resultSet = connect.issueSelectStatement(mysqlRequest, rocketChatUsername);
+        boolean result = resultSet.next();
+        connect.close();
+        return result;
+    }
+
     public List<User> getUsersByProjectName(String projectName) {
         connect.connect();
         String query =
@@ -107,9 +118,6 @@ public class UserDAO {
         return getUserByField("email", email);
     }
 
-    public User getUserByToken(String token) {
-        return getUserByField("token", token);
-    }
 
     private User getUserByField(String field, String value) {
         connect.connect();
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserView.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserView.java
index 1be58094c6dc4d3fcae8dd7473c48a7f95cc5e52..a06604a7ff2186526240984414b430367b90b5cf 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserView.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserView.java
@@ -3,7 +3,6 @@ package unipotsdam.gf.modules.user;
 import unipotsdam.gf.modules.project.Management;
 import unipotsdam.gf.session.GFContexts;
 import unipotsdam.gf.interfaces.ICommunication;
-import unipotsdam.gf.modules.communication.service.CommunicationDummyService;
 
 import javax.annotation.ManagedBean;
 import javax.inject.Inject;
@@ -28,7 +27,6 @@ public class UserView {
     private ICommunication communicationService;
     private UserDAO userDAO;
 
-    @Inject
     private Management management;
 
     @Inject
@@ -79,8 +77,7 @@ public class UserView {
             @FormParam("email") String email) throws URISyntaxException {
 
         User user = new User(name, password, email, null);
-        ICommunication iCommunication = new CommunicationDummyService();
-        boolean isLoggedIn = iCommunication.loginUser(user);
+        boolean isLoggedIn = communicationService.loginUser(user);
         if (isLoggedIn) {
             return login(req, false, user);
         } else {
@@ -110,7 +107,7 @@ public class UserView {
      * @return
      * @throws URISyntaxException
      */
-    protected Response login(HttpServletRequest req, boolean createUser, User user) throws URISyntaxException {
+    public Response login(HttpServletRequest req, boolean createUser, User user) throws URISyntaxException {
 
         if (management.exists(user)) {
             if (!createUser) {
@@ -121,7 +118,7 @@ public class UserView {
             return forwardToLocation(existsUrl);
         } else {
             if (createUser) {
-                boolean isRegisteredAndLoggedIn = communicationService.registerAndLoginUser(user);
+                boolean isRegisteredAndLoggedIn = communicationService.registerUser(user);
                 if (!isRegisteredAndLoggedIn) {
                     return registrationError();
                 }
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/util/ResultSetUtil.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/util/ResultSetUtil.java
index 02d5ce213e71467b805f17e9e99ed6ba9ec6f2bf..82e595e43d3c3ae4410a41a3021c61f481a4bc1f 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/util/ResultSetUtil.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/util/ResultSetUtil.java
@@ -11,7 +11,10 @@ public class ResultSetUtil {
         String email = vereinfachtesResultSet.getString("email");
         String rocketChatId = vereinfachtesResultSet.getString("rocketChatId");
         String rocketChatAuthToken = vereinfachtesResultSet.getString("rocketChatAuthToken");
+        String rocketChatPersonalAccessToken = vereinfachtesResultSet.getString("rocketChatPersonalAccessToken");
+        String rocketChatUserId = vereinfachtesResultSet.getString("rocketChatUserId");
         Boolean isStudent = vereinfachtesResultSet.getBoolean("isStudent");
-        return new User(name, password, email, rocketChatId, rocketChatAuthToken, isStudent);
+        return new User(name, password, email, rocketChatUsername, rocketChatAuthToken,
+                rocketChatPersonalAccessToken, rocketChatUserId, isStudent);
     }
 }
diff --git a/gemeinsamforschen/src/main/webapp/communication/chatWindow.tld b/gemeinsamforschen/src/main/webapp/communication/chatWindow.tld
deleted file mode 100644
index e98a7ae49e0b8eba380ac79f2efd35b0840c63cc..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/main/webapp/communication/chatWindow.tld
+++ /dev/null
@@ -1,16 +0,0 @@
-<taglib>
-    <tlib-version>1.0</tlib-version>
-    <jsp-version>2.0</jsp-version>
-    <short-name>chatWindow</short-name>
-
-    <tag>
-        <name>chatWindow</name>
-        <tag-class>unipotsdam.gf.modules.communication.ChatWindow</tag-class>
-        <body-content>empty</body-content>
-        <attribute>
-            <name>orientation</name>
-            <required>yes</required>
-            <rtexprvalue>no</rtexprvalue>
-        </attribute>
-    </tag>
-</taglib>
\ No newline at end of file
diff --git a/gemeinsamforschen/src/main/webapp/profile/profile.jsp b/gemeinsamforschen/src/main/webapp/profile/profile.jsp
index b849f708fdf3fe0b07b6eb3875e01b32de819ef2..cb935e74e5bd5191f40e4b12660ba00adf37f496 100644
--- a/gemeinsamforschen/src/main/webapp/profile/profile.jsp
+++ b/gemeinsamforschen/src/main/webapp/profile/profile.jsp
@@ -4,6 +4,13 @@
 <%@ taglib uri="../taglibs/gemeinsamForschen.tld" prefix="headLine" %>
 <%@ taglib uri="../taglibs/gemeinsamForschen.tld" prefix="omniDependencies" %>
 <%@ taglib uri="../taglibs/gemeinsamForschen.tld" prefix="footer" %>
+<%@ page import="unipotsdam.gf.core.database.mysql.MysqlConnect" %>
+<%@ page import="unipotsdam.gf.core.management.user.User" %>
+<%@ page import="unipotsdam.gf.core.management.user.UserDAO" %>
+<%@ taglib uri="../core/gemeinsamForschen.tld" prefix="menu" %>
+<%@ taglib uri="../core/gemeinsamForschen.tld" prefix="headLine" %>
+<%@ taglib uri="../core/gemeinsamForschen.tld" prefix="omniDependencies" %>
+<%@ taglib uri="../core/gemeinsamForschen.tld" prefix="footer" %>
 
 
 <!DOCTYPE html>
@@ -16,9 +23,17 @@
     <script src="js/profile.js"></script>
 </head>
 
+
+<%
+    // Retrieve user to be used here
+    String token = request.getParameter("token");
+    UserDAO userDAO = new UserDAO(new MysqlConnect());
+    User user = userDAO.getUserByToken(token);
+%>
+
 <body>
-<menu:menu hierarchy="1"/>
 <div id="wrapper">
+    <menu:menu hierarchy="1"/>
 
     <div class="page-content-wrapper">
         <headLine:headLine/>
@@ -30,7 +45,7 @@
                         <%-- TODO: retrieve profile data --%>
                         <ul class="list-group">
                             <li class="list-group-item">
-
+                                <p>Name: <%=user.getName()%></p>
                             </li>
                             <li class="list-group-item">
                                 <p>Sonstiges:</p>
diff --git a/gemeinsamforschen/src/main/webapp/taglibs/gemeinsamForschen.tld b/gemeinsamforschen/src/main/webapp/taglibs/gemeinsamForschen.tld
index 6af4372d639f544d0312122d565139d96dac602d..e253dbf3fd4501432b913f8d4ab0ce52344e25b2 100644
--- a/gemeinsamforschen/src/main/webapp/taglibs/gemeinsamForschen.tld
+++ b/gemeinsamforschen/src/main/webapp/taglibs/gemeinsamForschen.tld
@@ -53,6 +53,15 @@
         </attribute>
     </tag>
 
-
+    <tag>
+        <name>chatWindow</name>
+        <tag-class>unipotsdam.gf.modules.communication.ChatWindow</tag-class>
+        <body-content>empty</body-content>
+        <attribute>
+            <name>orientation</name>
+            <required>yes</required>
+            <rtexprvalue>no</rtexprvalue>
+        </attribute>
+    </tag>
 
 </taglib>
\ No newline at end of file
diff --git a/gemeinsamforschen/src/scripts/dbschema/createDummyUsersGroupsProject.sql b/gemeinsamforschen/src/scripts/dbschema/createDummyUsersGroupsProject.sql
index e0e2a801f08174f4f017b052b4fa2315a8481a03..34a7e7d32f82dfbd1c3549e0311fd598051566d6 100644
--- a/gemeinsamforschen/src/scripts/dbschema/createDummyUsersGroupsProject.sql
+++ b/gemeinsamforschen/src/scripts/dbschema/createDummyUsersGroupsProject.sql
@@ -3,28 +3,28 @@
   Functions with empty grouptable only (because of autoincrement id of group)
  */
 
-INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatId`, `rocketChatAuthToken`) VALUES
+INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatUserId`, `rocketChatAuthToken`) VALUES
   ('teststudent1', 'egal', 'test1@uni.de', 'test1','1','abc');
 
-INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatId`, `rocketChatAuthToken`) VALUES
+INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatUserId`, `rocketChatAuthToken`) VALUES
   ('teststudent2', 'egal', 'test2@uni.de', 'test1','1','abc');
 
-INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatId`, `rocketChatAuthToken`) VALUES
+INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatUserId`, `rocketChatAuthToken`) VALUES
   ('teststudent3', 'egal', 'test3@uni.de', 'test1','1','abc');
 
-INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatId`, `rocketChatAuthToken`) VALUES
+INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatUserId`, `rocketChatAuthToken`) VALUES
   ('teststudent4', 'egal', 'test4@uni.de', 'test1','1','abc');
 
-INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatId`, `rocketChatAuthToken`) VALUES
+INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatUserId`, `rocketChatAuthToken`) VALUES
   ('teststudent5', 'egal', 'test5@uni.de', 'test1','1','abc');
 
-INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatId`, `rocketChatAuthToken`) VALUES
+INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatUserId`, `rocketChatAuthToken`) VALUES
   ('teststudent6', 'egal', 'test6@uni.de', 'test1','1','abc');
 
-INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatId`, `rocketChatAuthToken`) VALUES
+INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatUserId`, `rocketChatAuthToken`) VALUES
   ('teststudent7', 'egal', 'test7@uni.de', 'test1','1','abc');
 
-INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatId`, `rocketChatAuthToken`) VALUES
+INSERT INTO `users` (`name`, `password`, `email`, `token`, `rocketChatUserId`, `rocketChatAuthToken`) VALUES
   ('teststudent8', 'egal', 'test8@uni.de', 'test1','1','abc');
 
 INSERT INTO  `projects` (`id`, `password`,`active`,`timecreated`,`authorEmail`,`adminpassword`,`token`,`phase`) VALUES
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/CommunicationDummyServiceTest.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/CommunicationDummyServiceTest.java
deleted file mode 100644
index 6c6e0577b2c756e3841a38d76f8d5b3d29e14218..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/CommunicationDummyServiceTest.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package unipotsdam.gf.modules.communication.service;
-
-import org.junit.Before;
-import org.junit.Test;
-import unipotsdam.gf.modules.user.User;
-import unipotsdam.gf.interfaces.ICommunication;
-
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-public class CommunicationDummyServiceTest {
-
-    private ICommunication iCommunication;
-    private User user;
-
-    @Before
-    public void setUp() {
-        iCommunication = new CommunicationDummyService();
-        user = new User("name", "password", "email", true);
-    }
-
-    @Test
-    public void loginUser() {
-        boolean isLoggedIn = iCommunication.loginUser(user);
-        assertNotNull(user.getRocketChatId());
-        assertNotNull(user.getRocketChatAuthToken());
-        assertTrue(isLoggedIn);
-    }
-
-    @Test
-    public void registerUser() {
-        boolean userCreated = iCommunication.registerUser(user);
-        assertNotNull(user.getRocketChatId());
-        assertNull(user.getRocketChatAuthToken());
-        assertTrue(userCreated);
-    }
-}
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/CommunicationServiceTest.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/CommunicationServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..344bef48bcfa3b9b33535134f792327b6c2fd176
--- /dev/null
+++ b/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/CommunicationServiceTest.java
@@ -0,0 +1,283 @@
+package unipotsdam.gf.modules.communication.service;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import uk.co.jemos.podam.api.PodamFactory;
+import uk.co.jemos.podam.api.PodamFactoryImpl;
+import unipotsdam.gf.core.database.InMemoryMySqlConnect;
+import unipotsdam.gf.core.database.mysql.MysqlConnect;
+import unipotsdam.gf.core.management.ManagementImpl;
+import unipotsdam.gf.core.management.group.Group;
+import unipotsdam.gf.core.management.project.Project;
+import unipotsdam.gf.core.management.project.ProjectDAO;
+import unipotsdam.gf.core.management.user.User;
+import unipotsdam.gf.core.management.user.UserDAO;
+import unipotsdam.gf.core.management.user.UserProfile;
+import unipotsdam.gf.core.management.user.UserService;
+import unipotsdam.gf.core.states.model.Constraints;
+import unipotsdam.gf.core.states.model.ConstraintsMessages;
+import unipotsdam.gf.interfaces.ICommunication;
+import unipotsdam.gf.modules.assessment.controller.model.StudentIdentifier;
+import unipotsdam.gf.modules.communication.model.EMailMessage;
+import unipotsdam.gf.modules.groupfinding.service.GroupDAO;
+
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static unipotsdam.gf.config.GFRocketChatConfig.ADMIN_USER;
+import static unipotsdam.gf.config.GFRocketChatConfig.ROCKET_CHAT_ROOM_LINK;
+import static unipotsdam.gf.config.GFRocketChatConfig.TEST_USER;
+
+public class CommunicationServiceTest {
+
+    private ICommunication iCommunication;
+    private User user;
+    private GroupDAO groupDAO;
+    private UserDAO userDAO;
+
+    private List<String> createdChatRooms;
+
+    @Before
+    public void setUp() {
+        InMemoryMySqlConnect inMemoryMySqlConnect = new InMemoryMySqlConnect();
+        userDAO = new UserDAO(inMemoryMySqlConnect);
+        groupDAO = new GroupDAO(inMemoryMySqlConnect);
+        iCommunication = new CommunicationService(new UnirestService(), userDAO, groupDAO);
+        user = new User("Vorname Nachname", "password", "email@uni.de", true);
+        createdChatRooms = new ArrayList<>();
+    }
+
+    @After
+    public void tearDown() {
+        createdChatRooms.forEach(createdChatRoom -> iCommunication.deleteChatRoom(createdChatRoom));
+        createdChatRooms.clear();
+    }
+
+    @Test
+    public void loginUser() {
+        assertTrue(iCommunication.loginUser(TEST_USER));
+        assertTrue(!TEST_USER.getRocketChatAuthToken().isEmpty());
+        assertTrue(TEST_USER.getRocketChatUserId().isEmpty());
+
+        User falseLoginUser = new User("name", "password", "email", true);
+        assertFalse(iCommunication.loginUser(falseLoginUser));
+    }
+
+    @Test
+    public void registerUser() {
+        boolean userCreated = iCommunication.registerUser(user);
+        assertTrue(userCreated);
+        assertNotNull(user.getRocketChatUserId());
+        assertNotNull(user.getRocketChatAuthToken());
+        assertNotNull(user.getRocketChatPersonalAccessToken());
+
+    }
+
+    @Test
+    public void createEmptyChatRoom() {
+        String chatRoom = iCommunication.createEmptyChatRoom("Test", false);
+        assertNotNull(chatRoom);
+        assertFalse(chatRoom.isEmpty());
+        assertTrue(iCommunication.exists(chatRoom));
+
+
+        String chatRoomReadOnly = iCommunication.createEmptyChatRoom("Test2", true);
+        assertNotNull(chatRoomReadOnly);
+        assertFalse(chatRoomReadOnly.isEmpty());
+        assertTrue(iCommunication.exists(chatRoomReadOnly));
+
+        createdChatRooms.addAll(Arrays.asList(chatRoom, chatRoomReadOnly));
+    }
+
+    @Test
+    public void createChatRoomWithUser() {
+        List<User> userList = Arrays.asList(ADMIN_USER, TEST_USER);
+        String chatRoom = iCommunication.createChatRoom("ChatWithUser", false, userList);
+
+        assertNotNull(chatRoom);
+        assertFalse(chatRoom.isEmpty());
+        assertTrue(iCommunication.exists(chatRoom));
+
+        createdChatRooms.add(chatRoom);
+    }
+
+    @Test
+    public void createChatRoomWithGroup() {
+        Group group = new Group();
+        group.setMembers(Collections.singletonList(ADMIN_USER));
+        group.setProjectId("chatWithGroup");
+        group.setId(1);
+        boolean successful = iCommunication.createChatRoom(group, false);
+        assertTrue(successful);
+
+        createdChatRooms.add(group.getChatRoomId());
+    }
+
+    @Test
+    public void getChatRoomName() {
+        String expectedChatRoomName = "ChatRoomName";
+        String chatRoomId = iCommunication.createEmptyChatRoom(expectedChatRoomName, false);
+        assertNotNull(chatRoomId);
+        assertFalse(chatRoomId.isEmpty());
+
+        String actualChatRoomName = iCommunication.getChatRoomName(chatRoomId);
+        assertEquals(expectedChatRoomName, actualChatRoomName);
+
+        String nonExistingChatRoomName = iCommunication.getChatRoomName("1");
+        assertTrue(nonExistingChatRoomName.isEmpty());
+
+        createdChatRooms.add(chatRoomId);
+    }
+
+    @Test
+    public void getChatRoomLink() {
+        String projectId = "Projekt";
+        Group group = new Group();
+        userDAO.persist(ADMIN_USER, new UserProfile());
+
+        group.setProjectId(projectId);
+        group.setMembers(Collections.singletonList(ADMIN_USER));
+        groupDAO.persist(group);
+        iCommunication.createChatRoom(group, false);
+        groupDAO.update(group);
+
+        String chatRoomLink = iCommunication.getChatRoomLink(ADMIN_USER.getToken(), projectId);
+        assertNotNull(chatRoomLink);
+        assertFalse(chatRoomLink.isEmpty());
+        String expectedUrl = ROCKET_CHAT_ROOM_LINK + projectId + "-" + group.getId() + "?layout=embedded";
+        assertEquals(expectedUrl, chatRoomLink);
+
+        createdChatRooms.add(group.getChatRoomId());
+
+    }
+
+    @Test
+    public void exists() {
+        String expectedChatRoomName = "ChatRoomName";
+        String chatRoomId = iCommunication.createEmptyChatRoom(expectedChatRoomName, false);
+        assertNotNull(chatRoomId);
+        assertFalse(chatRoomId.isEmpty());
+
+        assertTrue(iCommunication.exists(chatRoomId));
+        assertFalse(iCommunication.exists("1"));
+
+        createdChatRooms.add(chatRoomId);
+    }
+
+    @Test
+    public void addUserToChatRoom() {
+        String chatRoomId = iCommunication.createEmptyChatRoom("addUser", false);
+        assertNotNull(chatRoomId);
+        assertFalse(chatRoomId.isEmpty());
+
+        assertTrue(iCommunication.addUserToChatRoom(TEST_USER, chatRoomId));
+
+        createdChatRooms.add(chatRoomId);
+    }
+
+    @Test
+    public void removeUserFromChatRoom() {
+        String chatRoomId = iCommunication.createEmptyChatRoom("removeUser", false);
+        assertNotNull(chatRoomId);
+        assertFalse(chatRoomId.isEmpty());
+
+        assertTrue(iCommunication.addUserToChatRoom(TEST_USER, chatRoomId));
+
+        assertTrue(iCommunication.removeUserFromChatRoom(TEST_USER, chatRoomId));
+
+        createdChatRooms.add(chatRoomId);
+    }
+
+    @Test
+    public void deleteChatRoom() {
+        String chatRoomId = iCommunication.createEmptyChatRoom("deleteChatRoom", false);
+        assertNotNull(chatRoomId);
+        assertFalse(chatRoomId.isEmpty());
+        assertTrue(iCommunication.exists(chatRoomId));
+
+        assertTrue(iCommunication.deleteChatRoom(chatRoomId));
+        assertFalse(iCommunication.exists(chatRoomId));
+    }
+
+    @Test
+    @Ignore
+    public void sendSingleMessage() {
+        User user = new User();
+        // Permalink for email-address: http://www.trashmail.de/index.php?search=javatest
+        user.setEmail("javatest@trashmail.de");
+        EMailMessage eMailMessage = new EMailMessage();
+        eMailMessage.setSubject("Test Email");
+        eMailMessage.setBody("Test Body");
+
+        iCommunication.sendSingleMessage(eMailMessage, user);
+    }
+
+    @Test
+    @Ignore
+    public void informAboutMissingTasks() {
+        HashMap<StudentIdentifier, ConstraintsMessages> tasks = new HashMap<>();
+        Project project = new Project();
+        String projectId = "Projekt";
+        project.setId(projectId);
+        StudentIdentifier studentIdentifier = new StudentIdentifier();
+        studentIdentifier.setProjectId(projectId);
+        // Permalink for email-address: http://www.trashmail.de/index.php?search=javatest
+        studentIdentifier.setStudentId("javatest@trashmail.de");
+        ConstraintsMessages constraintsMessages = new ConstraintsMessages(Constraints.QuizCount, studentIdentifier);
+        tasks.put(studentIdentifier, constraintsMessages);
+        boolean successful = iCommunication.informAboutMissingTasks(tasks, project);
+        assertTrue(successful);
+    }
+
+    @Test
+    @Ignore
+    public void createTestData() {
+        User user = new User();
+        user.setName("Martin Nachname");
+        user.setPassword("test1234");
+        user.setEmail("martin@test.com");
+        user.setStudent(true);
+        MysqlConnect mysqlConnect = new MysqlConnect();
+        UserDAO userDAO = new UserDAO(mysqlConnect);
+        GroupDAO groupDAO = new GroupDAO(mysqlConnect);
+        ProjectDAO projectDAO = new ProjectDAO(mysqlConnect);
+        UnirestService unirestService = new UnirestService();
+        CommunicationService communicationService = new CommunicationService(unirestService, userDAO, groupDAO);
+        ManagementImpl management = new ManagementImpl(userDAO, groupDAO, projectDAO, mysqlConnect);
+        UserService userService = new UserService(communicationService, userDAO, management);
+        try {
+            userService.login(true, user);
+        } catch (URISyntaxException e) {
+            Assert.fail();
+        }
+        assertTrue(userDAO.exists(user));
+
+        PodamFactory podamFactory = new PodamFactoryImpl();
+        Project project = podamFactory.manufacturePojo(Project.class);
+        // for the dummy data on website
+        String projectId = "gemeinsamForschen";
+        project.setId(projectId);
+        projectDAO.persist(project);
+        assertTrue(projectDAO.exists(project));
+
+        Group group = new Group();
+        group.setProjectId(projectId);
+        group.setMembers(Collections.singletonList(user));
+        groupDAO.persist(group);
+        assertTrue(groupDAO.exists(group));
+
+        boolean success = communicationService.createChatRoom(group, false);
+        assertTrue(success);
+    }
+}
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/SampleServiceTest.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/SampleServiceTest.java
deleted file mode 100644
index e510a60cc1682b78b89721be660fe320cd093f51..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/SampleServiceTest.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package unipotsdam.gf.modules.communication.service;
-
-
-import org.junit.Test;
-import unipotsdam.gf.modules.communication.model.SampleAnswer;
-
-import static org.junit.Assert.assertEquals;
-
-
-public class SampleServiceTest {
-
-    @Test
-    public void returnCorrectMessage() {
-        SampleService sampleService = new SampleService();
-        SampleAnswer sampleAnswer = sampleService.provideSampleAnswer("test");
-
-        assertEquals(sampleAnswer.getAnswer(), "Hello test");
-    }
-}