Orders module

.idea/gradle.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>

src/main/java/com/retail_store/order_management/application/OrderManagement.java

@@ -2,14 +2,15 @@ package com.retail_store.order_management.application;
 
 import com.retail_store.order_management.service.RetailStore;
 import com.retail_store.order_management.service.RetailStoreService;
-import com.retail_store.order_management.utils.Validate;
 
 import java.sql.SQLException;
 import java.util.Scanner;
 import java.util.logging.Logger;
 
+import static com.retail_store.order_management.utils.Utility.getInt;
+
 public class OrderManagement {
-    private final Scanner scanner;
+    private Scanner scanner;
     private final Logger logger;
 
     public OrderManagement() {
@@ -20,34 +21,39 @@ public class OrderManagement {
     }
 
     public void menu() {
-        logger.info("Welcome to GAP Business Management");
-        RetailStore gap = new RetailStoreService(scanner, logger);
-        String menu = "\nMenu \n 1. add product to your stock \n 2. get products available for customers \n 3. get order details \n 4. exit";
         boolean flag = true;
+        logger.info("Welcome to GAP Business Management");
+        RetailStore gap = new RetailStoreService();
+        String menu = "\n------------------------\nMenu\n------------------------\n" +
+                "1. Add product to your stock\n------------------------\n" +
+                "2. Order Product\n------------------------\n" +
+                "3. Get order details\n------------------------\n" +
+                "4. Exit";
         logger.info(menu);
-        int menuOption = 0;
         while (flag) {
-            try {
-                menuOption = scanner.nextInt();
-            } catch (Exception e) {
-                scanner.reset();
-                menu();
-            }
+            int menuOption;
+            menuOption = getInt();
             switch (menuOption) {
                 case 1:
                     try {
-                        gap.addProduct();
+                        gap.addProducts();
                     } catch (Exception e) {
                         e.printStackTrace();
                         menu();
                     }
-                    logger.info("Please enter 5 for menu\n To exit please enter 4\n To Add more enter 1");
+                    logger.info("\n------------------------\nPlease enter 5 for menu\n------------------------\n" +
+                            "To exit please enter 4\n------------------------\n" +
+                            "To Add more enter 1\n------------------------\n");
                     break;
                 case 2:
-                    gap.placeOrder();
-                    logger.info("Please enter 5 for menu\n To exit please enter 4");
+                    gap.placeOrders();
+                    logger.info("\n------------------------\nPlease enter 5 for menu\n------------------------\n" +
+                            "To exit please enter 4");
                     break;
                 case 3:
+                    gap.showOrders();
+                    logger.info("\n------------------------\nPlease enter 5 for menu\n------------------------\n" +
+                            "To exit please enter 4");
                     break;
                 case 4:
                     flag = false;
@@ -56,42 +62,14 @@ public class OrderManagement {
                     logger.info(menu);
                     break;
                 default:
-                    logger.warning("Please enter valid menu option");
+                    logger.warning("\n------------------------\nPlease enter valid menu option\n------------------------\n");
                     logger.info(menu);
-
             }
-
         }
     }
 
     public static void main(String[] args) throws SQLException {
         OrderManagement orderManagement = new OrderManagement();
         orderManagement.menu();
-//        Statement statement = Database.getConnection().createStatement();
-//        ResultSet resultSet = statement.executeQuery("select * from gap.products where gender='Men' group by gender");
-//        ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
-//        while (resultSet.next()) {
-//            for (int i = 1; i <= resultSetMetaData.getColumnCount(); i++) {
-//                System.out.println(resultSet.getString(i) + "\t");
-//            }
-//            System.out.println();
-//        }
-        RetailStore gap = new RetailStoreService(new Scanner(System.in), Logger.getLogger(RetailStore.class.getName()));
-//        LinkedHashMap<Size, Integer> sizeIntegerLinkedHashMap = new LinkedHashMap<>();
-//        sizeIntegerLinkedHashMap.put(Size.S, 0);
-//        sizeIntegerLinkedHashMap.put(Size.M, 3);
-//        sizeIntegerLinkedHashMap.put(Size.L, 4);
-//        sizeIntegerLinkedHashMap.put(Size.XL, 3);
-//        sizeIntegerLinkedHashMap.put(Size.XXL, 0);
-//        Product shirt1 = new Product("abcd", "men regular fit shirt", Category.HOODIES, Color.BLUE, 500.00, Gender.MEN, sizeIntegerLinkedHashMap);
-//        System.out.println(        gap.addProductToCart(new ArrayList<Product>(), shirt1, Database.getConnection()));
-//        System.out.println(gap.addProductToCart(shirt1));
-        //        gap.searchProduct();
-//        gap.getCategoriesByGender(Gender.FEMALE);
-//        gap.getProductsByGenderAndCategory(Gender.WOMEN, Category.SHIRTS);
-//        gap.getColorsByGenderAndCategory(Gender.MEN, Category.DRESS);
-
-//        System.out.println(UUID.randomUUID());
-        Validate validate = new Validate();
     }
 }

src/main/java/com/retail_store/order_management/constants/Category.java

 package com.retail_store.order_management.constants;
 
 public enum Category {
-    SHIRTS(1), PANTS(2), JEANS(3), SHORTS(4), T_SHIRTS(5), POLOS(6), HOODIES(7), KURTA(8), SWEATSHIRTS(9), DRESS(10), TOPS(11);
+    EXIT(0), SHIRTS(1), PANTS(2), JEANS(3), SHORTS(4), T_SHIRTS(5), POLOS(6), HOODIES(7), KURTA(8), SWEATSHIRTS(9), DRESS(10), TOPS(11);
     int option;
 
     public int getOption() {

src/main/java/com/retail_store/order_management/constants/Color.java

 package com.retail_store.order_management.constants;
 
 public enum Color {
-    RED(1), GREEN(2), BLUE(3), BROWN(4), GREY(5), WHITE(6), PINK(7), YELLOW(8), BLACK(9), PURPLE(10), ORANGE(11), SKY_BLUE(12);
+    EXIT(0), RED(1), GREEN(2), BLUE(3), BROWN(4), GREY(5), WHITE(6), PINK(7), YELLOW(8), BLACK(9), PURPLE(10), ORANGE(11), SKY_BLUE(12);
     int option;
 
     public int getOption() {

src/main/java/com/retail_store/order_management/constants/Gender.java

 package com.retail_store.order_management.constants;
 
 public enum Gender {
-    MEN(1, "Men"), WOMEN(2, "Women");
+    EXIT(0,"exit"),MEN(1, "Men"), WOMEN(2, "Women");
     int option;
     String gender;
 

src/main/java/com/retail_store/order_management/constants/Size.java

 package com.retail_store.order_management.constants;
 
 public enum Size {
-    S(1, "size_s"), M(2, "size_m"), L(3, "size_l"), XL(4, "size_xl"), XXL(5, "size_xxl");
+    EXIT(0, "exit"), S(1, "size_s"), M(2, "size_m"), L(3, "size_l"), XL(4, "size_xl"), XXL(5, "size_xxl");
     int option;
     String name;
 

src/main/java/com/retail_store/order_management/model/Order.java

@@ -12,17 +12,56 @@ public class Order {
     private LocalTime localTime;
     private String customerName;
     private String phoneNumber;
+    private double totalBill;
     List<OrderedProduct> productsList;
 
-    public Order(String orderId, LocalDate orderDate, LocalTime localTime, String customerName, String phoneNumber, List<OrderedProduct> productsList) {
+    public Order(String orderId, LocalDate orderDate, LocalTime localTime, String customerName, String phoneNumber, double totalBill, List<OrderedProduct> productsList) {
         this.orderId = orderId;
         this.orderDate = orderDate;
         this.localTime = localTime;
         this.customerName = customerName;
         this.phoneNumber = phoneNumber;
+        this.totalBill = totalBill;
         this.productsList = productsList;
     }
 
+    public String getOrderId() {
+        return orderId;
+    }
+
+    public LocalDate getOrderDate() {
+        return orderDate;
+    }
+
+    public LocalTime getLocalTime() {
+        return localTime;
+    }
+
+    public String getCustomerName() {
+        return customerName;
+    }
+
+    public String getPhoneNumber() {
+        return phoneNumber;
+    }
+
+    public double getTotalBill() {
+        return totalBill;
+    }
+
+    public List<OrderedProduct> getProductsList() {
+        return productsList;
+    }
+
+
+    public String showOrder() {
+        return "order id : " + orderId + "\nCustomer name: " + customerName + "\tPhone number: " + phoneNumber + "\nDate: " + orderDate + "\tTime: " + localTime + "\n Total Bill: " + totalBill;
+    }
+
+    public String showProducts() {
+        return productsList.stream().map(product -> product.getId() + "\t" + product.getName() + "\n" + product.getCategory() + "\t" + product.getSize() + "\n" + product.getQuantity() + "\t" + product.getPrice() + "\t" + product.getQuantity() * product.getPrice()).reduce("", (productsList, product) -> productsList + "\n" + product);
+    }
+
     public String orderIdGenerator() {
         return Arrays.stream(UUID.randomUUID().toString().split("-")).findFirst().get() + "#" + Order.class.getSimpleName();
     }

src/main/java/com/retail_store/order_management/model/Product.java

@@ -64,7 +64,7 @@ public class Product {
     }
 
     public String showSizes() {
-        return outOfStock() ? "* Out of Stock *" : size.entrySet().stream().map(size -> size.getKey() + "-" + size.getValue()).reduce((sizes, size) -> sizes + ", " + size).get();
+        return outOfStock() ? "* Out of Stock *" : "Sizes available : " + size.entrySet().stream().map(size -> size.getKey() + "-" + size.getValue()).reduce((sizes, size) -> sizes + ", " + size).get();
     }
 
     public String productShowcaseInMenu() {

src/main/java/com/retail_store/order_management/service/ProductFilter.java

@@ -3,18 +3,22 @@ package com.retail_store.order_management.service;
 import com.retail_store.order_management.constants.Category;
 import com.retail_store.order_management.constants.Color;
 import com.retail_store.order_management.constants.Gender;
+import com.retail_store.order_management.model.Order;
 import com.retail_store.order_management.model.Product;
 
-import java.util.Collection;
+import java.sql.Connection;
 import java.util.Map;
 
 public interface ProductFilter {
 
     public Map<Integer, Category> getCategoriesByGender(Gender gender);
 
+    public Map<Integer, Order> getOrders(Connection connection);
+
+
     public Map<Integer, Color> getColorsByGenderAndCategory(Gender gender, Category category);
 
     public Map<Integer, Product> getProductsByGenderAndCategory(Gender gender, Category category);
 
-    public Map<Integer, Product> getProductsByGenderAndColor(Collection<Product> productList, Color color);
+//    public Map<Integer, Product> getProductsByGenderAndColor(Collection<Product> productList, Color color);
 }

src/main/java/com/retail_store/order_management/service/RetailStore.java

@@ -8,9 +8,11 @@ import java.sql.Connection;
 import java.util.Collection;
 
 public interface RetailStore {
-    public boolean addProduct();
+    public boolean addProducts();
 
-    public boolean placeOrder();
+    public boolean placeOrders();
+
+    public void showOrders();
 
     public Collection<OrderedProduct> createOrder(Connection connection);
 

src/main/java/com/retail_store/order_management/service/RetailStoreService.java

@@ -4,9 +4,9 @@ import com.retail_store.order_management.constants.Category;
 import com.retail_store.order_management.constants.Color;
 import com.retail_store.order_management.constants.Gender;
 import com.retail_store.order_management.constants.Size;
+import com.retail_store.order_management.model.Order;
 import com.retail_store.order_management.model.OrderedProduct;
 import com.retail_store.order_management.model.Product;
-import com.retail_store.order_management.utils.Validate;
 
 import java.sql.Date;
 import java.sql.*;
@@ -14,28 +14,22 @@ import java.time.LocalDate;
 import java.time.LocalTime;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.logging.Logger;
 
 import static com.retail_store.order_management.utils.Database.getConnection;
+import static com.retail_store.order_management.utils.Utility.*;
 
 
-public class RetailStoreService extends Validate implements RetailStore, ProductFilter {
+public class RetailStoreService implements RetailStore, ProductFilter {
 
-    public RetailStoreService(Scanner scanner, Logger logger) {
-        this.scanner = scanner;
-        this.logger = logger;
-    }
-
-    public boolean addProduct() {
+    public boolean addProducts() {
         boolean productAdded = false;
         String id = productIdGenerator();
-        scanner = new Scanner(System.in);
-        logger.info("Enter Product details \n Enter Product Name");
-        String name = scanner.next();
-        name += scanner.nextLine();
+        getLogger().info("Enter Product details \n Enter Product Name");
+        String name = getScanner().next();
+        name += getScanner().nextLine();
         Category category = getCategory(true, "Enter Product Category");
         Color color = getColor(true, "Select color of the product");
-        double price = getPrice(true);
+        double price = getDouble(true, "Enter price of the product");
         Gender gender = getGender(true, "Product is ideal for");
         Map<Size, Integer> size = getProductSizes();
         Connection connection = getConnection();
@@ -54,49 +48,49 @@ public class RetailStoreService extends Validate implements RetailStore, Product
             preparedStatement.setInt(11, size.get(Size.XXL));
             productAdded = preparedStatement.executeUpdate() > 0;
             if (productAdded) {
-                logger.info("Your product with name : " + name + " is added successfully");
+                getLogger().info("Your product with name : " + name + " is added successfully");
             } else {
-                logger.info("Your product is not added successfully");
-                productAdded = addProduct();
+                getLogger().info("Your product is not added successfully");
+                productAdded = addProducts();
             }
         } catch (SQLException e) {
-//            e.printStackTrace();
-            logger.warning(e.getMessage());
-            logger.info("Your product is not added successfully");
-            productAdded = addProduct();
+            getScanner().reset();
+            getLogger().warning(e.getMessage());
+            getLogger().warning("Your product is not added successfully");
+            productAdded = addProducts();
         }
         return productAdded;
     }
 
 
-    public boolean placeOrder() {
+    public boolean placeOrders() {
         Connection connection = getConnection();
+        int confirmOrder;
+        String orderMessage;
         try {
             connection.setAutoCommit(false);
-            List<OrderedProduct> orderedProductList = new ArrayList<>(createOrder(connection));
-            if (orderedProductList.isEmpty()) {
-                logger.info("Since your order list is empty, unable to place order\n To make an order please enter 1\n Press any key to exit");
-                try {
-                    int option = scanner.nextInt();
+
+            List<OrderedProduct> orderedProductList = createOrder(connection);
+            if (orderedProductList == null || orderedProductList.isEmpty()) {
+                getLogger().info("Since your order list is empty, unable to place order\n To make an order please enter 1\n Press any number to exit");
+                int option = getInt();
                 if (option == 1) {
-                        return placeOrder();
+                    return placeOrders();
                 } else {
-                        return false;
-                    }
-                } catch (Exception e) {
+                    getScanner().reset();
                     return false;
                 }
             }
             String orderId = orderIdGenerator();
-            logger.info("Please enter Customer name");
-            String name = scanner.next();
-            name += scanner.nextLine();
-            logger.info("Please enter Phone number");
-            String phone = scanner.next();
+            getLogger().info("Please enter Customer name");
+            String name = getScanner().next();
+            name += getScanner().nextLine();
+            getLogger().info("Please enter Phone number");
+            String phone = getScanner().next();
             Date date = Date.valueOf(LocalDate.now());
             Time time = Time.valueOf(LocalTime.now());
-            connection = getConnection();
             double bill = orderedProductList.stream().map(product -> product.getPrice() * product.getQuantity()).reduce(0.00, (totalBill, productBill) -> totalBill + productBill);
+            orderMessage = "Order ID: " + orderId + "\nName: " + name + "\nProducts: " + orderedProductList.stream().map(product -> product.getName() + "\t-\tPrice: " + product.getPrice() + "\t-\tQuantity: " + product.getQuantity() + "\t-\tCost: " + product.getPrice() * product.getQuantity()).reduce("", (products, product) -> products + "\n" + product) + "\nTotal Bill : " + bill;
             PreparedStatement preparedStatement = connection.prepareStatement("insert into orders values(?,?,?,?,?,?)");
             preparedStatement.setString(1, orderId);
             preparedStatement.setString(2, name);
@@ -120,32 +114,46 @@ public class RetailStoreService extends Validate implements RetailStore, Product
                 }
                 preparedStatement.executeBatch();
             }
+            getLogger().info("to confirm the order enter 1\n to cancel enter any number");
+            confirmOrder = getScanner().nextInt();
+            switch (confirmOrder) {
+                case 1:
+                    getLogger().info("Your order is successfully placed.");
+                    getLogger().info(orderMessage);
                     connection.commit();
+                    break;
+                default:
+                    getLogger().info("Your order is not confirmed");
+                    connection.rollback();
+            }
             return true;
         } catch (SQLException e) {
-            logger.warning(e.getMessage());
+            getLogger().warning(e.getMessage());
             try {
                 connection.rollback();
             } catch (SQLException ex) {
-                logger.warning(ex.getMessage());
+                getLogger().warning(ex.getMessage());
             }
             return true;
         }
     }
 
     @Override
-    public Collection<OrderedProduct> createOrder(Connection connection) {
+    public List<OrderedProduct> createOrder(Connection connection) {
         List<OrderedProduct> cart = new ArrayList<>();
         boolean orderBoolean = true;
         while (orderBoolean) {
-            logger.info("********************GAP********************* " + "\n \t (1) Men  \t \t \t \t (2) Women");
-            Gender gender = null;
-            gender = getGender(false, "Please select...");
+            getLogger().info("********************GAP********************* " + "\n \t (1) Men  \t \t \t \t (2) Women\n-----------------------------\nto exit enter 0\n-----------------------------\n");
+            Gender gender = getGender(false, "Please select...");
+            if (gender == Gender.EXIT) {
+                cart = null;
+                break;
+            }
             boolean genderBoolean = true;
             while (genderBoolean) {
                 Map<Integer, Category> categoryMenu = getCategoriesByGender(gender);
-                logger.info("Select the category\nTo change the gender please enter 0");
-                int categoryMenuNumber = scanner.nextInt();
+                getLogger().info("\n-----------------------------\nSelect the category\n-----------------------------\nTo change the gender please enter 0");
+                int categoryMenuNumber = getInt();
                 Category category = categoryMenu.get(categoryMenuNumber);
                 if (category == null) {
                     break;
@@ -153,23 +161,25 @@ public class RetailStoreService extends Validate implements RetailStore, Product
                 boolean categoryBoolean = true;
                 while (categoryBoolean) {
                     Map<Integer, Product> productsByGenderAndCategory = getProductsByGenderAndCategory(gender, category);
-                    logger.info("Select the product\n To change the category please enter 0");
-                    int productMenuNumber = scanner.nextInt();
+                    getLogger().info("\n-----------------------------\nSelect the product\n-----------------------------\nTo change the category please enter 0");
+                    int productMenuNumber = getInt();
                     Product product = productsByGenderAndCategory.get(productMenuNumber);
                     if (product == null) {
                         break;
                     }
                     if (!addProductToCart(cart, product, connection)) {
-                        logger.info("Sorry to say this. Currently this product was out of stock.");
+                        getLogger().info("\n-----------------------------\nSorry to say this. Currently this product was out of stock.\n-----------------------------\n");
                         continue;
                     } else {
-                        logger.info("Your product : " + product.getName() + " is added to your cart.");
+                        getLogger().info("\n-----------------------------\nYour product : " + product.getName() + " is added to your cart.\n-----------------------------\n");
                     }
                     boolean menuFlag = true;
-                    logger.info("Please enter 1 - to continue the shopping \nPress 2 to place the order");
+                    getLogger().info("\n-----------------------------\nPlease enter 1 - to continue the shopping" +
+                            "\n-----------------------------\nEnter 2 to place the order" +
+                            "\n-----------------------------\nEnter 3 to go back");
                     while (menuFlag) {
-                        try {
-                            int order = scanner.nextInt();
+
+                        int order = getInt();
                         switch (order) {
                             case 1:
                                 categoryBoolean = false;
@@ -177,17 +187,21 @@ public class RetailStoreService extends Validate implements RetailStore, Product
                                 menuFlag = false;
                                 break;
                             case 2:
-                                    logger.info("Order Placed");
+                                categoryBoolean = false;
+                                genderBoolean = false;
+                                menuFlag = false;
+                                orderBoolean = false;
+                                break;
+                            case 3:
+                                cart = null;
                                 categoryBoolean = false;
                                 genderBoolean = false;
                                 menuFlag = false;
                                 orderBoolean = false;
                                 break;
                             default:
-                                    logger.info("Please enter valid option");
-                            }
-                        } catch (Exception e) {
-                            logger.info("Please enter valid option");
+                                getLogger().info("\n-----------------------------\nPlease enter valid option\n-----------------------------\n");
+                                createOrder(connection);
                         }
                     }
                 }
@@ -201,10 +215,10 @@ public class RetailStoreService extends Validate implements RetailStore, Product
         if (product.outOfStock()) {
             return false;
         }
-        logger.info(product.showSizes());
+        getLogger().info(product.showSizes());
         Size size = getSize(true, "Please Select Size");
-        logger.info("Please enter quantity required");
-        int quantity = getCount();
+        getLogger().info("\n-----------------------------\nPlease enter quantity required\n-----------------------------\n");
+        int quantity = getInt();
         int availableQuantity = product.getSize().get(size);
         if (quantity <= availableQuantity) {
             int remaining = availableQuantity - quantity;
@@ -214,13 +228,13 @@ public class RetailStoreService extends Validate implements RetailStore, Product
                 preparedStatement.setString(2, product.getId());
                 preparedStatement.executeUpdate();
             } catch (SQLException e) {
-                logger.info(e.getMessage());
-                logger.warning("Unable to add product to cart");
+                getLogger().warning("\n-----------------------------\nUnable to add product to cart\n-----------------------------\n");
+                getLogger().warning(e.getMessage());
                 return addProductToCart(cart, product, connection);
             }
             return cart.add(new OrderedProduct(product.getId(), product.getName(), product.getCategory(), product.getColor(), product.getPrice(), product.getIdealFor(), size, quantity));
         } else {
-            logger.warning("your requirement is out of our quantity.\n please enter quantity less or equal to the stock available");
+            getLogger().warning("\n-----------------------------\nplease enter quantity less or equal to the stock available\n-----------------------------\n");
             return addProductToCart(cart, product, connection);
         }
     }
@@ -238,15 +252,15 @@ public class RetailStoreService extends Validate implements RetailStore, Product
                 categoryMap.put(number.incrementAndGet(), Category.valueOf(resultSet.getString(1)));
             }
         } catch (SQLException e) {
-            logger.info(e.getMessage());
-            logger.info("got error while fetching the gender. please try again");
+            getLogger().warning(e.getMessage());
+            getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
             return getCategoriesByGender(gender);
         }
         if (categoryMap.isEmpty()) {
-            logger.info("Categories not found in " + gender);
+            getLogger().info("\n-----------------------------\nCategories not found in " + gender + "\n-----------------------------\n");
         } else {
             String menu = categoryMap.entrySet().stream().map(entry -> entry.getKey() + ". " + entry.getValue()).reduce("", (categories, category) -> categories + "\n" + category);
-            logger.info(menu);
+            getLogger().info(menu);
         }
         return categoryMap;
     }
@@ -267,15 +281,15 @@ public class RetailStoreService extends Validate implements RetailStore, Product
                 productMap.put(number.incrementAndGet(), product);
             }
         } catch (SQLException e) {
-            logger.info(e.getMessage());
-            logger.info("got error while fetching the gender. please try again");
+            getLogger().warning(e.getMessage());
+            getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
             return getProductsByGenderAndCategory(gender, category);
         }
         if (productMap.isEmpty()) {
-            logger.info("Products not found in " + category);
+            getLogger().info("\n-----------------------------\nProducts not found in " + category + "\n-----------------------------\n");
         } else {
             String menu = productMap.entrySet().stream().map(entry -> entry.getKey() + ". " + entry.getValue().productShowcaseInMenu()).reduce("", (products, product) -> products + "\n" + product);
-            logger.info(menu);
+            getLogger().info(menu);
         }
         return productMap;
     }
@@ -294,21 +308,75 @@ public class RetailStoreService extends Validate implements RetailStore, Product
                 colorMap.put(number.incrementAndGet(), Color.valueOf(resultSet.getString(1)));
             }
         } catch (SQLException e) {
-            logger.info(e.getMessage());
-            logger.info("got error while fetching the gender. please try again");
+            getLogger().warning(e.getMessage());
+            getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
             return getColorsByGenderAndCategory(gender, category);
         }
         if (colorMap.isEmpty()) {
-            logger.info("Colors not found in " + category + " for " + gender);
+            getLogger().info("\n-----------------------------\nColors not found in " + category + " for " + gender + "\n-----------------------------\n");
         } else {
             String menu = colorMap.entrySet().stream().map(entry -> entry.getKey() + ". " + entry.getValue()).reduce("", (colors, color) -> colors + "\n" + color);
-            logger.info(menu);
+            getLogger().info(menu);
         }
         return colorMap;
     }
 
     @Override
-    public Map<Integer, Product> getProductsByGenderAndColor(Collection<Product> productList, Color color) {
-        return null;
+    public void showOrders() {
+        boolean orderSelectFlag = true;
+        Connection connection = getConnection();
+        while (orderSelectFlag) {
+            Map<Integer, Order> orders = getOrders(connection);
+            String orderMenu = orders.entrySet().stream().map(entry -> entry.getKey() + ". " + entry.getValue().getOrderId() + "\t" + entry.getValue().getCustomerName()).reduce((allorders, order) -> allorders + "\n" + order).get();
+            getLogger().info(orderMenu);
+            getLogger().info("\n-----------------------------\nEnter 0 to go back.\n-----------------------------\n");
+            getLogger().info("\n-----------------------------\nSelect order from the above list\n-----------------------------\n");
+            int orderSelected = getInt();
+            if (orderSelected == 0) {
+                orderSelectFlag = false;
+                break;
+            }
+            Order order = orders.get(orderSelected);
+            if (order == null) {
+                getLogger().info("\n-----------------------------\nPlease select an order available in the list\n-----------------------------\n");
+                showOrders();
+            } else {
+                getLogger().info(order.showOrder());
+                getLogger().info("\n-----------------------------\nenter 1 to view products \n2 to see orders \nenter any keyword to exit");
+                int chooseProductList = getInt();
+                switch (chooseProductList) {
+                    case 1:
+                        getLogger().info(order.showProducts());
+                        break;
+                    case 2:
+                        continue;
+                    default:
+                        orderSelectFlag = false;
+                }
+            }
+        }
     }
+
+    public Map<Integer, Order> getOrders(Connection connection) {
+        Map<Integer, Order> ordersMenu = new LinkedHashMap<>();
+        List<OrderedProduct> orderedProductList = new ArrayList<>();
+        AtomicInteger number = new AtomicInteger(0);
+        try {
+            PreparedStatement preparedStatement = connection.prepareStatement("select * from orders order by date desc");
+            ResultSet resultSet = preparedStatement.executeQuery();
+            while (resultSet.next()) {
+                PreparedStatement innerPreparedStatement = connection.prepareStatement("select * from ordered_products where order_id = ?");
+                innerPreparedStatement.setString(1, resultSet.getString(1));
+                ResultSet innerResultSet = innerPreparedStatement.executeQuery();
+                while (innerResultSet.next()) {
+                    orderedProductList.add(new OrderedProduct(innerResultSet.getString(1), innerResultSet.getString(2), Category.valueOf(innerResultSet.getString(3)), Color.valueOf(innerResultSet.getString(4)), innerResultSet.getDouble(5), Gender.valueOf(innerResultSet.getString(6).toUpperCase()), Size.valueOf(innerResultSet.getString(7)), innerResultSet.getInt(8)));
+                }
+                ordersMenu.put(number.incrementAndGet(), new Order(resultSet.getString(1), resultSet.getDate(4).toLocalDate(), resultSet.getTime(5).toLocalTime(), resultSet.getString(2), resultSet.getString(3), resultSet.getDouble(6), orderedProductList));
+            }
+        } catch (Exception e) {
+            getLogger().warning(e.getMessage());
+        }
+        return ordersMenu;
+    }
+
 }
\ No newline at end of file

src/main/java/com/retail_store/order_management/utils/Database.java

@@ -4,9 +4,12 @@ import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.SQLException;
 
-public class Database {
+public final class Database {
     private static Connection connection;
 
+    private Database() {
+    }
+
     public static Connection getConnection() {
         String url = "jdbc:mysql://localhost:3306/gap";
         String userName = "root";

src/main/java/com/retail_store/order_management/utils/Utility.java

+package com.retail_store.order_management.utils;
+
+import com.retail_store.order_management.application.OrderManagement;
+import com.retail_store.order_management.constants.Category;
+import com.retail_store.order_management.constants.Color;
+import com.retail_store.order_management.constants.Gender;
+import com.retail_store.order_management.constants.Size;
+import com.retail_store.order_management.model.Order;
+import com.retail_store.order_management.service.RetailStore;
+
+import java.util.*;
+import java.util.logging.Logger;
+
+public final class Utility {
+    private static final Scanner SCANNER = null;
+    private static final Logger LOGGER = null;
+
+    private Utility() {
+    }
+
+    public static Category getCategory(boolean check, String message) {
+        String categoryOptions = Arrays.stream(Category.values()).filter(category -> !category.equals(Category.EXIT)).map(category -> "(" + category.getOption() + ")" + category).reduce((categories, category) -> categories + " " + category).get() + "\nPress 0 to go back.";
+        if (check) {
+            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
+        }
+        int option = getInt();
+        return Arrays.stream(Category.values()).filter(category -> category.getOption() == option).findFirst().orElseGet(() -> {
+            getLogger().info("\n------------------------\n+Please enter valid category\n------------------------\n" + categoryOptions + "\n------------------------\n");
+            return getCategory(false, message);
+        });
+    }
+
+    public static Size getSize(boolean check, String message) {
+        String categoryOptions = Arrays.stream(Size.values()).filter(size -> !size.equals(Size.EXIT)).map(size -> "(" + size.getOption() + ")" + size).reduce((sizes, size) -> sizes + " " + size).get() + "\nPress 0 to go back.";
+        if (check) {
+            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
+        }
+        int option = getInt();
+        return Arrays.stream(Size.values()).filter(size -> size.getOption() == option).findFirst().orElseGet(() -> {
+            getLogger().info("\n------------------------\nPlease enter valid category\n------------------------\n" + categoryOptions + "\n------------------------\n");
+            return getSize(false, message);
+        });
+    }
+
+    public static Gender getGender(boolean check, String message) {
+        String genderOptions = Arrays.stream(Gender.values()).filter(gender -> !gender.equals(Gender.EXIT)).map(gender -> "(" + gender.getOption() + ")" + gender).reduce((genders, gender) -> genders + " " + gender).get() + "\nPress 0 to go back.";
+        if (check) {
+            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + genderOptions + "\n------------------------\n");
+        }
+        int option = getInt();
+        return Arrays.stream(Gender.values()).filter(gender -> gender.getOption() == option).findFirst().orElseGet(() -> {
+            getLogger().info("\n------------------------\nPlease enter valid gender\n------------------------\n" + genderOptions + "\n------------------------\n");
+            return getGender(false, message);
+        });
+    }
+
+    public static Color getColor(boolean check, String message) {
+        String colorOptions = Arrays.stream(Color.values()).filter(color -> !color.equals(Color.EXIT)).map(color -> "(" + color.getOption() + ")" + color).reduce((categories, category) -> categories + " " + category).get() + "\nPress 0 to go back.";
+        if (check) {
+            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + colorOptions + "\n------------------------\n");
+        }
+        int option = getInt();
+        return Arrays.stream(Color.values()).filter(color -> color.getOption() == option).findFirst().orElseGet(() -> {
+            getLogger().info("\n------------------------\n+Please enter valid color\n------------------------\n" + colorOptions + "\n------------------------\n");
+            return getColor(false, message);
+        });
+    }
+
+    public static double getDouble(boolean flag, String message) {
+        double number;
+        Scanner scanner = new Scanner(System.in);
+        if (flag) {
+            getLogger().info(message);
+        }
+        try {
+            number = scanner.nextDouble();
+            if (number < 0) {
+                throw new RuntimeException();
+            }
+            return number;
+        } catch (InputMismatchException e) {
+            getLogger().warning("\n------------------------\nPlease enter valid price\n------------------------\n");
+            scanner.reset();
+            return getDouble(false, message);
+        }
+    }
+
+    public static int getInt() {
+        int number;
+        Scanner scanner = new Scanner(System.in);
+        try {
+            number = scanner.nextInt();
+            if (number < 0) {
+                throw new RuntimeException();
+            }
+            return number;
+        } catch (Exception e) {
+            getLogger().warning("\n------------------------\nPlease enter valid number\n------------------------\n");
+            scanner.reset();
+            return getInt();
+        }
+    }
+
+    public static Logger getLogger() {
+        return LOGGER == null ? Logger.getLogger(OrderManagement.class.getName()) : LOGGER;
+    }
+
+    public static Scanner getScanner() {
+        return SCANNER == null ? new Scanner(System.in) : SCANNER;
+    }
+
+    public static LinkedHashMap<Size, Integer> getProductSizes() {
+        LinkedHashMap<Size, Integer> productSizes = new LinkedHashMap<>();
+        getLogger().info("Please enter the available stock for particular sizes \n Number of products with size S");
+        productSizes.put(Size.S, getInt());
+        getLogger().info("Number of products with size M");
+        productSizes.put(Size.M, getInt());
+        getLogger().info("Number of products with size L");
+        productSizes.put(Size.L, getInt());
+        getLogger().info("Number of products with size XL");
+        productSizes.put(Size.XL, getInt());
+        getLogger().info("Number of products with size XXL");
+        productSizes.put(Size.XXL, getInt());
+        return productSizes;
+    }
+
+    public static Map<Size, Integer> getProductSizes(int s, int m, int l, int xl, int xxl) {
+        LinkedHashMap<Size, Integer> productSizes = new LinkedHashMap<>();
+        productSizes.put(Size.S, s);
+        productSizes.put(Size.M, m);
+        productSizes.put(Size.L, l);
+        productSizes.put(Size.XL, xl);
+        productSizes.put(Size.XXL, xxl);
+        return productSizes;
+    }
+
+    public static String productIdGenerator() {
+        return Arrays.stream(UUID.randomUUID().toString().split("-")).skip(1).findFirst().get() + "#" + RetailStore.class.getSimpleName();
+    }
+
+    public static String orderIdGenerator() {
+        return Arrays.stream(UUID.randomUUID().toString().split("-")).findFirst().get() + "#" + Order.class.getSimpleName();
+    }
+}
\ No newline at end of file

src/main/java/com/retail_store/order_management/utils/Validate.java

-package com.retail_store.order_management.utils;
-
-import com.retail_store.order_management.constants.Category;
-import com.retail_store.order_management.constants.Color;
-import com.retail_store.order_management.constants.Gender;
-import com.retail_store.order_management.constants.Size;
-import com.retail_store.order_management.model.Order;
-import com.retail_store.order_management.service.RetailStore;
-
-import java.util.*;
-import java.util.logging.Logger;
-
-public class Validate {
-    protected Logger logger;
-    protected Scanner scanner;
-
-    public Category getCategory(boolean check, String message) {
-        String categoryOptions = Arrays.stream(Category.values()).map(category -> category + "(" + category.getOption() + ")").reduce((categories, category) -> categories + " " + category).get();
-        if (check) {
-            logger.info(message + "\n" + categoryOptions);
-        }
-        try {
-            int option = scanner.nextInt();
-            return Arrays.stream(Category.values()).filter(category -> category.getOption() == option).findFirst().orElseGet(() -> {
-                logger.info("Please enter valid category\n" + categoryOptions);
-                return getCategory(false, message);
-            });
-        } catch (InputMismatchException e) {
-            logger.info("Please enter valid category\n" + categoryOptions);
-            scanner.reset();
-            return getCategory(false, message);
-        } catch (Exception e) {
-            logger.info(e.getMessage());
-            scanner.reset();
-            return getCategory(false, message);
-        }
-    }
-
-    public Size getSize(boolean check, String message) {
-        String categoryOptions = Arrays.stream(Size.values()).map(size -> size + "(" + size.getOption() + ")").reduce((sizes, size) -> sizes + " " + size).get();
-        if (check) {
-            logger.info(message + "\n" + categoryOptions);
-        }
-        try {
-            int option = scanner.nextInt();
-            return Arrays.stream(Size.values()).filter(size -> size.getOption() == option).findFirst().orElseGet(() -> {
-                logger.info("Please enter valid category\n" + categoryOptions);
-                return getSize(false, message);
-            });
-        } catch (InputMismatchException e) {
-            logger.info("Please enter valid category\n" + categoryOptions);
-            scanner.reset();
-            return getSize(false, message);
-        } catch (Exception e) {
-            logger.info(e.getMessage());
-            scanner.reset();
-            return getSize(false, message);
-        }
-    }
-
-    public Gender getGender(boolean check, String message) {
-        String genderOptions = Arrays.stream(Gender.values()).map(category -> category + "(" + category.getOption() + ")").reduce((categories, category) -> categories + " " + category).get();
-        if (check) {
-            logger.info(message + "\n" + genderOptions);
-        }
-        try {
-            int option = scanner.nextInt();
-            return Arrays.stream(Gender.values()).filter(gender -> gender.getOption() == option).findFirst().orElseGet(() -> {
-                logger.info("Please enter valid gender\n" + genderOptions);
-                return getGender(false, message);
-            });
-        } catch (InputMismatchException e) {
-            logger.info("Please enter valid gender\n" + genderOptions);
-            scanner.reset();
-            return getGender(false, message);
-        } catch (Exception e) {
-            logger.warning(e.getMessage());
-            scanner.reset();
-            return getGender(false, message);
-        }
-    }
-
-
-    public Color getColor(boolean check, String message) {
-        String colorOptions = Arrays.stream(Color.values()).map(category -> category + "(" + category.getOption() + ")").reduce((categories, category) -> categories + " " + category).get();
-        if (check) {
-            logger.info(message + "\n" + colorOptions);
-        }
-        try {
-            int option = scanner.nextInt();
-            return Arrays.stream(Color.values()).filter(color -> color.getOption() == option).findFirst().orElseGet(() -> {
-                logger.info("Please enter valid color\n" + colorOptions);
-                return getColor(false, message);
-            });
-        } catch (InputMismatchException e) {
-            logger.info("Please enter valid color\n" + colorOptions);
-            scanner.reset();
-            return getColor(false, message);
-        } catch (Exception e) {
-            logger.info(e.getMessage());
-            scanner.reset();
-            return getColor(false, message);
-        }
-    }
-
-    public double getPrice(boolean flag) {
-        if (flag) {
-            logger.info("Enter price for the product");
-        }
-        try {
-            return scanner.nextDouble();
-        } catch (InputMismatchException e) {
-            logger.warning("Please enter valid price");
-            scanner.reset();
-            return getPrice(false);
-        }
-    }
-
-    public int getCount() {
-        int count;
-        try {
-            count = scanner.nextInt();
-            if (count < 0) {
-                throw new RuntimeException();
-            }
-            return count;
-        } catch (Exception e) {
-            logger.warning("Please enter valid number");
-            scanner.reset();
-            return getCount();
-        }
-    }
-
-    public LinkedHashMap<Size, Integer> getProductSizes() {
-        LinkedHashMap<Size, Integer> productSizes = new LinkedHashMap<>();
-        logger.info("Please enter the available stock for particular sizes \n Number of products with size S");
-        productSizes.put(Size.S, getCount());
-        logger.info("Number of products with size M");
-        productSizes.put(Size.M, getCount());
-        logger.info("Number of products with size L");
-        productSizes.put(Size.L, getCount());
-        logger.info("Number of products with size XL");
-        productSizes.put(Size.XL, getCount());
-        logger.info("Number of products with size XXL");
-        productSizes.put(Size.XXL, getCount());
-        return productSizes;
-    }
-
-    public Map<Size, Integer> getProductSizes(int s, int m, int l, int xl, int xxl) {
-        LinkedHashMap<Size, Integer> productSizes = new LinkedHashMap<>();
-        productSizes.put(Size.S, s);
-        productSizes.put(Size.M, m);
-        productSizes.put(Size.L, l);
-        productSizes.put(Size.XL, xl);
-        productSizes.put(Size.XXL, xxl);
-        return productSizes;
-    }
-
-    public String productIdGenerator() {
-        return Arrays.stream(UUID.randomUUID().toString().split("-")).skip(1).findFirst().get() + "#" + RetailStore.class.getSimpleName();
-    }
-
-    public String orderIdGenerator() {
-        return Arrays.stream(UUID.randomUUID().toString().split("-")).findFirst().get() + "#" + Order.class.getSimpleName();
-    }
-}
\ No newline at end of file