Merge branch 'group-chat' into 'master'

Implement group chat

See merge request !6

src/main/java/dao/GroupChatDAO.java

 package dao;
 
+import data.GroupChat;
+import data.Message;
 import data.User;
-
+import java.sql.*;
 import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.TimeZone;
+
+import static dao.Database.close;
+
 
+/**
+ * Data access object for GroupChat
+ */
 public class GroupChatDAO {
 
-    //Made so that the rest of the application runs without group chats implemented.
+    /**
+     * Add a new GroupChat
+     * @param groupChat GroupChat to be added
+     * @return GroupChat, empty GroupChat object if unsuccessful
+     */
+
+
+    public GroupChat addGroupChat(GroupChat groupChat){
+        PreparedStatement preparedStatement = null;
+        Connection connection = null;
+        ResultSet resultSet = null;
+        try{
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement("INSERT INTO groupChat (groupChatName) VALUES (?)", Statement.RETURN_GENERATED_KEYS);
+            preparedStatement.setString(1, groupChat.getGroupChatName());
+
+            int result = preparedStatement.executeUpdate();
+
+            if(result == 1){
+                resultSet = preparedStatement.getGeneratedKeys();
+                if(resultSet.next()){
+                    int groupChatId = resultSet.getInt(1);
+                    groupChat.setGroupChatId(groupChatId);
+
+                    ArrayList<User> users = groupChat.getUserList();
+                    preparedStatement = connection.prepareStatement("INSERT INTO user_groupChat (userId, groupChatId) VALUES (?, ?) ");
+                    for(User user:users){
+                        preparedStatement.setInt(1, user.getUserId());
+                        preparedStatement.setInt(2, groupChatId);
+                        preparedStatement.executeUpdate();
+                    }
+                    return groupChat;
+                }
+            }
+
+        }catch (SQLException e){
+            e.printStackTrace();
+        }finally{
+            close(connection, preparedStatement, resultSet);
+        }
+        return new GroupChat();
+    }
+
+    /**
+     * Get a GroupChat, with given groupChatId
+     * @param groupChatId groupChatId as int
+     * @return requested GroupChat if found, empty GroupChat object if not found
+     */
+
+
+    public GroupChat getGroupChat(int groupChatId){
+        PreparedStatement preparedStatement = null;
+        Connection connection = null;
+        ResultSet resultSet = null;
+        GroupChat groupChat = new GroupChat();
+        try{
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement("SELECT * FROM groupChat WHERE groupChatId = ?");
+            preparedStatement.setInt(1, groupChatId);
+            resultSet = preparedStatement.executeQuery();
+            while(resultSet.next()) {
+                groupChat.setGroupChatId(groupChatId);
+                groupChat.setGroupChatName(resultSet.getString("groupChatName"));
+            }
+        }catch(SQLException e){
+            e.printStackTrace();
+        }finally{
+            close(connection, preparedStatement, resultSet);
+        }
+        return groupChat;
+    }
+
+
+
+    /**
+     * Get all GroupChats for user with given userId
+     * @param userId int userId of the user
+     * @return ArrayList of GroupChats
+     */
+
+
+    public ArrayList<GroupChat> getGroupChatByUserId(int userId){
+        ArrayList<GroupChat> groupChats = new ArrayList<>();
+        PreparedStatement preparedStatement = null;
+        Connection connection = null;
+        ResultSet resultSet = null;
+        try{
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement("SELECT * FROM groupChat WHERE groupChatId IN (SELECT groupChatId FROM user_groupChat WHERE userId = ?)");
+            preparedStatement.setInt(1, userId);
+            resultSet = preparedStatement.executeQuery();
+            GroupChat groupChat;
+            while(resultSet.next()){
+                groupChat = new GroupChat();
+                groupChat.setGroupChatId(resultSet.getInt("groupChatId"));
+                groupChat.setGroupChatName(resultSet.getString("groupChatName"));
+                groupChats.add(groupChat);
+            }
+            return groupChats;
+        }catch (SQLException e){
+            e.printStackTrace();
+        }finally{
+            close(connection, preparedStatement, resultSet);
+        }
+        return groupChats;
+    }
+
+    /**
+     * Get all messages for a GroupChat
+     * @param groupChatId groupChatId as int
+     * @return ArrayList of Messages
+     */
+
+
+    public ArrayList<Message> getGroupChatMessages(int groupChatId){
+        ArrayList<Message> messages = new ArrayList<>();
+        PreparedStatement preparedStatement = null;
+        Connection connection = null;
+        ResultSet resultSet = null;
+        try{
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement("SELECT * FROM message WHERE groupChatId = ?");
+            preparedStatement.setInt(1, groupChatId);
+            resultSet = preparedStatement.executeQuery();
+
+            Message message;
+            while(resultSet.next()){
+                message = new Message();
+                message.setMessageId(resultSet.getInt("messageId"));
+                message.setUserId1(resultSet.getInt("userId1"));
+                Calendar cal = Calendar.getInstance();
+                cal.setTimeZone(TimeZone.getTimeZone("UTC"));
+                message.setTimestamp(resultSet.getTimestamp("timestamp",cal));
+                message.setMessageContent(resultSet.getString("messageContent"));
+                message.setGroupChatId(resultSet.getInt("groupChatId"));
+                messages.add(message);
+            }
+        }catch (SQLException e){
+            e.printStackTrace();
+        }finally {
+            close(connection, preparedStatement, resultSet);
+        }
+        return messages;
+    }
+
+    /**
+     * Adds a Message to a GroupChat
+     * @param groupChatId groupChatId as int
+     * @param message Message object to be added to GroupChat
+     * @return The message that was added
+     */
+
+    public Message addMessage(int groupChatId, Message message){
+        PreparedStatement preparedStatement = null;
+        Connection connection = null;
+        try{
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement("INSERT INTO message (userId1, timestamp, messageContent, groupChatId) VALUES (?, NOW(), ?, ?)");
+            preparedStatement.setInt(1, message.getUserId1());
+            preparedStatement.setString(2, message.getMessageContent());
+            preparedStatement.setInt(3, groupChatId);
+
+            preparedStatement.executeUpdate();
+        }catch (SQLException e){
+            e.printStackTrace();
+        }finally{
+            close(connection, preparedStatement, null);
+        }
+        return message;
+    }
+
+    /**
+     * Get all users in a GroupChat
+     * @param groupChatId groupChatId as int
+     * @return ArrayList of Users the GroupChat
+     */
+
+
     public ArrayList<User> getGroupChatUsers(int groupChatId){
-        return null;
+        ArrayList<User> users = new ArrayList<>();
+        PreparedStatement preparedStatement = null;
+        ResultSet resultSet = null;
+        Connection connection = null;
+        try{
+            connection = Database.instance().getConnection();
+            preparedStatement = connection.prepareStatement("SELECT * FROM user WHERE user.userId IN (SELECT userId FROM user_groupChat WHERE groupChatId = ?)");
+            preparedStatement.setInt(1, groupChatId);
+            resultSet = preparedStatement.executeQuery();
+
+            User user;
+            while(resultSet.next()){
+                user = new User();
+                user.setUserId(resultSet.getInt("userId"));
+                user.setUsername(resultSet.getString("username"));
+                users.add(user);
+            }
+        }catch(SQLException e){
+            e.printStackTrace();
+        }finally{
+            close(connection, preparedStatement, resultSet);
+        }
+        return users;
     }
 }

src/main/java/data/GroupChat.java

 package data;
 
+import java.util.ArrayList;
+
 /**
  * Class for the GroupChat object as saved in database
  */
-public class GroupChat {}
+public class GroupChat {
+    private int groupChatId;
+    private String groupChatName;
+    private ArrayList<Message> messageList = new ArrayList<>();
+    private ArrayList<User> userList = new ArrayList<>();
+
+    public GroupChat() {}
+
+    public GroupChat(int groupChatId, String groupChatName) {
+        this.groupChatId = groupChatId;
+        this.groupChatName = groupChatName;
+    }
+
+    public int getGroupChatId() {
+        return groupChatId;
+    }
+
+    public String getGroupChatName() {
+        return groupChatName;
+    }
+    public ArrayList<Message> getMessageList() {
+        return messageList;
+    }
+
+    public ArrayList<User> getUserList() {
+        return userList;
+    }
+
+    public void setGroupChatId(int groupChatId) {
+        this.groupChatId = groupChatId;
+    }
+
+    public void setGroupChatName(String groupChatName) {
+        this.groupChatName = groupChatName;
+    }
+
+    public void setMessageList(ArrayList<Message> messageList) {
+        this.messageList = messageList;
+    }
+
+    public void setUserList(ArrayList<User> userList) {
+        this.userList = userList;
+    }
+}

src/main/java/resources/GroupChatResource.java

 package resources;
 
 import data.GroupChat;
+import data.Message;
+
+import java.util.ArrayList;
 
 import javax.ws.rs.*;
 import javax.ws.rs.core.MediaType;
 
+import dao.GroupChatDAO;
+
 /**
  * GroupChat resource exposed at "/groupchat" path
  */
@@ -20,7 +25,48 @@ public class GroupChatResource {
     @Path ("{groupChatId}")
     @Produces (MediaType.APPLICATION_JSON)
     public GroupChat getGroupChat(@PathParam("groupChatId") int groupChatId){
-        return null;
+        GroupChatDAO groupChatDAO = new GroupChatDAO();
+
+        GroupChat groupChat = groupChatDAO.getGroupChat(groupChatId);
+        groupChat.setMessageList(groupChatDAO.getGroupChatMessages(groupChatId));
+        groupChat.setUserList(groupChatDAO.getGroupChatUsers(groupChatId));
+        return groupChat;
+    }
+
+    @GET
+    @Path("user/{userId}")
+    @Produces (MediaType.APPLICATION_JSON)
+    public ArrayList<GroupChat> getGroupChatByUserId(@PathParam("userId") int userId) {
+        GroupChatDAO groupChatDAO = new GroupChatDAO();
+
+        return groupChatDAO.getGroupChatByUserId(userId);
+    }
+
+    @POST
+    @Produces (MediaType.APPLICATION_JSON)
+    @Consumes (MediaType.APPLICATION_JSON)
+    public GroupChat postGroupChat(GroupChat groupChat) {
+        GroupChatDAO groupChatDAO = new GroupChatDAO();
+
+        return groupChatDAO.addGroupChat(groupChat);
+    }
+
+    @GET
+    @Path("{groupChatId}/message")
+    @Produces (MediaType.APPLICATION_JSON)
+    public ArrayList<Message> getGroupChatMessages(@PathParam("groupChatId") int groupChatId) {
+        GroupChatDAO groupChatDAO = new GroupChatDAO();
+        return groupChatDAO.getGroupChatMessages(groupChatId);
+    }
+
+    @POST
+    @Path ("{groupChatId}/message")
+    @Produces (MediaType.APPLICATION_JSON)
+    @Consumes (MediaType.APPLICATION_JSON)
+    public Message postMessage(@PathParam("groupChatId") int groupChatId, Message message) {
+        GroupChatDAO groupChatDAO = new GroupChatDAO();
+        return groupChatDAO.addMessage(groupChatId, message);
+
     }
 
 }

src/main/webapp/app.html

@@ -30,6 +30,7 @@
             </div>
 
             <ul id="userList">
+                <li onclick="openNewGroupChatForm();"><i class="fas fa-plus userIcon"></i>Ny Gruppechat</li>
                 <li onclick="openCalculator(); toggleUserList();"><i class="fas fa-user userIcon"></i>Kalkulator</li>
             </ul>
 

src/test/java/GroupChatDAOTest.java

