Merge pull request #3 from jakub-balinski/develop

Finish all major functionalities

Author: balins

.gitattributes

@@ -1,2 +1,2 @@
-/* linguist-vendored
+./* linguist-vendored
 sakila-min.sql linguist-vendored=true

README.md

@@ -0,0 +1,4 @@
+To use your own database, configure properly properties file under server/src/main/resources/database.properties,
+then initialize the database with sakila-min.sql script.
+
+API Default Admin User: user=sa, token=bdd69043cade8ba513813e2e17cd25e241e259bdac956dab2d437b43f40d9514

pom.xml

@@ -10,7 +10,6 @@
     <version>1.0-SNAPSHOT</version>
     <modules>
         <module>server</module>
-        <module>webapp</module>
     </modules>
 
 

sakila-min.sql

@@ -2,7 +2,8 @@
 
 CREATE CACHED TABLE PUBLIC.USER(
     USER_ID INT IDENTITY NOT NULL PRIMARY KEY,
-    NAME VARCHAR(45) NOT NULL UNIQUE,
+    ROLE VARCHAR(5) NOT NULL,
+    NAME VARCHAR(45) NOT NULL,
     TOKEN VARCHAR(64) NOT NULL,
     REQUESTS_SENT INT NOT NULL DEFAULT 0,
     USE_LIMIT INT NOT NULL,
@@ -38,6 +39,8 @@ CREATE CACHED TABLE PUBLIC.LANGUAGE(
     LAST_UPDATE TIMESTAMP NOT NULL
 );
 
+INSERT INTO PUBLIC.USER (ROLE, NAME, TOKEN, REQUESTS_SENT, USE_LIMIT, DATE_REGISTERED, LAST_UPDATE) VALUES ('admin', 'sa', 'bdd69043cade8ba513813e2e17cd25e241e259bdac956dab2d437b43f40d9514', 0, 100000000, '1970-01-01', '1970-01-01');
+
 INSERT INTO PUBLIC.ACTOR (FIRST_NAME, LAST_NAME, LAST_UPDATE) VALUES ('PENELOPE', 'GUINESS', '2006-02-15 04:34:33.000000000');
 INSERT INTO PUBLIC.ACTOR (FIRST_NAME, LAST_NAME, LAST_UPDATE) VALUES ('NICK', 'WAHLBERG', '2006-02-15 04:34:33.000000000');
 INSERT INTO PUBLIC.ACTOR (FIRST_NAME, LAST_NAME, LAST_UPDATE) VALUES ('ED', 'CHASE', '2006-02-15 04:34:33.000000000');

server/pom.xml

@@ -29,11 +29,6 @@
           <artifactId>jetty-servlet</artifactId>
           <version>9.4.25.v20191220</version>
       </dependency>
-      <dependency>
-          <groupId>org.eclipse.jetty</groupId>
-          <artifactId>jetty-webapp</artifactId>
-          <version>9.4.25.v20191220</version>
-      </dependency>
       <dependency>
           <groupId>com.h2database</groupId>
           <artifactId>h2</artifactId>

server/src/main/java/com/balinski/api_project/Main.java

@@ -1,6 +1,6 @@
 package com.balinski.api_project;
 
-import com.balinski.api_project.database.DaoManager;
+import com.balinski.api_project.database.dao.DaoManager;
 
 import com.balinski.api_project.database.dao.DaoException;
 import com.balinski.api_project.database.model.Film;
@@ -9,9 +9,9 @@
 import java.util.List;
 
 public class Main {
-
+    //"name":"jakub","token":"7f078d288631a4de5fc1ce01fa4e0addeebed19ad5c6d6f543fcc160c5c5cdfc"
     public static void main(String[] args) {
-        testDatabase();
+        //testDatabase();
         runApplication();
     }
 
@@ -27,7 +27,7 @@ static void runApplication() {
 
     static void testDatabase() {
         try {
-            List<Film> list = new DaoManager().getFilmDao().getAvailableInLanguage("jaPANESE");
+            List<Film> list = DaoManager.getFilmDao().getAll();
             for(var film : list)
                 System.out.println(film.getTitle());
         } catch (DaoException e) {

server/src/main/java/com/balinski/api_project/database/DaoManager.java

@@ -0,0 +1,15 @@
+package com.balinski.api_project.database;
+
+public class DatabaseException extends RuntimeException {
+    public DatabaseException(String message) {
+        super(message);
+    }
+
+    public DatabaseException(Throwable cause) {
+        super(cause);
+    }
+
+    public DatabaseException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

server/src/main/java/com/balinski/api_project/database/DatabaseException.java

@@ -1,50 +1,118 @@
 package com.balinski.api_project.database;
 
-import com.balinski.api_project.util.SqlExceptionPrinter;
 import org.apache.commons.dbcp2.BasicDataSource;
 
+import java.io.IOException;
 import java.sql.*;
 import java.util.*;
 import java.util.stream.Stream;
 
 public class DatabaseProxy {
-    private BasicDataSource dataSource;
-    private Connection connection;
-    private String url;
-    private String username;
-    private String password;
+    protected static BasicDataSource dataSource;
+    protected static Connection connection;
+    protected static String driver;
+    protected static String url;
+    protected static String username;
+    protected static String password;
 
-    public DatabaseProxy(Properties props) {
-        try {
-            loadDatabaseProperties(props);
-            initDataSource();
-        } catch (Exception e) {
-            System.err.println("Cannot initialize database data source: " + e.getMessage());
+    static {
+        loadDatabaseProperties();
+        loadDriver();
+        testConnection();
+        initDataSource();
+    }
+
+    private DatabaseProxy(){};
+
+    public static List<Map<String, Object>> querySelect(String sql) throws DatabaseException {
+        List<Map<String, Object>> data;
+
+        try(Connection connection = getConnection()) {
+            try(Statement statement = connection.createStatement()) {
+                try(ResultSet rs = statement.executeQuery(sql)) {
+                    ResultSetMetaData md = rs.getMetaData();
+                    int columns = md.getColumnCount();
+                    data = new LinkedList<>();
+
+                    while(rs.next()) {
+                        Map<String, Object> row = new HashMap<>(columns);
+
+                        for(int i = 1; i <= columns; i++)
+                            row.put(md.getColumnName(i), rs.getObject(i));
+
+                        data.add(row);
+                    }
+                }
+            }
+        } catch (SQLException e) {
+            throw new DatabaseException("An error occurred when trying to query the database.", e);
+        } finally {
+            closeConnection();
+        }
+
+        return data;
+    }
+
+    public static int queryUpdate(String sql, boolean transaction) throws DatabaseException {
+        int rowsAffected = 0;
+
+        try(Connection connection = getConnection()) {
+            if(transaction)
+                connection.setAutoCommit(false);
+
+            try(Statement statement = connection.createStatement()) {
+                rowsAffected = statement.executeUpdate(sql);
+            }
+
+            if(transaction) {
+                connection.setAutoCommit(true);
+                connection.commit();
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            throw new DatabaseException("An error occurred when trying to update the database.", e);
+        } finally {
+            closeConnection();
         }
+
+        return rowsAffected;
     }
 
-    public Connection getConnection() {
+    protected static Connection getConnection() throws DatabaseException {
         try {
-            this.connection = dataSource.getConnection();
+            connection = dataSource.getConnection();
         } catch (SQLException e) {
-            SqlExceptionPrinter.print("Could not obtain an instance of connection from given data source.", e);
+            throw new DatabaseException("Could not obtain an instance of connection from given data source.", e);
         }
 
         return connection;
     }
 
-    public void closeConnection() {
+    protected static void closeConnection() throws DatabaseException {
         if(connection == null)
             return;
 
         try {
-            this.connection.close();
+            connection.close();
+        } catch (SQLException e) {
+            throw new DatabaseException("Cannot close the connection.", e);
+        }
+    }
+
+    private static void testConnection() throws DatabaseException {
+        if(Stream.of(url, driver, username, password).anyMatch(Objects::isNull)) {
+            throw new DatabaseException("One of the database properties (url, driver, username, password) is missing. " +
+                    "Check the file containing database properties.");
+        }
+
+        try(Connection ignored = DriverManager.getConnection(url, username, password)) {
+            System.out.println("The database connection was configured successfully.");
         } catch (SQLException e) {
-            SqlExceptionPrinter.print("Cannot close the connection.", e);
+            throw new DatabaseException("Wrong credentials or internal database error.", e);
         }
     }
 
-    private void initDataSource() {
+    protected static void initDataSource() {
         dataSource = new BasicDataSource();
         dataSource.setUrl(url);
         dataSource.setUsername(username);
@@ -54,20 +122,26 @@ private void initDataSource() {
         dataSource.setMaxOpenPreparedStatements(100);
     }
 
-    private void loadDatabaseProperties(Properties props) throws NullPointerException, ClassNotFoundException {
+    protected static void loadDatabaseProperties() throws DatabaseException {
+        Properties props;
+        try {
+            props = FilePropertiesLoader.load("server/src/main/resources/database.properties");
+        } catch (IOException e) {
+            throw new DatabaseException("Could not find database properties file under given path: "
+                    + "server/src/main/resources/database.properties", e);
+        }
+
         url = props.getProperty("url");
-        String driver = props.getProperty("driver");
+        driver = props.getProperty("driver");
         username = props.getProperty("username");
         password = props.getProperty("password");
+    }
 
-        if(Stream.of(url, driver, username, password).anyMatch(Objects::isNull)) {
-            throw new NullPointerException("One or more of properties (url, driver, username, password) is missing");
-        }
-
+    private static void loadDriver() throws DatabaseException {
         try {
             Class.forName(driver);
         } catch (ClassNotFoundException e) {
-            throw new ClassNotFoundException("Driver class " + driver + " not found.", e);
+            throw new DatabaseException("Driver class " + driver + " not found.", e);
         }
     }
 }