hw6

build.gradle

@@ -12,6 +12,12 @@ repositories {
 sourceCompatibility = 10
 
 dependencies {
+    // https://mvnrepository.com/artifact/org.hsqldb/hsqldb
+    compile group: 'org.hsqldb', name: 'hsqldb', version: '2.4.1'
+
+    // https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2
+    compile group: 'org.apache.commons', name: 'commons-dbcp2', version: '2.5.0'
+
     // https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind
     compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.9.7'
 

src/main/java/DAO/OrderItemDao.java

@@ -0,0 +1,78 @@
+package DAO;
+
+import DTO.Order;
+import DTO.OrderItem;
+import util.DataSourceProvider;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.LinkedList;
+import java.util.List;
+
+public class OrderItemDao {
+
+    public static List<OrderItem> getItemsForOrderId(int id) {
+        List<OrderItem> result = new LinkedList<>();
+        String sql = "select item_name, quantity, price from order_items where ORDER_ID=?";
+        try (Connection con = DataSourceProvider.getDataSource().getConnection();
+             PreparedStatement ps = con.prepareStatement(sql)) {
+            ps.setInt(1, id);
+            try(ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    OrderItem item = new OrderItem();
+                    item.setItemName(rs.getString(1));
+                    item.setQuantity(rs.getInt(2));
+                    item.setPrice(rs.getInt(3));
+                    result.add(item);
+                }
+            }
+
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+        return result;
+    }
+
+    public static void saveOrderItem(OrderItem item, int orderId) {
+        String sql = "insert into order_items (order_id, item_name, quantity, price) VALUES (?,?,?,?);";
+        try (Connection con = DataSourceProvider.getDataSource().getConnection();
+             PreparedStatement ps = con.prepareStatement(sql)) {
+            ps.setInt(1, orderId);
+            ps.setString(2, item.getItemName());
+            ps.setInt(3, item.getQuantity());
+            ps.setInt(4, item.getPrice());
+            ps.execute();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void saveOrderItems(List<OrderItem> items, int orderId) {
+        for (OrderItem item: items){
+            saveOrderItem(item, orderId);
+        }
+    }
+
+    public static void deleteOrderItemsForOrderId(int id) {
+        String sql = "delete from order_items where ORDER_ID=?";
+        try (Connection con = DataSourceProvider.getDataSource().getConnection();
+             PreparedStatement ps = con.prepareStatement(sql)) {
+            ps.setInt(1, id);
+            ps.executeUpdate();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void deleteAllOrderItems() {
+        String sql = "delete from order_items";
+        try (Connection con = DataSourceProvider.getDataSource().getConnection();
+             PreparedStatement ps = con.prepareStatement(sql)) {
+            ps.executeUpdate();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/DAO/OrdersDao.java

@@ -0,0 +1,114 @@
+package DAO;
+
+import DTO.Order;
+import Exceptions.ValidationException;
+import util.DataSourceProvider;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class OrdersDao {
+
+    public static Order getOrderForId(int id) {
+        Order order = new Order();
+        String sql = "select order_number from ORDERS where id=?;";
+        try (Connection connection = DataSourceProvider.getDataSource().getConnection();
+             PreparedStatement ps = connection.prepareStatement(sql)) {
+            ps.setInt(1, id);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (rs.next()) {
+                    order.setId(id);
+                    order.setOrderNumber(rs.getString(1));
+
+                    order.setOrderRows(OrderItemDao.getItemsForOrderId(id));
+                    return order;
+                }
+            }
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+        return null;
+    }
+    public static List<Order> getAllOrders() {
+        List<Order> orders = new ArrayList<Order>();
+        String sql = "select id, order_number from orders;";
+        try (Connection connection = DataSourceProvider.getDataSource().getConnection();
+             Statement statement = connection.createStatement() ){
+
+            try (ResultSet rs = statement.executeQuery(sql)) {
+                while(rs.next()) {
+                    Order order = new Order();
+                    order.setId(rs.getInt(1));
+
+                    order.setOrderNumber(rs.getString(2));
+
+                    order.setOrderRows(OrderItemDao.getItemsForOrderId(order.getId()));
+                    orders.add(order);
+                }
+            }
+
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+
+
+        return orders;
+    }
+
+    public static void saveOrder(Order order) {
+        String sql = "insert into orders (order_number) values (?);";
+        try (Connection connection = DataSourceProvider.getDataSource().getConnection();
+             PreparedStatement ps = connection.prepareStatement(sql);
+             PreparedStatement call = connection.prepareCall("CALL IDENTITY();")) {
+            ps.setString(1, order.getOrderNumber());
+            ps.executeUpdate();
+            try (ResultSet rs = call.executeQuery()) {
+                if (rs.next()) {
+                    order.setId(rs.getInt(1));
+                    OrderItemDao.saveOrderItems(order.getOrderRows(), order.getId());
+                }
+            }
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void deleteOrderForId(int id) {
+        String sql = "DELETE FROM orders WHERE id=?;";
+        try (Connection connection = DataSourceProvider.getDataSource().getConnection();
+             PreparedStatement ps = connection.prepareStatement(sql)) {
+            ps.setInt(1, id);
+            ps.executeUpdate();
+            OrderItemDao.deleteOrderItemsForOrderId(id);
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static int getCount() {
+        String sql = "select count(*) from orders;";
+        try (Connection connection = DataSourceProvider.getDataSource().getConnection();
+             Statement ps = connection.createStatement()) {
+            try (ResultSet rs = ps.executeQuery(sql)) {
+                if (rs.next()) {
+                    return rs.getInt(1);
+                }
+            }
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+        return 0;
+    }
+
+    public static void deleteAllOrders() {
+        String sql = "delete from orders;";
+        try (Connection connection = DataSourceProvider.getDataSource().getConnection();
+             PreparedStatement ps = connection.prepareStatement(sql)) {
+            OrderItemDao.deleteAllOrderItems();
+            ps.executeUpdate();
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/main/java/DAO/ReportDao.java

@@ -0,0 +1,25 @@
+package DAO;
+
+import DTO.Order;
+import DTO.OrderItem;
+import DTO.Report;
+
+public class ReportDao {
+    public static Report getReport() {
+        Report report = new Report();
+        report.setCount(OrdersDao.getCount());
+        report.setTurnoverWithoutVAT(0);
+        int itemCount = 0;
+        for (Order order: OrdersDao.getAllOrders()) {
+            for (OrderItem orderItem: order.getOrderRows()) {
+                int turnover = report.getTurnoverWithoutVAT() + (orderItem.getPrice() * orderItem.getQuantity());
+                report.setTurnoverWithoutVAT(turnover);
+                itemCount++;
+            }
+        }
+        report.setAverageOrderAmount(report.getTurnoverWithoutVAT() / itemCount);
+        report.setTurnoverVAT((int)(report.getTurnoverWithoutVAT() * 0.2));
+        report.setTurnoverWithVAT(report.getTurnoverVAT() + report.getTurnoverWithoutVAT());
+        return report;
+    }
+}

src/main/java/DTO/Order.java

@@ -1,10 +1,12 @@
 package DTO;
+import Exceptions.ValidationException;
 import lombok.Data;
 
+import java.util.LinkedList;
 import java.util.List;
 
 public @Data class Order {
     private int id;
     private String orderNumber;
-    private List<OrderItem> orderRows;
+    private List<OrderItem> orderRows = new LinkedList<>();
 }

src/main/java/DTO/Report.java

@@ -0,0 +1,14 @@
+package DTO;
+
+import lombok.Data;
+
+@Data
+public class Report {
+
+    private Integer count;
+    private Integer averageOrderAmount;
+    private Integer turnoverWithoutVAT;
+    private Integer turnoverVAT;
+    private Integer turnoverWithVAT;
+
+}

src/main/java/DTO/ValidationError.java

@@ -0,0 +1,10 @@
+package DTO;
+
+import lombok.Data;
+import java.util.List;
+
+@Data
+public class ValidationError {
+    private String code;
+    private List<String> arguments;
+}

src/main/java/DTO/ValidationErrors.java

@@ -0,0 +1,16 @@
+package DTO;
+
+import lombok.Data;
+
+import java.util.LinkedList;
+import java.util.List;
+
+@Data
+public class ValidationErrors {
+
+    private List<ValidationError> errors = new LinkedList<>();
+
+    public void addError(ValidationError error) {
+        errors.add(error);
+    }
+}

src/main/java/Exceptions/ValidationException.java

@@ -0,0 +1,13 @@
+package Exceptions;
+
+import DTO.ValidationError;
+import lombok.Getter;
+import lombok.Setter;
+
+public class ValidationException extends Exception {
+    @Getter private ValidationError error = new ValidationError();
+
+    public ValidationException(String code) {
+        error.setCode(code);
+    }
+}

src/main/java/Startup.java

@@ -0,0 +1,39 @@
+import util.DataSourceProvider;
+
+import javax.servlet.ServletContextEvent;
+import javax.servlet.ServletContextListener;
+import javax.servlet.annotation.WebListener;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static util.FileUtil.readFileFromClasspath;
+
+@WebListener
+public class Startup implements ServletContextListener {
+
+    @Override
+    public void contextInitialized(ServletContextEvent sce) {
+        System.out.println("Set jdbc provider url");
+        DataSourceProvider.setDbUrl("jdbc:hsqldb:mem:shop.");
+
+        System.out.println("Load sql");
+        String sql = readFileFromClasspath("sql/schema.sql");
+
+        try (Connection connection = DataSourceProvider.getDataSource().getConnection();
+            Statement statement = connection.createStatement()) {
+
+            statement.execute(sql);
+
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+        System.out.println("Ready");
+    }
+
+    @Override
+    public void contextDestroyed(ServletContextEvent sce) {
+
+    }
+}

src/main/java/servlet/api/Orders.java

@@ -1,51 +1,40 @@
-package api;
+package servlet.api;
 
+import DAO.OrdersDao;
 import DTO.Order;
+import DTO.ValidationError;
+import DTO.ValidationErrors;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
-import javax.servlet.ServletContextEvent;
-import javax.servlet.ServletContextListener;
 import javax.servlet.ServletException;
-import javax.servlet.annotation.WebListener;
 import javax.servlet.annotation.WebServlet;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
-import java.util.HashMap;
+import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 @WebServlet(urlPatterns = "/api/orders", name="Orders")
-@WebListener
+public class Orders extends HttpServlet {
-public class Orders extends HttpServlet implements ServletContextListener {
     private static final long serialVersionUID = 1L;
-    private static int nextOrderId = 0;
-    private static Map orders = new HashMap<Integer, Order>();
-
-    public int addOrder(Order order) {
-        int orderId = nextOrderId;
-        nextOrderId++;
-        order.setId(orderId);
-        orders.put(orderId, order);
-        return orderId;
-    }
 
     @Override
     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        resp.setContentType("application/json");
         String idString = req.getParameter("id");
         if (idString != null) {
             int id = Integer.parseInt(idString);
-            Order order = (Order) orders.get(id);
+            Order order = OrdersDao.getOrderForId(id);
             if (order == null) {
                 resp.setStatus(404);
                 return;
             }
-            resp.setContentType("application/json");
             resp.getWriter().print(new ObjectMapper().writeValueAsString(order));
             return;
         }
-        resp.getWriter().format("%s %d", getServletName(), orders.size());
+        List<Order> orders = OrdersDao.getAllOrders();
+        resp.getWriter().print(new ObjectMapper().writeValueAsString(orders));
     }
 
     @Override
@@ -54,19 +43,32 @@ public class Orders extends HttpServlet implements ServletContextListener {
         String orderJson = req.getReader().lines().collect(Collectors.joining(" "));
 
         Order order = new ObjectMapper().readValue(orderJson, Order.class);
-        addOrder(order);
+
+        if (order.getOrderNumber().length() < 2) {
+            resp.setStatus(400, "orderNumber parameter is empty");
+            resp.setContentType("application/json");
+            ValidationErrors errors = new ValidationErrors();
+            ValidationError error = new ValidationError();
+            error.setCode("too_short_number");
+            errors.addError(error);
+            resp.getWriter().print(new ObjectMapper().writeValueAsString(errors));
+            return;
+        }
+
+        OrdersDao.saveOrder(order);
         resp.getWriter().print(new ObjectMapper().writeValueAsString(order));
 
     }
 
     @Override
-    public void contextInitialized(ServletContextEvent sce) {
+    protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-        // fixme horrible hack
+        resp.setContentType("application/json");
-        sce.getServletContext().setAttribute("Orders", this);
+        String idString = req.getParameter("id");
-    }
+        if (idString != null) {
-
+            int id = Integer.parseInt(idString);
-    @Override
+            OrdersDao.deleteOrderForId(id);
-    public void contextDestroyed(ServletContextEvent sce) {
+        } else {
-
+            OrdersDao.deleteAllOrders();
+        }
     }
 }

src/main/java/servlet/api/OrdersReport.java

@@ -0,0 +1,22 @@
+package servlet.api;
+
+import DAO.ReportDao;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+@WebServlet(urlPatterns = "/api/orders/report", name="OrdersReport")
+public class OrdersReport extends HttpServlet {
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+        resp.setContentType("application/json");
+        resp.getWriter().print(new ObjectMapper().writeValueAsString(ReportDao.getReport()));
+    }
+}

src/main/java/servlet/html/Index.java

@@ -1,4 +1,6 @@
-package form;
+package servlet.html;
+
+import util.FileUtil;
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -12,6 +14,7 @@ public class Index extends HttpServlet {
 
     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         response.setContentType("text/html; charset=utf-8");
-        response.getWriter().print("<a href=/orders/form>Orders form</a>");
+        String index = FileUtil.readFileFromClasspath("html/index.html");
+        response.getWriter().print(index);
     }
 }

src/main/java/servlet/html/OrdersForm.java

@@ -1,7 +1,12 @@
-package form;
+package servlet.html;
 
+import DAO.OrdersDao;
 import DTO.Order;
-import api.Orders;
+import DTO.ValidationError;
+import DTO.ValidationErrors;
+import Exceptions.ValidationException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import servlet.api.Orders;
 
 import javax.servlet.ServletException;
 import javax.servlet.annotation.WebServlet;
@@ -29,12 +34,6 @@ public class OrdersForm extends HttpServlet
     @Override
     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
         resp.setContentType("application/json");
-        // fixme horrible hack
-        Orders orders = (Orders) getServletContext().getAttribute("Orders");
-        if (orders == null) {
-            throw new NullPointerException("Orders servlet not found");
-        }
-
         String orderNumber = req.getParameter("orderNumber");
         if (orderNumber == null) {
             resp.setStatus(400, "orderNumber parameter is empty");
@@ -44,7 +43,17 @@ public class OrdersForm extends HttpServlet
 
         Order order = new Order();
         order.setOrderNumber(orderNumber);
-        int orderId = orders.addOrder(order);
+        if (order.getOrderNumber().length() < 2) {
-        resp.getWriter().format("%d", orderId);
+            resp.setStatus(400, "orderNumber parameter is empty");
+            resp.setContentType("application/json");
+            ValidationErrors errors = new ValidationErrors();
+            ValidationError error = new ValidationError();
+            error.setCode("too_short_number");
+            errors.addError(error);
+            resp.getWriter().print(new ObjectMapper().writeValueAsString(errors));
+            return;
+        }
+        OrdersDao.saveOrder(order);
+        resp.getWriter().format("%d", order.getId());
     }
 }

src/main/java/servlet/test/HelloServlet.java

@@ -1,4 +1,4 @@
-package test;
+package servlet.test;
 
 import java.io.IOException;
 import javax.servlet.ServletException;

src/main/java/util/DataSourceProvider.java

@@ -0,0 +1,35 @@
+package util;
+
+import org.apache.commons.dbcp2.BasicDataSource;
+
+import javax.sql.DataSource;
+
+public class DataSourceProvider {
+
+    private static String dbUrl = null;
+
+    private static BasicDataSource dataSource = null;
+
+    public static void setDbUrl(String url) {
+        dbUrl = url;
+    }
+
+    public static DataSource getDataSource() {
+        if (dataSource != null) {
+            return dataSource;
+        }
+
+        if (dbUrl == null) {
+            throw new IllegalStateException(
+                    "Database url not configured. Use setDbUrl()");
+        }
+
+        dataSource = new BasicDataSource();
+        dataSource.setDriverClassName("org.hsqldb.jdbcDriver");
+        dataSource.setUrl(dbUrl);
+        dataSource.setMaxTotal(3);
+
+        return dataSource;
+    }
+
+}

src/main/java/util/FileUtil.java

@@ -0,0 +1,26 @@
+package util;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.stream.Collectors;
+
+public class FileUtil {
+
+    public static String readFileFromClasspath(String pathOnClasspath) {
+        try (InputStream is = FileUtil.class.getClassLoader().getResourceAsStream(pathOnClasspath)) {
+            if (is == null) {
+                throw new IllegalStateException("can't load file: " + pathOnClasspath);
+            }
+
+            BufferedReader buffer = new BufferedReader(new InputStreamReader(is));
+
+            return buffer.lines().collect(Collectors.joining("\n"));
+
+        } catch (IOException e) {
+            throw new RuntimeException();
+        }
+    }
+
+}

src/main/resources/html/index.html

@@ -0,0 +1,9 @@
+<!doctype html>
+<html>
+<title>Index</title>
+<h1>Shop</h1>
+<h3>Menu</h3>
+<ul>
+    <li><a href=/orders/form>Orders form</a></li>
+</ul>
+</html>

src/main/resources/sql/schema.sql

@@ -0,0 +1,16 @@
+CREATE TABLE orders (
+  id BIGINT NOT NULL PRIMARY KEY IDENTITY,
+  order_number VARCHAR (255)
+);
+
+CREATE TABLE order_items (
+  id BIGINT NOT NULL PRIMARY KEY IDENTITY,
+  order_id BIGINT NOT NULL,
+  item_name VARCHAR (255),
+  quantity INT,
+  price INT,
+  FOREIGN KEY (order_id) REFERENCES orders (id)
+);
+
+--INSERT INTO orders (order_number) values ('asdf');
+--INSERT INTO order_items (order_id, item_name, quantity, price) values (0, 'test', 1, 10);