+import dao.Database;
+import dao.GroupChatDAO;
+import data.GroupChat;
+import data.Message;
+import data.User;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.test.JerseyTest;
+import org.glassfish.jersey.test.TestProperties;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import javax.ws.rs.core.Application;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+public class GroupChatDAOTest extends JerseyTest {
+    private Connection connection;
+    private Statement statement;
+    private GroupChatDAO groupChatDAO;
+
+    @Before
+    public void SetUp () {
+        try{
+            connection = Database.instance().getConnection();
+            groupChatDAO = new GroupChatDAO();
+            statement = connection.createStatement();
+
+        } catch (SQLException se) {
+            System.out.println("Could not connect to test-database");
+            se.printStackTrace();
+        }
+        //DROP TABLE queries
+        String dropTableUserGroupChat = "DROP TABLE IF EXISTS user_groupChat";
+        String dropTableGroupChat = "DROP TABLE IF EXISTS groupChat";
+        String dropTableMessage = "DROP TABLE IF EXISTS message";
+        String dropTableUser = "DROP TABLE IF EXISTS user";
+
+        //CREATE TABLE
+        String createTableUser =
+                "CREATE TABLE user (\n" +
+                        "  userId INT(11) NOT NULL AUTO_INCREMENT,\n" +
+                        "  username VARCHAR(64) NOT NULL UNIQUE,\n" +
+                        "  password TEXT,\n" +
+                        "  salt BLOB,\n" +
+                        "  PRIMARY KEY (userId)\n" +
+                        ")";
+
+        String createTableMessage =
+                "CREATE TABLE message (\n" +
+                        "  messageId INT(11) NOT NULL AUTO_INCREMENT,\n" +
+                        "  userId1 INT(11) NOT NULL,\n" +
+                        "  userId2 INT(11),\n" +
+                        "  timestamp TIMESTAMP NOT NULL,\n" +
+                        "  messageContent VARCHAR (500) NOT NULL,\n" +
+                        "  groupChatId INT(11),\n" +
+                        "  PRIMARY KEY (messageId),\n" +
+                        "  KEY userId1 (userId1),\n" +
+                        "  KEY userId2 (userId2),\n" +
+                        "  CONSTRAINT message_ibfk_3 FOREIGN KEY (userId1) REFERENCES user (userId) ON DELETE CASCADE ON UPDATE CASCADE,\n" +
+                        "  CONSTRAINT message_ibfk_4 FOREIGN KEY (userId2) REFERENCES user (userId) ON DELETE CASCADE ON UPDATE CASCADE,\n" +
+                        "  CONSTRAINT message_ibfk_5 foreign key (groupChatId) REFERENCES groupChat (groupChatId) ON DELETE CASCADE ON UPDATE CASCADE\n" +
+                        ")";
+
+        String createTableGroupChat =
+                "CREATE TABLE groupChat(\n" +
+                        "  groupChatId INT(11) NOT NULL AUTO_INCREMENT,\n" +
+                        "  groupChatName VARCHAR(64) NOT NULL,\n" +
+                        "  PRIMARY KEY (groupChatId)\n" +
+                        ")";
+
+        String createTableUserGroupChat =
+                "CREATE TABLE user_groupChat (\n" +
+                        "  userId INT(11) NOT NULL,\n" +
+                        "  groupChatId INT(11) NOT NULL,\n" +
+                        "  PRIMARY KEY (userId, groupChatId),\n" +
+                        "  CONSTRAINT user_groupChat_ibfk_3 FOREIGN KEY (userId) REFERENCES user (userId) ON DELETE CASCADE ON UPDATE CASCADE,\n" +
+                        "  CONSTRAINT user_groupChat_ibfk_4 FOREIGN KEY (groupChatId) REFERENCES groupChat (groupChatId) ON DELETE CASCADE ON UPDATE CASCADE\n" +
+                        ")";
+
+        //INSERT INTO statements
+        String insertUser = "INSERT INTO user (username) VALUES ('username')";
+        String insertUser2 = "INSERT INTO user (username) VALUES ('username2')";
+
+        String insertMessage = "INSERT INTO message (userId1, userId2, TIMESTAMP , messageContent) VALUES (1, 2, NOW(), 'test message')";
+        String insertMessage2 = "INSERT INTO message (userId1, userId2, TIMESTAMP, messageContent) VALUES (2, 1, NOW(), 'test response message')";
+
+        String insertGroupChat = "INSERT INTO groupChat (groupChatName) VALUES ('groupchat')";
+
+        String insertUserGroupChat = "INSERT INTO user_groupChat (userId, groupChatId) VALUES (1, 1)";
+
+        String insertGroupChatMessage = "INSERT INTO message (userId1, TIMESTAMP , messageContent, groupChatId) VALUES (1, NOW(), 'test groupchat message', 1)";
+
+        try {
+            // execute queries
+            statement.executeUpdate(dropTableMessage);
+            statement.executeUpdate(dropTableUserGroupChat);
+            statement.executeUpdate(dropTableGroupChat);
+            statement.executeUpdate(dropTableUser);
+            statement.executeUpdate(createTableUser);
+            statement.executeUpdate(createTableGroupChat);
+            statement.executeUpdate(createTableUserGroupChat);
+            statement.executeUpdate(createTableMessage);
+
+            // execute insert updates
+            statement.executeUpdate(insertUser);
+            statement.executeUpdate(insertUser2);
+            statement.executeUpdate(insertMessage);
+            statement.executeUpdate(insertMessage2);
+            statement.executeUpdate(insertGroupChat);
+            statement.executeUpdate(insertUserGroupChat);
+            statement.executeUpdate(insertGroupChatMessage);
+
+        } catch (SQLException se) {
+            System.out.println("Error: insert statements");
+            se.printStackTrace();
+
+        } finally {
+            try {
+                statement.close();
+
+            } catch (SQLException se) {
+                se.printStackTrace();
+            }
+        }
+    }
+
+    @After
+    public void tearDown () {
+        try {
+            groupChatDAO = null;
+            connection.close();
+
+        } catch (SQLException se) {
+            System.out.println("disconnecting failed");
+            se.printStackTrace();
+        }
+    }
+
+    @Override
+    public Application configure() {
+        enable(TestProperties.LOG_TRAFFIC);
+        enable(TestProperties.DUMP_ENTITY);
+        forceSet(TestProperties.CONTAINER_PORT, "0");
+        return new ResourceConfig(GroupChatDAO.class);
+    }
+
+    @Test
+    public void testAddGroupChat() {
+        GroupChat groupChat = new GroupChat();
+        groupChat.setGroupChatName("test groupchat");
+
+        groupChatDAO.addGroupChat(groupChat);
+
+        GroupChat groupChatFromDatabase = groupChatDAO.getGroupChat(2);
+
+        assertEquals(groupChat.getGroupChatName(), groupChatFromDatabase.getGroupChatName());
+        assertEquals(groupChat.getGroupChatId(), groupChatFromDatabase.getGroupChatId());
+    }
+
+    @Test
+    public void testGetGroupChat() {
+        final GroupChat expectedResult = new GroupChat(1, "groupchat");
+
+        final GroupChat result = groupChatDAO.getGroupChat(1);
+
+        assertEquals(expectedResult.getGroupChatId(), result.getGroupChatId());
+        assertEquals(expectedResult.getGroupChatName(), result.getGroupChatName());
+    }
+
+    @Test
+    public void testGetGroupChatByUserId() {
+        final List<GroupChat> result1 = groupChatDAO.getGroupChatByUserId(1);
+        final List<GroupChat> result2 = groupChatDAO.getGroupChatByUserId(2);
+
+        assertEquals("User 1 should have 1 Groupchat", 1, result1.size());
+        assertEquals("User 2 should have 0 Groupchats", 0, result2.size());
+    }
+
+    @Test
+    public void testGetGroupChatMessages() {
+        ArrayList<String> expectedResult = new ArrayList<>();
+        expectedResult.add("test groupchat message");
+
+        ArrayList<Message> result = groupChatDAO.getGroupChatMessages(1);
+        ArrayList<String> resultStrings = new ArrayList<>();
+
+        for (Message message : result) resultStrings.add(message.getMessageContent());
+
+        assertEquals(expectedResult, resultStrings);
+    }
+
+    @Test
+    public void testAddMessage() {
+        final int groupChatId = 1;
+        Message message = new Message();
+        message.setUserId1(1);
+        message.setTimestamp(new Timestamp(1220227200L * 1000));
+        message.setMessageContent("test add message groupchat");
+        message.setGroupChatId(groupChatId);
+
+        ArrayList<Message> beforeAddMessage = groupChatDAO.getGroupChatMessages(groupChatId);
+        groupChatDAO.addMessage(groupChatId, message);
+        ArrayList<Message> afterAddMessage = groupChatDAO.getGroupChatMessages(groupChatId);
+
+        assertNotEquals(beforeAddMessage.size(), afterAddMessage.size());
+    }
+
+    @Test
+    public void testGetGroupChatUsers() {
+        final int groupChatId = 1;
+        ArrayList<String> expected = new ArrayList<>();
+        expected.add("username");
+
+        final ArrayList<User> result = groupChatDAO.getGroupChatUsers(groupChatId);
+        ArrayList<String> resultUsernames = new ArrayList<>();
+
+        for (User user : result) resultUsernames.add(user.getUsername());
+
+        assertEquals(expected, resultUsernames);
+    }
+}

