Skip to content

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

Changes according to the review comments, 

Added test cases.
parent e3fd38fc
Hide whitespace changes
Inline Side-by-side
Showing with 302 additions and 132 deletions
src/main/java/com/retail_store/order_management/application/OrderManagement.java → src/main/java/com/retailstore/ordermanagement/application/OrderManagement.java
View file @ 4abed227
......@@ -31,14 +31,22 @@ public class OrderManagement {
* functionality regarding the selected option in the console.
*/
public void menu() {
String option1 = "1. Add product to your stock";
String option2 = "2. Order Product";
String option3 = "3. Get order details";
String option4 = "4. Exit";
String toExit = "To exit please enter 4";
String toAddMore = "To Add more enter 1";
String enterForMenu = "Please enter 5 for menu";
boolean flag = true;
logger.info("Welcome to RetailStore 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";
option1 + "\n------------------------\n" +
option2 + "\n------------------------\n" +
option3 + "\n------------------------\n" +
option4;
logger.info(menu);
while (flag) {
int menuOption;
......
src/main/java/com/retail_store/order_management/model/Order.java → src/main/java/com/retailstore/ordermanagement/model/Order.java
View file @ 4abed227
package com.retail_store.order_management.model;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import java.time.LocalDate;
......@@ -13,6 +14,7 @@ import java.util.List;
*/
@Getter
@AllArgsConstructor
@Builder
public class Order {
private String orderId;
private LocalDate orderDate;
......
src/main/java/com/retail_store/order_management/service/ProductFilter.java → src/main/java/com/retailstore/ordermanagement/service/ProductService.java
View file @ 4abed227
package com.retail_store.order_management.service;
package com.retailstore.ordermanagement.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 com.retailstore.ordermanagement.constants.Category;
import com.retailstore.ordermanagement.constants.Color;
import com.retailstore.ordermanagement.constants.Gender;
import com.retailstore.ordermanagement.model.Order;
import com.retailstore.ordermanagement.model.Product;
import java.sql.Connection;
import java.util.Map;
......
src/main/java/com/retail_store/order_management/service/RetailStore.java → src/main/java/com/retailstore/ordermanagement/service/RetailStoreService.java
View file @ 4abed227
package com.retail_store.order_management.service;
package com.retailstore.ordermanagement.service;
import com.retail_store.order_management.model.OrderedProduct;
import com.retail_store.order_management.model.Product;
import com.retailstore.ordermanagement.model.OrderedProduct;
import com.retailstore.ordermanagement.model.Product;
import java.sql.Connection;
import java.util.Collection;
......
src/main/java/com/retail_store/order_management/service/RetailStoreService.java → src/main/java/com/retailstore/ordermanagement/service/RetailStoreServiceImpl.java
View file @ 4abed227
package com.retail_store.order_management.service;
package com.retailstore.ordermanagement.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.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.retailstore.ordermanagement.constants.Category;
import com.retailstore.ordermanagement.constants.Color;
import com.retailstore.ordermanagement.constants.Gender;
import com.retailstore.ordermanagement.constants.Size;
import com.retailstore.ordermanagement.model.Order;
import com.retailstore.ordermanagement.model.OrderedProduct;
import com.retailstore.ordermanagement.model.Product;
import com.retailstore.ordermanagement.utils.Database;
import com.retailstore.ordermanagement.utils.Utility;
import java.sql.Date;
import java.sql.*;
......@@ -15,9 +17,6 @@ import java.time.LocalTime;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import static com.retail_store.order_management.utils.Database.getConnection;
import static com.retail_store.order_management.utils.Utility.*;
/**
* Class RetailStoreService
* This class implements from previous interfaces RetailStore and ProductFilter so
......@@ -27,24 +26,24 @@ public class RetailStoreService implements RetailStore, ProductFilter {
public boolean addProducts() {
boolean productAdded = false;
String id = productIdGenerator();
getLogger().info("Enter Product details \n Enter Product Name");
String name = getScanner().nextLine();
Category category = getCategory(true, "Enter Product Category");
String id = Utility.productIdGenerator();
Utility.getLogger().info("Enter Product details \n Enter Product Name");
String name = Utility.getScanner().nextLine();
Category category = Utility.getCategory(true, "Enter Product Category");
if (category == null) {
return false;
}
Color color = getColor(true, "Select color of the product");
Color color = Utility.getColor(true, "Select color of the product");
if (category == null) {
return false;
}
Gender gender = getGender(true, "Product is ideal for");
Gender gender = Utility.getGender(true, "Product is ideal for");
if (category == null) {
return false;
}
double price = getDouble(true, "Enter price of the product");
Map<Size, Integer> size = getProductSizes();
Connection connection = getConnection();
double price = Utility.getDouble(true, "Enter price of the product");
Map<Size, Integer> size = Utility.getProductSizes();
Connection connection = Database.getConnection();
try {
PreparedStatement preparedStatement = connection.prepareStatement("insert into products values(?,?,?,?,?,?,?,?,?,?,?)");
preparedStatement.setString(1, id);
......@@ -60,22 +59,22 @@ public class RetailStoreService implements RetailStore, ProductFilter {
preparedStatement.setInt(11, size.get(Size.XXL));
productAdded = preparedStatement.executeUpdate() > 0;
if (productAdded) {
getLogger().info("Your product with name : " + name + " is added successfully");
Utility.getLogger().info("Your product with name : " + name + " is added successfully");
} else {
getLogger().info("Your product is not added successfully");
Utility.getLogger().info("Your product is not added successfully");
productAdded = addProducts();
}
} catch (SQLException e) {
getScanner().reset();
getLogger().warning(e.getMessage());
getLogger().warning("Your product is not added successfully");
Utility.getScanner().reset();
Utility.getLogger().warning(e.getMessage());
Utility.getLogger().warning("Your product is not added successfully");
productAdded = addProducts();
}
return productAdded;
}
public boolean placeOrders() {
Connection connection = getConnection();
Connection connection = Database.getConnection();
int confirmOrder;
String orderMessage;
try {
......@@ -83,20 +82,20 @@ public class RetailStoreService implements RetailStore, ProductFilter {
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();
Utility.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 = Utility.getInt();
if (option == 1) {
return placeOrders();
} else {
getScanner().reset();
Utility.getScanner().reset();
return false;
}
}
String orderId = orderIdGenerator();
getLogger().info("Please enter Customer name");
String name = getScanner().nextLine();
getLogger().info("Please enter Phone number");
String phone = phoneNumberValidator();
String orderId = Utility.orderIdGenerator();
Utility.getLogger().info("Please enter Customer name");
String name = Utility.getScanner().nextLine();
Utility.getLogger().info("Please enter Phone number");
String phone = Utility.phoneNumberValidator();
Date date = Date.valueOf(LocalDate.now());
Time time = Time.valueOf(LocalTime.now());
double bill = orderedProductList.stream().map(product -> product.getPrice() * product.getQuantity()).reduce(0.00, (totalBill, productBill) -> totalBill + productBill);
......@@ -124,25 +123,25 @@ public class RetailStoreService implements RetailStore, ProductFilter {
}
preparedStatement.executeBatch();
}
getLogger().info("to confirm the order enter 1\n to cancel enter any number");
confirmOrder = getScanner().nextInt();
Utility.getLogger().info("to confirm the order enter 1\n to cancel enter any number");
confirmOrder = Utility.getScanner().nextInt();
switch (confirmOrder) {
case 1:
getLogger().info("Your order is successfully placed.");
getLogger().info(orderMessage);
Utility.getLogger().info("Your order is successfully placed.");
Utility.getLogger().info(orderMessage);
connection.commit();
break;
default:
getLogger().info("Your order is not confirmed");
Utility.getLogger().info("Your order is not confirmed");
connection.rollback();
}
return true;
} catch (Exception e) {
getLogger().warning(e.getMessage());
Utility.getLogger().warning(e.getMessage());
try {
connection.rollback();
} catch (Exception ex) {
getLogger().warning(ex.getMessage());
Utility.getLogger().warning(ex.getMessage());
}
return true;
}
......@@ -153,8 +152,8 @@ public class RetailStoreService implements RetailStore, ProductFilter {
List<OrderedProduct> cart = new ArrayList<>();
boolean orderBoolean = true;
while (orderBoolean) {
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...");
Utility.getLogger().info("********************GAP********************* " + "\n \t (1) Men \t \t \t \t (2) Women\n-----------------------------\nto exit enter 0\n-----------------------------\n");
Gender gender = Utility.getGender(false, "Please select...");
if (gender == Gender.EXIT) {
cart = null;
break;
......@@ -162,8 +161,8 @@ public class RetailStoreService implements RetailStore, ProductFilter {
boolean genderBoolean = true;
while (genderBoolean) {
Map<Integer, Category> categoryMenu = getCategoriesByGender(gender);
getLogger().info("\n-----------------------------\nSelect the category\n-----------------------------\nTo change the gender please enter 0");
int categoryMenuNumber = getInt();
Utility.getLogger().info("\n-----------------------------\nSelect the category\n-----------------------------\nTo change the gender please enter 0");
int categoryMenuNumber = Utility.getInt();
Category category = categoryMenu.get(categoryMenuNumber);
if (category == null) {
break;
......@@ -171,8 +170,8 @@ public class RetailStoreService implements RetailStore, ProductFilter {
boolean categoryBoolean = true;
while (categoryBoolean) {
Map<Integer, Product> productsByGenderAndCategory = getProductsByGenderAndCategory(gender, category);
getLogger().info("\n-----------------------------\nSelect the product\n-----------------------------\nTo change the category please enter 0");
int productMenuNumber = getInt();
Utility.getLogger().info("\n-----------------------------\nSelect the product\n-----------------------------\nTo change the category please enter 0");
int productMenuNumber = Utility.getInt();
Product product = productsByGenderAndCategory.get(productMenuNumber);
if (product == null) {
break;
......@@ -180,14 +179,14 @@ public class RetailStoreService implements RetailStore, ProductFilter {
if (!addProductToCart(cart, product, connection)) {
continue;
} else {
getLogger().info("\n-----------------------------\nYour product : " + product.getName() + " is added to your cart.\n-----------------------------\n");
Utility.getLogger().info("\n-----------------------------\nYour product : " + product.getName() + " is added to your cart.\n-----------------------------\n");
}
boolean menuFlag = true;
getLogger().info("\n-----------------------------\nPlease enter 1 - to continue the shopping" +
Utility.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) {
int order = getInt();
int order = Utility.getInt();
switch (order) {
case 1:
categoryBoolean = false;
......@@ -208,7 +207,7 @@ public class RetailStoreService implements RetailStore, ProductFilter {
orderBoolean = false;
break;
default:
getLogger().info("\n-----------------------------\nPlease enter valid option\n-----------------------------\n");
Utility.getLogger().info("\n-----------------------------\nPlease enter valid option\n-----------------------------\n");
createOrder(connection);
}
}
......@@ -221,18 +220,18 @@ public class RetailStoreService implements RetailStore, ProductFilter {
@Override
public synchronized boolean addProductToCart(Collection<OrderedProduct> cart, Product product, Connection connection) {
if (product.outOfStock()) {
getLogger().info("\n-----------------------------\nSorry to say this. Currently this product was out of stock.\n-----------------------------\n");
Utility.getLogger().info("\n-----------------------------\nSorry to say this. Currently this product was out of stock.\n-----------------------------\n");
return false;
}
getLogger().info(product.showSizes());
Size size = getSize(true, "Please Select Size");
Utility.getLogger().info(product.showSizes());
Size size = Utility.getSize(true, "Please Select Size");
if (size == null) {
return false;
}
getLogger().info("\n-----------------------------\nPlease enter quantity required\n-----------------------------\n");
int quantity = getInt();
Utility.getLogger().info("\n-----------------------------\nPlease enter quantity required\n-----------------------------\n");
int quantity = Utility.getInt();
if (quantity <= 0) {
getLogger().info("\n-----------------------------\nPlease enter atleast 1 quantity.\n-----------------------------\n");
Utility.getLogger().info("\n-----------------------------\nPlease enter atleast 1 quantity.\n-----------------------------\n");
return false;
}
int availableQuantity = product.getSize().get(size);
......@@ -244,22 +243,22 @@ public class RetailStoreService implements RetailStore, ProductFilter {
preparedStatement.setString(2, product.getId());
preparedStatement.executeUpdate();
} catch (SQLException e) {
getLogger().warning("\n-----------------------------\nUnable to add product to cart\n-----------------------------\n");
getLogger().warning(e.getMessage());
Utility.getLogger().warning("\n-----------------------------\nUnable to add product to cart\n-----------------------------\n");
Utility.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 {
getLogger().warning("\n-----------------------------\nplease enter quantity less or equal to the stock available\n-----------------------------\n");
Utility.getLogger().warning("\n-----------------------------\nplease enter quantity less or equal to the stock available\n-----------------------------\n");
return addProductToCart(cart, product, connection);
}
}
@Override
public Map<Integer, Category> getCategoriesByGender(Gender gender) {
Map<Integer, Category> categoryMap = new LinkedHashMap<>();
public LinkedHashMap<Integer, Category> getCategoriesByGender(Gender gender) {
LinkedHashMap<Integer, Category> categoryMap = new LinkedHashMap<>();
AtomicInteger number = new AtomicInteger(0);
Connection connection = getConnection();
Connection connection = Database.getConnection();
try {
PreparedStatement preparedStatement = connection.prepareStatement("select category from gap.products where gender=? group by category");
preparedStatement.setString(1, gender.getGender());
......@@ -268,15 +267,15 @@ public class RetailStoreService implements RetailStore, ProductFilter {
categoryMap.put(number.incrementAndGet(), Category.valueOf(resultSet.getString(1)));
}
} catch (SQLException e) {
getLogger().warning(e.getMessage());
getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
Utility.getLogger().warning(e.getMessage());
Utility.getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
return getCategoriesByGender(gender);
}
if (categoryMap.isEmpty()) {
getLogger().info("\n-----------------------------\nCategories not found in " + gender + "\n-----------------------------\n");
Utility.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);
getLogger().info(menu);
Utility.getLogger().info(menu);
}
return categoryMap;
}
......@@ -285,7 +284,7 @@ public class RetailStoreService implements RetailStore, ProductFilter {
public Map<Integer, Product> getProductsByGenderAndCategory(Gender gender, Category category) {
Map<Integer, Product> productMap = new LinkedHashMap<>();
AtomicInteger number = new AtomicInteger(0);
Connection connection = getConnection();
Connection connection = Database.getConnection();
try {
PreparedStatement preparedStatement = connection.prepareStatement("select * from gap.products where gender=? and category =?");
preparedStatement.setString(1, gender.getGender());
......@@ -293,19 +292,19 @@ public class RetailStoreService implements RetailStore, ProductFilter {
ResultSet resultSet = preparedStatement.executeQuery();
ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
while (resultSet.next()) {
Product product = new Product(resultSet.getString(1), resultSet.getString(2), Category.valueOf(resultSet.getString(3)), Color.valueOf(resultSet.getString(4)), resultSet.getDouble(5), Gender.valueOf(resultSet.getString(6).toUpperCase()), getProductSizes(resultSet.getInt(7), resultSet.getInt(8), resultSet.getInt(9), resultSet.getInt(10), resultSet.getInt(11)));
Product product = new Product(resultSet.getString(1), resultSet.getString(2), Category.valueOf(resultSet.getString(3)), Color.valueOf(resultSet.getString(4)), resultSet.getDouble(5), Gender.valueOf(resultSet.getString(6).toUpperCase()), Utility.getProductSizes(resultSet.getInt(7), resultSet.getInt(8), resultSet.getInt(9), resultSet.getInt(10), resultSet.getInt(11)));
productMap.put(number.incrementAndGet(), product);
}
} catch (SQLException e) {
getLogger().warning(e.getMessage());
getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
Utility.getLogger().warning(e.getMessage());
Utility.getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
return getProductsByGenderAndCategory(gender, category);
}
if (productMap.isEmpty()) {
getLogger().info("\n-----------------------------\nProducts not found in " + category + "\n-----------------------------\n");
Utility.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);
getLogger().info(menu);
Utility.getLogger().info(menu);
}
return productMap;
}
......@@ -314,7 +313,7 @@ public class RetailStoreService implements RetailStore, ProductFilter {
public Map<Integer, Color> getColorsByGenderAndCategory(Gender gender, Category category) {
Map<Integer, Color> colorMap = new LinkedHashMap<>();
AtomicInteger number = new AtomicInteger(0);
Connection connection = getConnection();
Connection connection = Database.getConnection();
try {
PreparedStatement preparedStatement = connection.prepareStatement("select color from gap.products where gender=? and category=? group by color");
preparedStatement.setString(1, gender.getGender());
......@@ -324,15 +323,15 @@ public class RetailStoreService implements RetailStore, ProductFilter {
colorMap.put(number.incrementAndGet(), Color.valueOf(resultSet.getString(1)));
}
} catch (SQLException e) {
getLogger().warning(e.getMessage());
getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
Utility.getLogger().warning(e.getMessage());
Utility.getLogger().warning("\n-----------------------------\ngot error while fetching the gender. please try again\n-----------------------------\n");
return getColorsByGenderAndCategory(gender, category);
}
if (colorMap.isEmpty()) {
getLogger().info("\n-----------------------------\nColors not found in " + category + " for " + gender + "\n-----------------------------\n");
Utility.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);
getLogger().info(menu);
Utility.getLogger().info(menu);
}
return colorMap;
}
......@@ -340,29 +339,29 @@ public class RetailStoreService implements RetailStore, ProductFilter {
@Override
public void showOrders() {
boolean orderSelectFlag = true;
Connection connection = getConnection();
Connection connection = Database.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).orElse("\n----------\nNo orders currently in your orders list");
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();
Utility.getLogger().info(orderMenu);
Utility.getLogger().info("\n-----------------------------\nEnter 0 to go back.\n-----------------------------\n");
Utility.getLogger().info("\n-----------------------------\nSelect order from the above list\n-----------------------------\n");
int orderSelected = Utility.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");
Utility.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();
Utility.getLogger().info(order.showOrder());
Utility.getLogger().info("\n-----------------------------\nenter 1 to view products \n2 to see orders \nenter any keyword to exit");
int chooseProductList = Utility.getInt();
switch (chooseProductList) {
case 1:
getLogger().info("\n-----------------------------\n" + order.showProducts() + "\n-----------------------------\n");
Utility.getLogger().info("\n-----------------------------\n" + order.showProducts() + "\n-----------------------------\n");
break;
case 2:
continue;
......@@ -391,7 +390,7 @@ public class RetailStoreService implements RetailStore, ProductFilter {
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());
Utility.getLogger().warning(e.getMessage());
}
return ordersMenu;
}
......
src/main/java/com/retail_store/order_management/utils/Database.java → src/main/java/com/retailstore/ordermanagement/utils/DBUtil.java
View file @ 4abed227
package com.retail_store.order_management.utils;
package com.retailstore.ordermanagement.utils;
import java.sql.Connection;
import java.sql.DriverManager;
......
src/main/java/com/retail_store/order_management/utils/Utility.java → src/main/java/com/retailstore/ordermanagement/utils/InputUtil.java
View file @ 4abed227
package com.retail_store.order_management.utils;
package com.retailstore.ordermanagement.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 com.retailstore.ordermanagement.application.OrderManagement;
import com.retailstore.ordermanagement.constants.Category;
import com.retailstore.ordermanagement.constants.Color;
import com.retailstore.ordermanagement.constants.Gender;
import com.retailstore.ordermanagement.constants.Size;
import com.retailstore.ordermanagement.model.Order;
import com.retailstore.ordermanagement.service.RetailStoreService;
import java.util.*;
import java.util.logging.Logger;
......@@ -17,7 +17,7 @@ import java.util.logging.Logger;
* Class used to import the values of the option given in the console and print accordingly
* of the required choice chosen
*/
public final class Utility {
public class Utility {
private static final Scanner SCANNER = null;
private static final Logger LOGGER = null;
......@@ -40,7 +40,7 @@ public final class Utility {
if (check) {
getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
}
int option = getInt();
int option = validateInputNumber();
categoryValue = 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);
......@@ -61,7 +61,7 @@ public final class Utility {
if (check) {
getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
}
int option = getInt();
int option = validateInputNumber();
sizeValue = 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);
......@@ -82,7 +82,7 @@ public final class Utility {
if (check) {
getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + genderOptions + "\n------------------------\n");
}
int option = getInt();
int option = validateInputNumber();
genderValue = 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);
......@@ -103,7 +103,7 @@ public final class Utility {
if (check) {
getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + colorOptions + "\n------------------------\n");
}
int option = getInt();
int option = validateInputNumber();
colorValue = 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);
......@@ -119,7 +119,7 @@ public final class Utility {
* @param message
* @return double
*/
public static double getDouble(boolean flag, String message) {
public static double validateInputPrice(boolean flag, String message) {
double number;
Scanner scanner = new Scanner(System.in);
if (flag) {
......@@ -134,7 +134,7 @@ public final class Utility {
} catch (InputMismatchException e) {
getLogger().warning("\n------------------------\nPlease enter valid price\n------------------------\n");
scanner.reset();
return getDouble(false, message);
return validateInputPrice(false, message);
}
}
......@@ -144,19 +144,19 @@ public final class Utility {
*
* @return int
*/
public static int getInt() {
public static int validateInputNumber() {
int number;
Scanner scanner = new Scanner(System.in);
try {
number = scanner.nextInt();
if (number < 0) {
throw new RuntimeException();
throw new RuntimeException("Number cannot be negative");
}
return number;
} catch (Exception e) {
getLogger().warning("\n------------------------\nPlease enter valid number\n------------------------\n");
getLogger().warning(e.getMessage() + "\n------------------------\nPlease enter valid number\n------------------------\n");
scanner.reset();
return getInt();
return validateInputNumber();
}
}
......@@ -178,7 +178,7 @@ public final class Utility {
getLogger().warning("Please enter valid phone number");
return phoneNumberValidator();
}
return phoneNumber.toString();
return phoneNumber;
}
/**
......@@ -206,18 +206,18 @@ public final class Utility {
*
* @return integer according to key type size
*/
public static LinkedHashMap<Size, Integer> getProductSizes() {
LinkedHashMap<Size, Integer> productSizes = new LinkedHashMap<>();
public static Map<Size, Integer> getProductSizes() {
Map<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());
productSizes.put(Size.S, validateInputNumber());
getLogger().info("Number of products with size M");
productSizes.put(Size.M, getInt());
productSizes.put(Size.M, validateInputNumber());
getLogger().info("Number of products with size L");
productSizes.put(Size.L, getInt());
productSizes.put(Size.L, validateInputNumber());
getLogger().info("Number of products with size XL");
productSizes.put(Size.XL, getInt());
productSizes.put(Size.XL, validateInputNumber());
getLogger().info("Number of products with size XXL");
productSizes.put(Size.XXL, getInt());
productSizes.put(Size.XXL, validateInputNumber());
return productSizes;
}
......@@ -233,7 +233,7 @@ public final class Utility {
* @return integer according to key type size
*/
public static Map<Size, Integer> getProductSizes(int s, int m, int l, int xl, int xxl) {
LinkedHashMap<Size, Integer> productSizes = new LinkedHashMap<>();
Map<Size, Integer> productSizes = new LinkedHashMap<>();
productSizes.put(Size.S, s);
productSizes.put(Size.M, m);
productSizes.put(Size.L, l);
......@@ -249,7 +249,7 @@ public final class Utility {
* @return string
*/
public static String productIdGenerator() {
return Arrays.stream(UUID.randomUUID().toString().split("-")).skip(1).findFirst().get() + "#" + RetailStore.class.getSimpleName();
return Arrays.stream(UUID.randomUUID().toString().split("-")).skip(1).findFirst().get() + "#" + RetailStoreService.class.getSimpleName();
}
/**
......
src/test/java/com/retailstore/ordermanagement/service/ProductServiceTest.java 0 → 100644
View file @ 4abed227
package com.retailstore.ordermanagement.service;
import com.retailstore.ordermanagement.constants.Category;
import com.retailstore.ordermanagement.constants.Color;
import com.retailstore.ordermanagement.constants.Gender;
import com.retailstore.ordermanagement.model.Order;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import java.sql.Connection;
import java.util.*;
import java.util.stream.Collectors;
class ProductFilterTest {
@Mock
Connection connection;
RetailStoreService service;
@BeforeEach
void createretailsStoreObject() {
service = new RetailStoreService();
}
@AfterEach
void removeretailsStoreObject() {
service = null;
}
@Test
void getCategoriesByGenderTest() {
Map<Integer, Category> categoryMap = new HashMap<>();
categoryMap.put(1, Category.SWEATSHIRTS);
categoryMap.put(2, Category.T_SHIRTS);
categoryMap.put(3, Category.SHIRTS);
categoryMap.put(4, Category.SHORTS);
categoryMap.put(5, Category.HOODIES);
categoryMap.put(6, Category.PANTS);
categoryMap.put(7, Category.JEANS);
categoryMap.put(8, Category.POLOS);
Assertions.assertEquals(categoryMap, service.getCategoriesByGender(Gender.MEN));
}
@Test
void getProductsByGenderAndCategoryTest() {
List<String> productsList = new ArrayList<>();
productsList.add("14e0#Gap");
productsList.add("86f0#Gap");
productsList.add("9064#Gap");
productsList.add("b715#Gap");
Assertions.assertEquals(productsList, service.getProductsByGenderAndCategory(Gender.MEN, Category.HOODIES).entrySet().stream().map(product -> product.getValue().getId()).collect(Collectors.toList()));
productsList.clear();
Assertions.assertEquals(productsList, service.getProductsByGenderAndCategory(Gender.WOMEN, Category.PANTS).entrySet().stream().map(product -> product.getValue().getId()).collect(Collectors.toList()));
}
@Test
void getColorsByGenderAndCategoryTest() {
Map<Integer, Color> colorMap = new HashMap<>();
colorMap.put(1, Color.BLUE);
colorMap.put(2, Color.GREY);
colorMap.put(3, Color.BLACK);
Assertions.assertEquals(colorMap, service.getColorsByGenderAndCategory(Gender.MEN, Category.JEANS));
colorMap.clear();
Assertions.assertEquals(colorMap, service.getColorsByGenderAndCategory(Gender.MEN, Category.DRESS));
}
@Test
void getOrdersTest() {
List<Order> orderList = new ArrayList<>();
Map<Integer, Order> ordersMap = new HashMap<>();
Assertions.assertEquals(ordersMap, service.getOrders(connection));
}
}
\ No newline at end of file
src/test/java/com/retailstore/ordermanagement/service/RetailStoreServiceTest.java 0 → 100644
View file @ 4abed227
package com.retailstore.ordermanagement.service;
import com.retailstore.ordermanagement.constants.Category;
import com.retailstore.ordermanagement.constants.Color;
import com.retailstore.ordermanagement.constants.Gender;
import com.retailstore.ordermanagement.constants.Size;
import com.retailstore.ordermanagement.model.Order;
import com.retailstore.ordermanagement.model.OrderedProduct;
import com.retailstore.ordermanagement.utils.Utility;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
import java.sql.Connection;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
class RetailStoreTest {
@Mock
Connection connection;
RetailStoreService service;
@Spy
@InjectMocks
Utility utility;
@BeforeEach
void createretailsStoreObject() {
service = new RetailStoreService();
}
@AfterEach
void removeretailsStoreObject() {
service = null;
}
@Test
void addProducts() {
LinkedHashMap<Size, Integer> sizeMap = new LinkedHashMap<>();
sizeMap.put(Size.S, 2);
sizeMap.put(Size.M, 2);
sizeMap.put(Size.L, 2);
sizeMap.put(Size.XL, 2);
sizeMap.put(Size.XXL, 2);
Mockito.when(utility.productIdGenerator()).thenReturn("TestMethod" + LocalDate.now() + LocalTime.now());
Mockito.when(Utility.getScanner().nextLine()).thenReturn("TestProduct");
Mockito.when(Utility.getCategory(true, "Test check")).thenReturn(Category.JEANS);
Mockito.when(Utility.getColor(true, "Test check")).thenReturn(Color.BLACK);
Mockito.when(Utility.getGender(true, "Test check")).thenReturn(Gender.WOMEN);
Mockito.when(Utility.getDouble(true, "Test price")).thenReturn(1350.00);
Mockito.when(Utility.getProductSizes()).thenReturn(sizeMap);
Assertions.assertEquals(true, service.addProducts());
}
@Test
void placeOrders() {
}
@Test
void showOrdersTest() {
Map<Integer, Order> ordersMap = Mockito.mock(LinkedHashMap.class);
List<OrderedProduct> orderedProductList = Mockito.mock(ArrayList.class);
ordersMap.put(1, new Order("10bc46f3#Order", LocalDate.now(), LocalTime.now(), "Customer", "9633214574", 2500.00, new ArrayList<OrderedProduct>()));
Mockito.when(service.getOrders(connection)).thenReturn(ordersMap);
}
@Test
void createOrder() {
ArrayList<OrderedProduct> orderedProducts = new ArrayList<>();
orderedProducts.add(new OrderedProduct("test1", "testname", Category.JEANS, Color.BLACK, 1200.00, Gender.MEN, Size.L, 2));
// Mockito.when(getGender(true, "Test check")).thenReturn(Gender.WOMEN);
}
@Test
void addProductToCart() {
}
}
\ 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