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 d8690cf1aff2e60c34147eadc637a9a82fb9c490..7f54357ce3fd7e7fda8c8577ba8d92d2562c5e24 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFApplicationBinder.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFApplicationBinder.java
@@ -6,14 +6,11 @@ import unipotsdam.gf.modules.annotation.controller.AnnotationController;
import unipotsdam.gf.modules.annotation.controller.FeedbackImpl;
import unipotsdam.gf.modules.assessment.controller.service.AssessmentDBCommunication;
import unipotsdam.gf.modules.assessment.controller.service.PeerAssessment;
-import unipotsdam.gf.modules.communication.service.CommunicationDummyService;
-import unipotsdam.gf.modules.group.DummyProjectCreationService;
+import unipotsdam.gf.modules.communication.service.CommunicationService;
+import unipotsdam.gf.modules.communication.service.UnirestService;
import unipotsdam.gf.modules.group.GroupDAO;
import unipotsdam.gf.modules.group.GroupfindingImpl;
import unipotsdam.gf.modules.journal.service.IJournalImpl;
-import unipotsdam.gf.modules.journal.service.JournalService;
-import unipotsdam.gf.modules.journal.service.JournalServiceImpl;
-import unipotsdam.gf.modules.journal.util.JournalUtils;
import unipotsdam.gf.modules.project.Management;
import unipotsdam.gf.modules.project.ManagementImpl;
import unipotsdam.gf.modules.project.ProjectConfigurationDAO;
@@ -35,18 +32,17 @@ 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);
bind(GFContext.class).to(GFContext.class);
- bind(JournalUtils.class).to(JournalUtils.class);
- bind(JournalServiceImpl.class).to(JournalService.class);
bind(ManagementImpl.class).to(Management.class);
- bind(FeedbackImpl.class).to(Feedback.class);
bind(DummyResearchReportManagement.class).to(ResearchReportManagement.class);
bind(IJournalImpl.class).to(IJournal.class);
bind(GroupfindingImpl.class).to(IGroupFinding.class);
@@ -59,16 +55,20 @@ public class GFApplicationBinder extends AbstractBinder {
bind(SubmissionController.class).to(SubmissionController.class);
bind(AnnotationController.class).to(AnnotationController.class);
bind(ProjectConfigurationDAO.class).to(ProjectConfigurationDAO.class);
- bind(DummyProjectCreationService.class).to(DummyProjectCreationService.class);
bind(UserDAO.class).to(UserDAO.class);
bind(ProjectDAO.class).to(ProjectDAO.class);
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/GFDatabaseConfig.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFDatabaseConfig.java
index 252905102d2472eaa125f06499bbdfe1663ea254..9d61aea469fb9aebdd44000313224d34bb8c5b1b 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFDatabaseConfig.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFDatabaseConfig.java
@@ -10,4 +10,5 @@ public class GFDatabaseConfig {
public static final String USER = "root";
public static final String PASS = "";
public static final String DB_NAME = "fltrail";
+ public static final String TEST_DB_NAME = "fltrail_test";
}
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..8fd0ea098cf755ec609feaa4f76069bf4f8bcddd 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFRocketChatConfig.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/config/GFRocketChatConfig.java
@@ -1,8 +1,52 @@
package unipotsdam.gf.config;
+
+import unipotsdam.gf.modules.communication.model.RocketChatUser;
+import unipotsdam.gf.modules.user.User;
+
+/**
+ * ROCKET CHAT NEEDS TO KNOW THE ENDPOINT FOR THE SSO CONFIGURE LIKE IN README
+ *
+ * 1. FOR API URL: http://141.89.53.195:8080/gemeinsamforschen/rest/chat/sso
+ * localhost:8080/gemeinsamforschen/rest/chat/sso
+ *
+ * 1. FOR IFRAME URL: http://141.89.53.195:8080/gemeinsamforschen/rest/chat/login
+ * localhost:8080/gemeinsamforschen/rest/chat/login
+ */
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_LINK_0 = "https://rocket.farm-test.rz.uni-potsdam.de";
+ // public static final String ROCKET_CHAT_LINK = "https://rocket.farm-test.rz.uni-potsdam.de/";
+
+ public static final String ROCKET_CHAT_LINK_0 = "http://fleckenroller.cs.uni-potsdam.de:3000";
+ public static final String ROCKET_CHAT_LINK = "http://fleckenroller.cs.uni-potsdam.de:3000/";
+
+ /**
+ * username: fltrailadmin pw: GEbCM1Rso6TUGGMKtGmg6c5EydMQEu61K9zdD10F
+ */
+
+ 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 RocketChatUser TEST_USER = new RocketChatUser("student1", "egal",
+ "student1@yolo.com", "student1", "",
+ "", "6ofqfp8J9ynfvspBJ", false);
+
+ /* public static final User ADMIN_USER = new User("admin nachname", "passwort",
+ "email", "rocketChatUsername", "rocketChatAuthToken",
+ "rocketChatPersonalAccessToken", "rocketChatUserId", false);*/
+ public static final RocketChatUser ADMIN_USER = new RocketChatUser("fltrailadmin", "GEbCM1Rso6TUGGMKtGmg6c5EydMQEu61K9zdD10F",
+ "julian.dehne@uni-potsdam.de", "rocketChatUsername", "rocketChatAuthToken",
+ "rocketChatPersonalAccessToken", "SuFbpF3P9aYEo634W", false);
+
+
+
+ /**
+ * curl -H "Content-type:application/json" \
+ * https://rocket.farm-test.rz.uni-potsdam.de/api/v1/login \
+ * -d '{ "user": "test@stuff.com", "password": "passwort" }'
+ * um
+ */
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/MysqlDownException.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/MysqlDownException.java
new file mode 100644
index 0000000000000000000000000000000000000000..647f39f6954cdad03233c8af372089ad7816d65a
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/MysqlDownException.java
@@ -0,0 +1,4 @@
+package unipotsdam.gf.exceptions;
+
+public class MysqlDownException {
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/RocketChatDownException.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/RocketChatDownException.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b9bdb421f2ff7fa7ba214ebe78c6b7aff1c7398
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/RocketChatDownException.java
@@ -0,0 +1,4 @@
+package unipotsdam.gf.exceptions;
+
+public class RocketChatDownException extends Exception {
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserDoesNotExistInMysqlException.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserDoesNotExistInMysqlException.java
new file mode 100644
index 0000000000000000000000000000000000000000..5231c47a4ce7f4b3764a223a3730964dabc75e5e
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserDoesNotExistInMysqlException.java
@@ -0,0 +1,4 @@
+package unipotsdam.gf.exceptions;
+
+public class UserDoesNotExistInMysqlException extends Exception {
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserDoesNotExistInRocketChatException.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserDoesNotExistInRocketChatException.java
new file mode 100644
index 0000000000000000000000000000000000000000..a877a7f2ec4b0c6fed06392bcc6c40a53cab4372
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserDoesNotExistInRocketChatException.java
@@ -0,0 +1,4 @@
+package unipotsdam.gf.exceptions;
+
+public class UserDoesNotExistInRocketChatException extends Exception {
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserExistsInMysqlException.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserExistsInMysqlException.java
new file mode 100644
index 0000000000000000000000000000000000000000..f9982f918896a8397294fdbf7bc18ad8b8fb0f1d
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserExistsInMysqlException.java
@@ -0,0 +1,9 @@
+package unipotsdam.gf.exceptions;
+
+public class UserExistsInMysqlException extends Exception {
+
+ @Override
+ public String getMessage() {
+ return "Tried to create User but exists in mysql";
+ }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserExistsInRocketChatException.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserExistsInRocketChatException.java
new file mode 100644
index 0000000000000000000000000000000000000000..8160dadf6cc03059fe1bb5d20ff447902a613b65
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/exceptions/UserExistsInRocketChatException.java
@@ -0,0 +1,8 @@
+package unipotsdam.gf.exceptions;
+
+public class UserExistsInRocketChatException extends Exception {
+ @Override
+ public String getMessage() {
+ return "Tried to create User but exists in RocketChat";
+ }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/ICommunication.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/ICommunication.java
index ece710bea944cf6039ef9aa659244b169757e9f1..4d1a3f7781d82e58d91d3ef9fe19c4aba9f7c939 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/ICommunication.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/ICommunication.java
@@ -1,12 +1,17 @@
package unipotsdam.gf.interfaces;
+
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
+import unipotsdam.gf.exceptions.UserExistsInRocketChatException;
+import unipotsdam.gf.modules.assessment.controller.model.StudentIdentifier;
+import unipotsdam.gf.modules.communication.model.EMailMessage;
+import unipotsdam.gf.modules.communication.model.RocketChatUser;
+import unipotsdam.gf.modules.communication.model.chat.ChatMessage;
+import unipotsdam.gf.modules.group.Group;
import unipotsdam.gf.modules.project.Project;
import unipotsdam.gf.modules.user.User;
import unipotsdam.gf.process.constraints.ConstraintsMessages;
-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 java.util.List;
import java.util.Map;
@@ -23,21 +28,39 @@ 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)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException;
+
+ /**
+ * 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)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException;
+ String createEmptyChatRoom(String name, boolean readOnly)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException;
+
+ void deleteChatRoom(Group group) throws RocketChatDownException, UserDoesNotExistInRocketChatException;
+
+ void deleteChatRoom(Project project) throws RocketChatDownException, UserDoesNotExistInRocketChatException;
+
+ boolean deleteChatRoom(String roomId) throws RocketChatDownException, UserDoesNotExistInRocketChatException;
/**
* endpoint: https://rocket.chat/docs/developer-guides/rest-api/groups/invite/
@@ -46,9 +69,11 @@ 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)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException;
- boolean removeUserFromChatRoom(User user, String roomId) ;
+ boolean removeUserFromChatRoom(User user, String roomId)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException;
/**
* endpoint: https://rocket.chat/docs/developer-guides/rest-api/groups/settopic/
@@ -57,6 +82,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 +93,9 @@ public interface ICommunication {
* @param roomId chat room id
* @return chat room information
*/
- ChatRoom getChatRoomInfo(String roomId);
+ String getChatRoomName(String roomId) throws RocketChatDownException, UserDoesNotExistInRocketChatException;
+
+ boolean exists(String roomId) throws RocketChatDownException, UserDoesNotExistInRocketChatException;
/**
* api: https://rocket.chat/docs/developer-guides/rest-api/authentication/login/
@@ -75,26 +103,36 @@ public interface ICommunication {
* @param user username and password
* @return information about user, especially authtoken for later use of endpoints
*/
- boolean loginUser(User user);
+ RocketChatUser loginUser(User user)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException;
/**
+ * 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
* @return user id
*/
- boolean registerUser(User user);
+ boolean registerUser(User user)
+ throws RocketChatDownException, UserExistsInRocketChatException;
- boolean registerAndLoginUser(User user);
+ String getChatRoomLink(String userEmail, String projectId)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException;
- String getChatRoomLink(String userEmail, String projectToken, String groupToken);
+ String getProjectChatRoomLink(String projectName);
// 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);
+
+ boolean sendMessageToUsers(Project project, EMailMessage eMailMessage);
+
+ public void delete(User user) throws RocketChatDownException, UserDoesNotExistInRocketChatException;
+
- // TODO implement as Email or whatever
- void sendMessageToUsers(Project project, String message);
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/IGroupFinding.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/IGroupFinding.java
index 2b1ee6f6aa1590c5d597afafcd4b1b258fdf8474..c76efc824ba40a36109ee20a9b0aa55308de4a2a 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/IGroupFinding.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/interfaces/IGroupFinding.java
@@ -1,5 +1,7 @@
package unipotsdam.gf.interfaces;
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
import unipotsdam.gf.modules.group.Group;
import unipotsdam.gf.modules.assessment.controller.model.StudentIdentifier;
import unipotsdam.gf.modules.project.Project;
@@ -7,6 +9,7 @@ import unipotsdam.gf.modules.group.GroupFormationMechanism;
import unipotsdam.gf.modules.group.GroupfindingCriteria;
import java.util.ArrayList;
+import java.util.List;
public interface IGroupFinding {
@@ -18,6 +21,8 @@ public interface IGroupFinding {
void selectGroupfindingCriteria(
GroupfindingCriteria groupfindingCriteria, Project project);
+ GroupFormationMechanism getGFM(Project project);
+
/**
* Persist the selected manual groups
* @param groupComposition
@@ -45,4 +50,13 @@ public interface IGroupFinding {
ArrayList<String> getStudentsInSameGroup(StudentIdentifier student);
int getMinNumberOfStudentsNeeded(Project project);
+
+ void deleteGroups(Project project);
+
+ List<Group> createRandomGroups(Project project);
+
+ /**
+ * finish the groups in the db
+ */
+ void finalizeGroups(Project project) throws RocketChatDownException, UserDoesNotExistInRocketChatException;
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/ChatWindow.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/ChatWindow.java
deleted file mode 100644
index 1a0d657baba3b66527714bd71550de846525ce0a..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/ChatWindow.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package unipotsdam.gf.modules.communication;
-
-import unipotsdam.gf.interfaces.ICommunication;
-import unipotsdam.gf.modules.communication.service.CommunicationDummyService;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.jsp.JspWriter;
-import javax.servlet.jsp.PageContext;
-import javax.servlet.jsp.tagext.SimpleTagSupport;
-import java.io.IOException;
-
-public class ChatWindow extends SimpleTagSupport {
-
- private String orientation;
-
- public void doTag() throws IOException {
- 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);
-
- JspWriter out = getJspContext().getOut();
- out.println("<iframe width=\"30%\" height=\"100%\" src=\"" + chatRoomLink + "\"/>");
- }
-
- public void setOrientation(String orientation) {
- this.orientation = orientation;
- }
-
- public String getOrientation() {
- return 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..229e4a12795e4d660da2d8fe67212c5993e3dd28 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,39 @@
package unipotsdam.gf.modules.communication;
+
+import unipotsdam.gf.modules.communication.model.EMailMessage;
import unipotsdam.gf.modules.project.Project;
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.getName() + ": Gruppenerstellung abgeschlossen");
+ eMailMessage.setBody("Die Gruppen wurden für den Kurs " + project.getName() + " 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.getName() + ": Feedbackaufgabe erstellt");
+ eMailMessage.setBody("Eine neue Feedbackaufgabe wurde für den Kurs " + project.getName() + " 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.getName() + ": 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.getName() + ": 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/LoginToken.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/LoginToken.java
new file mode 100644
index 0000000000000000000000000000000000000000..67b37b22728e42f4cce4fdb67a3c412e1f2f6933
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/LoginToken.java
@@ -0,0 +1,21 @@
+package unipotsdam.gf.modules.communication.model;
+
+public class LoginToken {
+ private String loginToken;
+
+
+ public LoginToken(String loginToken) {
+ this.loginToken = loginToken;
+ }
+
+ public LoginToken( ) {
+ }
+
+ public String getLoginToken() {
+ return loginToken;
+ }
+
+ public void setLoginToken(String loginToken) {
+ this.loginToken = loginToken;
+ }
+}
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/RocketChatUser.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/RocketChatUser.java
new file mode 100644
index 0000000000000000000000000000000000000000..131f285cc8ceb00e2338eaca9207499f78cf1991
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/RocketChatUser.java
@@ -0,0 +1,50 @@
+package unipotsdam.gf.modules.communication.model;
+
+import unipotsdam.gf.modules.user.User;
+
+public class RocketChatUser extends User {
+ private String rocketChatAuthToken;
+ // not in this version
+ private String rocketChatPersonalAccessToken;
+ // the actual id that oculd be used instead of the email with the queries
+ private String rocketChatUserId;
+
+ public RocketChatUser(String name, String password, String email, String rocketChatUsername,
+ String rocketChatAuthToken, String rocketChatPersonalAccessToken, String rocketChatUserId,
+ Boolean isStudent) {
+ super(name, password,email,rocketChatUsername, isStudent);
+ this.rocketChatAuthToken = rocketChatAuthToken;
+ this.rocketChatPersonalAccessToken = rocketChatPersonalAccessToken;
+ this.rocketChatUserId = rocketChatUserId;
+
+ }
+
+ public RocketChatUser() {
+
+ }
+
+
+ public String getRocketChatUserId() {
+ return rocketChatUserId;
+ }
+
+ public void setRocketChatUserId(String rocketChatUserId) {
+ this.rocketChatUserId = rocketChatUserId;
+ }
+
+ public String getRocketChatAuthToken() {
+ return rocketChatAuthToken;
+ }
+
+ public void setRocketChatAuthToken(String rocketChatAuthToken) {
+ this.rocketChatAuthToken = rocketChatAuthToken;
+ }
+
+ public String getRocketChatPersonalAccessToken() {
+ return rocketChatPersonalAccessToken;
+ }
+
+ public void setRocketChatPersonalAccessToken(String rocketChatPersonalAccessToken) {
+ this.rocketChatPersonalAccessToken = rocketChatPersonalAccessToken;
+ }
+}
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/model/rocketChat/RocketChatSuccessResponse.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/rocketChat/RocketChatSuccessResponse.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fa718f0eb8cbc88b8d18141618dd217a43e763c
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/model/rocketChat/RocketChatSuccessResponse.java
@@ -0,0 +1,19 @@
+package unipotsdam.gf.modules.communication.model.rocketChat;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class RocketChatSuccessResponse {
+ private String success;
+
+ public RocketChatSuccessResponse() {
+ }
+
+ public String getSuccess() {
+ return success;
+ }
+
+ public void setSuccess(String success) {
+ this.success = success;
+ }
+}
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..7e2a4734664bae88631544cd9234037e31d997c0
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/service/CommunicationService.java
@@ -0,0 +1,545 @@
+package unipotsdam.gf.modules.communication.service;
+
+import io.github.openunirest.http.HttpResponse;
+import io.github.openunirest.request.body.RequestBodyEntity;
+import org.apache.http.HttpEntity;
+import org.apache.logging.log4j.util.Strings;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import unipotsdam.gf.config.GFRocketChatConfig;
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
+import unipotsdam.gf.exceptions.UserExistsInRocketChatException;
+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.RocketChatUser;
+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.model.rocketChat.RocketChatSuccessResponse;
+import unipotsdam.gf.modules.communication.util.RocketChatHeaderMapBuilder;
+import unipotsdam.gf.modules.group.Group;
+import unipotsdam.gf.modules.group.GroupDAO;
+import unipotsdam.gf.modules.project.Project;
+import unipotsdam.gf.modules.user.User;
+import unipotsdam.gf.modules.user.UserDAO;
+import unipotsdam.gf.process.constraints.ConstraintsMessages;
+
+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.ADMIN_USER;
+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);
+
+ @Inject
+ private UnirestService unirestService;
+ @Inject
+ private UserDAO userDAO;
+ @Inject
+ private GroupDAO groupDAO;
+
+ public CommunicationService() {
+
+ }
+
+/* private static Boolean isUpdated;
+
+ private static synchronized Boolean setAdminToken() {
+ if (isUpdated == null) {
+ isUpdated = true;
+ } else {
+ return isUpdated;
+ }
+ return null;
+ }
+
+
+ private static synchronized Boolean unsetAdminToken() {
+ if (isUpdated == null) {
+ } else {
+ isUpdated = false;
+ }
+ return null;
+ }*/
+
+ @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)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ return createChatRoom(name, readOnly, new ArrayList<>());
+ }
+
+ @Override
+ public String createChatRoom(String name, boolean readOnly, List<User> member)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ //loginUser(ADMIN_USER);
+
+ Map<String, String> headerMap = new RocketChatHeaderMapBuilder().withRocketChatAdminAuth(this).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);
+
+
+ RequestBodyEntity body =
+ unirestService.post(ROCKET_CHAT_API_LINK + "groups.create").headers(headerMap).body(bodyMap);
+
+ HttpEntity entity = body.getEntity();
+
+ HttpResponse<Map> response = body.asObject(Map.class);
+
+ if (isBadRequest(response)) {
+ 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)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ //loginUser(ADMIN_USER);
+
+ // chatRoom name: projectId - GroupId
+ String chatRoomName = getChatRoomName(group);
+ if (exists(chatRoomName)) {
+ return true;
+ }
+ String chatRoomId = createChatRoom(chatRoomName, readOnly, group.getMembers());
+ if (chatRoomId.isEmpty()) {
+ return false;
+ }
+ group.setChatRoomId(chatRoomId);
+ groupDAO.update(group);
+ return true;
+ }
+
+ @Override
+ public void deleteChatRoom(Group group) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ deleteChatRoom(getChatRoomName(group));
+ }
+
+ @Override
+ public void deleteChatRoom(Project project) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ deleteChatRoom(project.getName());
+ }
+
+ private String getChatRoomName(Group group) {
+ return String.join("-", group.getProjectName(), String.valueOf(group.getId()));
+ }
+
+ @Override
+ public boolean deleteChatRoom(String roomId) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ // TODO: maybe add lock for getChatRoomName, so synchronized access doesn't create errors while deleting
+ //loginUser(ADMIN_USER);
+
+ Map<String, String> headerMap = new RocketChatHeaderMapBuilder().withRocketChatAdminAuth(this).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)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ return modifyChatRoom(user, roomId, true);
+ }
+
+ @Override
+ public boolean removeUserFromChatRoom(User user, String roomId)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ return modifyChatRoom(user, roomId, false);
+ }
+
+ private boolean modifyChatRoom(User user, String roomId, boolean addUser)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ //loginUser(ADMIN_USER);
+ RocketChatUser student = loginUser(user);
+
+ if (hasEmptyParameter(user.getRocketChatUsername(), roomId)) {
+ return false;
+ }
+ Map<String, String> headerMap = new RocketChatHeaderMapBuilder().withRocketChatAdminAuth(this).build();
+ Map<String, String> bodyMap = new HashMap<>();
+ bodyMap.put("roomId", roomId);
+ bodyMap.put("userId", student.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) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+
+ //loginUser(ADMIN_USER);
+
+ Map<String, String> headerMap = new RocketChatHeaderMapBuilder().withRocketChatAdminAuth(this).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 RocketChatUser loginUser(User user) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+
+ if (hasEmptyParameter(user.getEmail(), user.getPassword())) {
+ return null;
+ }
+
+ //
+ 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)) {
+ throw new UserDoesNotExistInRocketChatException();
+ } else {
+ /*if (ADMIN_USER.equals(user)) {
+ setAdminToken();
+ }*/
+ }
+
+ RocketChatLoginResponse rocketChatLoginResponse = response.getBody();
+
+ RocketChatUser rocketChatUser = new RocketChatUser();
+ rocketChatUser.setEmail(user.getEmail());
+ rocketChatUser.setPassword(user.getPassword());
+ rocketChatUser.setRocketChatUserId(rocketChatLoginResponse.getUserId());
+ rocketChatUser.setRocketChatAuthToken(rocketChatLoginResponse.getAuthToken());
+
+ return rocketChatUser;
+ }
+
+ @Override
+ public boolean registerUser(User user) throws RocketChatDownException, UserExistsInRocketChatException {
+
+ if (hasEmptyParameter(user.getEmail(), user.getName(), user.getPassword())) {
+ return false;
+ }
+
+ HashMap<String, String> rocketChatRegister = new HashMap<>();
+ if (user.getRocketChatUsername() == null) {
+ String rocketChatUsername = createRocketChatUsername(user);
+ user.setRocketChatUsername(rocketChatUsername);
+ }
+ rocketChatRegister.put("username", user.getRocketChatUsername());
+ 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);
+
+ Boolean badRequest = isBadRequest(response);
+ if (badRequest) {
+ throw new UserExistsInRocketChatException();
+ }
+
+ RocketChatRegisterResponse registerResponse = response.getBody();
+
+ // not sure we need this test
+ if (!registerResponse.isSuccessful()) {
+ return false;
+ }
+
+ // updateRocketChatUserName user with rocket chat data
+ userDAO.updateRocketChatUserName(user);
+ /**
+ * TODO with higher rocket chat version a personal access tokens exist and this function can be used
+ */
+ //return createCustomAccessToken(user);
+ return true;
+ }
+
+ /**
+ *
+ * @param userEmail
+ * @param projectName
+ * @return
+ * @throws RocketChatDownException
+ * @throws UserDoesNotExistInRocketChatException
+ */
+ public String getChatRoomLink(String userEmail, String projectName)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+
+ //loginUser(ADMIN_USER);
+
+ String chatRoomId = groupDAO.getGroupChatRoomId(new User(userEmail), new Project(projectName));
+ if (chatRoomId.isEmpty()) {
+ return Strings.EMPTY;
+ }
+
+ String chatRoomName = getChatRoomName(chatRoomId);
+ if (chatRoomName.isEmpty()) {
+ return Strings.EMPTY;
+ }
+
+ return ROCKET_CHAT_ROOM_LINK + chatRoomName + "?layout=embedded";
+ }
+
+ @Override
+ public String getProjectChatRoomLink(String projectName) {
+ return ROCKET_CHAT_ROOM_LINK + projectName + "?layout=embedded";
+ }
+
+
+ // TODO: Think about splitting email and chat communication into different
+ @Override
+ public boolean sendSingleMessage(EMailMessage eMailMessage, User user) {
+
+ //loginUser(ADMIN_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().getUserEmail());
+ EMailMessage eMailMessage = new EMailMessage();
+ eMailMessage.setSubject("Benachrichtigung über nicht erledigte Aufgaben im Projekt " + project.getName());
+ 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.getUsersByProjectName(project.getName());
+ 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;
+ }
+
+ /**
+ * TODO with higher rocket chat version a personal access tokens exist and this function can be used (ab 0.69
+ * präferiert 0.70)
+ */
+/* 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) throws RocketChatDownException {
+ int status = response.getStatus();
+ if (Response.Status.OK.getStatusCode() == status) {
+ return false;
+ }
+ if (Response.Status.UNAUTHORIZED.getStatusCode() == status) {
+ //unsetAdminToken();
+ return true;
+ }
+ if (Response.Status.NOT_FOUND.getStatusCode() == status) {
+ //unsetAdminToken();
+ throw new RocketChatDownException();
+ } else {
+ return true;
+ }
+ }
+
+
+ @Override
+ public boolean exists(String roomId) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ return !getChatRoomName(roomId).isEmpty();
+ }
+
+ public void delete(User user) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ //loginUser(ADMIN_USER);
+ // we need the rocketchatid
+ if (!(user instanceof RocketChatUser)) {
+ // we need the password to delete the user
+ if (user.getPassword() == null) {
+ user = userDAO.getUserByEmail(user.getEmail());
+ }
+ // fetchign the rocketchat id
+ try {
+ RocketChatUser rocketLeagueUser = loginUser(user);
+ // the actual delete
+ Map<String, String> headerMap = new RocketChatHeaderMapBuilder().withRocketChatAdminAuth(this).build();
+ Map<String, String> bodyMap = new HashMap<>();
+ bodyMap.put("userId", rocketLeagueUser.getRocketChatUserId());
+
+ HttpResponse<RocketChatSuccessResponse> response =
+ unirestService.post(ROCKET_CHAT_API_LINK + "users.delete").headers(headerMap).body(bodyMap).asObject(RocketChatSuccessResponse.class);
+
+ Boolean badRequest = isBadRequest(response);
+ if (badRequest) {
+ //throw new UserDoesNotExistInRocketChatException();
+ }
+ } catch (UserDoesNotExistInRocketChatException e) {
+ // wenn der Nutzer nicht existiert, brauchen wir ihn auch nicht löschen
+ }
+ }
+
+
+ }
+}
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..8def9d716f836665c67762a09823c73d137b9044
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/communication/util/RocketChatHeaderMapBuilder.java
@@ -0,0 +1,44 @@
+package unipotsdam.gf.modules.communication.util;
+
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
+import unipotsdam.gf.modules.communication.model.RocketChatUser;
+import unipotsdam.gf.modules.communication.service.CommunicationService;
+
+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(CommunicationService communicationService)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ // with new version of rocketChat: RocketChatHeaderMapBuilder rocketChatHeaderMapBuilder = withAuthTokenHeader(ADMIN_USER.getRocketChatPersonalAccessToken());
+
+ RocketChatUser admin = communicationService.loginUser(ADMIN_USER);
+
+ RocketChatHeaderMapBuilder rocketChatHeaderMapBuilder = withAuthTokenHeader(admin.getRocketChatAuthToken());
+ return rocketChatHeaderMapBuilder.withRocketChatUserId(admin.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..d1e34cb5a31875c9770d44247aa88bcaeadee665 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
@@ -2,15 +2,18 @@ package unipotsdam.gf.modules.communication.view;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import unipotsdam.gf.config.GFRocketChatConfig;
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
+import unipotsdam.gf.modules.communication.model.LoginToken;
+import unipotsdam.gf.modules.communication.model.RocketChatUser;
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 unipotsdam.gf.session.GFContexts;
import javax.annotation.ManagedBean;
import javax.inject.Inject;
+import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
@@ -18,6 +21,7 @@ import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;
@@ -36,60 +40,28 @@ public class CommunicationView {
@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("/info/{roomId}")
- public Response getChatRoomInformation(@PathParam("roomId") String roomId) {
- ChatRoom chatRoom = communicationService.getChatRoomInfo(roomId);
- if (isNull(chatRoom)) {
+ public Response getChatRoomInformation(@PathParam("roomId") String roomId)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ 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
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
@Path("/addUser/{roomId}")
- public Response addUserToChatRoom(@PathParam("roomId") String roomId, User user) {
+ public Response addUserToChatRoom(@PathParam("roomId") String roomId, User user)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
if (isNull(user)) {
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();
@@ -100,7 +72,9 @@ public class CommunicationView {
response = Response.ok(wasAdded).build();
} else {
log.error("error while adding user to chat room");
- response = Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("error while adding user to chatRoom").build();
+ response =
+ Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("error while adding user to chatRoom")
+ .build();
}
return response;
}
@@ -110,7 +84,8 @@ public class CommunicationView {
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
@Path("/removeUser/{roomId}")
- public Response removeUserFromChatRoom(User user, @PathParam("roomId") String roomId) {
+ public Response removeUserFromChatRoom(User user, @PathParam("roomId") String roomId)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
if (isNull(user)) {
log.trace("removeUser user object was null");
return Response.status(Response.Status.BAD_REQUEST).entity("must provide user").build();
@@ -126,31 +101,9 @@ public class CommunicationView {
response = Response.ok(wasRemoved).build();
} else {
log.error("error while adding user to chat room");
- response = Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("error while adding user to chatRoom").build();
- }
- 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();
+ response =
+ Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("error while adding user to chatRoom")
+ .build();
}
return response;
}
@@ -158,13 +111,15 @@ public class CommunicationView {
@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)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
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();
}
@@ -172,15 +127,30 @@ public class CommunicationView {
return Response.status(Response.Status.CREATED).entity(chatId).build();
}
- // Temp: just get user as json
- // TODO: remove after done implementing
- @GET
- @Path("/user")
+ @POST
@Produces(MediaType.APPLICATION_JSON)
- public Response getUser() {
- User user = ((CommunicationDummyService) communicationService).getUser();
- return Response.ok(user).build();
+ @Path("/sso")
+ public LoginToken provideLoginToken(@Context HttpServletRequest req, Object payload)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ if (req.getSession().getAttribute(GFContexts.ROCKETCHATAUTHTOKEN) != null) {
+ String token = getAuthToken(req);
+ return new LoginToken(token);
+ } else {
+ RocketChatUser user = communicationService.loginUser(GFRocketChatConfig.ADMIN_USER);
+ return new LoginToken(user.getRocketChatAuthToken());
+ }
}
+ private String getAuthToken(@Context HttpServletRequest req) {
+ return req.getSession().getAttribute(GFContexts.ROCKETCHATAUTHTOKEN).toString();
+ }
+ @GET
+ @Produces(MediaType.TEXT_HTML)
+ @Path("/login")
+ public String provideLoginHTML(@Context HttpServletRequest req) {
+ String rocketChatIntegration = "<script> window.parent.postMessage({event: 'login-with-token',loginToken:" +
+ " '"+getAuthToken(req)+"'}, '"+GFRocketChatConfig.ROCKET_CHAT_LINK_0 +"');</script>";
+ return rocketChatIntegration;
+ }
}
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/group/DummyProjectCreationService.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/DummyProjectCreationService.java
deleted file mode 100644
index 4ed0dd14eeea8d363d9d2ba376489c4b6eec8ff1..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/DummyProjectCreationService.java
+++ /dev/null
@@ -1,113 +0,0 @@
-package unipotsdam.gf.modules.group;
-
-import uk.co.jemos.podam.api.PodamFactory;
-import uk.co.jemos.podam.api.PodamFactoryImpl;
-import unipotsdam.gf.modules.project.Management;
-import unipotsdam.gf.modules.group.Group;
-import unipotsdam.gf.modules.project.Project;
-import unipotsdam.gf.modules.user.User;
-import unipotsdam.gf.modules.user.UserDAO;
-import unipotsdam.gf.modules.user.UserProfile;
-import unipotsdam.gf.interfaces.ICommunication;
-import unipotsdam.gf.modules.group.GroupDAO;
-
-import javax.annotation.ManagedBean;
-import javax.annotation.Resource;
-import javax.inject.Inject;
-import javax.inject.Singleton;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-
-@ManagedBean
-@Resource
-@Singleton
-public class DummyProjectCreationService {
-
-
- private PodamFactory factory = new PodamFactoryImpl();
-
- private ICommunication communicationService;
- private Management management;
- private GroupDAO groupDAO;
- private UserDAO userDAO;
-
- @Inject
- public DummyProjectCreationService(ICommunication communicationService, Management management, GroupDAO groupDAO, UserDAO userDAO) {
- this.communicationService = communicationService;
- this.management = management;
- this.groupDAO = groupDAO;
- this.userDAO = userDAO;
- }
-
- public boolean createExampleProject() {
-
- Project project = factory.manufacturePojo(Project.class);
-
- User docentUser = getDocentUser();
- if (!management.exists(docentUser)) {
- management.create(docentUser, null);
- }
-
- if (!management.exists(project)) {
- management.create(project);
- }
-
- List<Group> groups = createDummyGroups(project.getName());
-
- List<Group> nonCreatedGroups = groups.stream().filter(group -> !management.exists(group)).collect(Collectors.toList());
-
- nonCreatedGroups.forEach(group -> management.create(group));
-
- List<Group> groupsWithId = groupDAO.getGroupsByProjectName(project.getName());
- groupsWithId.forEach(group -> {
- String chatRoomName = String.join(" - ", project.getName(), String.valueOf(group.getId()));
- group.setChatRoomId(communicationService.createChatRoom(chatRoomName, group.getMembers()));
- management.update(group);
- });
-
- return true;
- }
-
- public List<Group> createDummyGroups(String projectName) {
- Group group1 = new Group(new ArrayList<>(), projectName);
- Group group2 = new Group(new ArrayList<>(), projectName);
- Group group3 = new Group(new ArrayList<>(), projectName);
- Group group4 = new Group(new ArrayList<>(), projectName);
- List<Group> groups = Arrays.asList(group1, group2, group3, group4);
-
- String baseUserName = "Name ";
- String password = "test123";
- String baseEMailFront = "test";
- String baseEMailDomain = "@example.com";
- boolean isStudentValue = true;
- for (int userNumber = 0; userNumber < groups.size() * 5; userNumber++) {
- String userName = baseUserName + (userNumber + 1);
- String email = baseEMailFront + (userNumber + 1) + baseEMailDomain;
- User user = new User(userName, password, email, isStudentValue);
- if (!management.exists(user)) {
- saveUserToDatabase(user);
- int groupPosition = userNumber % groups.size();
- groups.get(groupPosition).addMember(user);
- }
- }
- return groups;
- }
-
- public User getDocentUser() {
- User docent = new User("Julian", "docent", "docent@docent.com", false);
- if (!management.exists(docent)) {
- saveUserToDatabase(docent);
- } else {
- docent = userDAO.getUserByEmail(docent.getEmail());
- }
- return docent;
- }
-
- private void saveUserToDatabase(User user) {
- communicationService.registerAndLoginUser(user);
- management.create(user, new UserProfile());
- }
-}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/DummyProjectCreationView.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/DummyProjectCreationView.java
deleted file mode 100644
index 4e3950d0cfa532ad23fe92bceef94a321c2016ba..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/DummyProjectCreationView.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package unipotsdam.gf.modules.group;
-
-import javax.inject.Inject;
-import javax.ws.rs.GET;
-import javax.ws.rs.Path;
-import javax.ws.rs.Produces;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-
-@Path("/dummy/project/")
-public class DummyProjectCreationView {
-
- @Inject
- DummyProjectCreationService dummyProjectCreationService;
-
- @GET
- @Produces(MediaType.APPLICATION_JSON)
- @Path("/create")
- public Response createDummyProject() {
-
- boolean success = dummyProjectCreationService.createExampleProject();
-
- Response response;
- if (success) {
- response = Response.ok("Dummy-Project created").build();
- } else {
- response = Response.serverError().build();
- }
-
- return response;
- }
-
-
-}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/EnumeratedProfileQuestion.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/EnumeratedProfileQuestion.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c48efbced68608c4f678f5f0904e7249ce19da0
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/EnumeratedProfileQuestion.java
@@ -0,0 +1,27 @@
+package unipotsdam.gf.modules.group;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * If the question asks the user to select an option then
+ * the question neds to provide a list of options as string
+ * else: the number of checkboxes is stored and the answer is an index
+ * note: multiple select is not implemented
+ */
+public class EnumeratedProfileQuestion extends ProfileQuestion {
+ private java.util.List<String> options;
+
+ public EnumeratedProfileQuestion() {
+ super();
+ this.options = new ArrayList<>();
+ }
+
+ public List<String> getOptions() {
+ return options;
+ }
+
+ public void setOptions(List<String> options) {
+ this.options = options;
+ }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/Group.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/Group.java
index 0453ce6b9c817164a797f6b4f1834173a4e0f582..f7b551f5fa017eed2ec82e5036251313d9cdb619 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/Group.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/Group.java
@@ -11,6 +11,7 @@ public class Group {
private List<User> members;
private String projectName;
private String chatRoomId;
+ private String name;
public Group() {
members = new ArrayList<>();
@@ -68,8 +69,6 @@ public class Group {
members.add(user);
}
-
-
public int getId() {
return id;
}
@@ -88,4 +87,12 @@ public class Group {
public int hashCode() {
return getId();
}
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupDAO.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupDAO.java
index 85bbf3eecb249154dbff5e33dc9a3f94f0ae8f6e..5d8ed5f03db2b26035d37db1c87026338c6d23f2 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupDAO.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupDAO.java
@@ -1,5 +1,6 @@
package unipotsdam.gf.modules.group;
+import org.apache.logging.log4j.util.Strings;
import unipotsdam.gf.modules.project.Project;
import unipotsdam.gf.mysql.MysqlConnect;
import unipotsdam.gf.mysql.VereinfachtesResultSet;
@@ -151,6 +152,43 @@ public class GroupDAO {
connect.close();
return groupFormationMechanism;
}
+
+ public String getGroupChatRoomId(User user, Project project) {
+ connect.connect();
+ StringBuilder stringBuilder = new StringBuilder();
+ stringBuilder.append("SELECT g.chatRoomId FROM groups g ");
+ stringBuilder.append("join groupuser gu on g.id=gu.groupId ");
+ stringBuilder.append("where g.projectName=? and gu.userEmail=?");
+
+ VereinfachtesResultSet resultSet = connect.issueSelectStatement(stringBuilder.toString(), project.getName(),
+ user.getEmail());
+ if (Objects.isNull(resultSet)) {
+ connect.close();
+ return Strings.EMPTY;
+ }
+ String chatRoomId = Strings.EMPTY;
+ if (resultSet.next()) {
+ chatRoomId = resultSet.getString("chatRoomId");
+ }
+ connect.close();
+ return chatRoomId;
+ }
+
+ public void clearChatRoomIdOfGroup(String chatRoomId) {
+ connect.connect();
+ String mysqlRequest = "updateRocketChatUserName groups SET chatRoomId = ? where chatRoomId = ?";
+ connect.issueUpdateStatement(mysqlRequest, "", chatRoomId);
+ connect.close();
+ }
+
+ public void deleteGroups(Project project) {
+ String query ="DELETE gu FROM groupuser gu INNER JOIN groups g ON gu.groupId=g.id WHERE g.projectName = ?;";
+ String query2="DELETE FROM groups WHERE projectName=?;";
+ connect.connect();
+ connect.issueInsertOrDeleteStatement(query, project.getName());
+ connect.issueInsertOrDeleteStatement(query2, project.getName());
+ connect.close();
+ }
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupData.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupData.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc78582ee0ab378776f969384f5179a0c2ed9ba4
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupData.java
@@ -0,0 +1,23 @@
+package unipotsdam.gf.modules.group;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GroupData {
+ List<Group> groups;
+
+ public GroupData() {
+ }
+
+ public GroupData(List<Group> groups) {
+ this.groups = groups;
+ }
+
+ public List<Group> getGroups() {
+ return groups;
+ }
+
+ public void setGroups(ArrayList<Group> groups) {
+ this.groups = groups;
+ }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupView.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupView.java
index ec10d90e4ac6f458e853ecf81507cb3f63d271c5..4c065f1f43f64e3c8be0dca1ce74c15205a8d9e0 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupView.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupView.java
@@ -1,5 +1,8 @@
package unipotsdam.gf.modules.group;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
import unipotsdam.gf.modules.project.Management;
import unipotsdam.gf.modules.project.Project;
import unipotsdam.gf.modules.project.ProjectDAO;
@@ -14,6 +17,7 @@ import java.io.IOException;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.List;
@Path("/group")
public class GroupView {
@@ -25,10 +29,20 @@ public class GroupView {
private Management iManagement;
@Inject
- ProjectDAO projectDAO;
+ private ProjectDAO projectDAO;
@Inject
- GroupFormationProcess groupFormationProcess;
+ private GroupFormationProcess groupFormationProcess;
+
+
+ @GET
+ @Produces(MediaType.APPLICATION_JSON)
+ @Path("/all/projects/{projectName}")
+ public GroupData getOrInitializeGroups(@PathParam("projectName") String projectName) {
+ GroupData data = groupFormationProcess.getOrInitializeGroups(new Project(projectName));
+ return data;
+ }
+
@GET
@Produces(MediaType.APPLICATION_JSON)
@@ -81,20 +95,48 @@ public class GroupView {
throw new WebApplicationException(
"the groupfindingmechanism needs to be one of " + GroupFormationMechanism.values().toString());
}
-
}
+ @GET
+ @Produces(MediaType.APPLICATION_JSON)
+ @Path("/get/projects/{projectName}")
+ public List<Group> getGroups(@PathParam("projectName") String projectName) {
+ List<Group> result = groupfinding.getGroups(projectDAO.getProjectByName(projectName));
+ return result;
+ }
-
+ /**
+ * find out if this is used by learning goal
+ * @param projectName
+ * @param groups
+ */
+ @Deprecated
@POST
@Consumes(MediaType.APPLICATION_JSON)
@Path("/projects/{projectName}")
public void saveGroups(@PathParam("projectName") String projectName, Group[] groups) {
Project project = new Project(projectName);
- groupfinding.persistGroups(Arrays.asList(groups), project);
+ groupFormationProcess.saveGroups(Arrays.asList(groups), project);
+ }
+
+ @PUT
+ @Consumes(MediaType.APPLICATION_JSON)
+ @Path("/projects/{projectName}/groups")
+ public void persistGroups(@PathParam("projectName") String projectName, GroupData data) {
+ Project project = new Project(projectName);
+ groupFormationProcess.saveGroups(data.getGroups(), project);
+ }
+
+ @POST
+ @Consumes(MediaType.APPLICATION_JSON)
+ @Path("/projects/{projectName}/groups/finalize")
+ public void finalizeGroups(@PathParam("projectName") String projectName)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ Project project = new Project(projectName);
+ groupFormationProcess.finalize(project);
}
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupfindingImpl.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupfindingImpl.java
index 24374f5e7c960d49199a6e0369b64294ff3adfd1..b0df88bbd61d735ac6abf1038b0bcf29bf1421a9 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupfindingImpl.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/GroupfindingImpl.java
@@ -1,11 +1,17 @@
package unipotsdam.gf.modules.group;
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
+import unipotsdam.gf.interfaces.ICommunication;
import unipotsdam.gf.modules.project.Project;
import unipotsdam.gf.interfaces.IGroupFinding;
import unipotsdam.gf.modules.assessment.controller.model.StudentIdentifier;
+import unipotsdam.gf.modules.user.User;
+import unipotsdam.gf.modules.user.UserDAO;
import javax.inject.Inject;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.List;
public class GroupfindingImpl implements IGroupFinding {
@@ -13,6 +19,12 @@ public class GroupfindingImpl implements IGroupFinding {
@Inject
private GroupDAO groupDAO;
+ @Inject
+ private UserDAO userDAO;
+
+ @Inject
+ private ICommunication iCommunication;
+
@Inject
public GroupfindingImpl(GroupDAO groupDAO) {
this.groupDAO = groupDAO;
@@ -24,6 +36,11 @@ public class GroupfindingImpl implements IGroupFinding {
//
}
+ @Override
+ public GroupFormationMechanism getGFM(Project project){
+ return groupDAO.getGroupFormationMechanism(project);
+ }
+
@Override
public void persistGroups(List<Group> groupComposition, Project project) {
for (Group group : groupComposition) {
@@ -60,4 +77,76 @@ public class GroupfindingImpl implements IGroupFinding {
return participantsNeeded;
}
+
+ @Override
+ public void deleteGroups(Project project){
+ groupDAO.deleteGroups(project);
+ }
+
+ @Override
+ public List<Group> createRandomGroups(Project project) {
+ ArrayList<Group> result = new ArrayList<>();
+ groupDAO.deleteGroups(project);
+ List<User> usersByProjectName = userDAO.getUsersByProjectName(project.getName());
+ int numberOfUsers = usersByProjectName.size();
+ if (usersByProjectName.size()<6){
+ Group group = new Group();
+ group.getMembers().addAll(usersByProjectName);
+ result.add(group);
+ } else {
+ int numberOf3Groups = getNumberOf3Groups(numberOfUsers);
+ //int numberOf4Groups = getNumberOf4Groups(numberOfUsers);
+
+ Group group = new Group();
+ int i = 1;
+ group.setName(i + "");
+ for (User user : usersByProjectName) {
+ if (numberOf3Groups > 0) {
+ numberOf3Groups--;
+ // TODO insert formula here for the correct groups
+ if (group.getMembers().size() == 3) {
+ result.add(group);
+ group = new Group();
+ i++;
+ group.setName(i + "");
+ }
+ } else {
+ if (group.getMembers().size() == 4) {
+ result.add(group);
+ group = new Group();
+ i++;
+ group.setName(i + "");
+ }
+ }
+ group.addMember(user);
+ // set group name 1 more
+ }
+ result.add(group);
+ }
+ return result;
+ }
+
+ /**
+ * after this groups should not be touched by the system
+ * @param project
+ */
+ @Override
+ public void finalizeGroups(Project project) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ // create group chat rooms
+ List<Group> groups = getGroups(project);
+ for (Group group : groups) {
+ iCommunication.createChatRoom(group, false);
+ }
+ }
+
+ // (number % 3) + (Math.floor(number/3)-(number%3)) = n für alle Zahlen größer als 5
+ public int getNumberOf4Groups(Integer number) {
+ return (number % 3);
+ }
+
+
+ // every number can be divided in factors 4 and 3 as long it is greater then 5
+ public int getNumberOf3Groups(Integer number) {
+ return (number / 3) - (number % 3);
+ }
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileDAO.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileDAO.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e468e6f61317a5a81787b63a190da7063ca0a62
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileDAO.java
@@ -0,0 +1,146 @@
+package unipotsdam.gf.modules.group;
+
+import unipotsdam.gf.mysql.MysqlConnect;
+import unipotsdam.gf.mysql.VereinfachtesResultSet;
+
+import javax.inject.Inject;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class ProfileDAO {
+ @Inject
+ private MysqlConnect connect;
+
+ /**
+ * helper function for persisting questions
+ * @param profileQuestion
+ * @return the id of the created question
+ */
+ private int persistHelper(ProfileQuestion profileQuestion) {
+
+ int result = -1;
+ connect.connect();
+
+ String query = "INSERT INTO profilequestions (`scaleSize`, `question`) values(?,?)";
+ result = connect.issueInsertStatementWithAutoincrement(query, profileQuestion.getScaleSize(),
+ profileQuestion.getQuestion());
+
+ connect.close();
+
+ return result;
+ }
+
+ /**
+ * persist questions with enumeration
+ * @param enumeratedProfileQuestion
+ */
+ public void persist(EnumeratedProfileQuestion enumeratedProfileQuestion) {
+ int questionId = persistHelper(enumeratedProfileQuestion);
+ connect.connect();
+ String query = "INSERT INTO profilequestionoptions (`profileQuestionId`, `name`) values (?,?)";
+ List<String> options = enumeratedProfileQuestion.getOptions();
+ for (String option : options) {
+ connect.issueInsertOrDeleteStatement(query, questionId, option);
+ }
+ connect.close();
+ }
+
+ /**
+ * persist questions with scale i.e. 1 to 5
+ * @param scaledProfileQuestion
+ */
+ public void persist(ScaledProfileQuestion scaledProfileQuestion) {
+ persistHelper(scaledProfileQuestion);
+ }
+
+ /**
+ * persist an answer
+ * @param profileQuestionAnswer
+ */
+ public void persist(ProfileQuestionAnswer profileQuestionAnswer) {
+ connect.connect();
+ String query =
+ "INSERT INTO profilequestionanswer (`profileQuestionId`,`answerIndex`, `selectedAnswer`, " + "`userEmail` values (?,?,?,?)";
+ connect.issueInsertOrDeleteStatement(query, profileQuestionAnswer.getQuestion().getId(),
+ profileQuestionAnswer.getAnswerIndex(), profileQuestionAnswer.getSelectedAnswer(),
+ profileQuestionAnswer.getUser().getEmail());
+ }
+
+ /**
+ * get all the questions
+ * @return
+ */
+ public java.util.List<ProfileQuestion> getQuestions() {
+ ArrayList<ProfileQuestion> profileQuestions = new ArrayList<>();
+ connect.connect();
+
+ String query =
+ "SELECT (q.id,q.scaleSize, q.question, o.name) from profilequestions q LEFT JOIN " + "profilequestionoptions o where q.id = o" + ".profileQuestionId group by q.id";
+ VereinfachtesResultSet vereinfachtesResultSet = connect.issueSelectStatement(query);
+ HashMap<Integer, ArrayList<String>> optionMap = new HashMap<>();
+ List<ProfileQuestion> tmpList = new ArrayList<>();
+ while (vereinfachtesResultSet.next()) {
+ String optionName = vereinfachtesResultSet.getString("name");
+ int questionId = vereinfachtesResultSet.getInt("id");
+ int scaleSize = vereinfachtesResultSet.getInt("scaleSize");
+ String question = vereinfachtesResultSet.getString("question");
+ if (optionName != null) {
+ if (optionMap.containsKey(optionName)) {
+ ArrayList<String> optionList = optionMap.get(optionName);
+ optionList.add(optionName);
+ optionMap.put(questionId, optionList);
+ } else {
+ ArrayList<String> optionList = new ArrayList<>();
+ optionList.add(optionName);
+ optionMap.put(questionId, optionList);
+ }
+ }
+ tmpList.add(new ProfileQuestion(questionId, scaleSize, question));
+ }
+
+ for (ProfileQuestion question : tmpList) {
+ if (optionMap.containsKey(question.getId())) {
+ EnumeratedProfileQuestion enumeratedProfileQuestion = new EnumeratedProfileQuestion();
+ enumeratedProfileQuestion.setScaleSize(question.getScaleSize());
+ enumeratedProfileQuestion.setOptions(optionMap.get(question.getId()));
+ enumeratedProfileQuestion.setQuestion(question.getQuestion());
+ profileQuestions.add(enumeratedProfileQuestion);
+ }else {
+ profileQuestions.add(question);
+ }
+ }
+
+ connect.close();
+ return profileQuestions;
+ }
+
+ public List<ProfileQuestionRelation> getProfileRelations() {
+ ArrayList<ProfileQuestionRelation>questionRelations = new ArrayList<>();
+ connect.connect();
+ String query = "SELCT * from profilequestionrelations";
+ VereinfachtesResultSet vereinfachtesResultSet = connect.issueSelectStatement(query);
+ while (vereinfachtesResultSet.next()) {
+ int firstQuestionId = vereinfachtesResultSet.getInt("firstQuestionId");
+ int secondQuestionId = vereinfachtesResultSet.getInt("secondQuestionId");
+ String relation = vereinfachtesResultSet.getString("relation");
+
+ ProfileQuestion profileQuestion1 = new ProfileQuestion(firstQuestionId);
+ ProfileQuestion profileQuestion2 = new ProfileQuestion(secondQuestionId);
+ ProfileQuestionRelationType profileQuestionRelationType = ProfileQuestionRelationType.valueOf(relation);
+ questionRelations.add(new ProfileQuestionRelation(profileQuestion1, profileQuestion2,
+ profileQuestionRelationType));
+ }
+
+ connect.close();
+ return questionRelations;
+ }
+
+ public void persistProfileRelation(ProfileQuestion firstQuestion, ProfileQuestion secondQuestion) {
+ // TODO implement
+ connect.connect();
+
+ connect.close();
+ }
+
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestion.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestion.java
new file mode 100644
index 0000000000000000000000000000000000000000..284014f8877032ebbc58facd36ebf6bf3610f8d1
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestion.java
@@ -0,0 +1,46 @@
+package unipotsdam.gf.modules.group;
+
+public class ProfileQuestion {
+ private int id;
+ private int scaleSize;
+ private String question;
+
+ public ProfileQuestion() {
+ }
+
+ public ProfileQuestion(int id, int scaleSize, String question) {
+ this.id = id;
+ this.scaleSize = scaleSize;
+ this.question = question;
+ }
+
+ public ProfileQuestion(int firstQuestionId) {
+ this.id= firstQuestionId;
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public void setId(int id) {
+ this.id = id;
+ }
+
+ public int getScaleSize() {
+ return scaleSize;
+ }
+
+ public void setScaleSize(int scaleSize) {
+ this.scaleSize = scaleSize;
+ }
+
+ public String getQuestion() {
+ return question;
+ }
+
+ public void setQuestion(String question) {
+ this.question = question;
+ }
+
+ //pr
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestionAnswer.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestionAnswer.java
new file mode 100644
index 0000000000000000000000000000000000000000..cdfe200c938d7d4bdeaba0f2c0ff61e7a7f0f7ba
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestionAnswer.java
@@ -0,0 +1,54 @@
+package unipotsdam.gf.modules.group;
+
+import unipotsdam.gf.modules.user.User;
+
+public class ProfileQuestionAnswer {
+ private ProfileQuestion question;
+ private Integer answerIndex;
+ // multiple is not implemented
+ private String selectedAnswer;
+ private User user;
+
+ public ProfileQuestionAnswer(
+ ProfileQuestion question, Integer answerIndex, String selectedAnswer, User user) {
+ this.question = question;
+ this.answerIndex = answerIndex;
+ this.selectedAnswer = selectedAnswer;
+ this.user = user;
+ }
+
+ public ProfileQuestionAnswer() {
+ }
+
+ public ProfileQuestion getQuestion() {
+ return question;
+ }
+
+ public void setQuestion(ProfileQuestion question) {
+ this.question = question;
+ }
+
+ public Integer getAnswerIndex() {
+ return answerIndex;
+ }
+
+ public void setAnswerIndex(Integer answerIndex) {
+ this.answerIndex = answerIndex;
+ }
+
+ public String getSelectedAnswer() {
+ return selectedAnswer;
+ }
+
+ public void setSelectedAnswer(String selectedAnswer) {
+ this.selectedAnswer = selectedAnswer;
+ }
+
+ public User getUser() {
+ return user;
+ }
+
+ public void setUser(User user) {
+ this.user = user;
+ }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestionRelation.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestionRelation.java
new file mode 100644
index 0000000000000000000000000000000000000000..b067cc651a9a7ed8630529119d7611eb5c43ea36
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestionRelation.java
@@ -0,0 +1,43 @@
+package unipotsdam.gf.modules.group;
+
+public class ProfileQuestionRelation {
+ private ProfileQuestion profileQuestion1;
+ private ProfileQuestion getProfileQuestion2;
+ private ProfileQuestionRelationType profileQuestionRelationType;
+
+ public ProfileQuestionRelation(
+ ProfileQuestion profileQuestion1, ProfileQuestion getProfileQuestion2,
+ ProfileQuestionRelationType profileQuestionRelationType) {
+ this.profileQuestion1 = profileQuestion1;
+ this.getProfileQuestion2 = getProfileQuestion2;
+ this.profileQuestionRelationType = profileQuestionRelationType;
+ }
+
+ public ProfileQuestionRelation() {
+ }
+
+ public ProfileQuestion getProfileQuestion1() {
+ return profileQuestion1;
+ }
+
+ public void setProfileQuestion1(ProfileQuestion profileQuestion1) {
+ this.profileQuestion1 = profileQuestion1;
+ }
+
+ public ProfileQuestion getGetProfileQuestion2() {
+ return getProfileQuestion2;
+ }
+
+ public void setGetProfileQuestion2(ProfileQuestion getProfileQuestion2) {
+ this.getProfileQuestion2 = getProfileQuestion2;
+ }
+
+ public ProfileQuestionRelationType getProfileQuestionRelationType() {
+ return profileQuestionRelationType;
+ }
+
+ public void setProfileQuestionRelationType(
+ ProfileQuestionRelationType profileQuestionRelationType) {
+ this.profileQuestionRelationType = profileQuestionRelationType;
+ }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestionRelationType.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestionRelationType.java
new file mode 100644
index 0000000000000000000000000000000000000000..7393a34ab11b372e5bc79037045adaa39f525609
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ProfileQuestionRelationType.java
@@ -0,0 +1,17 @@
+package unipotsdam.gf.modules.group;
+
+/**
+ * This type indicates how groups are affected by the underlying variable of the item
+ * if it is homogenous, the groups can't have enough of it i.e. motivation
+ *
+ * If it is heteogenous, the groups should have contrasting members, i.e. more of a leader type but not too many
+ * alphas
+ *
+ * If it is nivelled, it is an attribute best avoided beause it could be mission critial, such as a depressed person.
+ * Here the groups should be greated in a way, that the problematic people are distributed in the groups
+ */
+public enum ProfileQuestionRelationType {
+ HOMOGENOUS,
+ HETEROGENOUS,
+ NIVELLED
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ScaledProfileQuestion.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ScaledProfileQuestion.java
new file mode 100644
index 0000000000000000000000000000000000000000..5612a899ddee06c467cd523401e803748e2651a9
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/group/ScaledProfileQuestion.java
@@ -0,0 +1,4 @@
+package unipotsdam.gf.modules.group;
+
+public class ScaledProfileQuestion extends ProfileQuestion {
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ManagementImpl.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ManagementImpl.java
index de4ddbb6e7fe744450e98af3392d77d65f92850b..52a0203100f45e3b973f37fbc61233637ed9c728 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ManagementImpl.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ManagementImpl.java
@@ -74,7 +74,7 @@ public class ManagementImpl implements Management {
@Override
public void update(User user) {
- userDAO.update(user);
+ userDAO.updateRocketChatUserName(user);
}
@Override
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/Project.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/Project.java
index ecf2a19983f05e2836ee191f8a527254cbaa4f8f..058d9f97d3de00e961c183e78878767b9b2b362d 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/Project.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/Project.java
@@ -22,6 +22,7 @@ public class Project {
private String description;
public Project() {
+ tags = new String[0];
}
public Project(String name, String password, Boolean active, String author, String[] tags) {
@@ -49,13 +50,17 @@ public class Project {
this.description = description;
}
- public Project(String projectName, String password) {
+ public Project(String projectName, String authorEmail) {
this.name = projectName;
- this.password = password;
+ this.authorEmail = authorEmail;
+ this.active = true;
+ this.timecreated = System.currentTimeMillis();
+ tags = new String[0];
}
public Project(String projectName) {
this.name = projectName;
+ this.active = true;
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ProjectDAO.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ProjectDAO.java
index 27d504b281a6c2a9e7e5d96cdcac343e4e7c1cb8..ee89b87810dfb6e36a3563db3f013ade0cc88a6a 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ProjectDAO.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ProjectDAO.java
@@ -47,10 +47,11 @@ public class ProjectDAO {
java.sql.Timestamp timestamp = new java.sql.Timestamp(project.getTimecreated());
connect.connect();
String mysqlRequest =
- "INSERT INTO projects (`name`, `password`, `active`, `timecreated`, `author`, `phase`, `description`) values (?,?,?,?,?,?,?)";
+ "INSERT INTO projects (`name`, `password`, `active`, `timecreated`, `author`, " + "`phase`) " +
+ "values (?,?,?,?,?,?,?)";
connect.issueInsertOrDeleteStatement(mysqlRequest, project.getName(), project.getPassword(),
- project.isActive(), timestamp, project.getAuthorEmail(),
- project.getPhase() == null ? Phase.CourseCreation : project.getPhase(), project.getDescription());
+ project.isActive(), project.getTimecreated(), project.getAuthorEmail(),
+ project.getPhase() == null ? Phase.GroupFormation : project.getPhase());
connect.close();
@@ -75,6 +76,8 @@ public class ProjectDAO {
String mysqlRequest = "DELETE FROM projects where name = (?)";
connect.issueInsertOrDeleteStatement(mysqlRequest, project.getName());
connect.close();
+ // TODO: delete all groups of project?
+
}
public Boolean exists(Project project) {
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ProjectView.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ProjectView.java
index 6397b96dce48acd70d655668a9be9c18402963e8..a3a4684d33e0cb82ce4db65fabb412d1abc4521b 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ProjectView.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/project/ProjectView.java
@@ -3,8 +3,11 @@ package unipotsdam.gf.modules.project;
import com.sun.org.apache.xpath.internal.operations.Bool;
import unipotsdam.gf.process.ProjectCreationProcess;
import unipotsdam.gf.process.tasks.TaskDAO;
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
import unipotsdam.gf.modules.user.User;
import unipotsdam.gf.session.GFContext;
+import unipotsdam.gf.process.ProjectCreationProcess;
import unipotsdam.gf.session.GFContexts;
import javax.annotation.ManagedBean;
@@ -39,7 +42,8 @@ public class ProjectView {
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.TEXT_PLAIN)
@Path("/create")
- public String createProject(@Context HttpServletRequest req, Project project) throws URISyntaxException, IOException {
+ public String createProject(@Context HttpServletRequest req, Project project)
+ throws IOException, RocketChatDownException, UserDoesNotExistInRocketChatException {
String userEmail = gfContexts.getUserEmail(req);
User user = iManagement.getUserByEmail(userEmail);
assert user != null;
@@ -52,7 +56,8 @@ public class ProjectView {
@POST
@Path("/delete/project/{projectName}")
- public void deleteProject(@Context HttpServletRequest req, @PathParam("projectName") String projectName) throws URISyntaxException, IOException {
+ public void deleteProject(@Context HttpServletRequest req, @PathParam("projectName") String projectName)
+ throws URISyntaxException, IOException, RocketChatDownException, UserDoesNotExistInRocketChatException {
String userEmail1 = gfContexts.getUserEmail(req);
User user = iManagement.getUserByEmail(userEmail1);
Boolean isStudent= user.getStudent();
@@ -79,31 +84,26 @@ public class ProjectView {
@GET
@Produces(MediaType.APPLICATION_JSON)
@Path("/all/student/{studentEmail}")
- public List<Project> getProjectsStudent(
+ public java.util.List<Project> getProjectsStudent(
@PathParam("studentEmail") String studentEmail) {
return iManagement.getProjectsStudent(studentEmail);
}
- @GET
- @Produces(MediaType.APPLICATION_JSON)
- @Path("/all")
- public List<Project> getAllProjects() {
- return iManagement.getAllProjects();
- }
@GET
@Consumes(MediaType.TEXT_PLAIN)
@Produces(MediaType.TEXT_PLAIN)
@Path("/login/{projectName}")
- public String register(@Context HttpServletRequest req, @PathParam("projectName") String projectName,
- @QueryParam("password") String
- password) throws IOException {
+ public String register(
+ @Context HttpServletRequest req, @PathParam("projectName") String projectName,
+ @QueryParam("password") String password)
+ throws IOException, RocketChatDownException, UserDoesNotExistInRocketChatException {
User user = gfContexts.getUserFromSession(req);
Project project = projectDAO.getProjectByName(projectName);
- if (project == null){
+ if (project == null) {
return "project missing";
}
- if (!project.getPassword().equals(password) ) {
+ if (!project.getPassword().equals(password)) {
return "wrong password";
}
@@ -124,5 +124,4 @@ public class ProjectView {
}
-
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/submission/controller/SubmissionController.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/submission/controller/SubmissionController.java
index 51e65716eb57ef4f3107547b5c7d983e5facddeb..4f578ce9e93b59b9c09abc52aca1e5e7eb61a63b 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/submission/controller/SubmissionController.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/submission/controller/SubmissionController.java
@@ -576,7 +576,7 @@ public class SubmissionController implements ISubmission, HasProgress {
*/
public void markAsFinal(FullSubmission fullSubmission) {
connection.connect();
- String query = "update fullsubmissions set finalized = ? where id = ?";
+ String query = "updateRocketChatUserName fullsubmissions set finalized = ? where id = ?";
connection.issueUpdateStatement(query, 1, fullSubmission.getId());
connection.close();
}
@@ -591,7 +591,7 @@ public class SubmissionController implements ISubmission, HasProgress {
*/
public void updateFullSubmission(User submissionOwner, User feedbackGiver) {
connection.connect();
- String query = "update fullsubmissions set feedbackUser = ? where user = ?";
+ String query = "updateRocketChatUserName fullsubmissions set feedbackUser = ? where user = ?";
connection.issueUpdateStatement(query, feedbackGiver.getEmail(), submissionOwner.getEmail());
connection.close();
// TODO implement linking submission with group
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/HiddenUserTag.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/HiddenUserTag.java
index 836fd02959063f9bacc344ad6715286f645983e3..61e1e4afc5cf705bb654654fee6b5308b45caf10 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/HiddenUserTag.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/HiddenUserTag.java
@@ -9,7 +9,7 @@ import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;
/**
- * implemented while porting the login page. It might be useful to have a hidden user field on the page in order to
+ * implemented while porting the register page. It might be useful to have a hidden user field on the page in order to
* manipulate the user data with jquery
*/
@ManagedBean
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..2a877f7d7e042e7f0465c1d0acde24daa7c80e9f 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/User.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/User.java
@@ -1,5 +1,6 @@
package unipotsdam.gf.modules.user;
+import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import java.util.Objects;
@@ -13,38 +14,47 @@ public class User {
private String name;
private String password;
private String email;
- private String rocketChatAuthToken;
- private String rocketChatId;
+ // the speaking name must unique in rocket chat
+ private String rocketChatUsername;
+
private Boolean isStudent;
public User() {
}
- public User(String name, String password, String email, Boolean isStudent) {
- this(name, password, email, "", "", 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, Boolean isStudent) {
this.name = name;
this.password = password;
this.email = email;
- this.rocketChatAuthToken = rocketChatAuthToken;
- this.rocketChatId = rocketChatId;
- this.isStudent = isStudent;
+ this.rocketChatUsername = rocketChatUsername;
+ this.setStudent(isStudent);
}
+
+
public User(String authorEmail) {
this.email = authorEmail;
}
- public String getName() {
- return name;
+ public User(String name, String password, String email, Boolean isStudent) {
+ this.name = name;
+ this.password= password;
+ this.email = email;
+ this.isStudent = isStudent;
}
+
public void setName(String name) {
this.name = name;
}
+ public String getName() {
+ return name;
+ }
+
+ @JsonIgnore
public String getPassword() {
return password;
}
@@ -69,30 +79,25 @@ public class User {
isStudent = student;
}
- public String getRocketChatId() {
- return rocketChatId;
- }
- public void setRocketChatId(String rocketChatId) {
- this.rocketChatId = rocketChatId;
- }
- public String getRocketChatAuthToken() {
- return rocketChatAuthToken;
+ public String getRocketChatUsername() {
+ return rocketChatUsername;
}
- public void setRocketChatAuthToken(String rocketChatAuthToken) {
- this.rocketChatAuthToken = rocketChatAuthToken;
+ public void setRocketChatUsername(String rocketChatUsername) {
+ this.rocketChatUsername = rocketChatUsername;
}
+
+
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", password='" + password + '\'' +
", email='" + email + '\'' +
- ", rocketChatAuthToken='" + rocketChatAuthToken + '\'' +
- ", rocketChatId='" + rocketChatId + '\'' +
+ ", rocketChatUsername='" + rocketChatUsername + '\'' +
", isStudent=" + isStudent +
'}';
}
@@ -102,11 +107,11 @@ public class User {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
- return Objects.equals(name, user.name) &&
- Objects.equals(password, user.password) &&
- Objects.equals(email, user.email) &&
- Objects.equals(rocketChatAuthToken, user.rocketChatAuthToken) &&
- Objects.equals(rocketChatId, user.rocketChatId) &&
- Objects.equals(isStudent, user.isStudent);
+ return Objects.equals(email, user.email) ;
+ }
+
+ @Override
+ public int hashCode() {
+ return getEmail().hashCode();
}
}
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..5deba403998a2624d07f08ebdd349f52779cdec3 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,10 @@ public class UserDAO {
public void persist(User user, UserProfile profile) {
connect.connect();
String mysqlRequest = "INSERT INTO users (`name`, `password`, `email`, `isStudent`," +
- "`rocketChatId`,`rocketChatAuthToken`) values (?,?,?,?,?,?)";
+ "`rocketChatUsername`) " +
+ "values (?,?,?,?,?)";
connect.issueInsertOrDeleteStatement(mysqlRequest, user.getName(), user.getPassword(), user.getEmail(),
- user.getStudent(), user.getRocketChatId(), user.getRocketChatAuthToken());
+ user.getStudent(),user.getRocketChatUsername());
connect.close();
// TODO implmement UserProfile @Mar
}
@@ -43,14 +44,11 @@ public class UserDAO {
connect.close();
}
- public void update(User user) {
- 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
+ public void updateRocketChatUserName(User user) {
+ String mysqlRequest = "UPDATE `users` SET" +
+ "`rocketChatUsername`=? WHERE email=? LIMIT 1";
connect.connect();
- connect.issueUpdateStatement(mysqlRequest, user.getName(), user.getPassword(), user.getEmail(), user
- .getStudent(), user.getRocketChatId(), user.getRocketChatAuthToken(), user.getEmail());
+ connect.issueUpdateStatement(mysqlRequest, user.getRocketChatUsername(), user.getEmail());
connect.close();
}
@@ -65,6 +63,18 @@ 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);
+ if (resultSet == null) {
+ return false;
+ }
+ boolean result = resultSet.next();
+ connect.close();
+ return result;
+ }
+
public List<User> getUsersByProjectName(String projectName) {
connect.connect();
String query =
@@ -107,9 +117,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 f84848eed1543213c16bc52575fe392957eda8e3..b9b81e674dfb3d0d83d33cdc564008d94d1d2ed5 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserView.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/modules/user/UserView.java
@@ -1,9 +1,10 @@
package unipotsdam.gf.modules.user;
+import unipotsdam.gf.exceptions.*;
import unipotsdam.gf.modules.project.Management;
+import unipotsdam.gf.process.ProjectCreationProcess;
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;
@@ -25,12 +26,18 @@ import java.net.URISyntaxException;
@ManagedBean
public class UserView {
+ @Inject
private ICommunication communicationService;
+
+ @Inject
private UserDAO userDAO;
@Inject
private Management management;
+ @Inject
+ private ProjectCreationProcess projectCreationProcess;
+
@Inject
public UserView(ICommunication communicationService, UserDAO userDAO, Management management) {
this.communicationService = communicationService;
@@ -57,10 +64,35 @@ public class UserView {
@FormParam("email") String email, @FormParam("isStudent") String isStudent) throws URISyntaxException {
User user = new User(name, password, email, isStudent == null);
- return login(req, true, user);
+ try {
+ projectCreationProcess.createUser(user);
+ } catch (UserExistsInRocketChatException e) {
+ return registrationError();
+ } catch (UserExistsInMysqlException e) {
+ String existsUrl = "../register.jsp?userExists=true";
+ return forwardToLocation(existsUrl);
+ } catch (RocketChatDownException e) {
+ e.printStackTrace();
+ return registrationError();
+ }
+
+ try {
+ projectCreationProcess.authenticateUser(user, req);
+ } catch (UserDoesNotExistInRocketChatException e) {
+ loginError();
+ } catch (RocketChatDownException e) {
+ e.printStackTrace();
+ return registrationError();
+ }
+ return redirectToProjectPage(user);
}
+ private Response redirectToUserExists() throws URISyntaxException {
+ String existsUrl = "../index.jsp?userExists=false";
+ return forwardToLocation(existsUrl);
+ }
+
/**
* checks if a user exists in order to log him in
*
@@ -74,18 +106,25 @@ public class UserView {
@POST
@Produces(MediaType.TEXT_HTML)
@Path("/exists")
- public Response existsUser(
+ public Response authenticate(
@Context HttpServletRequest req, @FormParam("name") String name, @FormParam("password") String password,
@FormParam("email") String email) throws URISyntaxException {
User user = new User(name, password, email, null);
- ICommunication iCommunication = new CommunicationDummyService();
- boolean isLoggedIn = iCommunication.loginUser(user);
- if (isLoggedIn) {
- return login(req, false, user);
- } else {
+ try {
+ Boolean exists = projectCreationProcess.authenticateUser(user, req);
+ if (exists) {
+ user = fillUserFields(user);
+ return redirectToProjectPage(user);
+ } else {
+ return loginError();
+ }
+ } catch (UserDoesNotExistInRocketChatException e) {
+ return loginError();
+ } catch (RocketChatDownException e) {
return loginError();
}
+
}
@POST
@@ -102,40 +141,6 @@ public class UserView {
}
- /**
- * if create User is true, the user is created and logged in if he does not exist
- *
- * @param createUser
- * @param user
- * @return
- * @throws URISyntaxException
- */
- protected Response login(HttpServletRequest req, boolean createUser, User user) throws URISyntaxException {
-
- if (management.exists(user)) {
- if (!createUser) {
- user = fillUserFields(user);
- return redirectToProjectPage(req, user);
- }
- String existsUrl = "../register.jsp?userExists=true";
- return forwardToLocation(existsUrl);
- } else {
- if (createUser) {
- boolean isRegisteredAndLoggedIn = communicationService.registerAndLoginUser(user);
- if (!isRegisteredAndLoggedIn) {
- return registrationError();
- }
- management.create(user, null);
- user = fillUserFields(user);
- return redirectToProjectPage(req, user);
- } else {
- String existsUrl = "../index.jsp?userExists=false";
- return forwardToLocation(existsUrl);
- }
-
- }
- }
-
private User fillUserFields(User user) {
user = userDAO.getUserByEmail(user.getEmail());
return user;
@@ -158,7 +163,7 @@ public class UserView {
* @return
* @throws URISyntaxException
*/
- private Response redirectToProjectPage(HttpServletRequest req, User user) throws URISyntaxException {
+ private Response redirectToProjectPage(User user) throws URISyntaxException {
String successUrl;
if (user.getStudent() != null && user.getStudent()) {
@@ -166,7 +171,6 @@ public class UserView {
} else {
successUrl = "../project/overview-docent.jsp";
}
- req.getSession().setAttribute(GFContexts.USEREMAIL, user.getEmail());
Response result = forwardToLocation(successUrl);
return result;
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/mysql/MysqlConnectImpl.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/mysql/MysqlConnectImpl.java
index d0aecb4b7b4d8026a6b18327406833dc17a1cb8a..789cdb9a2f3766c625c3e9a5a7f2ed15129a4919 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/mysql/MysqlConnectImpl.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/mysql/MysqlConnectImpl.java
@@ -137,6 +137,7 @@ public class MysqlConnectImpl implements MysqlConnect {
}
private void printErrorMessage(String statement, SQLException ex) {
+ ex.printStackTrace();
String message = ex.toString() + " for statement \n" + statement;
log.error(message);
System.out.println(message);
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/process/GroupFormationProcess.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/process/GroupFormationProcess.java
index c26a91b6fb51d6c5786f91180dc6e81e2b5e8437..a289c669c5c442b0dae8ad0c87fae0a588454d9c 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/process/GroupFormationProcess.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/process/GroupFormationProcess.java
@@ -1,5 +1,8 @@
package unipotsdam.gf.process;
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
+import unipotsdam.gf.interfaces.ICommunication;
import unipotsdam.gf.interfaces.IGroupFinding;
import unipotsdam.gf.interfaces.IPhases;
import unipotsdam.gf.modules.group.Group;
@@ -34,7 +37,6 @@ public class GroupFormationProcess {
@Inject
private IGroupFinding groupfinding;
-
public void setGroupFormationMechanism(GroupFormationMechanism groupFormationMechanism, Project project) {
projectDAO.setGroupFormationMechanism(groupFormationMechanism, project);
}
@@ -55,7 +57,7 @@ public class GroupFormationProcess {
* this method finalizes the groups
* @param project
*/
- public void finalize(Project project) {
+ public void finalize(Project project) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
taskDAO.persistTeacherTask(project, TaskName.CLOSE_GROUP_FINDING_PHASE, Phase.GroupFormation);
/**
* Gruppenphase wird beendet
@@ -69,6 +71,9 @@ public class GroupFormationProcess {
// Die Studierenden müssen nicht mehr auf die Gruppenfindung warten
taskDAO.finishMemberTask(project, TaskName.WAITING_FOR_GROUP);
taskDAO.persistMemberTask(project, TaskName.CONTACT_GROUP_MEMBERS, Phase.GroupFormation);
+
+ //if the project is finalized create group chat room
+ groupfinding.finalizeGroups(project);
}
@@ -83,6 +88,5 @@ public class GroupFormationProcess {
public void saveGroups(List<Group> groups,Project project){
groupfinding.deleteGroups(project);
groupfinding.persistGroups(groups, project);
- taskDAO.finishMemberTask(project, TaskName.WAIT_FOR_PARTICPANTS);
}
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/process/ProjectCreationProcess.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/process/ProjectCreationProcess.java
index 6a4f30ebf195e6a6973a1aeadee9a6ea7fb324f5..35078a93ff5808b079a10305ca711961c1b67507 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/process/ProjectCreationProcess.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/process/ProjectCreationProcess.java
@@ -1,7 +1,10 @@
package unipotsdam.gf.process;
+import unipotsdam.gf.exceptions.*;
+import unipotsdam.gf.interfaces.ICommunication;
import unipotsdam.gf.modules.annotation.model.Category;
import unipotsdam.gf.modules.assessment.AssessmentMechanism;
+import unipotsdam.gf.modules.communication.model.RocketChatUser;
import unipotsdam.gf.modules.group.GroupDAO;
import unipotsdam.gf.modules.group.GroupFormationMechanism;
import unipotsdam.gf.modules.project.Management;
@@ -13,9 +16,11 @@ import unipotsdam.gf.process.phases.Phase;
import unipotsdam.gf.process.tasks.Task;
import unipotsdam.gf.process.tasks.TaskDAO;
import unipotsdam.gf.process.tasks.TaskName;
+import unipotsdam.gf.session.GFContexts;
import javax.inject.Inject;
import javax.inject.Singleton;
+import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.WebApplicationException;
import java.util.HashMap;
@@ -38,6 +43,11 @@ public class ProjectCreationProcess {
@Inject
private GroupDAO groupDAO;
+ @Inject
+ private ICommunication iCommunication;
+
+ @Inject
+ private GFContexts gfContexts;
/**
* STEP 1
@@ -45,7 +55,8 @@ public class ProjectCreationProcess {
* @param project which project is created
* @param author who creates the project
*/
- public void createProject(Project project, User author) {
+ public void createProject(Project project, User author)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
project.setAuthorEmail(author.getEmail());
try {
iManagement.create(project);
@@ -53,16 +64,10 @@ public class ProjectCreationProcess {
throw new WebApplicationException("Project already exists");
}
taskDao.createTaskWaitForParticipants(project, author);
- HashMap<Phase, Boolean> phase = new HashMap<>();
- phase.put(project.getPhase(), true);
- HashMap<Category, Boolean> category = new HashMap<>();
- category.put(Category.TITEL, true);
- ProjectConfiguration projectConfiguration = new ProjectConfiguration(
- phase,
- category,
- AssessmentMechanism.PEER_ASSESSMENT, //todo: its just a default by now. correct this
- GroupFormationMechanism.SingleUser); //todo: its just a default by now. fix it
- iManagement.create(projectConfiguration, project);
+
+ // create chatromm
+ iCommunication.createEmptyChatRoom(project.getName(), false);
+
}
/**
@@ -71,7 +76,8 @@ public class ProjectCreationProcess {
* @param project which project is entered
* @param user who is participates the project
*/
- public void studentEntersProject(Project project, User user) {
+ public void studentEntersProject(Project project, User user)
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException {
// student enters project
iManagement.register(user, project, null);
@@ -93,13 +99,47 @@ public class ProjectCreationProcess {
//phases.endPhase(Phase.GroupFormation, project);
}
}
+ iCommunication.addUserToChatRoom(user, project.getName());
}
- /**
+ public void createUser(User user)
+ throws UserExistsInMysqlException, RocketChatDownException, UserExistsInRocketChatException {
+ if(iManagement.exists(user)) {
+ throw new UserExistsInMysqlException();
+ }
+ // create user in rocket chat
+ iCommunication.registerUser(user);
+ // create user in mysql
+ iManagement.create(user, null);
+
+ }
+
+ public Boolean authenticateUser(User user, HttpServletRequest req)
+ throws UserDoesNotExistInRocketChatException, RocketChatDownException {
+ // todo implement
+
+ RocketChatUser isLoggedIn = iCommunication.loginUser(user);
+ gfContexts.updateUserSessionWithRocketChat(req, isLoggedIn);
+ gfContexts.updateUserWithEmail(req, isLoggedIn);
+ return iManagement.exists(user);
+ }
+
+ public void deleteUser(User user) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ iManagement.delete(user);
+ iCommunication.delete(user);
+ }
+
+ public void deleteProject(Project project) throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ // TODO implement
+ iManagement.delete(project);
+ iCommunication.deleteChatRoom(project);
+ }
+
+ /* *//**
* STEP N
*
* @param project the project to delete
- */
+ *//*
public void deleteProject(Project project) {
try {
iManagement.delete(project);
@@ -107,5 +147,5 @@ public class ProjectCreationProcess {
throw new WebApplicationException("Project already exists");
}
//taskDao.createTaskWaitForParticipants(project, author);
- }
+ }*/
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/process/tasks/TaskDAO.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/process/tasks/TaskDAO.java
index 3cd85a226e0fedf55d36040627055b037b6d5210..992d97837f02e7f1b7334c699820a4ff88c73233 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/process/tasks/TaskDAO.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/process/tasks/TaskDAO.java
@@ -1,6 +1,7 @@
package unipotsdam.gf.process.tasks;
import unipotsdam.gf.interfaces.IGroupFinding;
+import unipotsdam.gf.modules.group.GroupFormationMechanism;
import unipotsdam.gf.modules.project.Project;
import unipotsdam.gf.modules.project.ProjectDAO;
import unipotsdam.gf.modules.submission.controller.SubmissionController;
@@ -15,6 +16,8 @@ import javax.annotation.ManagedBean;
import javax.inject.Inject;
import java.sql.Timestamp;
import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
import java.util.Comparator;
import java.util.List;
@@ -95,7 +98,14 @@ public class TaskDAO {
project.setName(vereinfachtesResultSet.getString("projectName"));
ParticipantsCount participantsCount = projectDAO.getParticipantCount(project);
participantsCount.setParticipantsNeeded(groupFinding.getMinNumberOfStudentsNeeded(project));
- task.setTaskData(participantsCount);
+ Map<String, Object> taskData = new HashMap<>();
+ taskData.put("participantCount", participantsCount);
+ GroupFormationMechanism gfm =groupFinding.getGFM(project);
+ taskData.put("gfm", gfm);
+ task.setTaskData(taskData);
+ if (gfm.equals(GroupFormationMechanism.Manual)){
+ task.setTaskType(TaskType.LINKED);
+ }
task.setHasRenderModel(true);
return task;
}
@@ -303,7 +313,7 @@ public class TaskDAO {
}
/*
- * if this takes long rewrite it as batch update
+ * if this takes long rewrite it as batch updateRocketChatUserName
*/
public void finishMemberTask(Project project, TaskName taskName) {
java.util.List<User> members = userDAO.getUsersByProjectName(project.getName());
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/session/GFContexts.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/session/GFContexts.java
index 1c4f46a42c6c2539c67e2779f702c079625acb3f..7ec5417a9279235333ccc1b9cf98815e29ba111b 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/session/GFContexts.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/session/GFContexts.java
@@ -1,5 +1,6 @@
package unipotsdam.gf.session;
+import unipotsdam.gf.modules.communication.model.RocketChatUser;
import unipotsdam.gf.modules.user.User;
import unipotsdam.gf.modules.user.UserDAO;
@@ -14,6 +15,10 @@ public class GFContexts {
public static final String USEREMAIL = "userEmail";
public static final String PROJECTNAME = "projectName";
+ public static final String ROCKETCHATAUTHTOKEN = "rocketchatauthtoken";
+ public static final String ROCKETCHATID = "rocketchatid";
+
+
public String getUserEmail(HttpServletRequest req) throws IOException {
Object userEmail = req.getSession().getAttribute(GFContexts.USEREMAIL);
if (userEmail == null) {
@@ -27,4 +32,13 @@ public class GFContexts {
String userEmail = getUserEmail(req);
return userDAO.getUserByEmail(userEmail);
}
+
+ public void updateUserSessionWithRocketChat(HttpServletRequest req, RocketChatUser user) {
+ req.getSession().setAttribute(GFContexts.ROCKETCHATAUTHTOKEN, user.getRocketChatAuthToken());
+ req.getSession().setAttribute(GFContexts.ROCKETCHATID, user.getRocketChatUserId());
+ }
+
+ public void updateUserWithEmail(HttpServletRequest req, User user) {
+ req.getSession().setAttribute(GFContexts.USEREMAIL, user.getEmail());
+ }
}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/session/SessionExistsFilter.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/session/SessionExistsFilter.java
index 52afe707398ca028c6dfc9f0b17db023f47fe24f..16c4db2eb668a1e81ce4746410953b340a497df6 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/session/SessionExistsFilter.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/session/SessionExistsFilter.java
@@ -52,8 +52,8 @@ public class SessionExistsFilter implements Filter {
Object attribute = request1.getSession().getAttribute(GFContexts.USEREMAIL);
if (attribute == null) {
- //redirectToLogin(request, response);
- request1.getSession().setAttribute(GFContexts.USEREMAIL, attribute);
+ redirectToLogin(request, response);
+ //request1.getSession().setAttribute(GFContexts.USEREMAIL, "vodkas@yolo.com");
chain.doFilter(request,response);
} else {
final ServiceLocator locator = ServiceLocatorUtilities.bind(new GFApplicationBinder());
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/taglibs/ChatWindow.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/taglibs/ChatWindow.java
new file mode 100644
index 0000000000000000000000000000000000000000..09f624f0e549884b855ca921748647de9050223b
--- /dev/null
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/taglibs/ChatWindow.java
@@ -0,0 +1,99 @@
+package unipotsdam.gf.taglibs;
+
+import org.glassfish.hk2.api.ServiceLocator;
+import org.glassfish.hk2.utilities.ServiceLocatorUtilities;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import unipotsdam.gf.config.GFApplicationBinder;
+import unipotsdam.gf.config.GFRocketChatConfig;
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
+import unipotsdam.gf.interfaces.ICommunication;
+import unipotsdam.gf.modules.communication.service.CommunicationService;
+import unipotsdam.gf.session.GFContext;
+import unipotsdam.gf.session.GFContexts;
+
+import javax.inject.Inject;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.jsp.JspWriter;
+import javax.servlet.jsp.PageContext;
+import javax.servlet.jsp.tagext.SimpleTagSupport;
+import java.io.IOException;
+
+public class ChatWindow extends SimpleTagSupport {
+
+ private static final Logger log = LoggerFactory.getLogger(ChatWindow.class);
+
+ private String orientation;
+
+ private String scope;
+
+ @Inject
+ private ICommunication communicationService;
+
+ public void doTag() throws IOException {
+
+ final ServiceLocator locator = ServiceLocatorUtilities.bind(new GFApplicationBinder());
+ locator.inject(this);
+
+ PageContext pageContext = (PageContext) getJspContext();
+ HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
+ /*String token = request.getParameter("token"); */
+ String projectName = request.getParameter("projectName");
+ String userEmail = request.getSession().getAttribute(GFContexts.USEREMAIL).toString();
+
+ /**
+ * create project chatroom
+ */
+ if (getScope() == "project") {
+ String chatRoomLink = communicationService.getProjectChatRoomLink(projectName);
+ writeIframe(request, chatRoomLink);
+ /**
+ * create group chatroom
+ */
+ } else {
+ // scope is group
+ String projectChatRoomLink = null;
+ try {
+ projectChatRoomLink = communicationService.getChatRoomLink(userEmail, projectName);
+ } catch (RocketChatDownException e) {
+ e.printStackTrace();
+ } catch (UserDoesNotExistInRocketChatException e) {
+ e.printStackTrace();
+ }
+ if (projectChatRoomLink != null) {
+ writeIframe(request, projectChatRoomLink);
+ }
+ }
+
+ }
+
+ private void writeIframe(HttpServletRequest request, String chatRoomLink) throws
+ IOException {
+ String getAuthToken = request.getSession().getAttribute(GFContexts.ROCKETCHATAUTHTOKEN).toString();
+ String getId = request.getSession().getAttribute(GFContexts.ROCKETCHATID).toString();
+ JspWriter out = getJspContext().getOut();
+
+ log.debug("chatroom links for ChatWindow: {}", chatRoomLink);
+
+ out.println("<iframe height=\"400px\" src=\"" + chatRoomLink + "\">");
+ out.println("</iframe>");
+
+ }
+
+ public void setOrientation(String orientation) {
+ this.orientation = orientation;
+ }
+
+ public String getOrientation() {
+ return orientation;
+ }
+
+ public void setScope(String scope) {
+ this.scope = scope;
+ }
+
+ public String getScope() {
+ return scope;
+ }
+}
diff --git a/gemeinsamforschen/src/main/java/unipotsdam/gf/util/ResultSetUtil.java b/gemeinsamforschen/src/main/java/unipotsdam/gf/util/ResultSetUtil.java
index 4d0cf6ba5ff5c16f2b8db19ce57703cfd0cca2c7..ec7d9e929cae335f0f00040014a2897f7bd27ed2 100644
--- a/gemeinsamforschen/src/main/java/unipotsdam/gf/util/ResultSetUtil.java
+++ b/gemeinsamforschen/src/main/java/unipotsdam/gf/util/ResultSetUtil.java
@@ -1,7 +1,7 @@
package unipotsdam.gf.util;
-import unipotsdam.gf.mysql.VereinfachtesResultSet;
import unipotsdam.gf.modules.user.User;
+import unipotsdam.gf.mysql.VereinfachtesResultSet;
public class ResultSetUtil {
@@ -9,9 +9,8 @@ public class ResultSetUtil {
String name = vereinfachtesResultSet.getString("name");
String password = vereinfachtesResultSet.getString("password");
String email = vereinfachtesResultSet.getString("email");
- String rocketChatId = "";//vereinfachtesResultSet.getString("rocketChatId");
- String rocketChatAuthToken = "";//vereinfachtesResultSet.getString("rocketChatAuthToken");
+ String rocketChatUserName = vereinfachtesResultSet.getString("rocketChatUserName");
Boolean isStudent = vereinfachtesResultSet.getBoolean("isStudent");
- return new User(name, password, email, rocketChatId, rocketChatAuthToken, isStudent);
+ return new User(name, password, email, rocketChatUserName, isStudent);
}
}
diff --git a/gemeinsamforschen/src/main/webapp/project/js/create-project.js b/gemeinsamforschen/src/main/webapp/project/js/create-project.js
index 3560647017df66dd62c03a557a60af6287ca4438..27a0cef1c9ea7776cef2d21fc43d905b97ccce11 100644
--- a/gemeinsamforschen/src/main/webapp/project/js/create-project.js
+++ b/gemeinsamforschen/src/main/webapp/project/js/create-project.js
@@ -1,5 +1,6 @@
let allTheTags = [];
let projectName = "";
+var gfm = "";
/**
* Created by fides-WHK on 19.02.2018.
@@ -38,12 +39,11 @@ function createNewProject(allTheTags, activ) {
if (allTheTags.length !== 5) {
$('#exactNumberOfTags').show();
} else {
- createProjectinCompbase();
- location.href="tasks-student.jsp?projectName="+projectName;
+ sendGroupPreferences();
}
}
},
- error: function (a) {
+ error: function (a, b, c) {
console.log(a);
return true;
}
@@ -68,7 +68,7 @@ function initTagsInput(allTheTags) {
onAddTag: function (tag) {
allTheTags.push(tag);
},
- onRemoveTag: function () {
+ onRemoveTag: function (tag) {
allTheTags.pop(); //todo: löscht noch nicht den gewählten tag sondern den letzten
}
});
@@ -86,6 +86,10 @@ function initSendButton(allTheTags) {
function getProjectValues() {
projectName = $("#nameProject").val().trim();
let password = $("#passwordProject").val().trim();
+ let adminPassword = $("#adminPassword").val().trim();
+ if (adminPassword === "") {
+ adminPassword = "1234";
+ }
//allTheTags = $("#tagsProject").tagsInput('items');
//allTheTags = $("#tagsProject").val();
let reguexp = /^[a-zA-Z0-9äüöÄÜÖ]+$/;
@@ -114,6 +118,8 @@ function getProjectValues() {
"password" : password,
"description": description,
"active" : true,
+ "adminPassword": adminPassword,
+ "phase" : "GroupFormation",
"timecreated" : time,
"authorEmail": $('#userEmail').text().trim(),
"phase" : "CourseCreation",
@@ -140,7 +146,7 @@ function createProjectinCompbase() {
success: function (response) {
console.log(response);
// it actually worked, too
- sendGroupPreferences();
+ document.location.href = "tasks-docent.jsp?projectName="+projectName;
},
error: function (a) {
console.log(a);
@@ -149,3 +155,37 @@ function createProjectinCompbase() {
}
});
}
+
+
+function sendGroupPreferences() {
+ gfm = $('input[name=gfm]:checked').val();
+ if (gfm == "Basierend auf Präferenzen") {
+ // TODO implement preference based group selection
+ gfm = "UserProfilStrategy";
+ } else if (gfm == "per Hand") {
+ gfm = "Manual";
+ } else if (gfm == "Basierend auf Lernzielen") {
+ gfm = "LearningGoalStrategy";
+ } else if(gfm == "Keine Gruppen") {
+ gfm = "SingleUser";
+ }
+
+ var localurl = "../../gemeinsamforschen/rest/group/gfm/create/projects/" + projectName;
+ $.ajax({
+ gfm: gfm,
+ url: localurl,
+ contentType: 'application/json',
+ type: 'POST',
+ data: gfm,
+ success: function (a, b, c) {
+ if (gfm == "LearningGoalStrategy") {
+ createProjectinCompbase();
+ }
+ document.location.href = "tasks-docent.jsp?projectName="+projectName;
+ return true;
+ },
+ error: function (a, b, c) {
+ return false;
+ }
+ });
+}
diff --git a/gemeinsamforschen/src/main/webapp/project/overview-student.jsp b/gemeinsamforschen/src/main/webapp/project/overview-student.jsp
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/gemeinsamforschen/src/main/webapp/project/tasks-student.jsp b/gemeinsamforschen/src/main/webapp/project/tasks-student.jsp
index 8817b33e437a0bae90c8f32a72b4e595e3a0d11a..c13ff10484c3a680e2758bc5a33ad05415cd979c 100644
--- a/gemeinsamforschen/src/main/webapp/project/tasks-student.jsp
+++ b/gemeinsamforschen/src/main/webapp/project/tasks-student.jsp
@@ -10,6 +10,8 @@
<%@ taglib uri="../taglibs/gemeinsamForschen.tld" prefix="headLine" %>
<%@ taglib uri="../taglibs/gemeinsamForschen.tld" prefix="omniDependencies" %>
<%@ taglib uri="../taglibs/gemeinsamForschen.tld" prefix="footer" %>
+<%@ taglib uri="../taglibs/gemeinsamForschen.tld" prefix="chat" %>
+
<!DOCTYPE html>
<html lang="de">
<head>
@@ -50,9 +52,8 @@
</div>
</div>
-
-
</script>
+
<script id="finishedTaskTemplate" type="text/x-jQuery-tmpl">
<div class="card ${phase}">
<div class="card-finished"><h4 class="icon closed">${infoText}</h4>
@@ -60,6 +61,10 @@
</div>
</div>
</script>
+
+<chat:chatWindow orientation="right" scope="project"></chat:chatWindow>
+<chat:chatWindow orientation="right" scope="group"></chat:chatWindow>
+
<footer:footer/>
</body>
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/core/context/group/ProfileDAOTest.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/core/context/group/ProfileDAOTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..57ae0fb2a1b5d18fb4f2886c096d7349e1432888
--- /dev/null
+++ b/gemeinsamforschen/src/test/java/unipotsdam/gf/core/context/group/ProfileDAOTest.java
@@ -0,0 +1,41 @@
+package unipotsdam.gf.core.context.group;
+
+import ch.vorburger.exec.ManagedProcessException;
+import org.glassfish.hk2.api.ServiceLocator;
+import org.glassfish.hk2.utilities.ServiceLocatorUtilities;
+import org.junit.Before;
+import org.junit.Test;
+import unipotsdam.gf.core.database.TestGFApplicationBinder;
+import unipotsdam.gf.core.database.UpdateDB;
+import unipotsdam.gf.modules.group.Group;
+import unipotsdam.gf.modules.user.User;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.List;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+public class ProfileDAOTest {
+ @Before
+ public void setUp() throws IOException, SQLException, ManagedProcessException {
+ final ServiceLocator locator = ServiceLocatorUtilities.bind(new TestGFApplicationBinder());
+ //final ServiceLocator locator = ServiceLocatorUtilities.bind(new GFApplicationBinder());
+ locator.inject(this);
+
+ UpdateDB.updateTestDB();
+ }
+
+ @Test
+ public void testCreate() {
+
+ }
+
+ @Test
+ public void testDelete() {
+
+ }
+
+
+}
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/core/context/user/UserDAOTest.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/core/context/user/UserDAOTest.java
index 47c98e52f0e5bcfca2f304adaa9b49051b2a3fde..91d41f32e66cd4f53bd24482c5507a99db814547 100644
--- a/gemeinsamforschen/src/test/java/unipotsdam/gf/core/context/user/UserDAOTest.java
+++ b/gemeinsamforschen/src/test/java/unipotsdam/gf/core/context/user/UserDAOTest.java
@@ -90,7 +90,7 @@ public class UserDAOTest {
assertTrue(userDAO.exists(user));
user.setStudent(false);
- userDAO.update(user);
+ userDAO.updateRocketChatUserName(user);
assertTrue(userDAO.exists(user));
User managementUser = userDAO.getUserByEmail(user.getEmail());
assertEquals(user.getStudent(), managementUser.getStudent());
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/InMemoryMySqlConnect.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/InMemoryMySqlConnect.java
index 0919b1232b4221dd880bcf37a2a0d885866b1703..e0b8ce48eb2e4789e645304a99b743efa79e052e 100644
--- a/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/InMemoryMySqlConnect.java
+++ b/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/InMemoryMySqlConnect.java
@@ -41,6 +41,17 @@ public class InMemoryMySqlConnect extends MysqlConnectImpl {
}
+ @Override
+ public void connect() {
+ //
+ if (conn == null) {
+ try {
+ conn = getConnection();
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+ }
@Override
public void close() {
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/MysqlTestConnect.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/MysqlTestConnect.java
index 62a10bfa5b174eefa38efa5498305712e8ea1716..50a53a86c32b03ef28abd8c502dad2dc4439cbb0 100644
--- a/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/MysqlTestConnect.java
+++ b/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/MysqlTestConnect.java
@@ -13,7 +13,8 @@ public class MysqlTestConnect extends MysqlConnectImpl {
private static String createConnectionString() {
String connString =
- "jdbc:mysql://" + "localhost" + "/" + GFDatabaseConfig.DB_NAME + "?user=" + GFDatabaseConfig.USER + "&password=" + GFDatabaseConfig.PASS;
+ "jdbc:mysql://" + "localhost" + "/" + GFDatabaseConfig.TEST_DB_NAME + "?user=" + GFDatabaseConfig.USER +
+ "&password=" + GFDatabaseConfig.PASS;
return String.format(connString, "fltrail_test");
}
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/UpdateDB.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/UpdateDB.java
index 35189bdbd2c59b80445e895da3c3d4de7c6d1b14..2485150f96f9b225170ec9aa4cd2a1074993c9f9 100644
--- a/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/UpdateDB.java
+++ b/gemeinsamforschen/src/test/java/unipotsdam/gf/core/database/UpdateDB.java
@@ -16,7 +16,8 @@ public class UpdateDB {
private boolean stopOnError;
private boolean autoCommit;
- private PrintWriter logWriter = new PrintWriter(System.out);
+ //private PrintWriter logWriter = new PrintWriter(System.out);
+ private PrintWriter logWriter = null;
private PrintWriter errorLogWriter = new PrintWriter(System.err);
private String delimiter = DEFAULT_DELIMITER;
@@ -29,8 +30,20 @@ public class UpdateDB {
UpdateDB updateDB = new UpdateDB(connection, true, false);
System.out.println(new java.io.File( "." ).getCanonicalPath());
+ updateDB.runScript(new FileReader("src/test/resources/database/db.sql"));
updateDB.runScript(new FileReader("src/test/resources/database/fltrail.sql"));
- updateDB.runScript(new FileReader("src/test/resources/database/testuser.sql"));
+ //updateDB.runScript(new FileReader("src/test/resources/database/testuser.sql"));
+ }
+
+ public static void updateTestDB() throws SQLException, ManagedProcessException, IOException {
+ MysqlConnect mysqlConnect = new MysqlTestConnect();
+ Connection connection = mysqlConnect.getConnection();
+
+ UpdateDB updateDB = new UpdateDB(connection, true, false);
+ System.out.println(new java.io.File( "." ).getCanonicalPath());
+ updateDB.runScript(new FileReader("src/test/resources/database/test_db.sql"));
+ updateDB.runScript(new FileReader("src/test/resources/database/fltrail.sql"));
+ //updateDB.runScript(new FileReader("src/test/resources/database/testuser.sql"));
}
public UpdateDB(Connection connection, boolean stopOnError, boolean autoCommit) {
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/interfaces/ActivityFlowTest.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/interfaces/ActivityFlowTest.java
index bda296be063d25b06930e3fe95136b7385519e5a..d79b7fdbeead1091a242fa8dc53af73d63c0e59a 100644
--- a/gemeinsamforschen/src/test/java/unipotsdam/gf/interfaces/ActivityFlowTest.java
+++ b/gemeinsamforschen/src/test/java/unipotsdam/gf/interfaces/ActivityFlowTest.java
@@ -111,7 +111,7 @@ public class ActivityFlowTest {
formGroups();
// end first phase
- phases.endPhase(Phase.CourseCreation, project);
+ phases.endPhase(Phase.GroupFormation, project);
// upload dossiers
uploadDossiers();
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/interfaces/PhaseTest.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/interfaces/PhaseTest.java
index 5928380b42700142cedd858b6e7c7c202652cf59..2f3f29b3f834f30f5a92cd20768b451abe9a2bd2 100644
--- a/gemeinsamforschen/src/test/java/unipotsdam/gf/interfaces/PhaseTest.java
+++ b/gemeinsamforschen/src/test/java/unipotsdam/gf/interfaces/PhaseTest.java
@@ -48,12 +48,7 @@ public class PhaseTest {
management.register(user, project, null);
}
- @Test
- public void phase1() {
- Project project = new Project();
- project.setName(projectName);
- phases.endPhase(Phase.CourseCreation, project);
- }
+
@Test
public void phase2() {
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..73e2b7c1db641c471305858d1f7fa18656523148
--- /dev/null
+++ b/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/communication/service/CommunicationServiceTest.java
@@ -0,0 +1,317 @@
+package unipotsdam.gf.modules.communication.service;
+
+import ch.vorburger.exec.ManagedProcessException;
+import org.glassfish.hk2.api.ServiceLocator;
+import org.glassfish.hk2.utilities.ServiceLocatorUtilities;
+import org.junit.*;
+import uk.co.jemos.podam.api.PodamFactory;
+import uk.co.jemos.podam.api.PodamFactoryImpl;
+import unipotsdam.gf.config.GFApplicationBinder;
+import unipotsdam.gf.core.database.TestGFApplicationBinder;
+import unipotsdam.gf.core.database.UpdateDB;
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
+import unipotsdam.gf.exceptions.UserExistsInRocketChatException;
+import unipotsdam.gf.interfaces.ICommunication;
+import unipotsdam.gf.modules.assessment.controller.model.StudentIdentifier;
+import unipotsdam.gf.modules.communication.model.EMailMessage;
+import unipotsdam.gf.modules.group.Group;
+import unipotsdam.gf.modules.group.GroupDAO;
+import unipotsdam.gf.modules.project.Management;
+import unipotsdam.gf.modules.project.Project;
+import unipotsdam.gf.modules.project.ProjectDAO;
+import unipotsdam.gf.modules.user.User;
+import unipotsdam.gf.modules.user.UserDAO;
+import unipotsdam.gf.modules.user.UserProfile;
+import unipotsdam.gf.process.constraints.Constraints;
+import unipotsdam.gf.process.constraints.ConstraintsMessages;
+
+import javax.inject.Inject;
+import java.io.IOException;
+import java.sql.SQLException;
+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 {
+
+ @Inject
+ private ICommunication iCommunication;
+
+ private User user;
+
+ @Inject
+ private GroupDAO groupDAO;
+
+ @Inject
+ private UserDAO userDAO;
+
+ @Inject
+ private ProjectDAO projectDAO;
+
+ private List<String> createdChatRooms;
+
+ @Inject
+ Management management;
+
+
+ @BeforeClass
+ public static void init() throws IOException, SQLException, ManagedProcessException {
+ //UpdateDB.updateTestDB();
+ }
+
+ @Before
+ public void setUp() {
+
+ //final ServiceLocator locator = ServiceLocatorUtilities.bind(new TestGFApplicationBinder());
+ final ServiceLocator locator = ServiceLocatorUtilities.bind(new GFApplicationBinder());
+ locator.inject(this);
+
+ user = new User("Vorname Nachname", "password", "email@uni.de", true);
+ userDAO.persist(user, null);
+
+ createdChatRooms = new ArrayList<>();
+
+ }
+
+ @After
+ public void tearDown() {
+ createdChatRooms.forEach(createdChatRoom -> {
+ try {
+ iCommunication.deleteChatRoom(createdChatRoom);
+ } catch (RocketChatDownException e) {
+ e.printStackTrace();
+ } catch (UserDoesNotExistInRocketChatException e) {
+ e.printStackTrace();
+ }
+ });
+ createdChatRooms.clear();
+
+
+ }
+
+ @Test
+ public void loginUser() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ assertNotNull(iCommunication.loginUser(TEST_USER));
+ assertTrue(!TEST_USER.getRocketChatAuthToken().isEmpty());
+ assertTrue(!TEST_USER.getRocketChatUserId().isEmpty());
+
+ User falseLoginUser = new User("name", "password", "email", true);
+ assertNotNull(iCommunication.loginUser(falseLoginUser));
+ }
+
+
+ @Ignore
+ @Test
+ public void registerUser() throws RocketChatDownException, UserExistsInRocketChatException {
+ // TODO Side effect is not optimal because you need to know that before persisting the user
+ boolean userCreated = iCommunication.registerUser(user);
+ //userDAO.persist(user, null);
+ assertTrue(userCreated);
+ }
+
+ @Test
+ public void createEmptyChatRoom() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ 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() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ 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() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ Group group = new Group();
+ group.setMembers(Collections.singletonList(ADMIN_USER));
+ group.setProjectName("chatWithGroup");
+ boolean successful = iCommunication.createChatRoom(group, false);
+ assertTrue(successful);
+ createdChatRooms.add(group.getChatRoomId());
+ }
+
+ @Test
+ public void getChatRoomName() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ 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() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ String projectId = "Projekt";
+ Project project = new Project(projectId, user.getEmail());
+ projectDAO.persist(project);
+
+ Group group = new Group();
+ userDAO.persist(ADMIN_USER, new UserProfile());
+ group.setProjectName(projectId);
+ group.setMembers(Collections.singletonList(ADMIN_USER));
+ groupDAO.persist(group);
+ iCommunication.createChatRoom(group, false);
+ groupDAO.update(group);
+
+ String chatRoomLink = iCommunication.getChatRoomLink(ADMIN_USER.getEmail(), 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() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ 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() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ String chatRoomId = iCommunication.createEmptyChatRoom("addUser", false);
+ assertNotNull(chatRoomId);
+ assertFalse(chatRoomId.isEmpty());
+
+ assertTrue(iCommunication.addUserToChatRoom(TEST_USER, chatRoomId));
+
+ createdChatRooms.add(chatRoomId);
+ }
+
+ @Test
+ public void removeUserFromChatRoom() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ 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() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ 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.setName(projectId);
+ StudentIdentifier studentIdentifier = new StudentIdentifier();
+ studentIdentifier.setProjectName(projectId);
+ // Permalink for email-address: http://www.trashmail.de/index.php?search=javatest
+ studentIdentifier.setUserEmail("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() throws RocketChatDownException, UserDoesNotExistInRocketChatException {
+ User user = new User();
+ user.setName("Martin Nachname");
+ user.setPassword("test1234");
+ user.setEmail("martin@test.com");
+ user.setStudent(true);
+
+ userDAO.persist(user, null);
+
+
+ /* try {
+ userService.register(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.setName(projectId);
+ projectDAO.persist(project);
+ assertTrue(projectDAO.exists(project));
+
+ management.register(user, project, null);
+
+ Group group = new Group();
+ group.setProjectName(projectId);
+ group.setMembers(Collections.singletonList(user));
+ groupDAO.persist(group);
+ assertTrue(groupDAO.exists(group));
+
+ boolean success = iCommunication.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");
- }
-}
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/groupfinding/dummy/service/DummyProjectCreationServiceTest.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/groupfinding/dummy/service/DummyProjectCreationServiceTest.java
deleted file mode 100644
index 04d3cab09c581f720baed4729fdbd876a0bd8f3e..0000000000000000000000000000000000000000
--- a/gemeinsamforschen/src/test/java/unipotsdam/gf/modules/groupfinding/dummy/service/DummyProjectCreationServiceTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-package unipotsdam.gf.modules.groupfinding.dummy.service;
-
-import org.glassfish.hk2.api.ServiceLocator;
-import org.glassfish.hk2.utilities.ServiceLocatorUtilities;
-import org.junit.Before;
-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.TestGFApplicationBinder;
-import unipotsdam.gf.modules.group.DummyProjectCreationService;
-import unipotsdam.gf.modules.project.Management;
-import unipotsdam.gf.modules.group.Group;
-import unipotsdam.gf.modules.project.Project;
-import unipotsdam.gf.modules.project.ProjectDAO;
-import unipotsdam.gf.modules.user.User;
-import unipotsdam.gf.modules.user.UserDAO;
-import unipotsdam.gf.interfaces.ICommunication;
-import unipotsdam.gf.modules.communication.service.CommunicationDummyService;
-import unipotsdam.gf.modules.group.GroupDAO;
-
-import javax.inject.Inject;
-import java.util.List;
-
-import static org.junit.Assert.assertTrue;
-
-public class DummyProjectCreationServiceTest {
-
- static PodamFactory factory = new PodamFactoryImpl();
-
-
- @Inject
- private UserDAO userDAO;
-
- @Inject
- private Management management;
-
- @Before
- public void setUp() {
- final ServiceLocator locator = ServiceLocatorUtilities.bind(new TestGFApplicationBinder());
- //final ServiceLocator locator = ServiceLocatorUtilities.bind(new GFApplicationBinder());
- locator.inject(this);
-
- }
-
-
- @Test
- public void testCreateExampleProject() {
- ICommunication communication = new CommunicationDummyService();
- InMemoryMySqlConnect inMemoryMySqlConnect = new InMemoryMySqlConnect();
- GroupDAO groupDAO = new GroupDAO(inMemoryMySqlConnect);
-
- DummyProjectCreationService
- dummyProjectCreationService = new DummyProjectCreationService(communication, management, groupDAO, userDAO);
-
- dummyProjectCreationService.createExampleProject();
-
- User docentUser = dummyProjectCreationService.getDocentUser();
- assertTrue(userDAO.exists(docentUser));
-
- ProjectDAO projectDAO = new ProjectDAO(inMemoryMySqlConnect);
- Project project = factory.manufacturePojo(Project.class);
- assertTrue(projectDAO.exists(project));
-
- List<Group> dummyGroups = dummyProjectCreationService.createDummyGroups(project.getName());
- dummyGroups.forEach(group -> group.setChatRoomId("1"));
- dummyGroups.forEach(group -> {
- assertTrue(groupDAO.exists(group));
- group.getMembers().forEach(user -> assertTrue(userDAO.exists(user)));
- });
- }
-}
diff --git a/gemeinsamforschen/src/test/java/unipotsdam/gf/process/tasks/GroupPhaseTaskTest.java b/gemeinsamforschen/src/test/java/unipotsdam/gf/process/tasks/GroupPhaseTaskTest.java
index 27ee1232b5686784b645b6d07d0017d4058c59ba..af8fbb9c08de24e86c5e5d8da3df1e23d6143abc 100644
--- a/gemeinsamforschen/src/test/java/unipotsdam/gf/process/tasks/GroupPhaseTaskTest.java
+++ b/gemeinsamforschen/src/test/java/unipotsdam/gf/process/tasks/GroupPhaseTaskTest.java
@@ -1,14 +1,24 @@
package unipotsdam.gf.process.tasks;
+import ch.vorburger.exec.ManagedProcessException;
import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.hk2.utilities.ServiceLocatorUtilities;
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.config.GFApplicationBinder;
import unipotsdam.gf.core.database.TestGFApplicationBinder;
+import unipotsdam.gf.core.database.UpdateDB;
+import unipotsdam.gf.exceptions.RocketChatDownException;
+import unipotsdam.gf.exceptions.UserDoesNotExistInRocketChatException;
+import unipotsdam.gf.exceptions.UserExistsInMysqlException;
+import unipotsdam.gf.exceptions.UserExistsInRocketChatException;
+import unipotsdam.gf.interfaces.ICommunication;
import unipotsdam.gf.interfaces.IGroupFinding;
import unipotsdam.gf.modules.group.Group;
+import unipotsdam.gf.modules.group.GroupData;
import unipotsdam.gf.modules.group.GroupFormationMechanism;
import unipotsdam.gf.modules.project.Management;
import unipotsdam.gf.modules.project.Project;
@@ -18,8 +28,11 @@ import unipotsdam.gf.process.ProjectCreationProcess;
import javax.inject.Inject;
+import java.io.IOException;
+import java.sql.SQLException;
import java.util.ArrayList;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class GroupPhaseTaskTest {
@@ -40,61 +53,82 @@ public class GroupPhaseTaskTest {
@Inject
private GroupFormationProcess groupFormationProcess;
+ @Inject
+ private ICommunication communication;
+
private PodamFactory factory = new PodamFactoryImpl();
- private User teacher;
+
@Before
- public void setUp() {
- /*final ServiceLocator locator = ServiceLocatorUtilities.bind(new GFApplicationBinder());*/
- final ServiceLocator locator = ServiceLocatorUtilities.bind(new TestGFApplicationBinder());
+ public void setUp() throws IOException, SQLException, ManagedProcessException {
+ UpdateDB.main(new String[0]);
+
+ final ServiceLocator locator = ServiceLocatorUtilities.bind(new GFApplicationBinder());
+ //final ServiceLocator locator = ServiceLocatorUtilities.bind(new TestGFApplicationBinder());
locator.inject(this);
}
+ @Ignore
@Test
- public void createCourse() {
-
- this.teacher = factory.manufacturePojo(User.class);
+ public void createUser()
+ throws RocketChatDownException, UserExistsInRocketChatException, UserExistsInMysqlException, UserDoesNotExistInRocketChatException {
+ User teacher = factory.manufacturePojo(User.class);
+ teacher.setEmail("vodka@yolo.com");
+ teacher.setPassword("egal");
teacher.setStudent(false);
- management.create(teacher, null);
- // add Titel
- Project project = factory.manufacturePojo(Project.class);
- project.setAuthorEmail(teacher.getEmail());
- management.create(project);
- management.register(teacher, project, null);
+ projectCreationProcess.deleteUser(teacher);
+ projectCreationProcess.createUser(teacher);
+ projectCreationProcess.deleteUser(teacher);
+ }
- /*ProjectConfiguration projectConfiguration = factory.manufacturePojo(ProjectConfiguration.class);
- management.create(projectConfiguration, project);
+ @Test
+ public void createCourse()
+ throws RocketChatDownException, UserDoesNotExistInRocketChatException, UserExistsInMysqlException, UserExistsInRocketChatException, IOException {
- GroupfindingCriteria groupfindingCriteria = factory.manufacturePojo(GroupfindingCriteria.class);
- groupFinding.selectGroupfindingCriteria(groupfindingCriteria, project);*/
+ // create teacher
+ User teacher = factory.manufacturePojo(User.class);
+ teacher.setEmail("vodka@yolo.com");
+ teacher.setPassword("egal");
+ teacher.setStudent(false);
+ projectCreationProcess.deleteUser(teacher);
+ projectCreationProcess.createUser(teacher);
- taskDAO.createTaskWaitForParticipants(project, teacher);
- ArrayList<Task> tasks = taskDAO.getTasks(teacher, project);
- assertTrue(tasks != null && tasks.size() > 0);
+ Project project = factory.manufacturePojo(Project.class);
+ project.setName("TEST");
+ projectCreationProcess.deleteProject(project);
+ projectCreationProcess.createProject(project, teacher);
+ groupFormationProcess.setGroupFormationMechanism(GroupFormationMechanism.Manual, project);
ArrayList<User> students = new ArrayList<>();
- for (int i = 0; i<5;i++) {
+ for (int i = 0; i < 30; i++) {
User user = factory.manufacturePojo(User.class);
user.setStudent(true);
- students.add(user);
-
- management.create(user, null);
+ user.setRocketChatUsername("student" + i);
+ user.setEmail("student" + i + "@stuff.com");
+ user.setPassword("egal");
+ projectCreationProcess.deleteUser(user);
+ projectCreationProcess.createUser(user);
projectCreationProcess.studentEntersProject(project, user);
+ students.add(user);
}
+ //groupFormationProcess.changeGroupFormationMechanism(GroupFormationMechanism.Manual, project);
+ GroupData orInitializeGroups = groupFormationProcess.getOrInitializeGroups(project);
+ assertFalse(orInitializeGroups.getGroups().isEmpty());
+ /* groupFormationProcess.finalize(project);*/
- groupFormationProcess.changeGroupFormationMechanism(GroupFormationMechanism.Manual, project);
- Group group = new Group();
- for (User student : students) {
- group.addMember(student);
- }
- groupFormationProcess.finish(project, group);
+ /*ArrayList<Task> tasks = taskDAO.getTasks(teacher, project);
+ assertTrue(tasks != null && tasks.size() > 0);*/
+ /* for (User student : students) {
+ projectCreationProcess.deleteUser(student);
+ projectCreationProcess.deleteProject(project);
+ }*/
}
diff --git a/gemeinsamforschen/src/test/resources/database/db.sql b/gemeinsamforschen/src/test/resources/database/db.sql
new file mode 100644
index 0000000000000000000000000000000000000000..5077fdd31903acb5e37a871746300826b8c2abe1
--- /dev/null
+++ b/gemeinsamforschen/src/test/resources/database/db.sql
@@ -0,0 +1,9 @@
+SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
+SET AUTOCOMMIT = 0;
+START TRANSACTION;
+SET time_zone = "+00:00";
+
+DROP DATABASE `fltrail`;
+CREATE DATABASE IF NOT EXISTS `fltrail` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci;
+
+USE `fltrail`;
\ No newline at end of file
diff --git a/gemeinsamforschen/src/test/resources/database/fltrail.sql b/gemeinsamforschen/src/test/resources/database/fltrail.sql
index 87e750a6749fde78f407f1d2895d54d0b2bfaa2d..8a3f7ab978e518860f72109d7b87930d09afe0c6 100644
--- a/gemeinsamforschen/src/test/resources/database/fltrail.sql
+++ b/gemeinsamforschen/src/test/resources/database/fltrail.sql
@@ -1,18 +1,7 @@
-SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
-SET AUTOCOMMIT = 0;
-START TRANSACTION;
-SET time_zone = "+00:00";
-
-/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
-/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
-/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
-/*!40101 SET NAMES utf8mb4 */;
-
-
CREATE TABLE `annotations` (
`id` varchar(120) NOT NULL,
`timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
- `userEmail` varchar(120) DEFAULT NULL,
+ `userEmail` varchar(255) DEFAULT NULL,
`targetId` varchar(120) DEFAULT NULL,
`targetCategory` varchar(30) NOT NULL,
`title` varchar(120) DEFAULT NULL,
@@ -72,6 +61,7 @@ CREATE TABLE `groups` (
`id` int(11) NOT NULL,
`projectName` varchar(200) NOT NULL,
`chatRoomId` varchar(400) NOT NULL
+ `name` varchar(255) NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `groupuser` (
@@ -96,16 +86,20 @@ CREATE TABLE `phasesselected` (
CREATE TABLE `projects` (
`name` varchar(100) NOT NULL,
+ `password` varchar(400) DEFAULT '',
+ `active` tinyint(1) NOT NULL DEFAULT true,
+ `timecreated` mediumtext,
`password` varchar(400) NOT NULL,
`active` tinyint(1) NOT NULL,
`timecreated` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
`author` varchar(100) NOT NULL,
- `phase` varchar(400) NOT NULL
+ `adminPassword` varchar(400),
+ `phase` varchar(400) NOT NULL DEFAULT 'GroupFormation'
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `projectuser` (
`projectName` varchar(100) NOT NULL,
- `userEmail` varchar(100) NOT NULL
+ `userEmail` varchar(255) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `quiz` (
@@ -126,7 +120,7 @@ CREATE TABLE `submissionpartbodyelements` (
CREATE TABLE `submissionparts` (
`timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
- `userEmail` varchar(120) NOT NULL,
+ `userEmail` varchar(255) NOT NULL,
`fullSubmissionId` varchar(120) NOT NULL,
`category` varchar(30) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
@@ -137,7 +131,7 @@ CREATE TABLE `tags` (
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `tasks` (
- `userEmail` varchar(100) NOT NULL,
+ `userEmail` varchar(255) NOT NULL,
`projectName` varchar(200) NOT NULL,
`taskName` varchar(100) DEFAULT NULL,
`groupTask` tinyint(4) DEFAULT NULL,
@@ -152,12 +146,11 @@ CREATE TABLE `tasks` (
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `users` (
- `name` varchar(100) NOT NULL,
- `password` varchar(200) NOT NULL,
- `email` varchar(255) NOT NULL,
- `rocketChatId` varchar(400) NOT NULL,
- `rocketChatAuthToken` varchar(800) NOT NULL,
- `isStudent` tinyint(1) DEFAULT '1'
+ `name` varchar(100) NOT NULL,
+ `password` varchar(200) NOT NULL,
+ `email` varchar(255) NOT NULL,
+ `rocketChatUserName` varchar(400),
+ `isStudent` tinyint(1) DEFAULT '1'
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `workrating` (
@@ -172,6 +165,12 @@ CREATE TABLE `workrating` (
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+CREATE TABLE submissionuser
+(
+ submissionId varchar(400),
+ userEmail varchar(255)
+);
+
ALTER TABLE `annotations`
ADD PRIMARY KEY (`id`),
ADD KEY `annotations_fullsubmissions_id_fk` (`targetId`);
@@ -276,8 +275,8 @@ ALTER TABLE `groups`
ADD CONSTRAINT `groups_projects_name_fk` FOREIGN KEY (`projectName`) REFERENCES `projects` (`name`) ON DELETE CASCADE ON UPDATE CASCADE;
ALTER TABLE `groupuser`
- ADD CONSTRAINT `groupuser_ibfk_1` FOREIGN KEY (`userEmail`) REFERENCES `users` (`email`),
- ADD CONSTRAINT `groupuser_ibfk_2` FOREIGN KEY (`groupId`) REFERENCES `groups` (`id`);
+ ADD CONSTRAINT `groupuser_ibfk_1` FOREIGN KEY (`userEmail`) REFERENCES `users` (`email`) ON DELETE CASCADE,
+ ADD CONSTRAINT `groupuser_ibfk_2` FOREIGN KEY (`groupId`) REFERENCES `groups` (`id`) ON DELETE CASCADE;
ALTER TABLE `phasesselected`
ADD CONSTRAINT `phasesselected_projects_name_fk` FOREIGN KEY (`projectName`) REFERENCES `projects` (`name`) ON DELETE CASCADE ON UPDATE CASCADE;
@@ -286,6 +285,8 @@ ALTER TABLE `projects`
ADD CONSTRAINT `projects_ibfk_1` FOREIGN KEY (`author`) REFERENCES `users` (`email`);
ALTER TABLE `projectuser`
+ ADD CONSTRAINT `projectuser_ibfk_1` FOREIGN KEY (`userEmail`) REFERENCES `users` (`email`) ON DELETE CASCADE,
+ ADD CONSTRAINT `projectuser_ibfk_2` FOREIGN KEY (`projectName`) REFERENCES `projects` (`name`) ON DELETE CASCADE;
ADD CONSTRAINT `projectuser_ibfk_1` FOREIGN KEY (`userEmail`) REFERENCES `users` (`email`),
ADD CONSTRAINT `projectuser_ibfk_2` FOREIGN KEY (`projectName`) REFERENCES `projects` (`name`) ON DELETE CASCADE ON UPDATE CASCADE;
@@ -299,6 +300,75 @@ ALTER TABLE `workrating`
ADD CONSTRAINT `workrating_projects_name_fk` FOREIGN KEY (`projectName`) REFERENCES `projects` (`name`) ON DELETE CASCADE ON UPDATE CASCADE;
COMMIT;
-/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
-/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
-/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
+CREATE UNIQUE INDEX fullsubmissions_user_projectName_uindex ON fullsubmissions (user, projectName);
+
+CREATE UNIQUE INDEX tasks_userEmail_projectName_taskName_uindex ON tasks (userEmail, projectName, taskName);
+
+CREATE TABLE profilequestions
+(
+ id int PRIMARY KEY AUTO_INCREMENT,
+ scaleSize int,
+ question varchar(500) NOT NULL
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE profilequestionoptions
+(
+ id int PRIMARY KEY AUTO_INCREMENT,
+ profileQuestionId int,
+ name varchar (255)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE profilequestionanswer
+(
+ profileQuestionId int,
+ answerIndex int,
+ selectedAnswer varchar(255) not null,
+ userEmail varchar(255) not null,
+ CONSTRAINT profilequestionanswer_profilequestions_id_fk FOREIGN KEY (profileQuestionId)
+ REFERENCES profilequestions(id),
+ CONSTRAINT profilequestionanswer_user_email_fk FOREIGN KEY (userEmail)
+ REFERENCES users(email)
+)ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE profilequestionrelations
+(
+ firstQuestionId int,
+ secondQuestionId int,
+ relation varchar(200),
+ CONSTRAINT profilequestionrelations_profilequestions_id_fk FOREIGN KEY (firstQuestionId) REFERENCES profilequestions (id),
+ CONSTRAINT profilequestionrelations_profilequestions2_id_fk FOREIGN KEY (secondQuestionId) REFERENCES profilequestions (id)
+);
+
+ALTER TABLE profilequestionrelations COMMENT = 'This indicates if a profile question leads to homogenity in groups';
+ALTER TABLE annotations COMMENT = 'Stores comments to a part of the dossier for a category such as RESEARCH';
+ALTER TABLE answeredquiz COMMENT = 'The answered quiz table holds the interpreted result of the quiz answer';
+ALTER TABLE assessmentmechanismselected COMMENT = 'Holds the peer assessement mechanism selected';
+ALTER TABLE categoriesselected COMMENT = 'NOT IMPLEMENTED';
+ALTER TABLE contributionrating COMMENT = 'TODO @Axel plz comment';
+ALTER TABLE fullsubmissions COMMENT = 'This holds the aggregated text of the dossier students should upload';
+ALTER TABLE grades COMMENT = 'Shows the grades that are calculated for a given student';
+ALTER TABLE groupfindingmechanismselected COMMENT = 'Groupfinding is done either automatically or manual';
+ALTER TABLE groups COMMENT = 'the groups that are created';
+ALTER TABLE groupuser COMMENT = 'n x m table for group and user';
+ALTER TABLE phasesselected COMMENT = 'the phase that is selected out of Phase enum';
+ALTER TABLE profilequestionanswer COMMENT = 'the answer to a profile question needed for group finding algorithm';
+ALTER TABLE profilequestionoptions COMMENT = 'the options for a profile question for thegroup finding algorithm';
+ALTER TABLE profilequestions COMMENT = 'stores the questions needed for group finding';
+ALTER TABLE projects COMMENT = 'just a list of all the projects';
+ALTER TABLE projectuser COMMENT = 'n x m for projects and user';
+ALTER TABLE quiz COMMENT = 'lists the quizzes for the app';
+ALTER TABLE submissionpartbodyelements COMMENT = 'holds the parts of a dossier that are annoated with category';
+ALTER TABLE submissionparts COMMENT = 'no idea what that it does but it is important';
+ALTER TABLE submissionuser COMMENT = 'no idea if that is needed. seems not be used';
+ALTER TABLE tags COMMENT = 'lists some tags for the project in order to make it more searchable and for groupfinding';
+ALTER TABLE tasks COMMENT = 'The task table is important. It lists the actual state of the system associated to tasks';
+ALTER TABLE users COMMENT = 'Just lists the users';
+ALTER TABLE workrating COMMENT = '@Axel plz comment';
+
+
+
+
+
+
+
+
diff --git a/gemeinsamforschen/src/test/resources/database/test_db.sql b/gemeinsamforschen/src/test/resources/database/test_db.sql
new file mode 100644
index 0000000000000000000000000000000000000000..5d93b29d8cf128ff167ed7a8525ce5b096070652
--- /dev/null
+++ b/gemeinsamforschen/src/test/resources/database/test_db.sql
@@ -0,0 +1,9 @@
+SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
+SET AUTOCOMMIT = 0;
+START TRANSACTION;
+SET time_zone = "+00:00";
+
+DROP DATABASE `fltrail_test`;
+CREATE DATABASE IF NOT EXISTS `fltrail_test` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci;
+
+USE `fltrail_test`;
\ No newline at end of file
diff --git a/gemeinsamforschen/src/test/resources/database/testuser.sql b/gemeinsamforschen/src/test/resources/database/testuser.sql
index fdbb25267ec35fa80e9c7f600c2017f46b0ee316..905e60a6aacad64d91cbabe9ddbc5aedcc9b00d6 100644
--- a/gemeinsamforschen/src/test/resources/database/testuser.sql
+++ b/gemeinsamforschen/src/test/resources/database/testuser.sql
@@ -1,10 +1,10 @@
-INSERT IGNORE INTO users (name, password, email, rocketChatId, rocketChatAuthToken, isStudent) values ("Julian Dehne",
+INSERT IGNORE INTO users (name, password, email, rocketChatUserId, rocketChatAuthToken, isStudent) values ("Julian Dehne",
"egal", "vodkas@yolo.com", "egal", "egal", 1);
-INSERT IGNORE INTO users (name, password, email, rocketChatId, rocketChatAuthToken, isStudent) values ("Axel Wiepke",
+INSERT IGNORE INTO users (name, password, email, rocketChatUserId, rocketChatAuthToken, isStudent) values ("Axel Wiepke",
"egal", "vodkass@yolo.com", "egal", "egal", 1);
-INSERT IGNORE INTO users (name, password, email, rocketChatId, rocketChatAuthToken, isStudent) values ("Herr Lehrer",
+INSERT IGNORE INTO users (name, password, email, rocketChatUserId, rocketChatAuthToken, isStudent) values ("Herr Lehrer",
"egal", "vodka@yolo.com", "egal", "egal", 0);