Merge remote-tracking branch 'origin/rocketChatApiImpl_#63' into development_master

# Conflicts:
#	gemeinsamforschen/pom.xml
#	gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFApplicationBinder.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/core/management/project/ProjectDAO.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/ICommunication.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/ChatWindow.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/Messages.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/CommunicationDummyService.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/DummyProjectCreationService.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/modules/groupfinding/service/GroupDAO.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/User.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserDAO.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserView.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/process/phases/PhasesImpl.java
#	gemeinsamforschen/src/main/java/unipotsdam/gf/util/ResultSetUtil.java
#	gemeinsamforschen/src/main/webapp/profile/profile.jsp
#	gemeinsamforschen/src/main/webapp/project-docent.jsp
#	gemeinsamforschen/src/main/webapp/project-student.jsp
#	gemeinsamforschen/src/main/webapp/taglibs/gemeinsamForschen.tld
#	gemeinsamforschen/src/scripts/dbschema/createDummyUser.sql
#	gemeinsamforschen/src/test/java/unipotsdam/gf/core/management/group/GroupDAOTest.java
#	gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/CommunicationDummyServiceTest.java
#	gemeinsamforschen/src/test/java/unipotsdam/gf/modules/groupfinding/dummy/service/DummyProjectCreationServiceTest.java
#	gemeinsamforschen/src/test/resources/database/fltrail.sql

gemeinsamforschen/README.md

+# 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

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>

gemeinsamforschen/src/main/java/unipotsdam/gf/config/Constants.java

-package unipotsdam.gf.config;
-
-public interface Constants {
-
-    String ROCKET_CHAT_URL = "http://rocketchat.westeurope.cloudapp.azure.com";
-}

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);
     }
 }

gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFMailConfig.java

+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 = "";
+}

gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFRocketChatConfig.java

 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);
 }

gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/ICommunication.java

 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);
 }

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/ChatWindow.java

 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) {

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/Messages.java

-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;
     }
 }

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/EMailMessage.java

+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;
+    }
+
+
+}

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/Message.java

-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 + '\'' +
-                '}';
-    }
-}

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/SampleAnswer.java

-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 + '\'' +
-                '}';
-    }
-}

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/chat/ChatRoom.java

 package unipotsdam.gf.modules.communication.model.chat;
 
+// TODO: never used at the moment by ICommunication, just context, maybe remove
 public class ChatRoom {
 
     String id;

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/rocketChat/RocketChatLoginResponse.java

+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() : "";
+    }
+}

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/rocketChat/RocketChatRegisterResponse.java

+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;
+    }
+}

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/CommunicationDummyService.java

-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);
-    }
-}

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/CommunicationService.java

+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();
+    }
+}

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/SampleService.java

-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;
-    }
-}

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/UnirestService.java

+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);
+    }
+}

gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/util/RocketChatHeaderMapBuilder.java

+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;
+    }
+}