src/test/java/GroupChatResourceTest.java

+import data.GroupChat;
+import data.Message;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.test.JerseyTest;
+import org.glassfish.jersey.test.TestProperties;
+import org.junit.Test;
+import resources.GroupChatResource;
+
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class GroupChatResourceTest extends JerseyTest {
+    private final GroupChatResource groupChatResource = new GroupChatResource();
+    private int groupChatId = 1;
+
+    @Override
+    public Application configure() {
+        enable(TestProperties.LOG_TRAFFIC);
+        enable(TestProperties.DUMP_ENTITY);
+        return new ResourceConfig(GroupChatResource.class);
+    }
+
+    @Test
+    public void testGetGroupChat() {
+        Response output = target("groupchat/" + groupChatId).request().get();
+        assertEquals("Should return status 200", 200, output.getStatus());
+        assertEquals("application/json", output.getHeaderString("Content-type"));
+        assertNotNull(output.getEntity());
+    }
+
+    @Test
+    public void testGetGroupChatByUserId() {
+        int userId = 1;
+        Response output = target("groupchat/user/" + userId).request().get();
+        assertEquals("Should return status 200", 200, output.getStatus());
+        assertEquals("application/json", output.getHeaderString("Content-type"));
+        assertNotNull(output.getEntity());
+    }
+
+    @Test
+    public void testGetMessages() {
+        Response output = target("groupchat/" + groupChatId + "/message").request().get();
+        assertEquals("Should return status 200", 200, output.getStatus());
+        assertEquals("application/json", output.getHeaderString("Content-type"));
+        assertNotNull(output.getEntity());
+    }
+
+    @Test
+    public void testPostGroupChat() {
+        GroupChat groupChat = new GroupChat();
+        groupChat.setGroupChatName("testPostGroupChat");
+
+        Response output = target("/groupchat").request().post(Entity.entity(groupChat, MediaType.APPLICATION_JSON));
+        assertEquals("Should return status 200",200,output.getStatus());
+        assertEquals("application/json",output.getHeaderString("Content-type"));
+        assertEquals("testPostGroupChat", groupChatResource.postGroupChat(groupChat).getGroupChatName());
+    }
+
+    @Test
+    public void testPostMessage() {
+        Message groupChatMessage = new Message();
+        groupChatMessage.setUserId1(1);
+        groupChatMessage.setMessageContent("testPostMessage");
+        groupChatMessage.setGroupChatId(groupChatId);
+
+        Response output = target("groupchat/" + groupChatId + "/message").request().post(Entity.entity(groupChatMessage, MediaType.APPLICATION_JSON));
+        assertEquals("Should return status 200",200, output.getStatus());
+        assertEquals("application/json", output.getHeaderString("Content-type"));
+        assertEquals("testPostMessage", groupChatResource.postMessage(groupChatId, groupChatMessage).getMessageContent());
+    }
+}