Skip to content

O
Order Management for Retail Store
Commit f39a3a0a authored by Bhargava Rellu's avatar Bhargava Rellu
Browse files
Options

Orders module

parent 1e8b4ec2
Show whitespace changes
Inline Side-by-side
Showing with 389 additions and 316 deletions
.idea/gradle.xml
View file @ f39a3a0a
<?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
View file @ f39a3a0a
......@@ -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
View file @ f39a3a0a
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
View file @ f39a3a0a
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
View file @ f39a3a0a
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
View file @ f39a3a0a
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
View file @ f39a3a0a
......@@ -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
View file @ f39a3a0a
......@@ -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
View file @ f39a3a0a
......@@ -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
View file @ f39a3a0a
......@@ -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
View file @ f39a3a0a
......@@ -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
View file @ f39a3a0a
......@@ -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 0 → 100644
View file @ f39a3a0a
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 deleted 100644 → 0
View file @ 1e8b4ec2
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
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment