code stringlengths 41 34.3k | lang stringclasses 8
values | review stringlengths 1 4.74k |
|---|---|---|
@@ -0,0 +1,25 @@
+package store.constants;
+
+public enum ErrorMessage {
+
+ PRODUCT_BUY_FORM_ERROR("올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요."),
+ NO_EXSIST_PRODUCT_ERROR("존재하지 않는 상품 입니다. 다시 입력해 주세요"),
+ NOT_ENOUGH_QUANTITY_ERROR("재고 수량을 초과하여 구매할 수 없습니다. 다시 입력해 주세요."),
+ NOT_POSITIVE_INPUT_ERROR("구입할 수량은 1 이상이어야 합니다. 다시 입력해 주세요."),
+ ETC_INPUT_ERROR("잘못된 입력입니다. 다시 입력해주세요."),
+ DUPLICATE_PRODUCT_INPUT_ERROR("같은 상품은 한 번에 여러개 구입합니다. 다시 입력해 주세요."),
+ PRODUCT_ERROR("잘못된 재고입니다."),
+ SYSTEM_ERROR("실행 오류 입니다.");
+
+ private final String prefix = "[ERROR] ";
+ private final String postfix = "\n";
+ private final String message;
+
+ ErrorMessage(String message) {
+ this.message = prefix + message + postfix;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+} | Java | 최소 구매 수량이 바뀌면 예외메시지도 바뀌어야 할 것 같아요. 상수를 외부에서 가져오도록 바꾸는 건 어떨까요?! |
@@ -0,0 +1,21 @@
+package store.constants;
+
+public enum InputPrompts {
+
+ START_PROMPTS("안녕하세요. W편의점입니다. \n현재 보유하고 있는 상품입니다. \n"),
+ ENTER_PURCHASE_PRODUCTS("구매하실 상품명과 수량을 입력해주세요. (예: [사이다-2],[감자칩-1])"),
+ PROMOTION_QUANTITY_ADD("현재 %s은(는) 1개를 무료로 더 받을 수 있습니다. 추가하시겠습니까? (Y/N)\n"),
+ NOT_ENOUGH_PROMOTION_QUANTITY("현재 %s %d개는 프로모션 할인이 적용되지 않습니다. 그래도 구매하시겠습니까? (Y/N)\n"),
+ MEMBERSHIP_DISCOUNT("\n멤버십 할인을 받으시겠습니까? (Y/N)"),
+ MORE_PURCHASE("감사합니다. 구매하고 싶은 다른 상품이 있나요? (Y/N)");
+
+ private final String prompt;
+
+ InputPrompts(String prompt) {
+ this.prompt = prompt;
+ }
+
+ public String getPrompt() {
+ return prompt;
+ }
+} | Java | 2+2 이벤트같은게 열리면 이 메시지는 잘못될 수도 있을 것 같아요! |
@@ -0,0 +1,29 @@
+package store.constants;
+
+public enum OutputPrompts {
+ WELCOME_MESSAGE("\n안녕하세요. W편의점입니다.\n"
+ + "현재 보유하고 있는 상품입니다.\n"),
+
+ PRODUCTS_HAVE_PROMOTION("- %s %s원 %s %s"),
+ PRODUCTS_NO_PROMOTION("- %s %s원 %s"),
+ RECEIPT_HEADER("\n==============W 편의점================\n"
+ + "상품명\t\t수량\t금액"),
+ RECEIPT_PRODUCTS("%s\t\t%d\t%s\n"),
+ RECEIPT_PROMOTION_HEADER("=============증\t정==============="),
+ RECEIPT_PROMOTION_PRODUCTS("%s\t\t%d\n"),
+ RECEIPT_TOTAL_PRICE_HEADER("===================================="),
+ RECEIPT_TOTAL_PRICE("총구매액\t\t%d\t%s\n"),
+ RECEIPT_PROMOTION_DISCOUNT("행사할인\t\t\t-%s\n"),
+ RECEIPT_MEMBERSHIP_DISCOUNT("멤버십할인\t\t\t-%s\n"),
+ RECEIPT_FINAL_PRICE("내실돈\t\t\t %s\n\n");
+
+ private final String prompts;
+
+ OutputPrompts(String prompts) {
+ this.prompts = prompts;
+ }
+
+ public String getPrompts() {
+ return prompts;
+ }
+} | Java | \n은 운영체제에 종속적인 줄바꿈인 것 같아요! 다른 방법이 없을까요!? |
@@ -0,0 +1,84 @@
+package store.controller;
+
+import camp.nextstep.edu.missionutils.Console;
+import java.io.IOException;
+import java.util.Map;
+import store.constants.ErrorMessage;
+import store.constants.StringConstants;
+import store.domain.Cart;
+import store.domain.Products;
+import store.domain.Promotions;
+import store.domain.Purchase;
+import store.domain.TotalPrice;
+import store.service.CartService;
+import store.service.InitService;
+import store.service.PromotionService;
+import store.view.InputView;
+import store.view.OutputView;
+
+public class StoreController {
+
+ private Products products;
+ private Promotions promotions;
+ private Cart cart;
+
+ private final InitService initService = new InitService();
+ private final PromotionService promotionService = new PromotionService();
+ private final CartService cartService = new CartService();
+ private final InputView inputView = new InputView();
+ private final OutputView outputView = new OutputView();
+
+ public void run() {
+ String next = StringConstants.YES.getString();
+ initStock();
+ while(next.equals(StringConstants.YES.getString())) {
+ start();
+ checkProducts();
+ result();
+ products = cartService.productsReduce(products, cart);
+ next = inputView.checkMorePurchase();
+ }
+ Console.close();
+ }
+
+ private void initStock() {
+ try {
+ products = initService.saveInitProducts();
+ promotions = initService.saveInitPromotions();
+ } catch (IOException e) {
+ System.out.println(ErrorMessage.SYSTEM_ERROR.getMessage());
+ }
+ }
+
+ private void start() {
+ outputView.productsOutput(this.products);
+ cart = inputView.readItem(products);
+ }
+
+ private void checkProducts() {
+ for (Purchase purchase : cart.getItems()) {
+ promotionService.setPromotion(purchase, products);
+ if (!purchase.getPromotion().equals(StringConstants.NO_PROMOTION.getString())) {
+ promotionService.promotionsAll(purchase, promotions, products, cart);
+ }
+ }
+ addCart();
+ }
+
+ private void addCart() {
+ promotionService.applyAddPurchaseToCart(cart);
+ }
+
+ private void result() {
+ Map<String, Purchase> items = cart.mergeItems(cart.getItems());
+ TotalPrice totalPrice = new TotalPrice(cart.getItems(), products);
+
+ totalPrice.setPromotionPrice(totalPrice.getPromotionSalePrice(cart.getItems(), promotions, products));
+ String answer = inputView.checkMemberShipSale();
+
+ if (answer.equals(StringConstants.YES.getString())) {
+ totalPrice.setMemberShipPrice(totalPrice.getMembershipSalePrice(cart.getItems(), products));
+ }
+ outputView.printReceipt(cart, products, promotions, items, totalPrice);
+ }
+} | Java | 문구 출력은 outputView에게 책임을 넘겨줘도 좋을 것 같아요! |
@@ -0,0 +1,84 @@
+package store.controller;
+
+import camp.nextstep.edu.missionutils.Console;
+import java.io.IOException;
+import java.util.Map;
+import store.constants.ErrorMessage;
+import store.constants.StringConstants;
+import store.domain.Cart;
+import store.domain.Products;
+import store.domain.Promotions;
+import store.domain.Purchase;
+import store.domain.TotalPrice;
+import store.service.CartService;
+import store.service.InitService;
+import store.service.PromotionService;
+import store.view.InputView;
+import store.view.OutputView;
+
+public class StoreController {
+
+ private Products products;
+ private Promotions promotions;
+ private Cart cart;
+
+ private final InitService initService = new InitService();
+ private final PromotionService promotionService = new PromotionService();
+ private final CartService cartService = new CartService();
+ private final InputView inputView = new InputView();
+ private final OutputView outputView = new OutputView();
+
+ public void run() {
+ String next = StringConstants.YES.getString();
+ initStock();
+ while(next.equals(StringConstants.YES.getString())) {
+ start();
+ checkProducts();
+ result();
+ products = cartService.productsReduce(products, cart);
+ next = inputView.checkMorePurchase();
+ }
+ Console.close();
+ }
+
+ private void initStock() {
+ try {
+ products = initService.saveInitProducts();
+ promotions = initService.saveInitPromotions();
+ } catch (IOException e) {
+ System.out.println(ErrorMessage.SYSTEM_ERROR.getMessage());
+ }
+ }
+
+ private void start() {
+ outputView.productsOutput(this.products);
+ cart = inputView.readItem(products);
+ }
+
+ private void checkProducts() {
+ for (Purchase purchase : cart.getItems()) {
+ promotionService.setPromotion(purchase, products);
+ if (!purchase.getPromotion().equals(StringConstants.NO_PROMOTION.getString())) {
+ promotionService.promotionsAll(purchase, promotions, products, cart);
+ }
+ }
+ addCart();
+ }
+
+ private void addCart() {
+ promotionService.applyAddPurchaseToCart(cart);
+ }
+
+ private void result() {
+ Map<String, Purchase> items = cart.mergeItems(cart.getItems());
+ TotalPrice totalPrice = new TotalPrice(cart.getItems(), products);
+
+ totalPrice.setPromotionPrice(totalPrice.getPromotionSalePrice(cart.getItems(), promotions, products));
+ String answer = inputView.checkMemberShipSale();
+
+ if (answer.equals(StringConstants.YES.getString())) {
+ totalPrice.setMemberShipPrice(totalPrice.getMembershipSalePrice(cart.getItems(), products));
+ }
+ outputView.printReceipt(cart, products, promotions, items, totalPrice);
+ }
+} | Java | service 계층을 분리했다면 비즈니스 로직은 service에게 위임하는 것도 좋을 것 같아요! |
@@ -0,0 +1,56 @@
+package store.domain;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import store.constants.ErrorMessage;
+
+public class Cart {
+
+ private List<Purchase> items;
+
+ public Cart(List<Purchase> items) {
+ this.items = new ArrayList<>();
+ addPurchase(new ArrayList<>(items));
+ }
+
+ public List<Purchase> getItems() {
+ return items;
+ }
+
+ private void addPurchase(List<Purchase> purchases) {
+ for (Purchase purchase : purchases) {
+ if(validateItem(purchase)) {
+ this.items.add(purchase);
+ }
+ }
+ }
+
+ private boolean validateItem(Purchase purchase) {
+ if (items.stream().anyMatch(item -> item.getName().equals(purchase.getName()))) {
+ throw new IllegalArgumentException(ErrorMessage.DUPLICATE_PRODUCT_INPUT_ERROR.getMessage());
+ }
+ return true;
+ }
+
+ public Map<String, Purchase> mergeItems(List<Purchase> purchases) {
+ Map<String, Purchase> itemsMap = new HashMap<>();
+ for (Purchase purchase : purchases) {
+ addItems(purchase, itemsMap);
+ }
+ return itemsMap;
+ }
+
+ private static void addItems(Purchase purchase, Map<String, Purchase> itemsMap) {
+ Purchase existingItem = itemsMap.get(purchase.getName());
+
+ if (existingItem != null) {
+ existingItem.setQuantity(existingItem.getQuantity() + purchase.getQuantity());
+ }
+ if (existingItem == null) {
+ Purchase item = new Purchase(purchase.getName(), purchase.getQuantity(), purchase.getPromotion());
+ itemsMap.put(item.getName(), item);
+ }
+ }
+} | Java | stream을 활용해볼 수 있지 않을까요..? 🤔 |
@@ -0,0 +1,56 @@
+package store.domain;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import store.constants.ErrorMessage;
+
+public class Cart {
+
+ private List<Purchase> items;
+
+ public Cart(List<Purchase> items) {
+ this.items = new ArrayList<>();
+ addPurchase(new ArrayList<>(items));
+ }
+
+ public List<Purchase> getItems() {
+ return items;
+ }
+
+ private void addPurchase(List<Purchase> purchases) {
+ for (Purchase purchase : purchases) {
+ if(validateItem(purchase)) {
+ this.items.add(purchase);
+ }
+ }
+ }
+
+ private boolean validateItem(Purchase purchase) {
+ if (items.stream().anyMatch(item -> item.getName().equals(purchase.getName()))) {
+ throw new IllegalArgumentException(ErrorMessage.DUPLICATE_PRODUCT_INPUT_ERROR.getMessage());
+ }
+ return true;
+ }
+
+ public Map<String, Purchase> mergeItems(List<Purchase> purchases) {
+ Map<String, Purchase> itemsMap = new HashMap<>();
+ for (Purchase purchase : purchases) {
+ addItems(purchase, itemsMap);
+ }
+ return itemsMap;
+ }
+
+ private static void addItems(Purchase purchase, Map<String, Purchase> itemsMap) {
+ Purchase existingItem = itemsMap.get(purchase.getName());
+
+ if (existingItem != null) {
+ existingItem.setQuantity(existingItem.getQuantity() + purchase.getQuantity());
+ }
+ if (existingItem == null) {
+ Purchase item = new Purchase(purchase.getName(), purchase.getQuantity(), purchase.getPromotion());
+ itemsMap.put(item.getName(), item);
+ }
+ }
+} | Java | 사이드이펙트를 지양해야 한다는 의견이시군요!! 저도 동의합니다! |
@@ -0,0 +1,49 @@
+package store.service;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import store.domain.Product;
+import store.domain.Products;
+import store.domain.Promotion;
+import store.domain.Promotions;
+import store.utils.FileRead;
+import store.utils.Split;
+
+public class InitService {
+
+ private static final String PRODUCTS_FILE_NAME = "src/main/resources/products.md";
+ private static final String PROMOTIONS_FILE_NAME = "src/main/resources/promotions.md";
+
+ public Products saveInitProducts() throws IOException {
+ List<String> fileContent = FileRead.readFile(PRODUCTS_FILE_NAME);
+ List<Product> productList = new ArrayList<>();
+ Set<String> productNames = new LinkedHashSet<>();
+
+ saveProducts(fileContent, productNames, productList);
+ Products products = new Products(productList);
+ products.setProductNames(new ArrayList<>(productNames));
+ products.addNoRegularProducts();
+ return products;
+ }
+
+ private static void saveProducts(List<String> fileContent, Set<String> productNames, List<Product> productList) {
+ for (String content : fileContent) {
+ List<String> split = Split.commaSpliter(content);
+ productNames.add(split.get(0));
+ productList.add(new Product(split.get(0), split.get(1), split.get(2), split.get(3)));
+ }
+ }
+
+ public Promotions saveInitPromotions() throws IOException {
+ List<String> fileContent = FileRead.readFile(PROMOTIONS_FILE_NAME);
+ List<Promotion> promotions = new ArrayList<>();
+ for (String content : fileContent) {
+ List<String> split = Split.commaSpliter(content);
+ promotions.add(new Promotion(split.get(0), split.get(1), split.get(2), split.get(3), split.get(4)));
+ }
+ return new Promotions(promotions);
+ }
+} | Java | 방어적 복사를 하셨네요!
여기서 방어적 복사를 진행하지 않으면 발생할 수 있는 문제는 뭐가 있을까요!? |
@@ -0,0 +1,49 @@
+package store.service;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import store.domain.Product;
+import store.domain.Products;
+import store.domain.Promotion;
+import store.domain.Promotions;
+import store.utils.FileRead;
+import store.utils.Split;
+
+public class InitService {
+
+ private static final String PRODUCTS_FILE_NAME = "src/main/resources/products.md";
+ private static final String PROMOTIONS_FILE_NAME = "src/main/resources/promotions.md";
+
+ public Products saveInitProducts() throws IOException {
+ List<String> fileContent = FileRead.readFile(PRODUCTS_FILE_NAME);
+ List<Product> productList = new ArrayList<>();
+ Set<String> productNames = new LinkedHashSet<>();
+
+ saveProducts(fileContent, productNames, productList);
+ Products products = new Products(productList);
+ products.setProductNames(new ArrayList<>(productNames));
+ products.addNoRegularProducts();
+ return products;
+ }
+
+ private static void saveProducts(List<String> fileContent, Set<String> productNames, List<Product> productList) {
+ for (String content : fileContent) {
+ List<String> split = Split.commaSpliter(content);
+ productNames.add(split.get(0));
+ productList.add(new Product(split.get(0), split.get(1), split.get(2), split.get(3)));
+ }
+ }
+
+ public Promotions saveInitPromotions() throws IOException {
+ List<String> fileContent = FileRead.readFile(PROMOTIONS_FILE_NAME);
+ List<Promotion> promotions = new ArrayList<>();
+ for (String content : fileContent) {
+ List<String> split = Split.commaSpliter(content);
+ promotions.add(new Promotion(split.get(0), split.get(1), split.get(2), split.get(3), split.get(4)));
+ }
+ return new Promotions(promotions);
+ }
+} | Java | split의 각 요소가 무엇을 의미하는지 명확하지 않은 것 같아요. 내부 클래스 매핑 등을 통해 각 자리에 어떤 의미의 필드가 들어있는지 명시하는 것도 좋을 것 같습니다! |
@@ -0,0 +1,21 @@
+package store.utils;
+
+import java.text.DecimalFormat;
+
+public class ConvertFormater {
+
+ private static final String COUNT_UNIT = "개";
+ private static final String ZERO_QUANTITY = "재고 없음";
+
+ public static String moneyFormat(int money) {
+ DecimalFormat df = new DecimalFormat("###,###");
+ return df.format(money);
+ }
+
+ public static String quantityFormat(int quantity) {
+ if (quantity == 0) {
+ return ZERO_QUANTITY;
+ }
+ return quantity + COUNT_UNIT;
+ }
+} | Java | 이 포맷은 상수화하지 않은 이유가 있으신가요!? |
@@ -0,0 +1,21 @@
+package store.utils;
+
+import java.text.DecimalFormat;
+
+public class ConvertFormater {
+
+ private static final String COUNT_UNIT = "개";
+ private static final String ZERO_QUANTITY = "재고 없음";
+
+ public static String moneyFormat(int money) {
+ DecimalFormat df = new DecimalFormat("###,###");
+ return df.format(money);
+ }
+
+ public static String quantityFormat(int quantity) {
+ if (quantity == 0) {
+ return ZERO_QUANTITY;
+ }
+ return quantity + COUNT_UNIT;
+ }
+} | Java | 개인적으로 상수 네이밍 단어를 통일하는 것도 좋을 것 같아요!
ex) `COUNT_UNIT` -> `QUANTITY_UNIT` |
@@ -0,0 +1,14 @@
+package store.utils;
+
+import store.constants.ErrorMessage;
+
+public class Parser {
+
+ public static int parseNumberToInt(String number) {
+ try {
+ return Integer.parseInt(number);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(ErrorMessage.ETC_INPUT_ERROR.getMessage());
+ }
+ }
+} | Java | 예외를 재포장하는 로직이 좋은 것 같아요! 👍 |
@@ -0,0 +1,106 @@
+package store.view;
+
+import camp.nextstep.edu.missionutils.Console;
+import java.util.ArrayList;
+import java.util.List;
+import store.constants.InputPrompts;
+import store.domain.Cart;
+import store.domain.Products;
+import store.domain.Purchase;
+import store.utils.Split;
+import store.validator.InputValidator;
+
+public class InputView {
+
+ public Cart readItem(Products products) {
+ while(true) {
+ try {
+ String input = getPurchaseInput();
+ InputValidator.validateInput(input);
+ List<String> purchase = Split.squareBracketsSpliter(Split.commaSpliter(input));
+ return validateReadItem(purchase, products);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private Cart validateReadItem(List<String> purchase, Products products) {
+ validatePurchase(purchase);
+ Cart cart = getCart(purchase);
+ InputValidator.validateHasProduct(cart, products);
+ InputValidator.validateSufficientStock(cart, products);
+ return cart;
+ }
+
+ public String checkPromotionCountAdd(Purchase purchase) {
+ while(true) {
+ try {
+ System.out.printf(InputPrompts.PROMOTION_QUANTITY_ADD.getPrompt(), purchase.getName());
+ String answer = Console.readLine();
+ InputValidator.validateAnswer(answer);
+ return answer;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ public String checkPromotionSaleNotAccept(Purchase purchase, int count) {
+ while(true) {
+ try {
+ System.out.printf(InputPrompts.NOT_ENOUGH_PROMOTION_QUANTITY.getPrompt(), purchase.getName(), count);
+ String answer = Console.readLine();
+ InputValidator.validateAnswer(answer);
+ return answer;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ public String checkMemberShipSale() {
+ while(true) {
+ try {
+ System.out.println(InputPrompts.MEMBERSHIP_DISCOUNT.getPrompt());
+ String answer = Console.readLine();
+ InputValidator.validateAnswer(answer);
+ return answer;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ public String checkMorePurchase() {
+ while(true) {
+ try {
+ System.out.println(InputPrompts.MORE_PURCHASE.getPrompt());
+ String answer = Console.readLine();
+ InputValidator.validateAnswer(answer);
+ return answer;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private String getPurchaseInput() {
+ System.out.println(InputPrompts.ENTER_PURCHASE_PRODUCTS.getPrompt());
+ String input = Console.readLine();
+ return input.replaceAll(" ", "");
+ }
+
+ private Cart getCart(List<String> purchase) {
+ List<Purchase> products = new ArrayList<>();
+ for (String productInput : purchase) {
+ List<String> buyInfo = Split.hyphenSpliter(productInput);
+ products.add(new Purchase(buyInfo.get(0), buyInfo.get(1)));
+ }
+ return new Cart(products);
+ }
+
+ private static void validatePurchase(List<String> purchase) {
+ InputValidator.validatePurchaseForm(purchase);
+ }
+} | Java | while, try-catch 코드가 동일한 구조로 여러 곳에서 중복되어 쓰이고 있는 것 같아요!
함수형 인터페이스를 활용하면 코드 중복을 최소화할 수 있을 것 같은데, 제가 학습한 내용을 아래 블로그에 게시해두었으니 관심있다면 한 번 읽어보세요! 😄
[함수형 인터페이스와 표준 API](https://velog.io/@songsunkook/%ED%95%A8%EC%88%98%ED%98%95-%EC%9D%B8%ED%84%B0%ED%8E%98%EC%9D%B4%EC%8A%A4%EC%99%80-%ED%91%9C%EC%A4%80-API) |
@@ -0,0 +1,67 @@
+package store.product.controller;
+
+import java.util.ArrayList;
+import java.util.List;
+import store.error.ErrorMessage;
+import store.product.domain.PurchaseProduct;
+import store.product.dto.PurchaseProductRequest;
+import store.product.service.ProductService;
+import store.product.view.ProductOutputView;
+import store.state.PurchaseState;
+import store.util.LoopTemplate;
+import store.util.StringParser;
+import store.util.StringValidator;
+import store.view.InputView;
+
+public class ProductController {
+
+ private final InputView inputView;
+ private final ProductOutputView outputView;
+ private final ProductService productService;
+
+ public ProductController(final InputView inputView, final ProductOutputView outputView,
+ final ProductService productService) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ this.productService = productService;
+ }
+
+ public void run() {
+ responseProductStatuses();
+ final List<PurchaseProduct> purchaseProducts = requestPurchaseProduct();
+ final PurchaseState purchaseState = PurchaseState.getInstance();
+ purchaseState.updatePurchaseProducts(purchaseProducts);
+ }
+
+ private void responseProductStatuses() {
+ outputView.printIntro();
+ outputView.printProductStatus(productService.getProductStatuses());
+ }
+
+ private List<PurchaseProduct> requestPurchaseProduct() {
+ return LoopTemplate.tryCatchLoop(() -> {
+ outputView.printAskPurchaseProduct();
+ final List<String> products = inputView.readProducts();
+ final List<PurchaseProductRequest> purchaseProductRequests = generatePurchaseProductRequests(products);
+ return productService.generatePurchaseProducts(purchaseProductRequests);
+ });
+ }
+
+ private List<PurchaseProductRequest> generatePurchaseProductRequests(final List<String> values) {
+ final List<PurchaseProductRequest> purchaseProductRequests = new ArrayList<>();
+ for (String value : values) {
+ StringValidator.validateFormat(value, ErrorMessage.INVALID_FORMAT_PRODUCT_AND_QUANTITY);
+ final String product = StringParser.removePattern(value.trim(), "[\\[\\]]");
+ purchaseProductRequests.add(createPurchaseProductRequest(product));
+ }
+ return purchaseProductRequests;
+ }
+
+ private PurchaseProductRequest createPurchaseProductRequest(final String product) {
+ final String[] splitProduct = product.split("-");
+ final String name = splitProduct[0];
+ final int quantity = StringParser.parseToNumber(splitProduct[1]);
+ return new PurchaseProductRequest(name, quantity);
+ }
+
+} | Java | ### 𝐐. 컨트롤러의 흐름 제어를 위해 PurchaseState를 도입하신 배경이 궁금합니다.
컨트롤러의 run() 메서드들이 반환 값 없이 void로 되어있더라구요. 대신 PurchaseState라는 싱글톤이 마치 Repository처럼 동작하면서 컨트롤러 간의 흐름을 제어하고 있습니다.
실제 Convenience 객체에서는 이런 식으로 구현되어 있더라구요:
```java
public void purchase() {
do {
productController.run();
promotionController.run();
paymentController.run();
} while (isRetryPurchase());
Console.close();
}
private boolean isRetryPurchase() {
return PurchaseState.getInstance().isRetryPurchase();
}
```
이렇게 보니 각 컨트롤러가 독립적인 모듈처럼 작동하고, 이 모듈들 사이의 데이터 흐름을 PurchaseState가 이어주고 있는 것 같은데요.
이런 구조를 채택하시게 된 특별한 계기나 고민의 과정이 있으셨나요? 처음부터 이런 구조를 계획하신 건지, 아니면 개발 과정에서 자연스럽게 발전된 건지 궁금합니다. 💭
저였다면 Controller에서 응답을 반환하고, 다른 컨트롤러에서 그 응답데이터를 가지고 요청을 시작할 것 같거든요.
하지만 단점이 존재합니다. 이렇게 하면 흐름제어의 부담이 커지기도 하고, 어쩌면 코드를 리팩토링 해야 하는 위험도 있습니다.
장점이라 하면 저는 그저 객체지향적이다..? 라고 밖에 생각이 안들거든요.. 즉, 저도 어떤게 좋은지 잘 모르고 있어요. 왜 이걸 써야만 하는지 정확한 이유를요..!
그래서 이렇게 만드신 이유를 제가 더욱더 궁금해 하는 것 같습니다 🥹
----
추가 내용:
이어서 코드를 읽다보니 구매자에게 상풍목록을 보여줄때 이때, ProductStatus가 조회용 DTO 역할도 하는 것 같습니다.
``` java
public List<ProductStatus> getProductStatuses() {
final List<ProductStatus> productStatuses = new ArrayList<>();
final List<Product> products = productRepository.findAll();
for (Product product : products) {
final ProductStatus productStatus = ProductStatus.of(product);
productStatuses.add(productStatus);
addNormalProduct(product, productStatuses);
}
return productStatuses;
}
```
사실상 ProductStatus가 DTO 응답 객체 역할을 하고 있었군요. 하지만 싱글톤 저장 기능을 곁들인.
이제야 왜 이렇게 짜셨는지 이해가 가네요.
혹시 여기에 더 수달님의 의견이 있으신지 여쭤보고 싶습니다. |
@@ -0,0 +1,67 @@
+package store.product.controller;
+
+import java.util.ArrayList;
+import java.util.List;
+import store.error.ErrorMessage;
+import store.product.domain.PurchaseProduct;
+import store.product.dto.PurchaseProductRequest;
+import store.product.service.ProductService;
+import store.product.view.ProductOutputView;
+import store.state.PurchaseState;
+import store.util.LoopTemplate;
+import store.util.StringParser;
+import store.util.StringValidator;
+import store.view.InputView;
+
+public class ProductController {
+
+ private final InputView inputView;
+ private final ProductOutputView outputView;
+ private final ProductService productService;
+
+ public ProductController(final InputView inputView, final ProductOutputView outputView,
+ final ProductService productService) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ this.productService = productService;
+ }
+
+ public void run() {
+ responseProductStatuses();
+ final List<PurchaseProduct> purchaseProducts = requestPurchaseProduct();
+ final PurchaseState purchaseState = PurchaseState.getInstance();
+ purchaseState.updatePurchaseProducts(purchaseProducts);
+ }
+
+ private void responseProductStatuses() {
+ outputView.printIntro();
+ outputView.printProductStatus(productService.getProductStatuses());
+ }
+
+ private List<PurchaseProduct> requestPurchaseProduct() {
+ return LoopTemplate.tryCatchLoop(() -> {
+ outputView.printAskPurchaseProduct();
+ final List<String> products = inputView.readProducts();
+ final List<PurchaseProductRequest> purchaseProductRequests = generatePurchaseProductRequests(products);
+ return productService.generatePurchaseProducts(purchaseProductRequests);
+ });
+ }
+
+ private List<PurchaseProductRequest> generatePurchaseProductRequests(final List<String> values) {
+ final List<PurchaseProductRequest> purchaseProductRequests = new ArrayList<>();
+ for (String value : values) {
+ StringValidator.validateFormat(value, ErrorMessage.INVALID_FORMAT_PRODUCT_AND_QUANTITY);
+ final String product = StringParser.removePattern(value.trim(), "[\\[\\]]");
+ purchaseProductRequests.add(createPurchaseProductRequest(product));
+ }
+ return purchaseProductRequests;
+ }
+
+ private PurchaseProductRequest createPurchaseProductRequest(final String product) {
+ final String[] splitProduct = product.split("-");
+ final String name = splitProduct[0];
+ final int quantity = StringParser.parseToNumber(splitProduct[1]);
+ return new PurchaseProductRequest(name, quantity);
+ }
+
+} | Java | #### 📚 배워갑니다. 🦦 좋은 코드 감사합니다!
try - catch 구조를 템플릿 패턴으로 정형화 한 방식 좋은 것 같습니다.
이번에 이 구조를 공부하고 적용해서 최종코테에 적용할 수 있도록 하고 싶은 마음이 뿜뿜들어요 ㅋㅋ
그리고 좀 여기서 더 개선할 수 있는지도 찾아보고 싶네요. |
@@ -0,0 +1,67 @@
+package store.product.controller;
+
+import java.util.ArrayList;
+import java.util.List;
+import store.error.ErrorMessage;
+import store.product.domain.PurchaseProduct;
+import store.product.dto.PurchaseProductRequest;
+import store.product.service.ProductService;
+import store.product.view.ProductOutputView;
+import store.state.PurchaseState;
+import store.util.LoopTemplate;
+import store.util.StringParser;
+import store.util.StringValidator;
+import store.view.InputView;
+
+public class ProductController {
+
+ private final InputView inputView;
+ private final ProductOutputView outputView;
+ private final ProductService productService;
+
+ public ProductController(final InputView inputView, final ProductOutputView outputView,
+ final ProductService productService) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ this.productService = productService;
+ }
+
+ public void run() {
+ responseProductStatuses();
+ final List<PurchaseProduct> purchaseProducts = requestPurchaseProduct();
+ final PurchaseState purchaseState = PurchaseState.getInstance();
+ purchaseState.updatePurchaseProducts(purchaseProducts);
+ }
+
+ private void responseProductStatuses() {
+ outputView.printIntro();
+ outputView.printProductStatus(productService.getProductStatuses());
+ }
+
+ private List<PurchaseProduct> requestPurchaseProduct() {
+ return LoopTemplate.tryCatchLoop(() -> {
+ outputView.printAskPurchaseProduct();
+ final List<String> products = inputView.readProducts();
+ final List<PurchaseProductRequest> purchaseProductRequests = generatePurchaseProductRequests(products);
+ return productService.generatePurchaseProducts(purchaseProductRequests);
+ });
+ }
+
+ private List<PurchaseProductRequest> generatePurchaseProductRequests(final List<String> values) {
+ final List<PurchaseProductRequest> purchaseProductRequests = new ArrayList<>();
+ for (String value : values) {
+ StringValidator.validateFormat(value, ErrorMessage.INVALID_FORMAT_PRODUCT_AND_QUANTITY);
+ final String product = StringParser.removePattern(value.trim(), "[\\[\\]]");
+ purchaseProductRequests.add(createPurchaseProductRequest(product));
+ }
+ return purchaseProductRequests;
+ }
+
+ private PurchaseProductRequest createPurchaseProductRequest(final String product) {
+ final String[] splitProduct = product.split("-");
+ final String name = splitProduct[0];
+ final int quantity = StringParser.parseToNumber(splitProduct[1]);
+ return new PurchaseProductRequest(name, quantity);
+ }
+
+} | Java | #### 📚 배워갑니다. 🦦 좋은 코드 감사합니다!
[ ] 을 지울 때 replaceAll 메서드가 있었군요.. 이것도 메모해 둬야겠습니다 😄
----
보여주기 부끄러운 저의 코드 :
```java
private String extractContentFromBrackets(final String input) {
return input.substring(1, input.length() - 1);
}``` |
@@ -0,0 +1,68 @@
+package store.product.domain;
+
+import java.util.Objects;
+import store.promotion.domain.Promotion;
+
+public class Product {
+
+ private static final String BLANK = "";
+ private static final int ZERO = 0;
+ private final long id;
+ private final ProductInfo productInfo;
+ private int quantity;
+
+ public Product(final Long id, final ProductInfo productInfo, final int quantity) {
+ this.id = id;
+ this.productInfo = productInfo;
+ this.quantity = quantity;
+ }
+
+ public Long getId() {
+ return this.id;
+ }
+
+ public void updateQuantity(final int quantity) {
+ this.quantity = quantity;
+ }
+
+ public String getPromotionName() {
+ final Promotion promotion = productInfo.promotion();
+ if (Objects.equals(promotion, null)) {
+ return BLANK;
+ }
+ return promotion.getPromotionName();
+ }
+
+ public boolean canReceiveMorePromotion(final int quantity) {
+ return productInfo.promotion().canPromotion(quantity);
+ }
+
+
+ public int calculateRemainingQuantity(final int quantity) {
+ final Promotion promotion = productInfo.promotion();
+ if (!Objects.equals(promotion, null)) {
+ return promotion.getRemainingQuantity(quantity);
+ }
+ return ZERO;
+ }
+
+ public int getBuyQuantity() {
+ return productInfo.promotion().getBuy();
+ }
+
+ public int getPrice() {
+ return productInfo.price();
+ }
+
+ public String getName() {
+ return productInfo.name();
+ }
+
+ public Promotion getPromotion() {
+ return productInfo.promotion();
+ }
+
+ public int getQuantity() {
+ return quantity;
+ }
+} | Java | ### 𝐐. Product 도메인의 설계 과정이 궁금합니다.
#### 질문의도:
이번에 프르모션 할인 때문에 Product와 Promotion은 개인적으로 서로가 필요한 관계처럼 느껴졌었습니다.
그래서 제겐 도메인 설계가 큰 과제였습니다. 그래서 이렇게 구상하시게 된 이유를 들어보고 싶습니다. 🥹
아래 사진은 수달님이 처음 설계하셨던 Product, 이후 최종 수정된 Product 입니다.
<img width="1188" alt="image" src="https://github.com/user-attachments/assets/d87d75f0-6788-46c9-bc8b-836599692032"> |
@@ -0,0 +1,42 @@
+package store.product.domain;
+
+public class ProductQuantity {
+
+ private int normalQuantity;
+ private int promotionQuantity;
+ private int nonPromotionQuantity;
+
+ public ProductQuantity(final int normalQuantity, final int promotionQuantity, final int nonPromotionQuantity) {
+ this.normalQuantity = normalQuantity;
+ this.promotionQuantity = promotionQuantity;
+ this.nonPromotionQuantity = nonPromotionQuantity;
+ }
+
+ public int calculateTotalQuantity() {
+ return normalQuantity + promotionQuantity + nonPromotionQuantity;
+ }
+
+ public int getNormalQuantity() {
+ return normalQuantity;
+ }
+
+ public int getPromotionQuantity() {
+ return promotionQuantity;
+ }
+
+ public int getNonPromotionQuantity() {
+ return nonPromotionQuantity;
+ }
+
+ public void updateNormalQuantity(final int normalQuantity) {
+ this.normalQuantity = normalQuantity;
+ }
+
+ public void updatePromotionQuantity(final int promotionQuantity) {
+ this.promotionQuantity = promotionQuantity;
+ }
+
+ public void updateNonPromotionQuantity(final int nonPromotionQuantity) {
+ this.nonPromotionQuantity = nonPromotionQuantity;
+ }
+} | Java | 수량 객체를 불변객체로 만들어 보는건 어떨까요?
예시
```java
public class ProductQuantity {
private final int normalQuantity; // < -- final 추가
private final int promotionQuantity; // < -- final 추가
private final int nonPromotionQuantity; // < -- final 추가
public ProductQuantity(final int normalQuantity,
final int promotionQuantity,
final int nonPromotionQuantity) {
this.normalQuantity = normalQuantity;
this.promotionQuantity = promotionQuantity;
this.nonPromotionQuantity = nonPromotionQuantity;
}
public ProductQuantity updateNormalQuantity(final int normalQuantity) {
return new ProductQuantity(normalQuantity, // <-- 변경시 새로운 객체로 반환
this.promotionQuantity,
this.nonPromotionQuantity);
}
public ProductQuantity updatePromotionQuantity(final int promotionQuantity) {
return new ProductQuantity(this.normalQuantity,
promotionQuantity,
this.nonPromotionQuantity);
}
```
## 수량을 불변 객체로 했을때 장점
### 1. 객체 상태 보장
이번 미션에서 재고 상태의 최신화를 항상 반영해야 하는 만큼,
객체 상태가 예기치 않게 변경될 가능성을 제거하는 것도 생각했었습니다. 그래서 저는 수량 객체를 불변타입으로 지정 했었습니다.
```java
ProductQuantity original = new ProductQuantity(10, 5, 3);
ProductQuantity modified = original.updateNormalQuantity(15); // 원본 original 객체는 변경되지 않음
```
### 2. 유지 보수향상
### 이전
``` java
ProducctQuantity original;
original.updateNormalQuantity(3);
original.updatePromotionQuantity(7);
```
### 리팩토링 후
```java
ProductQuantity updated = original.updateNormalQuantity(15)
.updatePromotionQuantity(8);
```
### 예를 들어 PromotionService 의 코드중 하나를 예를 들면
### 변경 전
<img width="547" alt="image" src="https://github.com/user-attachments/assets/5c0aa215-5d91-438e-a482-472c77ff9abd">
### 변경 후
<img width="667" alt="image" src="https://github.com/user-attachments/assets/5fb5a504-9f2d-4e8a-a72d-f500f98eb1e1"> |
@@ -0,0 +1,67 @@
+package store.product.controller;
+
+import java.util.ArrayList;
+import java.util.List;
+import store.error.ErrorMessage;
+import store.product.domain.PurchaseProduct;
+import store.product.dto.PurchaseProductRequest;
+import store.product.service.ProductService;
+import store.product.view.ProductOutputView;
+import store.state.PurchaseState;
+import store.util.LoopTemplate;
+import store.util.StringParser;
+import store.util.StringValidator;
+import store.view.InputView;
+
+public class ProductController {
+
+ private final InputView inputView;
+ private final ProductOutputView outputView;
+ private final ProductService productService;
+
+ public ProductController(final InputView inputView, final ProductOutputView outputView,
+ final ProductService productService) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ this.productService = productService;
+ }
+
+ public void run() {
+ responseProductStatuses();
+ final List<PurchaseProduct> purchaseProducts = requestPurchaseProduct();
+ final PurchaseState purchaseState = PurchaseState.getInstance();
+ purchaseState.updatePurchaseProducts(purchaseProducts);
+ }
+
+ private void responseProductStatuses() {
+ outputView.printIntro();
+ outputView.printProductStatus(productService.getProductStatuses());
+ }
+
+ private List<PurchaseProduct> requestPurchaseProduct() {
+ return LoopTemplate.tryCatchLoop(() -> {
+ outputView.printAskPurchaseProduct();
+ final List<String> products = inputView.readProducts();
+ final List<PurchaseProductRequest> purchaseProductRequests = generatePurchaseProductRequests(products);
+ return productService.generatePurchaseProducts(purchaseProductRequests);
+ });
+ }
+
+ private List<PurchaseProductRequest> generatePurchaseProductRequests(final List<String> values) {
+ final List<PurchaseProductRequest> purchaseProductRequests = new ArrayList<>();
+ for (String value : values) {
+ StringValidator.validateFormat(value, ErrorMessage.INVALID_FORMAT_PRODUCT_AND_QUANTITY);
+ final String product = StringParser.removePattern(value.trim(), "[\\[\\]]");
+ purchaseProductRequests.add(createPurchaseProductRequest(product));
+ }
+ return purchaseProductRequests;
+ }
+
+ private PurchaseProductRequest createPurchaseProductRequest(final String product) {
+ final String[] splitProduct = product.split("-");
+ final String name = splitProduct[0];
+ final int quantity = StringParser.parseToNumber(splitProduct[1]);
+ return new PurchaseProductRequest(name, quantity);
+ }
+
+} | Java | @plan11plan
싱글톤을 도입하게 된 과정은 다음과 같아요.
> 1. 3개의 컨트롤러가 모두 동일한 데이터(List<PurchaseProduct>)를 사용하고 있음
> 2. 해당 데이터를 매번 컨트롤러끼리 넘겨주는것 보다 더 나은 방법이 없을까 고민하게 됨
> 3. 그 과정 속에서 리액트 리덕스를 떠올리게 됨, 그래서 List<PurchaseProduct>의 상태를 관리하는 PurchaseState 클래스를 따로 두게 됨
> 4. PurchaseState가 관리하는 List<PurchaseProduct>은 애플리케이션 전역에서 동일한 데이터를 반환해야함
> 5. 따라서 PurchaseState은 단 하나의 인스턴스만 존재해야 하므로 싱글톤으로 구현하게 됨
하지만 이렇게 애플리케이션에서 전역으로 사용하는 싱글톤 객체의 경우 필드에 상태를 가지면, 나중에 버그가 터졌을때 디버깅하기 힘들다는 단점도 존재해요! 그래서 돌이켜보면 이렇게 싱글톤으로 작성해서 컨트롤러의 코드들이 이쁘게 작성이 됐지만, 조금은 아쉬운 설계라고 생각이 드네요 ㅎㅎ
---
```java
public List<ProductStatus> getProductStatuses() {
final List<ProductStatus> productStatuses = new ArrayList<>();
final List<Product> products = productRepository.findAll();
for (Product product : products) {
final ProductStatus productStatus = ProductStatus.of(product);
productStatuses.add(productStatus);
addNormalProduct(product, productStatuses);
}
return productStatuses;
}
```
그리고 짚어주신 요 부분은 PurchaseProduct를 사용하고 있지 않기 때문에, 싱글톤 객체에 저장하는 부분이 없어요
아마 제가 네이밍을 잘못해서 헷갈리신것 같아요 ㅎㅎ! |
@@ -0,0 +1,67 @@
+package store.product.controller;
+
+import java.util.ArrayList;
+import java.util.List;
+import store.error.ErrorMessage;
+import store.product.domain.PurchaseProduct;
+import store.product.dto.PurchaseProductRequest;
+import store.product.service.ProductService;
+import store.product.view.ProductOutputView;
+import store.state.PurchaseState;
+import store.util.LoopTemplate;
+import store.util.StringParser;
+import store.util.StringValidator;
+import store.view.InputView;
+
+public class ProductController {
+
+ private final InputView inputView;
+ private final ProductOutputView outputView;
+ private final ProductService productService;
+
+ public ProductController(final InputView inputView, final ProductOutputView outputView,
+ final ProductService productService) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ this.productService = productService;
+ }
+
+ public void run() {
+ responseProductStatuses();
+ final List<PurchaseProduct> purchaseProducts = requestPurchaseProduct();
+ final PurchaseState purchaseState = PurchaseState.getInstance();
+ purchaseState.updatePurchaseProducts(purchaseProducts);
+ }
+
+ private void responseProductStatuses() {
+ outputView.printIntro();
+ outputView.printProductStatus(productService.getProductStatuses());
+ }
+
+ private List<PurchaseProduct> requestPurchaseProduct() {
+ return LoopTemplate.tryCatchLoop(() -> {
+ outputView.printAskPurchaseProduct();
+ final List<String> products = inputView.readProducts();
+ final List<PurchaseProductRequest> purchaseProductRequests = generatePurchaseProductRequests(products);
+ return productService.generatePurchaseProducts(purchaseProductRequests);
+ });
+ }
+
+ private List<PurchaseProductRequest> generatePurchaseProductRequests(final List<String> values) {
+ final List<PurchaseProductRequest> purchaseProductRequests = new ArrayList<>();
+ for (String value : values) {
+ StringValidator.validateFormat(value, ErrorMessage.INVALID_FORMAT_PRODUCT_AND_QUANTITY);
+ final String product = StringParser.removePattern(value.trim(), "[\\[\\]]");
+ purchaseProductRequests.add(createPurchaseProductRequest(product));
+ }
+ return purchaseProductRequests;
+ }
+
+ private PurchaseProductRequest createPurchaseProductRequest(final String product) {
+ final String[] splitProduct = product.split("-");
+ final String name = splitProduct[0];
+ final int quantity = StringParser.parseToNumber(splitProduct[1]);
+ return new PurchaseProductRequest(name, quantity);
+ }
+
+} | Java | 감사합니다~ ☺️ |
@@ -0,0 +1,67 @@
+package store.product.controller;
+
+import java.util.ArrayList;
+import java.util.List;
+import store.error.ErrorMessage;
+import store.product.domain.PurchaseProduct;
+import store.product.dto.PurchaseProductRequest;
+import store.product.service.ProductService;
+import store.product.view.ProductOutputView;
+import store.state.PurchaseState;
+import store.util.LoopTemplate;
+import store.util.StringParser;
+import store.util.StringValidator;
+import store.view.InputView;
+
+public class ProductController {
+
+ private final InputView inputView;
+ private final ProductOutputView outputView;
+ private final ProductService productService;
+
+ public ProductController(final InputView inputView, final ProductOutputView outputView,
+ final ProductService productService) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ this.productService = productService;
+ }
+
+ public void run() {
+ responseProductStatuses();
+ final List<PurchaseProduct> purchaseProducts = requestPurchaseProduct();
+ final PurchaseState purchaseState = PurchaseState.getInstance();
+ purchaseState.updatePurchaseProducts(purchaseProducts);
+ }
+
+ private void responseProductStatuses() {
+ outputView.printIntro();
+ outputView.printProductStatus(productService.getProductStatuses());
+ }
+
+ private List<PurchaseProduct> requestPurchaseProduct() {
+ return LoopTemplate.tryCatchLoop(() -> {
+ outputView.printAskPurchaseProduct();
+ final List<String> products = inputView.readProducts();
+ final List<PurchaseProductRequest> purchaseProductRequests = generatePurchaseProductRequests(products);
+ return productService.generatePurchaseProducts(purchaseProductRequests);
+ });
+ }
+
+ private List<PurchaseProductRequest> generatePurchaseProductRequests(final List<String> values) {
+ final List<PurchaseProductRequest> purchaseProductRequests = new ArrayList<>();
+ for (String value : values) {
+ StringValidator.validateFormat(value, ErrorMessage.INVALID_FORMAT_PRODUCT_AND_QUANTITY);
+ final String product = StringParser.removePattern(value.trim(), "[\\[\\]]");
+ purchaseProductRequests.add(createPurchaseProductRequest(product));
+ }
+ return purchaseProductRequests;
+ }
+
+ private PurchaseProductRequest createPurchaseProductRequest(final String product) {
+ final String[] splitProduct = product.split("-");
+ final String name = splitProduct[0];
+ final int quantity = StringParser.parseToNumber(splitProduct[1]);
+ return new PurchaseProductRequest(name, quantity);
+ }
+
+} | Java | @plan11plan
replaceAll()은 정규식을 사용하기 때문에 다양한 패턴을 변환하기 좋더라구요 ㅎㅎ! |
@@ -0,0 +1,68 @@
+package store.product.domain;
+
+import java.util.Objects;
+import store.promotion.domain.Promotion;
+
+public class Product {
+
+ private static final String BLANK = "";
+ private static final int ZERO = 0;
+ private final long id;
+ private final ProductInfo productInfo;
+ private int quantity;
+
+ public Product(final Long id, final ProductInfo productInfo, final int quantity) {
+ this.id = id;
+ this.productInfo = productInfo;
+ this.quantity = quantity;
+ }
+
+ public Long getId() {
+ return this.id;
+ }
+
+ public void updateQuantity(final int quantity) {
+ this.quantity = quantity;
+ }
+
+ public String getPromotionName() {
+ final Promotion promotion = productInfo.promotion();
+ if (Objects.equals(promotion, null)) {
+ return BLANK;
+ }
+ return promotion.getPromotionName();
+ }
+
+ public boolean canReceiveMorePromotion(final int quantity) {
+ return productInfo.promotion().canPromotion(quantity);
+ }
+
+
+ public int calculateRemainingQuantity(final int quantity) {
+ final Promotion promotion = productInfo.promotion();
+ if (!Objects.equals(promotion, null)) {
+ return promotion.getRemainingQuantity(quantity);
+ }
+ return ZERO;
+ }
+
+ public int getBuyQuantity() {
+ return productInfo.promotion().getBuy();
+ }
+
+ public int getPrice() {
+ return productInfo.price();
+ }
+
+ public String getName() {
+ return productInfo.name();
+ }
+
+ public Promotion getPromotion() {
+ return productInfo.promotion();
+ }
+
+ public int getQuantity() {
+ return quantity;
+ }
+} | Java | @plan11plan
저는 `product.md`, `promotion.md` 이 두 파일이 마치 상품과 프로모션을 저장하고 있는 DB처럼 느껴졌거든요.
그래서 이 데이터들과 매핑할 수 있는 엔티티 객체가 필요해서 Product, Promotion 클래스를 두었고,
Product만 Promotion을 참조하는 단방향 다대일 관계로 풀어냈어요~
그리고 나중에 보니까 Product의 필드 수가 너무 많아져서 일부는 ProductInfo VO로 따로 빼서 관리를 하게끔 했어요~ |
@@ -0,0 +1,42 @@
+package store.product.domain;
+
+public class ProductQuantity {
+
+ private int normalQuantity;
+ private int promotionQuantity;
+ private int nonPromotionQuantity;
+
+ public ProductQuantity(final int normalQuantity, final int promotionQuantity, final int nonPromotionQuantity) {
+ this.normalQuantity = normalQuantity;
+ this.promotionQuantity = promotionQuantity;
+ this.nonPromotionQuantity = nonPromotionQuantity;
+ }
+
+ public int calculateTotalQuantity() {
+ return normalQuantity + promotionQuantity + nonPromotionQuantity;
+ }
+
+ public int getNormalQuantity() {
+ return normalQuantity;
+ }
+
+ public int getPromotionQuantity() {
+ return promotionQuantity;
+ }
+
+ public int getNonPromotionQuantity() {
+ return nonPromotionQuantity;
+ }
+
+ public void updateNormalQuantity(final int normalQuantity) {
+ this.normalQuantity = normalQuantity;
+ }
+
+ public void updatePromotionQuantity(final int promotionQuantity) {
+ this.promotionQuantity = promotionQuantity;
+ }
+
+ public void updateNonPromotionQuantity(final int nonPromotionQuantity) {
+ this.nonPromotionQuantity = nonPromotionQuantity;
+ }
+} | Java | @plan11plan
안그래도 요부분은 불변으로 리팩토링 해야겠다 라는 생각은 있었거든요 ㅎㅎ!
이거 외에도 불변으로 해야하는 포인트들이 몇군데 더 있어서 함께 리팩토링 할 예정이에요~! |
@@ -0,0 +1,34 @@
+package store;
+
+import camp.nextstep.edu.missionutils.Console;
+import store.payment.controller.PaymentController;
+import store.product.controller.ProductController;
+import store.promotion.controller.PromotionController;
+import store.state.PurchaseState;
+
+public class Convenience {
+
+ private final ProductController productController;
+ private final PromotionController promotionController;
+ private final PaymentController paymentController;
+
+ public Convenience(final ProductController productController, final PromotionController promotionController,
+ final PaymentController paymentController) {
+ this.productController = productController;
+ this.promotionController = promotionController;
+ this.paymentController = paymentController;
+ }
+
+ public void purchase() {
+ do {
+ productController.run();
+ promotionController.run();
+ paymentController.run();
+ } while (isRetryPurchase());
+ Console.close();
+ }
+
+ private boolean isRetryPurchase() {
+ return PurchaseState.getInstance().isRetryPurchase();
+ }
+} | Java | 싱글톤에 대해 알아보고 싶어서 질문해요.
저는 싱글톤을 유지하는 객체는 동시성 문제 때문에 상태를 갖는 필드를 지양해야 한다고 알고 있어요.
그런데 PurchaseState의 경우 purchaseProducts와 isRetryPurchase와 같이 상태를 가질 수 있는 필드가 존재한다고 생각해요.
이렇게 설계하였을 때 동시성 문제는 생기지 않나요?
발생하지 않는다면 왜 그런 건가요? |
@@ -0,0 +1,106 @@
+package store.config;
+
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayDeque;
+import java.util.List;
+import java.util.Queue;
+import store.error.ErrorMessage;
+import store.error.exception.InvalidFailInitialDataLoadException;
+import store.product.domain.Product;
+import store.product.domain.ProductInfo;
+import store.product.domain.ProductRepository;
+import store.promotion.domain.Promotion;
+import store.promotion.domain.PromotionDateTime;
+import store.promotion.domain.PromotionRepository;
+import store.promotion.domain.PromotionType;
+import store.util.StringParser;
+
+public class InitialDataLoader {
+
+ private static final String PATH_PROMOTIONS = "promotions.md";
+ private static final String PATH_PRODUCTS = "products.md";
+ private static final String DELIMITER_COMMA = ",";
+ private final PromotionRepository promotionRepository;
+ private final ProductRepository productRepository;
+ private Long promotionSequence = 1L;
+ private Long productSequence = 1L;
+
+ public InitialDataLoader(final PromotionRepository promotionRepository, final ProductRepository productRepository) {
+ this.promotionRepository = promotionRepository;
+ this.productRepository = productRepository;
+ }
+
+ public void initialize() {
+ saveAllPromotions();
+ saveAllProducts();
+ }
+
+ private void saveAllPromotions() {
+ final Queue<String> fileLines = readFileLines(PATH_PROMOTIONS);
+ if (fileLines.isEmpty()) {
+ return;
+ }
+ fileLines.poll();
+ while (!fileLines.isEmpty()) {
+ final String line = fileLines.poll();
+ savePromotion(line);
+ }
+ }
+
+
+ private void saveAllProducts() {
+ final Queue<String> fileLines = readFileLines(PATH_PRODUCTS);
+ if (fileLines.isEmpty()) {
+ return;
+ }
+ fileLines.poll();
+ while (!fileLines.isEmpty()) {
+ final String line = fileLines.poll();
+ saveProduct(line);
+ }
+ }
+
+ private void saveProduct(final String line) {
+ final List<String> tokens = StringParser.parseToTokens(line, DELIMITER_COMMA);
+ final Long id = productSequence++;
+ final Product product = createProduct(id, tokens);
+ productRepository.save(id, product);
+ }
+
+ private Product createProduct(final Long id, final List<String> tokens) {
+ final String promotionName = tokens.get(3);
+ final Promotion promotion = promotionRepository.findByPromotionType(PromotionType.findByName(promotionName))
+ .orElse(null);
+ final int price = StringParser.parseToNumber(tokens.get(1));
+ final int quantity = StringParser.parseToNumber(tokens.get(2));
+ final ProductInfo productInfo = new ProductInfo(tokens.get(0), price, promotion);
+ return new Product(id, productInfo, quantity);
+ }
+
+
+ private void savePromotion(final String line) {
+ final List<String> tokens = StringParser.parseToTokens(line, DELIMITER_COMMA);
+ final Promotion promotion = createPromotion(tokens);
+ promotionRepository.save(promotionSequence++, promotion);
+ }
+
+ private Promotion createPromotion(final List<String> tokens) {
+ final PromotionType type = PromotionType.findByName(tokens.get(0));
+ final int buy = StringParser.parseToNumber(tokens.get(1));
+ final int get = StringParser.parseToNumber(tokens.get(2));
+ final PromotionDateTime promotionDateTime = new PromotionDateTime(tokens.get(3), tokens.get(4));
+ return new Promotion(type, promotionDateTime, buy, get);
+ }
+
+
+ private Queue<String> readFileLines(final String path) {
+ try {
+ URI uri = getClass().getClassLoader().getResource(path).toURI();
+ return new ArrayDeque<>(Files.readAllLines(Paths.get(uri)));
+ } catch (Exception e) {
+ throw new InvalidFailInitialDataLoadException(ErrorMessage.INVALID_FAIL_INITIAL_DATA_LOAD);
+ }
+ }
+} | Java | p4
```suggestion
private static final String DELIMITER = ",";
```
구분자는 변경가능성이 크다고 조심스럽게 생각해 봅니다.
만약 구분자가 변경된다면 변수 이름도 변경해야하기 때문에 변경에도 유연하게 대처하기 위해 DELMITER로 변수명을 명명하는 것도 하나의 방법이 될것 같습니다. 😄 |
@@ -0,0 +1,106 @@
+package store.config;
+
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayDeque;
+import java.util.List;
+import java.util.Queue;
+import store.error.ErrorMessage;
+import store.error.exception.InvalidFailInitialDataLoadException;
+import store.product.domain.Product;
+import store.product.domain.ProductInfo;
+import store.product.domain.ProductRepository;
+import store.promotion.domain.Promotion;
+import store.promotion.domain.PromotionDateTime;
+import store.promotion.domain.PromotionRepository;
+import store.promotion.domain.PromotionType;
+import store.util.StringParser;
+
+public class InitialDataLoader {
+
+ private static final String PATH_PROMOTIONS = "promotions.md";
+ private static final String PATH_PRODUCTS = "products.md";
+ private static final String DELIMITER_COMMA = ",";
+ private final PromotionRepository promotionRepository;
+ private final ProductRepository productRepository;
+ private Long promotionSequence = 1L;
+ private Long productSequence = 1L;
+
+ public InitialDataLoader(final PromotionRepository promotionRepository, final ProductRepository productRepository) {
+ this.promotionRepository = promotionRepository;
+ this.productRepository = productRepository;
+ }
+
+ public void initialize() {
+ saveAllPromotions();
+ saveAllProducts();
+ }
+
+ private void saveAllPromotions() {
+ final Queue<String> fileLines = readFileLines(PATH_PROMOTIONS);
+ if (fileLines.isEmpty()) {
+ return;
+ }
+ fileLines.poll();
+ while (!fileLines.isEmpty()) {
+ final String line = fileLines.poll();
+ savePromotion(line);
+ }
+ }
+
+
+ private void saveAllProducts() {
+ final Queue<String> fileLines = readFileLines(PATH_PRODUCTS);
+ if (fileLines.isEmpty()) {
+ return;
+ }
+ fileLines.poll();
+ while (!fileLines.isEmpty()) {
+ final String line = fileLines.poll();
+ saveProduct(line);
+ }
+ }
+
+ private void saveProduct(final String line) {
+ final List<String> tokens = StringParser.parseToTokens(line, DELIMITER_COMMA);
+ final Long id = productSequence++;
+ final Product product = createProduct(id, tokens);
+ productRepository.save(id, product);
+ }
+
+ private Product createProduct(final Long id, final List<String> tokens) {
+ final String promotionName = tokens.get(3);
+ final Promotion promotion = promotionRepository.findByPromotionType(PromotionType.findByName(promotionName))
+ .orElse(null);
+ final int price = StringParser.parseToNumber(tokens.get(1));
+ final int quantity = StringParser.parseToNumber(tokens.get(2));
+ final ProductInfo productInfo = new ProductInfo(tokens.get(0), price, promotion);
+ return new Product(id, productInfo, quantity);
+ }
+
+
+ private void savePromotion(final String line) {
+ final List<String> tokens = StringParser.parseToTokens(line, DELIMITER_COMMA);
+ final Promotion promotion = createPromotion(tokens);
+ promotionRepository.save(promotionSequence++, promotion);
+ }
+
+ private Promotion createPromotion(final List<String> tokens) {
+ final PromotionType type = PromotionType.findByName(tokens.get(0));
+ final int buy = StringParser.parseToNumber(tokens.get(1));
+ final int get = StringParser.parseToNumber(tokens.get(2));
+ final PromotionDateTime promotionDateTime = new PromotionDateTime(tokens.get(3), tokens.get(4));
+ return new Promotion(type, promotionDateTime, buy, get);
+ }
+
+
+ private Queue<String> readFileLines(final String path) {
+ try {
+ URI uri = getClass().getClassLoader().getResource(path).toURI();
+ return new ArrayDeque<>(Files.readAllLines(Paths.get(uri)));
+ } catch (Exception e) {
+ throw new InvalidFailInitialDataLoadException(ErrorMessage.INVALID_FAIL_INITIAL_DATA_LOAD);
+ }
+ }
+} | Java | wow `URI` 타입이 있는지 이번에 처음에 알았습니다. 👍 저도 공부해보겠습니다.
감사합니다. ㅎㅎ |
@@ -0,0 +1,106 @@
+package store.config;
+
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayDeque;
+import java.util.List;
+import java.util.Queue;
+import store.error.ErrorMessage;
+import store.error.exception.InvalidFailInitialDataLoadException;
+import store.product.domain.Product;
+import store.product.domain.ProductInfo;
+import store.product.domain.ProductRepository;
+import store.promotion.domain.Promotion;
+import store.promotion.domain.PromotionDateTime;
+import store.promotion.domain.PromotionRepository;
+import store.promotion.domain.PromotionType;
+import store.util.StringParser;
+
+public class InitialDataLoader {
+
+ private static final String PATH_PROMOTIONS = "promotions.md";
+ private static final String PATH_PRODUCTS = "products.md";
+ private static final String DELIMITER_COMMA = ",";
+ private final PromotionRepository promotionRepository;
+ private final ProductRepository productRepository;
+ private Long promotionSequence = 1L;
+ private Long productSequence = 1L;
+
+ public InitialDataLoader(final PromotionRepository promotionRepository, final ProductRepository productRepository) {
+ this.promotionRepository = promotionRepository;
+ this.productRepository = productRepository;
+ }
+
+ public void initialize() {
+ saveAllPromotions();
+ saveAllProducts();
+ }
+
+ private void saveAllPromotions() {
+ final Queue<String> fileLines = readFileLines(PATH_PROMOTIONS);
+ if (fileLines.isEmpty()) {
+ return;
+ }
+ fileLines.poll();
+ while (!fileLines.isEmpty()) {
+ final String line = fileLines.poll();
+ savePromotion(line);
+ }
+ }
+
+
+ private void saveAllProducts() {
+ final Queue<String> fileLines = readFileLines(PATH_PRODUCTS);
+ if (fileLines.isEmpty()) {
+ return;
+ }
+ fileLines.poll();
+ while (!fileLines.isEmpty()) {
+ final String line = fileLines.poll();
+ saveProduct(line);
+ }
+ }
+
+ private void saveProduct(final String line) {
+ final List<String> tokens = StringParser.parseToTokens(line, DELIMITER_COMMA);
+ final Long id = productSequence++;
+ final Product product = createProduct(id, tokens);
+ productRepository.save(id, product);
+ }
+
+ private Product createProduct(final Long id, final List<String> tokens) {
+ final String promotionName = tokens.get(3);
+ final Promotion promotion = promotionRepository.findByPromotionType(PromotionType.findByName(promotionName))
+ .orElse(null);
+ final int price = StringParser.parseToNumber(tokens.get(1));
+ final int quantity = StringParser.parseToNumber(tokens.get(2));
+ final ProductInfo productInfo = new ProductInfo(tokens.get(0), price, promotion);
+ return new Product(id, productInfo, quantity);
+ }
+
+
+ private void savePromotion(final String line) {
+ final List<String> tokens = StringParser.parseToTokens(line, DELIMITER_COMMA);
+ final Promotion promotion = createPromotion(tokens);
+ promotionRepository.save(promotionSequence++, promotion);
+ }
+
+ private Promotion createPromotion(final List<String> tokens) {
+ final PromotionType type = PromotionType.findByName(tokens.get(0));
+ final int buy = StringParser.parseToNumber(tokens.get(1));
+ final int get = StringParser.parseToNumber(tokens.get(2));
+ final PromotionDateTime promotionDateTime = new PromotionDateTime(tokens.get(3), tokens.get(4));
+ return new Promotion(type, promotionDateTime, buy, get);
+ }
+
+
+ private Queue<String> readFileLines(final String path) {
+ try {
+ URI uri = getClass().getClassLoader().getResource(path).toURI();
+ return new ArrayDeque<>(Files.readAllLines(Paths.get(uri)));
+ } catch (Exception e) {
+ throw new InvalidFailInitialDataLoadException(ErrorMessage.INVALID_FAIL_INITIAL_DATA_LOAD);
+ }
+ }
+} | Java | p5
코드가 중복되기에 이렇게 해보시는 것도 하나의 방법이 될 것 같습니다.
하지만 만약 미래에 각각의 파일 양식이나 초기화하는 방법이 상이하게 변경될 경우도 고려했다면 수달님 방식이 더 좋을 것 같습니다.
```suggestion
public void initialize() {
saveAllData(PATH_PROMOTIONS, this::savePromotion);
saveAllData(PATH_PRODUCTS, this::saveProduct);
}
private void saveAllData(String path, Consumer<String> saveFunction) {
final Queue<String> fileLines = readFileLines(path);
if (fileLines.isEmpty()) {
return;
}
fileLines.poll();
while (!fileLines.isEmpty()) {
final String line = fileLines.poll();
saveFunction.accept(line);
}
}
``` |
@@ -0,0 +1,106 @@
+package store.config;
+
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayDeque;
+import java.util.List;
+import java.util.Queue;
+import store.error.ErrorMessage;
+import store.error.exception.InvalidFailInitialDataLoadException;
+import store.product.domain.Product;
+import store.product.domain.ProductInfo;
+import store.product.domain.ProductRepository;
+import store.promotion.domain.Promotion;
+import store.promotion.domain.PromotionDateTime;
+import store.promotion.domain.PromotionRepository;
+import store.promotion.domain.PromotionType;
+import store.util.StringParser;
+
+public class InitialDataLoader {
+
+ private static final String PATH_PROMOTIONS = "promotions.md";
+ private static final String PATH_PRODUCTS = "products.md";
+ private static final String DELIMITER_COMMA = ",";
+ private final PromotionRepository promotionRepository;
+ private final ProductRepository productRepository;
+ private Long promotionSequence = 1L;
+ private Long productSequence = 1L;
+
+ public InitialDataLoader(final PromotionRepository promotionRepository, final ProductRepository productRepository) {
+ this.promotionRepository = promotionRepository;
+ this.productRepository = productRepository;
+ }
+
+ public void initialize() {
+ saveAllPromotions();
+ saveAllProducts();
+ }
+
+ private void saveAllPromotions() {
+ final Queue<String> fileLines = readFileLines(PATH_PROMOTIONS);
+ if (fileLines.isEmpty()) {
+ return;
+ }
+ fileLines.poll();
+ while (!fileLines.isEmpty()) {
+ final String line = fileLines.poll();
+ savePromotion(line);
+ }
+ }
+
+
+ private void saveAllProducts() {
+ final Queue<String> fileLines = readFileLines(PATH_PRODUCTS);
+ if (fileLines.isEmpty()) {
+ return;
+ }
+ fileLines.poll();
+ while (!fileLines.isEmpty()) {
+ final String line = fileLines.poll();
+ saveProduct(line);
+ }
+ }
+
+ private void saveProduct(final String line) {
+ final List<String> tokens = StringParser.parseToTokens(line, DELIMITER_COMMA);
+ final Long id = productSequence++;
+ final Product product = createProduct(id, tokens);
+ productRepository.save(id, product);
+ }
+
+ private Product createProduct(final Long id, final List<String> tokens) {
+ final String promotionName = tokens.get(3);
+ final Promotion promotion = promotionRepository.findByPromotionType(PromotionType.findByName(promotionName))
+ .orElse(null);
+ final int price = StringParser.parseToNumber(tokens.get(1));
+ final int quantity = StringParser.parseToNumber(tokens.get(2));
+ final ProductInfo productInfo = new ProductInfo(tokens.get(0), price, promotion);
+ return new Product(id, productInfo, quantity);
+ }
+
+
+ private void savePromotion(final String line) {
+ final List<String> tokens = StringParser.parseToTokens(line, DELIMITER_COMMA);
+ final Promotion promotion = createPromotion(tokens);
+ promotionRepository.save(promotionSequence++, promotion);
+ }
+
+ private Promotion createPromotion(final List<String> tokens) {
+ final PromotionType type = PromotionType.findByName(tokens.get(0));
+ final int buy = StringParser.parseToNumber(tokens.get(1));
+ final int get = StringParser.parseToNumber(tokens.get(2));
+ final PromotionDateTime promotionDateTime = new PromotionDateTime(tokens.get(3), tokens.get(4));
+ return new Promotion(type, promotionDateTime, buy, get);
+ }
+
+
+ private Queue<String> readFileLines(final String path) {
+ try {
+ URI uri = getClass().getClassLoader().getResource(path).toURI();
+ return new ArrayDeque<>(Files.readAllLines(Paths.get(uri)));
+ } catch (Exception e) {
+ throw new InvalidFailInitialDataLoadException(ErrorMessage.INVALID_FAIL_INITIAL_DATA_LOAD);
+ }
+ }
+} | Java | p4
```suggestion
private final AtomicLong promotionSequence = new AtomicLong(1);
private final AtomicLong productSequence = new AtomicLong(1);
```
`AtomicLong`을 사용하면 멀티스레드에도 대응이 되고 `final Long id = productSequence++` 처럼 후위 증감 연산자 대신 `final Long id = productSequence.getAndIncrement()` 메서드를 통해서 관리가 가능해집니다. |
@@ -0,0 +1,67 @@
+package store.product.controller;
+
+import java.util.ArrayList;
+import java.util.List;
+import store.error.ErrorMessage;
+import store.product.domain.PurchaseProduct;
+import store.product.dto.PurchaseProductRequest;
+import store.product.service.ProductService;
+import store.product.view.ProductOutputView;
+import store.state.PurchaseState;
+import store.util.LoopTemplate;
+import store.util.StringParser;
+import store.util.StringValidator;
+import store.view.InputView;
+
+public class ProductController {
+
+ private final InputView inputView;
+ private final ProductOutputView outputView;
+ private final ProductService productService;
+
+ public ProductController(final InputView inputView, final ProductOutputView outputView,
+ final ProductService productService) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ this.productService = productService;
+ }
+
+ public void run() {
+ responseProductStatuses();
+ final List<PurchaseProduct> purchaseProducts = requestPurchaseProduct();
+ final PurchaseState purchaseState = PurchaseState.getInstance();
+ purchaseState.updatePurchaseProducts(purchaseProducts);
+ }
+
+ private void responseProductStatuses() {
+ outputView.printIntro();
+ outputView.printProductStatus(productService.getProductStatuses());
+ }
+
+ private List<PurchaseProduct> requestPurchaseProduct() {
+ return LoopTemplate.tryCatchLoop(() -> {
+ outputView.printAskPurchaseProduct();
+ final List<String> products = inputView.readProducts();
+ final List<PurchaseProductRequest> purchaseProductRequests = generatePurchaseProductRequests(products);
+ return productService.generatePurchaseProducts(purchaseProductRequests);
+ });
+ }
+
+ private List<PurchaseProductRequest> generatePurchaseProductRequests(final List<String> values) {
+ final List<PurchaseProductRequest> purchaseProductRequests = new ArrayList<>();
+ for (String value : values) {
+ StringValidator.validateFormat(value, ErrorMessage.INVALID_FORMAT_PRODUCT_AND_QUANTITY);
+ final String product = StringParser.removePattern(value.trim(), "[\\[\\]]");
+ purchaseProductRequests.add(createPurchaseProductRequest(product));
+ }
+ return purchaseProductRequests;
+ }
+
+ private PurchaseProductRequest createPurchaseProductRequest(final String product) {
+ final String[] splitProduct = product.split("-");
+ final String name = splitProduct[0];
+ final int quantity = StringParser.parseToNumber(splitProduct[1]);
+ return new PurchaseProductRequest(name, quantity);
+ }
+
+} | Java | p3
클린 코드(Clean Code, 로버트 C. 마틴)에서는 변수명은 코드의 목적과 의도를 명확히 보여줘야 한다고 말합니다.
예를 들어, values 대신 리스트가 무엇을 나타내는지를 더 잘 표현하는 이름을 사용할 수 있습니다.
따라서 values보다는 rawProductInputs나 products와 같이, 리스트에 담긴 데이터가 어떤 맥락에서 사용되는지 보여주는 이름이 더 좋지 않을까 생각이됩니다.
실제로 저도 코드리뷰하면서 values가 뭔지 몰라서 generatePurchaseProductRequests가 사용된 곳으로 가서 인수가 무엇인지 확인했습니다. ㅜ
```suggestion
private List<PurchaseProductRequest> generatePurchaseProductRequests(final List<String> products) {
final List<PurchaseProductRequest> purchaseProductRequests = new ArrayList<>();
for (String product : products) {
StringValidator.validateFormat(value, ErrorMessage.INVALID_FORMAT_PRODUCT_AND_QUANTITY);
final String product = StringParser.removePattern(product.trim(), "[\\[\\]]");
purchaseProductRequests.add(createPurchaseProductRequest(product));
}
return purchaseProductRequests;
}
``` |
@@ -0,0 +1,34 @@
+package store;
+
+import camp.nextstep.edu.missionutils.Console;
+import store.payment.controller.PaymentController;
+import store.product.controller.ProductController;
+import store.promotion.controller.PromotionController;
+import store.state.PurchaseState;
+
+public class Convenience {
+
+ private final ProductController productController;
+ private final PromotionController promotionController;
+ private final PaymentController paymentController;
+
+ public Convenience(final ProductController productController, final PromotionController promotionController,
+ final PaymentController paymentController) {
+ this.productController = productController;
+ this.promotionController = promotionController;
+ this.paymentController = paymentController;
+ }
+
+ public void purchase() {
+ do {
+ productController.run();
+ promotionController.run();
+ paymentController.run();
+ } while (isRetryPurchase());
+ Console.close();
+ }
+
+ private boolean isRetryPurchase() {
+ return PurchaseState.getInstance().isRetryPurchase();
+ }
+} | Java | `PurchaseState`에서 `getInstatnce`를 사용하지 않고 내부에서 재구매를 할 것인가에 대한 메서드를 선언해 사용하면, 디미터의 법칙을 지킬 수 있을 것 같은데 여기에 대한 수달님의 의견이 궁금합니다! |
@@ -0,0 +1,107 @@
+package store.config;
+
+import store.Convenience;
+import store.payment.controller.PaymentController;
+import store.payment.service.PaymentService;
+import store.payment.view.PaymentOutputView;
+import store.payment.view.console.ConsolePaymentOutputView;
+import store.product.controller.ProductController;
+import store.product.domain.ProductRepository;
+import store.product.service.ProductService;
+import store.product.service.PurchaseProductGenerator;
+import store.product.view.ProductOutputView;
+import store.product.view.console.ConsoleProductOutputView;
+import store.promotion.controller.PromotionController;
+import store.promotion.domain.PromotionRepository;
+import store.promotion.service.PromotionService;
+import store.promotion.view.PromotionOutputView;
+import store.promotion.view.console.ConsolePromotionOutputView;
+import store.view.InputView;
+import store.view.console.ConsoleInputView;
+
+public class AppConfig {
+
+ private final ProductRepository productRepository;
+ private final PromotionRepository promotionRepository;
+
+ public AppConfig(final ProductRepository productRepository, final PromotionRepository promotionRepository) {
+ this.productRepository = productRepository;
+ this.promotionRepository = promotionRepository;
+ }
+
+ public Convenience convenience() {
+ return new Convenience(
+ productController(),
+ promotionController(),
+ paymentController()
+ );
+ }
+
+ public InitialDataLoader initialDataLoader() {
+ return new InitialDataLoader(
+ promotionRepository,
+ productRepository
+ );
+ }
+
+ private PurchaseProductGenerator purchaseProductGenerator() {
+ return new PurchaseProductGenerator(productRepository);
+ }
+
+ private ProductService productService() {
+ return new ProductService(
+ productRepository,
+ purchaseProductGenerator()
+ );
+ }
+
+ private PromotionService promotionService() {
+ return new PromotionService(productRepository);
+ }
+
+ private PaymentService paymentService() {
+ return new PaymentService(productRepository);
+ }
+
+ private InputView inputView() {
+ return new ConsoleInputView();
+ }
+
+ private ProductOutputView productOutputView() {
+ return new ConsoleProductOutputView();
+ }
+
+ private PromotionOutputView promotionOutputView() {
+ return new ConsolePromotionOutputView();
+ }
+
+ private PaymentOutputView paymentOutputView() {
+ return new ConsolePaymentOutputView();
+ }
+
+ private ProductController productController() {
+ return new ProductController(
+ inputView(),
+ productOutputView(),
+ productService()
+ );
+ }
+
+ private PromotionController promotionController() {
+ return new PromotionController(
+ inputView(),
+ promotionOutputView(),
+ promotionService()
+ );
+ }
+
+ private PaymentController paymentController() {
+ return new PaymentController(
+ inputView(),
+ paymentOutputView(),
+ paymentService()
+ );
+ }
+
+
+} | Java | 공백도 컨벤션이다! 👀 |
@@ -1 +1,206 @@
-# java-convenience-store-precourse
+
+노션 링크를 통해 더 편하게 볼 수 있습니다.
+
+https://tangy-napkin-64d.notion.site/4-_-_-14e5dc39aa55800480aecff3d88bce24?pvs=4
+
+## 👉 로직
+
+✅ **요구사항 해석한 내용** (주관적일 수 있다고 생각하여 적어봤습니다 🙌)
+
+- **프로모션 할인**
+ - **오늘 날짜가 프로모션 기간 내에 포함된 경우에만 할인을 적용한다.**
+ - **프로모션 혜택은 프로모션 재고 내에서만 적용할 수 있다.**
+ - 프로모션 적용이 가능한 상품에 대해, 고객이 해당 수량보다 적게 가져와 추가하는 경우,
+ 추가하는 상품 1개는 프로모션 재고가 감소된다. 이때 프로모셔 재고가 추가적으로 1개가 더 있는지 확인해야 한다고 생각함.
+ - **프로모션 기간 중이라면 프로모션 재고를 우선적으로 차감하며, 프로모션 재고가 부족할 경우에는 일반 재고를 사용한다.**
+ - **프로모션 기간이 아니라면, 이 경우에도 프로모션 재고를 우선적으로 차감할 것인가?**
+
+ 1번) 프로모션 기간 유무에 상관없이 무조건 프로모션 재고를 우선적으로 차감한다.
+
+ 2번) 프로모션 기간이 아니라면 우선 일반 재고를 우선적으로 차감한다.
+
+ 3번) 프로모션 기간이 아니라면 일반 재고만 차감 가능하다.
+
+ 4번) 프로모션 기간이 아니라면 구매 불가이다.
+
+ → **2번**으로 해석함. 이유는 나중에 미래에 프로모션 기간이 되었을 때를 생각하면 우선 일반재고를 차감해야 한다고 생각함.
+
+- **멤버십 할인**
+ - **멤버십 회원은 프로모션 미적용 금액의 30%를 할인받는다.**
+ - **프로모션 미적용이란?**
+
+ 1번) 프로모션 기간이 아닌 프로모션 상품은 프로모션 미적용 상품에 포함된다.
+
+ 2번) (1번과 반대)프로모션 기간이 아니더라도 프로모션 혜택이 가능했던 상품이기 때문에 프로모션 미적용 상품이 아니다.
+
+ 3번) 프로모션 상품이 줄어들어 0이 된 상황이면(일반 재고만으로 결제해야 하는 상황) 이 상품은 프로모션 미적용 상품이다.
+
+ → **1번&3번으로 해석함. (표로 정리한 내용은 노션 참고)**
+
+ - **프로모션 적용 후 남은 금액에 대해 멤버십 할인을 적용한다.**
+ - **멤버십 할인의 최대 한도는 8,000원이다.**
+ - **최대 한도 8000원은 플레이를 할 때마다 초기화 되는가?**
+
+ 1번) 멤버십 할인은 누적된다. 즉 한번 플레이할 때 멤버십 할인의 최대한도인 8000원이 전부 적용되면, 다음 플레이에서는 멤버십할인이 되지 않는다.
+
+ 2번) 멤버십 할인은 누적되지 않는다. 즉 한 번 플레이할 때 멤버십 할인이 8000원이 되더라도 다음 플레이에서 최대 8000원의 멤버십 할인을 받을 수 있다.
+
+ → **2번**으로 해석함.
+
+
+✅ **전제**
+
+- **사용자가 입력한 상품 종류 1개에 대한 구매 수량 = n**
+- **영수중에 출력되는 상품 수량은 “결제한다”고 표현했습니다.**
+ - **따라서 결재하는 상품의 수량과 n은 다를 수 있습니다.**
+- 프로모션 혜택이 가능한 상품, 프로모션 적용이 가능한 상품은 다릅니다. (위 표 참고)
+
+✅ **로직**
+
+1. **프로모션 기간 아님(**3️⃣,4️⃣) ****→ 일반 재고 우선 감소 + 나머지는 프로모션 재고 감소,
+
+- 프로모션 기간이 아닌 경우란?
+ - 프로모션 혜택이 가능한 상품이지만 기간이 아니라 ‘프로모션 미적용’ 상품인 경우 또는
+ 프로모션 혜택이 애초에 없어 ‘프로모션 미적용’ 상품인 경우(처음부터 일반재고만 있는 경우)
+- 일반재고 ≥ n, 일반재고 < n 나눠서 일반재고/프로모션 재고 “결제”함
+- 멤버십 할인 있음
+
+2. **프로모션 기간(**1️⃣,2️⃣) → 프로모션 재고 우선 감소
+
+- **case1) 프로모션 재고 > n**
+ - 프로모션 재고만으로 제품을 충분히 구매할 수 있는 경우
+ - 이때 “결제”하는 프로모션 재고의 수는 n개
+ - 고객이 해당 수량보다 적게 가져온 경우 추가 여부를 입력받음
+ - 추가 가능할 정도로 프로모션 재고가 충분한지 검사 후, 추가 여부 묻기
+ - 추가함 → “결제”하는 프로모션 재고의 수/증정품 수/결제한 상품의 수량을 **1개** 늘림, 멤버십 할인 받지 않음
+ - 추가하지 않음 → 멤버십 할인 받지 않음(프로모션 상품이기 때문에, ‘실행 결과 예시’ 참고하기)
+
+- **case2) 프로모션 재고 == n**
+ - “결제”해야 하는 프로모션 재고의 수는 n개
+ - 프로모션 적용이 가능한 상품에 대해,
+ - 프로모션 혜택 없이 결제해야 하는 상품의 개수라면
+ - 일부 수량(k개)에 대해 정가로 결제할지 여부를 입력받음
+ - 정가 결제하지 않음 → “결제” 해야하는 프로모션 재고의 수 == n-k, 일반재고 “결제” 아무것도 안함, **결제할 상품의 수량을 k개 줄임**, 멤버십 할인 받지 않음
+ - 정가로 결제함 →프로모션 재고 모두 “결제”, 멤버십 할인 받지 않음
+
+- **case3) 프로모션 재고 < n**
+ - 프로모션 재고가 부족한 경우
+ - 프로모션 적용이 가능한 상품에 대해,
+ - 프로모션 혜택 없이 결제해야 하는 상품의 개수만큼 남았다면
+ - 일부 수량(k개)에 대해 정가로 결제할지 여부를 입력받음
+ - 정가 결제하지 않음 → “결제” 해야하는 프로모션 재고의 수 == n-k, 일반재고 “결제” 아무것도 안함, **결제할 상품의 수량을 k개 줄임**, 멤버십 할인 받지 않음
+ - 정가로 결제함 → 프로모션 재고 모두 “결제”, 나머지는 일반재고에서 “결제”, 멤버십 할인 받지 않음
+ - **단 k==n인 경우(프로모션 재고가 0개여서 구매 수량을 전부 일반재고에서 “결제”해야 하는 경우)는 멤버십 할인을 받음**
+
+- **case4) 추가적으로 물어볼거 없을 때**
+ - 정가로 결제할 상품의 수량, 추가할 수량이 없을 때
+ - “결제” 해야하는 프로모션 재고의 수 == n
+ - 멤버십 할인 받지 않음
+
+## 👉 입력
+
+- 입력값 전체 공통 예외처리
+ - [x] 빈값 또는 null값 입력시
+
+- **구매할 상품과 수량**
+ - 상품명,수량은 하이픈(-)으로
+ - 개별 상품은 대괄호([])로 묶어 쉼표(,)로 구분
+ - `구매하실 상품명과 수량을 입력해 주세요. (예: [사이다-2],[감자칩-1])`
+ - 예외처리
+ - `,`으로 split한 후 각각에 대해서…
+ - [x] []이 ‘양쪽 끝에’ 각각 없으면
+ - [x] -이 없으면
+
+ → 빈문자열인지도 함께 확인이 가능
+
+ - -으로 split한 후 각각에 대해서…
+ - [x] (스스로 판단한 내용) 상품 이름 중복 입력시
+ - [x] 판매 상품이 아니면
+ - [x] 재고 수량을 초과했으면
+ - 프로모션 재고가 부족할 경우에는 일반 재고를 사용함
+ - [x] 수량을 숫자 아닌 자료형으로 입력하면
+ - [x] 수량을 0이하 입력하면
+
+- Y/N 공통 예외처리
+ - [x] `Y` 또는 `N` 이 아닌 값을 입력했을 때
+- **증정 받을 수 있는 상품 추가 여부**
+ - 프로모션이 적용이 가능한 상품에 대해 고객이 해당 수량보다 적게 가져온 경우,
+ - 그 수량만큼 추가 여부를 입력받기
+ - `현재 {상품명}은(는) 1개를 무료로 더 받을 수 있습니다. 추가하시겠습니까? (Y/N)`
+- **정가로 결제할지에 대한 여부**
+ - 프로모션 재고가 부족하여 일부 수량을 프로모션 혜택 없이 결제해야 하는 경우,
+ - 일부 수량에 대해 정가로 결제할지 여부를 입력받기
+ - `현재 {상품명} {수량}개는 프로모션 할인이 적용되지 않습니다. 그래도 구매하시겠습니까? (Y/N)`
+ - 스스로 판단한 내용
+ - `N`를 입력시 : 구매를 아예 하지 않음
+- **멤버십 할인 적용 여부**
+ - `멤버십 할인을 받으시겠습니까? (Y/N)`
+ - 멤버십 회원은 프로모션 미적용 금액의 30%를 할인받는다.
+ - 프로모션 적용 후 남은 금액에 대해 멤버십 할인을 적용한다.
+ - 멤버십 할인의 최대 한도는 8,000원이다.
+- **추가 구매 여부**
+ - `감사합니다. 구매하고 싶은 다른 상품이 있나요? (Y/N)`
+
+## 👉 출력
+
+- 환영 인사와 함께 상품명, 가격, 프로모션 이름, 재고를 안내한다. 만약 재고가 0개라면 `재고 없음`을 출력
+ - **천단위 쉼표 찍기**
+
+ ```java
+ 안녕하세요. W편의점입니다.
+ 현재 보유하고 있는 상품입니다.
+
+ - 콜라 1,000원 10개 탄산2+1
+ - 콜라 1,000원 10개
+ - 사이다 1,000원 8개 탄산2+1
+ - 사이다 1,000원 7개
+ - 오렌지주스 1,800원 9개 MD추천상품
+ - 오렌지주스 1,800원 재고 없음
+ - 탄산수 1,200원 5개 탄산2+1
+ - 탄산수 1,200원 재고 없음
+ - 물 500원 10개
+ - 비타민워터 1,500원 6개
+ - 감자칩 1,500원 5개 반짝할인
+ - 감자칩 1,500원 5개
+ - 초코바 1,200원 5개 MD추천상품
+ - 초코바 1,200원 5개
+ - 에너지바 2,000원 5개
+ - 정식도시락 6,400원 8개
+ - 컵라면 1,700원 1개 MD추천상품
+ - 컵라면 1,700원 10개
+ ```
+
+
+- 구매 상품 내역, 증정 상품 내역, 금액 정보를 출력
+ - **천단위 쉼표 찍기**
+
+ ```java
+ ==============W 편의점================
+ 상품명 수량 금액
+ 콜라 3 3,000
+ 에너지바 5 10,000
+ =============증 정===============
+ 콜라 1
+ ====================================
+ 총구매액 8 13,000
+ 행사할인 -1,000
+ 멤버십할인 -3,000
+ 내실돈 9,000
+ ```
+
+
+- 에러 메시지
+ - 사용자가 잘못된 값을 입력했을 때, **"[ERROR]"로 시작**하는 오류 메시지와 함께 상황에 맞는 안내를 출력한다.
+ - 구매할 상품과 수량 형식이 올바르지 않은 경우: `[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.`
+ - 존재하지 않는 상품을 입력한 경우: `[ERROR] 존재하지 않는 상품입니다. 다시 입력해 주세요.`
+ - 구매 수량이 재고 수량을 초과한 경우: `[ERROR] 재고 수량을 초과하여 구매할 수 없습니다. 다시 입력해 주세요.`
+ - 기타 잘못된 입력의 경우: `[ERROR] 잘못된 입력입니다. 다시 입력해 주세요.`
+
+- 사용자가 잘못된 값을 입력할 경우 `IllegalArgumentException`를 발생시키고, "[ERROR]"로 시작하는 에러 메시지를 출력 후 그 부분부터 입력을 다시 받는다.
+ - `Exception`이 아닌 `IllegalArgumentException`, `IllegalStateException` 등과 같은 명확한 유형을 처리한다.
+
+## 👉 추가 라이브러리
+
+- `camp.nextstep.edu.missionutils`에서 제공하는 `DateTimes` 및 `Console` API를 사용하여 구현해야 한다.
+ - 현재 날짜와 시간을 가져오려면 `camp.nextstep.edu.missionutils.DateTimes`의 `now()`를 활용한다.
+ - 사용자가 입력하는 값은 `camp.nextstep.edu.missionutils.Console`의 `readLine()`을 활용한다. | Unknown | 프로모션 재고가 없는 경우 어차피 추가가 불가능하기 때문에 추가하는 경우에 들어가기 전에 확인 해야한다고 생각합니다. |
@@ -1 +1,206 @@
-# java-convenience-store-precourse
+
+노션 링크를 통해 더 편하게 볼 수 있습니다.
+
+https://tangy-napkin-64d.notion.site/4-_-_-14e5dc39aa55800480aecff3d88bce24?pvs=4
+
+## 👉 로직
+
+✅ **요구사항 해석한 내용** (주관적일 수 있다고 생각하여 적어봤습니다 🙌)
+
+- **프로모션 할인**
+ - **오늘 날짜가 프로모션 기간 내에 포함된 경우에만 할인을 적용한다.**
+ - **프로모션 혜택은 프로모션 재고 내에서만 적용할 수 있다.**
+ - 프로모션 적용이 가능한 상품에 대해, 고객이 해당 수량보다 적게 가져와 추가하는 경우,
+ 추가하는 상품 1개는 프로모션 재고가 감소된다. 이때 프로모셔 재고가 추가적으로 1개가 더 있는지 확인해야 한다고 생각함.
+ - **프로모션 기간 중이라면 프로모션 재고를 우선적으로 차감하며, 프로모션 재고가 부족할 경우에는 일반 재고를 사용한다.**
+ - **프로모션 기간이 아니라면, 이 경우에도 프로모션 재고를 우선적으로 차감할 것인가?**
+
+ 1번) 프로모션 기간 유무에 상관없이 무조건 프로모션 재고를 우선적으로 차감한다.
+
+ 2번) 프로모션 기간이 아니라면 우선 일반 재고를 우선적으로 차감한다.
+
+ 3번) 프로모션 기간이 아니라면 일반 재고만 차감 가능하다.
+
+ 4번) 프로모션 기간이 아니라면 구매 불가이다.
+
+ → **2번**으로 해석함. 이유는 나중에 미래에 프로모션 기간이 되었을 때를 생각하면 우선 일반재고를 차감해야 한다고 생각함.
+
+- **멤버십 할인**
+ - **멤버십 회원은 프로모션 미적용 금액의 30%를 할인받는다.**
+ - **프로모션 미적용이란?**
+
+ 1번) 프로모션 기간이 아닌 프로모션 상품은 프로모션 미적용 상품에 포함된다.
+
+ 2번) (1번과 반대)프로모션 기간이 아니더라도 프로모션 혜택이 가능했던 상품이기 때문에 프로모션 미적용 상품이 아니다.
+
+ 3번) 프로모션 상품이 줄어들어 0이 된 상황이면(일반 재고만으로 결제해야 하는 상황) 이 상품은 프로모션 미적용 상품이다.
+
+ → **1번&3번으로 해석함. (표로 정리한 내용은 노션 참고)**
+
+ - **프로모션 적용 후 남은 금액에 대해 멤버십 할인을 적용한다.**
+ - **멤버십 할인의 최대 한도는 8,000원이다.**
+ - **최대 한도 8000원은 플레이를 할 때마다 초기화 되는가?**
+
+ 1번) 멤버십 할인은 누적된다. 즉 한번 플레이할 때 멤버십 할인의 최대한도인 8000원이 전부 적용되면, 다음 플레이에서는 멤버십할인이 되지 않는다.
+
+ 2번) 멤버십 할인은 누적되지 않는다. 즉 한 번 플레이할 때 멤버십 할인이 8000원이 되더라도 다음 플레이에서 최대 8000원의 멤버십 할인을 받을 수 있다.
+
+ → **2번**으로 해석함.
+
+
+✅ **전제**
+
+- **사용자가 입력한 상품 종류 1개에 대한 구매 수량 = n**
+- **영수중에 출력되는 상품 수량은 “결제한다”고 표현했습니다.**
+ - **따라서 결재하는 상품의 수량과 n은 다를 수 있습니다.**
+- 프로모션 혜택이 가능한 상품, 프로모션 적용이 가능한 상품은 다릅니다. (위 표 참고)
+
+✅ **로직**
+
+1. **프로모션 기간 아님(**3️⃣,4️⃣) ****→ 일반 재고 우선 감소 + 나머지는 프로모션 재고 감소,
+
+- 프로모션 기간이 아닌 경우란?
+ - 프로모션 혜택이 가능한 상품이지만 기간이 아니라 ‘프로모션 미적용’ 상품인 경우 또는
+ 프로모션 혜택이 애초에 없어 ‘프로모션 미적용’ 상품인 경우(처음부터 일반재고만 있는 경우)
+- 일반재고 ≥ n, 일반재고 < n 나눠서 일반재고/프로모션 재고 “결제”함
+- 멤버십 할인 있음
+
+2. **프로모션 기간(**1️⃣,2️⃣) → 프로모션 재고 우선 감소
+
+- **case1) 프로모션 재고 > n**
+ - 프로모션 재고만으로 제품을 충분히 구매할 수 있는 경우
+ - 이때 “결제”하는 프로모션 재고의 수는 n개
+ - 고객이 해당 수량보다 적게 가져온 경우 추가 여부를 입력받음
+ - 추가 가능할 정도로 프로모션 재고가 충분한지 검사 후, 추가 여부 묻기
+ - 추가함 → “결제”하는 프로모션 재고의 수/증정품 수/결제한 상품의 수량을 **1개** 늘림, 멤버십 할인 받지 않음
+ - 추가하지 않음 → 멤버십 할인 받지 않음(프로모션 상품이기 때문에, ‘실행 결과 예시’ 참고하기)
+
+- **case2) 프로모션 재고 == n**
+ - “결제”해야 하는 프로모션 재고의 수는 n개
+ - 프로모션 적용이 가능한 상품에 대해,
+ - 프로모션 혜택 없이 결제해야 하는 상품의 개수라면
+ - 일부 수량(k개)에 대해 정가로 결제할지 여부를 입력받음
+ - 정가 결제하지 않음 → “결제” 해야하는 프로모션 재고의 수 == n-k, 일반재고 “결제” 아무것도 안함, **결제할 상품의 수량을 k개 줄임**, 멤버십 할인 받지 않음
+ - 정가로 결제함 →프로모션 재고 모두 “결제”, 멤버십 할인 받지 않음
+
+- **case3) 프로모션 재고 < n**
+ - 프로모션 재고가 부족한 경우
+ - 프로모션 적용이 가능한 상품에 대해,
+ - 프로모션 혜택 없이 결제해야 하는 상품의 개수만큼 남았다면
+ - 일부 수량(k개)에 대해 정가로 결제할지 여부를 입력받음
+ - 정가 결제하지 않음 → “결제” 해야하는 프로모션 재고의 수 == n-k, 일반재고 “결제” 아무것도 안함, **결제할 상품의 수량을 k개 줄임**, 멤버십 할인 받지 않음
+ - 정가로 결제함 → 프로모션 재고 모두 “결제”, 나머지는 일반재고에서 “결제”, 멤버십 할인 받지 않음
+ - **단 k==n인 경우(프로모션 재고가 0개여서 구매 수량을 전부 일반재고에서 “결제”해야 하는 경우)는 멤버십 할인을 받음**
+
+- **case4) 추가적으로 물어볼거 없을 때**
+ - 정가로 결제할 상품의 수량, 추가할 수량이 없을 때
+ - “결제” 해야하는 프로모션 재고의 수 == n
+ - 멤버십 할인 받지 않음
+
+## 👉 입력
+
+- 입력값 전체 공통 예외처리
+ - [x] 빈값 또는 null값 입력시
+
+- **구매할 상품과 수량**
+ - 상품명,수량은 하이픈(-)으로
+ - 개별 상품은 대괄호([])로 묶어 쉼표(,)로 구분
+ - `구매하실 상품명과 수량을 입력해 주세요. (예: [사이다-2],[감자칩-1])`
+ - 예외처리
+ - `,`으로 split한 후 각각에 대해서…
+ - [x] []이 ‘양쪽 끝에’ 각각 없으면
+ - [x] -이 없으면
+
+ → 빈문자열인지도 함께 확인이 가능
+
+ - -으로 split한 후 각각에 대해서…
+ - [x] (스스로 판단한 내용) 상품 이름 중복 입력시
+ - [x] 판매 상품이 아니면
+ - [x] 재고 수량을 초과했으면
+ - 프로모션 재고가 부족할 경우에는 일반 재고를 사용함
+ - [x] 수량을 숫자 아닌 자료형으로 입력하면
+ - [x] 수량을 0이하 입력하면
+
+- Y/N 공통 예외처리
+ - [x] `Y` 또는 `N` 이 아닌 값을 입력했을 때
+- **증정 받을 수 있는 상품 추가 여부**
+ - 프로모션이 적용이 가능한 상품에 대해 고객이 해당 수량보다 적게 가져온 경우,
+ - 그 수량만큼 추가 여부를 입력받기
+ - `현재 {상품명}은(는) 1개를 무료로 더 받을 수 있습니다. 추가하시겠습니까? (Y/N)`
+- **정가로 결제할지에 대한 여부**
+ - 프로모션 재고가 부족하여 일부 수량을 프로모션 혜택 없이 결제해야 하는 경우,
+ - 일부 수량에 대해 정가로 결제할지 여부를 입력받기
+ - `현재 {상품명} {수량}개는 프로모션 할인이 적용되지 않습니다. 그래도 구매하시겠습니까? (Y/N)`
+ - 스스로 판단한 내용
+ - `N`를 입력시 : 구매를 아예 하지 않음
+- **멤버십 할인 적용 여부**
+ - `멤버십 할인을 받으시겠습니까? (Y/N)`
+ - 멤버십 회원은 프로모션 미적용 금액의 30%를 할인받는다.
+ - 프로모션 적용 후 남은 금액에 대해 멤버십 할인을 적용한다.
+ - 멤버십 할인의 최대 한도는 8,000원이다.
+- **추가 구매 여부**
+ - `감사합니다. 구매하고 싶은 다른 상품이 있나요? (Y/N)`
+
+## 👉 출력
+
+- 환영 인사와 함께 상품명, 가격, 프로모션 이름, 재고를 안내한다. 만약 재고가 0개라면 `재고 없음`을 출력
+ - **천단위 쉼표 찍기**
+
+ ```java
+ 안녕하세요. W편의점입니다.
+ 현재 보유하고 있는 상품입니다.
+
+ - 콜라 1,000원 10개 탄산2+1
+ - 콜라 1,000원 10개
+ - 사이다 1,000원 8개 탄산2+1
+ - 사이다 1,000원 7개
+ - 오렌지주스 1,800원 9개 MD추천상품
+ - 오렌지주스 1,800원 재고 없음
+ - 탄산수 1,200원 5개 탄산2+1
+ - 탄산수 1,200원 재고 없음
+ - 물 500원 10개
+ - 비타민워터 1,500원 6개
+ - 감자칩 1,500원 5개 반짝할인
+ - 감자칩 1,500원 5개
+ - 초코바 1,200원 5개 MD추천상품
+ - 초코바 1,200원 5개
+ - 에너지바 2,000원 5개
+ - 정식도시락 6,400원 8개
+ - 컵라면 1,700원 1개 MD추천상품
+ - 컵라면 1,700원 10개
+ ```
+
+
+- 구매 상품 내역, 증정 상품 내역, 금액 정보를 출력
+ - **천단위 쉼표 찍기**
+
+ ```java
+ ==============W 편의점================
+ 상품명 수량 금액
+ 콜라 3 3,000
+ 에너지바 5 10,000
+ =============증 정===============
+ 콜라 1
+ ====================================
+ 총구매액 8 13,000
+ 행사할인 -1,000
+ 멤버십할인 -3,000
+ 내실돈 9,000
+ ```
+
+
+- 에러 메시지
+ - 사용자가 잘못된 값을 입력했을 때, **"[ERROR]"로 시작**하는 오류 메시지와 함께 상황에 맞는 안내를 출력한다.
+ - 구매할 상품과 수량 형식이 올바르지 않은 경우: `[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.`
+ - 존재하지 않는 상품을 입력한 경우: `[ERROR] 존재하지 않는 상품입니다. 다시 입력해 주세요.`
+ - 구매 수량이 재고 수량을 초과한 경우: `[ERROR] 재고 수량을 초과하여 구매할 수 없습니다. 다시 입력해 주세요.`
+ - 기타 잘못된 입력의 경우: `[ERROR] 잘못된 입력입니다. 다시 입력해 주세요.`
+
+- 사용자가 잘못된 값을 입력할 경우 `IllegalArgumentException`를 발생시키고, "[ERROR]"로 시작하는 에러 메시지를 출력 후 그 부분부터 입력을 다시 받는다.
+ - `Exception`이 아닌 `IllegalArgumentException`, `IllegalStateException` 등과 같은 명확한 유형을 처리한다.
+
+## 👉 추가 라이브러리
+
+- `camp.nextstep.edu.missionutils`에서 제공하는 `DateTimes` 및 `Console` API를 사용하여 구현해야 한다.
+ - 현재 날짜와 시간을 가져오려면 `camp.nextstep.edu.missionutils.DateTimes`의 `now()`를 활용한다.
+ - 사용자가 입력하는 값은 `camp.nextstep.edu.missionutils.Console`의 `readLine()`을 활용한다. | Unknown | 이런 의문은 안가졌었는데 꼼꼼히 하셨네요... 처음보는 시점입니다 |
@@ -1 +1,206 @@
-# java-convenience-store-precourse
+
+노션 링크를 통해 더 편하게 볼 수 있습니다.
+
+https://tangy-napkin-64d.notion.site/4-_-_-14e5dc39aa55800480aecff3d88bce24?pvs=4
+
+## 👉 로직
+
+✅ **요구사항 해석한 내용** (주관적일 수 있다고 생각하여 적어봤습니다 🙌)
+
+- **프로모션 할인**
+ - **오늘 날짜가 프로모션 기간 내에 포함된 경우에만 할인을 적용한다.**
+ - **프로모션 혜택은 프로모션 재고 내에서만 적용할 수 있다.**
+ - 프로모션 적용이 가능한 상품에 대해, 고객이 해당 수량보다 적게 가져와 추가하는 경우,
+ 추가하는 상품 1개는 프로모션 재고가 감소된다. 이때 프로모셔 재고가 추가적으로 1개가 더 있는지 확인해야 한다고 생각함.
+ - **프로모션 기간 중이라면 프로모션 재고를 우선적으로 차감하며, 프로모션 재고가 부족할 경우에는 일반 재고를 사용한다.**
+ - **프로모션 기간이 아니라면, 이 경우에도 프로모션 재고를 우선적으로 차감할 것인가?**
+
+ 1번) 프로모션 기간 유무에 상관없이 무조건 프로모션 재고를 우선적으로 차감한다.
+
+ 2번) 프로모션 기간이 아니라면 우선 일반 재고를 우선적으로 차감한다.
+
+ 3번) 프로모션 기간이 아니라면 일반 재고만 차감 가능하다.
+
+ 4번) 프로모션 기간이 아니라면 구매 불가이다.
+
+ → **2번**으로 해석함. 이유는 나중에 미래에 프로모션 기간이 되었을 때를 생각하면 우선 일반재고를 차감해야 한다고 생각함.
+
+- **멤버십 할인**
+ - **멤버십 회원은 프로모션 미적용 금액의 30%를 할인받는다.**
+ - **프로모션 미적용이란?**
+
+ 1번) 프로모션 기간이 아닌 프로모션 상품은 프로모션 미적용 상품에 포함된다.
+
+ 2번) (1번과 반대)프로모션 기간이 아니더라도 프로모션 혜택이 가능했던 상품이기 때문에 프로모션 미적용 상품이 아니다.
+
+ 3번) 프로모션 상품이 줄어들어 0이 된 상황이면(일반 재고만으로 결제해야 하는 상황) 이 상품은 프로모션 미적용 상품이다.
+
+ → **1번&3번으로 해석함. (표로 정리한 내용은 노션 참고)**
+
+ - **프로모션 적용 후 남은 금액에 대해 멤버십 할인을 적용한다.**
+ - **멤버십 할인의 최대 한도는 8,000원이다.**
+ - **최대 한도 8000원은 플레이를 할 때마다 초기화 되는가?**
+
+ 1번) 멤버십 할인은 누적된다. 즉 한번 플레이할 때 멤버십 할인의 최대한도인 8000원이 전부 적용되면, 다음 플레이에서는 멤버십할인이 되지 않는다.
+
+ 2번) 멤버십 할인은 누적되지 않는다. 즉 한 번 플레이할 때 멤버십 할인이 8000원이 되더라도 다음 플레이에서 최대 8000원의 멤버십 할인을 받을 수 있다.
+
+ → **2번**으로 해석함.
+
+
+✅ **전제**
+
+- **사용자가 입력한 상품 종류 1개에 대한 구매 수량 = n**
+- **영수중에 출력되는 상품 수량은 “결제한다”고 표현했습니다.**
+ - **따라서 결재하는 상품의 수량과 n은 다를 수 있습니다.**
+- 프로모션 혜택이 가능한 상품, 프로모션 적용이 가능한 상품은 다릅니다. (위 표 참고)
+
+✅ **로직**
+
+1. **프로모션 기간 아님(**3️⃣,4️⃣) ****→ 일반 재고 우선 감소 + 나머지는 프로모션 재고 감소,
+
+- 프로모션 기간이 아닌 경우란?
+ - 프로모션 혜택이 가능한 상품이지만 기간이 아니라 ‘프로모션 미적용’ 상품인 경우 또는
+ 프로모션 혜택이 애초에 없어 ‘프로모션 미적용’ 상품인 경우(처음부터 일반재고만 있는 경우)
+- 일반재고 ≥ n, 일반재고 < n 나눠서 일반재고/프로모션 재고 “결제”함
+- 멤버십 할인 있음
+
+2. **프로모션 기간(**1️⃣,2️⃣) → 프로모션 재고 우선 감소
+
+- **case1) 프로모션 재고 > n**
+ - 프로모션 재고만으로 제품을 충분히 구매할 수 있는 경우
+ - 이때 “결제”하는 프로모션 재고의 수는 n개
+ - 고객이 해당 수량보다 적게 가져온 경우 추가 여부를 입력받음
+ - 추가 가능할 정도로 프로모션 재고가 충분한지 검사 후, 추가 여부 묻기
+ - 추가함 → “결제”하는 프로모션 재고의 수/증정품 수/결제한 상품의 수량을 **1개** 늘림, 멤버십 할인 받지 않음
+ - 추가하지 않음 → 멤버십 할인 받지 않음(프로모션 상품이기 때문에, ‘실행 결과 예시’ 참고하기)
+
+- **case2) 프로모션 재고 == n**
+ - “결제”해야 하는 프로모션 재고의 수는 n개
+ - 프로모션 적용이 가능한 상품에 대해,
+ - 프로모션 혜택 없이 결제해야 하는 상품의 개수라면
+ - 일부 수량(k개)에 대해 정가로 결제할지 여부를 입력받음
+ - 정가 결제하지 않음 → “결제” 해야하는 프로모션 재고의 수 == n-k, 일반재고 “결제” 아무것도 안함, **결제할 상품의 수량을 k개 줄임**, 멤버십 할인 받지 않음
+ - 정가로 결제함 →프로모션 재고 모두 “결제”, 멤버십 할인 받지 않음
+
+- **case3) 프로모션 재고 < n**
+ - 프로모션 재고가 부족한 경우
+ - 프로모션 적용이 가능한 상품에 대해,
+ - 프로모션 혜택 없이 결제해야 하는 상품의 개수만큼 남았다면
+ - 일부 수량(k개)에 대해 정가로 결제할지 여부를 입력받음
+ - 정가 결제하지 않음 → “결제” 해야하는 프로모션 재고의 수 == n-k, 일반재고 “결제” 아무것도 안함, **결제할 상품의 수량을 k개 줄임**, 멤버십 할인 받지 않음
+ - 정가로 결제함 → 프로모션 재고 모두 “결제”, 나머지는 일반재고에서 “결제”, 멤버십 할인 받지 않음
+ - **단 k==n인 경우(프로모션 재고가 0개여서 구매 수량을 전부 일반재고에서 “결제”해야 하는 경우)는 멤버십 할인을 받음**
+
+- **case4) 추가적으로 물어볼거 없을 때**
+ - 정가로 결제할 상품의 수량, 추가할 수량이 없을 때
+ - “결제” 해야하는 프로모션 재고의 수 == n
+ - 멤버십 할인 받지 않음
+
+## 👉 입력
+
+- 입력값 전체 공통 예외처리
+ - [x] 빈값 또는 null값 입력시
+
+- **구매할 상품과 수량**
+ - 상품명,수량은 하이픈(-)으로
+ - 개별 상품은 대괄호([])로 묶어 쉼표(,)로 구분
+ - `구매하실 상품명과 수량을 입력해 주세요. (예: [사이다-2],[감자칩-1])`
+ - 예외처리
+ - `,`으로 split한 후 각각에 대해서…
+ - [x] []이 ‘양쪽 끝에’ 각각 없으면
+ - [x] -이 없으면
+
+ → 빈문자열인지도 함께 확인이 가능
+
+ - -으로 split한 후 각각에 대해서…
+ - [x] (스스로 판단한 내용) 상품 이름 중복 입력시
+ - [x] 판매 상품이 아니면
+ - [x] 재고 수량을 초과했으면
+ - 프로모션 재고가 부족할 경우에는 일반 재고를 사용함
+ - [x] 수량을 숫자 아닌 자료형으로 입력하면
+ - [x] 수량을 0이하 입력하면
+
+- Y/N 공통 예외처리
+ - [x] `Y` 또는 `N` 이 아닌 값을 입력했을 때
+- **증정 받을 수 있는 상품 추가 여부**
+ - 프로모션이 적용이 가능한 상품에 대해 고객이 해당 수량보다 적게 가져온 경우,
+ - 그 수량만큼 추가 여부를 입력받기
+ - `현재 {상품명}은(는) 1개를 무료로 더 받을 수 있습니다. 추가하시겠습니까? (Y/N)`
+- **정가로 결제할지에 대한 여부**
+ - 프로모션 재고가 부족하여 일부 수량을 프로모션 혜택 없이 결제해야 하는 경우,
+ - 일부 수량에 대해 정가로 결제할지 여부를 입력받기
+ - `현재 {상품명} {수량}개는 프로모션 할인이 적용되지 않습니다. 그래도 구매하시겠습니까? (Y/N)`
+ - 스스로 판단한 내용
+ - `N`를 입력시 : 구매를 아예 하지 않음
+- **멤버십 할인 적용 여부**
+ - `멤버십 할인을 받으시겠습니까? (Y/N)`
+ - 멤버십 회원은 프로모션 미적용 금액의 30%를 할인받는다.
+ - 프로모션 적용 후 남은 금액에 대해 멤버십 할인을 적용한다.
+ - 멤버십 할인의 최대 한도는 8,000원이다.
+- **추가 구매 여부**
+ - `감사합니다. 구매하고 싶은 다른 상품이 있나요? (Y/N)`
+
+## 👉 출력
+
+- 환영 인사와 함께 상품명, 가격, 프로모션 이름, 재고를 안내한다. 만약 재고가 0개라면 `재고 없음`을 출력
+ - **천단위 쉼표 찍기**
+
+ ```java
+ 안녕하세요. W편의점입니다.
+ 현재 보유하고 있는 상품입니다.
+
+ - 콜라 1,000원 10개 탄산2+1
+ - 콜라 1,000원 10개
+ - 사이다 1,000원 8개 탄산2+1
+ - 사이다 1,000원 7개
+ - 오렌지주스 1,800원 9개 MD추천상품
+ - 오렌지주스 1,800원 재고 없음
+ - 탄산수 1,200원 5개 탄산2+1
+ - 탄산수 1,200원 재고 없음
+ - 물 500원 10개
+ - 비타민워터 1,500원 6개
+ - 감자칩 1,500원 5개 반짝할인
+ - 감자칩 1,500원 5개
+ - 초코바 1,200원 5개 MD추천상품
+ - 초코바 1,200원 5개
+ - 에너지바 2,000원 5개
+ - 정식도시락 6,400원 8개
+ - 컵라면 1,700원 1개 MD추천상품
+ - 컵라면 1,700원 10개
+ ```
+
+
+- 구매 상품 내역, 증정 상품 내역, 금액 정보를 출력
+ - **천단위 쉼표 찍기**
+
+ ```java
+ ==============W 편의점================
+ 상품명 수량 금액
+ 콜라 3 3,000
+ 에너지바 5 10,000
+ =============증 정===============
+ 콜라 1
+ ====================================
+ 총구매액 8 13,000
+ 행사할인 -1,000
+ 멤버십할인 -3,000
+ 내실돈 9,000
+ ```
+
+
+- 에러 메시지
+ - 사용자가 잘못된 값을 입력했을 때, **"[ERROR]"로 시작**하는 오류 메시지와 함께 상황에 맞는 안내를 출력한다.
+ - 구매할 상품과 수량 형식이 올바르지 않은 경우: `[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.`
+ - 존재하지 않는 상품을 입력한 경우: `[ERROR] 존재하지 않는 상품입니다. 다시 입력해 주세요.`
+ - 구매 수량이 재고 수량을 초과한 경우: `[ERROR] 재고 수량을 초과하여 구매할 수 없습니다. 다시 입력해 주세요.`
+ - 기타 잘못된 입력의 경우: `[ERROR] 잘못된 입력입니다. 다시 입력해 주세요.`
+
+- 사용자가 잘못된 값을 입력할 경우 `IllegalArgumentException`를 발생시키고, "[ERROR]"로 시작하는 에러 메시지를 출력 후 그 부분부터 입력을 다시 받는다.
+ - `Exception`이 아닌 `IllegalArgumentException`, `IllegalStateException` 등과 같은 명확한 유형을 처리한다.
+
+## 👉 추가 라이브러리
+
+- `camp.nextstep.edu.missionutils`에서 제공하는 `DateTimes` 및 `Console` API를 사용하여 구현해야 한다.
+ - 현재 날짜와 시간을 가져오려면 `camp.nextstep.edu.missionutils.DateTimes`의 `now()`를 활용한다.
+ - 사용자가 입력하는 값은 `camp.nextstep.edu.missionutils.Console`의 `readLine()`을 활용한다. | Unknown | java가 아닌 text나 아예 제거하는게 좋을 것 같습니다. 크게 차이는 없겠지만 혹시나해서 남겨둬요 |
@@ -1,7 +1,16 @@
package store;
+import store.controller.Screen;
+import store.view.InputView;
+import store.view.OutputView;
+
public class Application {
public static void main(String[] args) {
- // TODO: 프로그램 구현
+ try {
+ Screen screen = new Screen(new InputView(), new OutputView());
+ screen.run();
+ } catch (IllegalArgumentException e) {
+ System.out.println("[ERROR] " + e.getMessage());
+ }
}
} | Java | 에러 메세지를 띄우고 해당 위치에서 다시 시작을 해야하는데 그 부분이 빠진 것 같습니다. 또한 에러를 출력하는 부분도 결국 view에서 해줘야한다고 생각합니다. |
@@ -0,0 +1,16 @@
+package store.constant;
+
+public enum MembershipDiscount {
+ MAX_DISCOUNT(8000),
+ DISCOUNT_RATE(0.3);
+
+ private final double value;
+
+ MembershipDiscount(double value) {
+ this.value = value;
+ }
+
+ public double getValue() {
+ return value;
+ }
+} | Java | 8000도 double을 이용하기에는 별로 좋지않은 것 같습니다. 필드에 저장하거나 일반 클래스의 필드로 만드는 것은 어떨까요? |
@@ -0,0 +1,22 @@
+package store.constant;
+
+public enum StockState {
+ NO_STOCK("0", "재고 없음"),
+ HAVE_STOCK("1", "");
+
+ private final String message;
+ private final String stockState;
+
+ StockState(String message, String stockState) {
+ this.message = message;
+ this.stockState = stockState;
+ }
+
+ public static String getMatchingState(String findAnswer) {
+ if (NO_STOCK.message.equals(findAnswer)) {
+ return NO_STOCK.stockState;
+ }
+ findAnswer = String.format("%,d", Integer.parseInt(findAnswer));
+ return findAnswer + "개";
+ }
+} | Java | enum의 성향보다는 그냥 재고 상태를 반환하는 느낌이 들어 비즈니스 로직에서 굳이 뺄 필요가 있냐는 생각이 들어요 |
@@ -0,0 +1,25 @@
+package store.constant;
+
+import store.exception.InvalidFormException;
+
+public enum YesNo {
+ YES("Y", true),
+ NO("N", false);
+
+ private final String message;
+ private final boolean answer;
+
+ YesNo(String message, Boolean answer) {
+ this.message = message;
+ this.answer = answer;
+ }
+
+ public static boolean getMatchingAnswer(String findAnswer) {
+ for (YesNo yesNo : YesNo.values()) {
+ if (yesNo.message.equals(findAnswer)) {
+ return yesNo.answer;
+ }
+ }
+ throw new InvalidFormException();
+ }
+} | Java | 이처럼 메서드 하나로 처리할 수 있는 것을 enum으로 처리하는 이유가 있을까요? |
@@ -0,0 +1,159 @@
+package store.controller;
+
+import store.constant.ProductState;
+import store.model.*;
+import store.util.Reader;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Screen {
+ public static final String PRODUCT_FILE_CATEGORY = "name,price,quantity,promotion\n";
+
+ private final InputView inputView;
+ private final OutputView outputView;
+
+
+ public Screen(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ }
+
+ public void run() {
+ do {
+ Store store = bringProducts();
+ outputView.printStoreMenu(store);
+
+ Orders orders = askProductAndPrice(store);
+ checkProducts(orders, store);
+
+ Receipt receipt = store.getReceipt(askGetMembership());
+ outputView.printReceipt(orders, store, receipt);
+ updateStockResult(store);
+ } while (askAdditionalPurchase());
+ }
+
+ public void checkProducts(Orders orders, Store store) {
+ for (Order order : orders.getOrders()) {
+ ProductState productState = store.getProductState(order);
+ if (productState == ProductState.NO_PROMOTION_PERIOD) {
+ continue;
+ }
+ calculateWhenPromotionPeriod(order, store, productState);
+ }
+ }
+
+ private void calculateWhenPromotionPeriod(Order order, Store store, ProductState productState) {
+ if (productState == ProductState.GET_ONE_FREE) {
+ store.calculateWhenGetOneFreeCase(order, askGetOneFree(order));
+ return;
+ }
+ if (productState == ProductState.BUY_ORIGINAL_PRICE) {
+ store.calculateWhenBuyOriginalPrice(order, askBuyOriginalPrice(order, store.countBuyOriginalPrice(order)));
+ return;
+ }
+ if (productState == ProductState.NOTHING_TO_ASK) {
+ store.calculateWhenNothingToAsk(order);
+ }
+ }
+
+ private Orders askProductAndPrice(Store store) {
+ return Task.repeatUntilValid(() -> {
+ String input = inputView.getProductAndPrice();
+ return makeValidateOrder(input, store);
+ });
+ }
+
+ private boolean askGetOneFree(Order order) {
+ return Task.repeatUntilValid(() -> inputView.getOneMoreFree(order));
+ }
+
+ private boolean askBuyOriginalPrice(Order order, int itemsAtOriginalPriceCount) {
+ return Task.repeatUntilValid(() -> inputView.getPurchaseOrNot(order.getName(), itemsAtOriginalPriceCount));
+ }
+
+ private boolean askGetMembership() {
+ return Task.repeatUntilValid(inputView::getMembershipDiscountOrNot);
+ }
+
+ private boolean askAdditionalPurchase() {
+ return Task.repeatUntilValid(inputView::getAdditionalPurchase);
+ }
+
+ private Orders makeValidateOrder(String input, Store store) {
+ String[] inputProducts = input.split(",", -1);
+ Orders orders = new Orders();
+ orders.addProduct(inputProducts, store);
+ return orders;
+ }
+
+ private Store bringProducts() {
+ Reader reader = new Reader();
+ List<String> lines = reader.readLines("src/main/resources/products.md").stream().skip(1).toList();
+ List<Product> promotionProducts = new ArrayList<>();
+ List<Product> normalProducts = new ArrayList<>();
+ lines.forEach(line -> updateProducts(line, promotionProducts, normalProducts));
+ return makeValidStore(promotionProducts, normalProducts);
+ }
+
+ private void updateProducts(String line, List<Product> promotionProducts, List<Product> normalProducts) {
+ Product product = new Product(line);
+ if (product.isPromotion()) {
+ promotionProducts.add(product);
+ return;
+ }
+ normalProducts.add(product);
+ }
+
+ private Store makeValidStore(List<Product> promotionProducts, List<Product> normalProducts) {
+ Store store = new Store();
+ promotionProducts.forEach(promotion -> {
+ Product normal = getNormalProduct(normalProducts, promotion);
+ normalProducts.remove(normal);
+ store.addProduct(promotion.getName(), new Products(List.of(promotion, normal)));
+ });
+ normalProducts.forEach(normal ->
+ store.addProduct(normal.getName(), new Products(List.of(normal)))
+ );
+ return store;
+ }
+
+ private void updateStockResult(Store store) {
+ try {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+ writer.write(PRODUCT_FILE_CATEGORY);
+ for (Map.Entry<String, Products> mapElement : store.getStoreProducts().entrySet()) {
+ writeProducts(writer, mapElement.getValue());
+ }
+ writer.close();
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private void writeProducts(BufferedWriter writer, Products products) {
+ try {
+ for (Product product : products.getProducts()) {
+ writer.write(product.getName() + "," + product.getPrice() + "," + product.getQuantity() + "," + product.getPromotion() + "\n");
+ }
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private Product getNormalProduct(List<Product> normalProducts, Product promotionProduct) {
+ for (Product normal : normalProducts) {
+ if (normal.getName().equals(promotionProduct.getName())) {
+ return normal;
+ }
+ }
+ return new Product(
+ promotionProduct.getName() + "," + promotionProduct.getPrice() + ",0,null");
+ }
+}
+ | Java | 컨트롤러는 클래스 이름에 컨트롤러가 있어야 좋다고 생각합니다. 하나의 도메인에 서비스, 컨트롤러와 같은 다양한 것들이 있어 이름을 짓기에 더 편해질 것 같아요 |
@@ -0,0 +1,159 @@
+package store.controller;
+
+import store.constant.ProductState;
+import store.model.*;
+import store.util.Reader;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Screen {
+ public static final String PRODUCT_FILE_CATEGORY = "name,price,quantity,promotion\n";
+
+ private final InputView inputView;
+ private final OutputView outputView;
+
+
+ public Screen(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ }
+
+ public void run() {
+ do {
+ Store store = bringProducts();
+ outputView.printStoreMenu(store);
+
+ Orders orders = askProductAndPrice(store);
+ checkProducts(orders, store);
+
+ Receipt receipt = store.getReceipt(askGetMembership());
+ outputView.printReceipt(orders, store, receipt);
+ updateStockResult(store);
+ } while (askAdditionalPurchase());
+ }
+
+ public void checkProducts(Orders orders, Store store) {
+ for (Order order : orders.getOrders()) {
+ ProductState productState = store.getProductState(order);
+ if (productState == ProductState.NO_PROMOTION_PERIOD) {
+ continue;
+ }
+ calculateWhenPromotionPeriod(order, store, productState);
+ }
+ }
+
+ private void calculateWhenPromotionPeriod(Order order, Store store, ProductState productState) {
+ if (productState == ProductState.GET_ONE_FREE) {
+ store.calculateWhenGetOneFreeCase(order, askGetOneFree(order));
+ return;
+ }
+ if (productState == ProductState.BUY_ORIGINAL_PRICE) {
+ store.calculateWhenBuyOriginalPrice(order, askBuyOriginalPrice(order, store.countBuyOriginalPrice(order)));
+ return;
+ }
+ if (productState == ProductState.NOTHING_TO_ASK) {
+ store.calculateWhenNothingToAsk(order);
+ }
+ }
+
+ private Orders askProductAndPrice(Store store) {
+ return Task.repeatUntilValid(() -> {
+ String input = inputView.getProductAndPrice();
+ return makeValidateOrder(input, store);
+ });
+ }
+
+ private boolean askGetOneFree(Order order) {
+ return Task.repeatUntilValid(() -> inputView.getOneMoreFree(order));
+ }
+
+ private boolean askBuyOriginalPrice(Order order, int itemsAtOriginalPriceCount) {
+ return Task.repeatUntilValid(() -> inputView.getPurchaseOrNot(order.getName(), itemsAtOriginalPriceCount));
+ }
+
+ private boolean askGetMembership() {
+ return Task.repeatUntilValid(inputView::getMembershipDiscountOrNot);
+ }
+
+ private boolean askAdditionalPurchase() {
+ return Task.repeatUntilValid(inputView::getAdditionalPurchase);
+ }
+
+ private Orders makeValidateOrder(String input, Store store) {
+ String[] inputProducts = input.split(",", -1);
+ Orders orders = new Orders();
+ orders.addProduct(inputProducts, store);
+ return orders;
+ }
+
+ private Store bringProducts() {
+ Reader reader = new Reader();
+ List<String> lines = reader.readLines("src/main/resources/products.md").stream().skip(1).toList();
+ List<Product> promotionProducts = new ArrayList<>();
+ List<Product> normalProducts = new ArrayList<>();
+ lines.forEach(line -> updateProducts(line, promotionProducts, normalProducts));
+ return makeValidStore(promotionProducts, normalProducts);
+ }
+
+ private void updateProducts(String line, List<Product> promotionProducts, List<Product> normalProducts) {
+ Product product = new Product(line);
+ if (product.isPromotion()) {
+ promotionProducts.add(product);
+ return;
+ }
+ normalProducts.add(product);
+ }
+
+ private Store makeValidStore(List<Product> promotionProducts, List<Product> normalProducts) {
+ Store store = new Store();
+ promotionProducts.forEach(promotion -> {
+ Product normal = getNormalProduct(normalProducts, promotion);
+ normalProducts.remove(normal);
+ store.addProduct(promotion.getName(), new Products(List.of(promotion, normal)));
+ });
+ normalProducts.forEach(normal ->
+ store.addProduct(normal.getName(), new Products(List.of(normal)))
+ );
+ return store;
+ }
+
+ private void updateStockResult(Store store) {
+ try {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+ writer.write(PRODUCT_FILE_CATEGORY);
+ for (Map.Entry<String, Products> mapElement : store.getStoreProducts().entrySet()) {
+ writeProducts(writer, mapElement.getValue());
+ }
+ writer.close();
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private void writeProducts(BufferedWriter writer, Products products) {
+ try {
+ for (Product product : products.getProducts()) {
+ writer.write(product.getName() + "," + product.getPrice() + "," + product.getQuantity() + "," + product.getPromotion() + "\n");
+ }
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private Product getNormalProduct(List<Product> normalProducts, Product promotionProduct) {
+ for (Product normal : normalProducts) {
+ if (normal.getName().equals(promotionProduct.getName())) {
+ return normal;
+ }
+ }
+ return new Product(
+ promotionProduct.getName() + "," + promotionProduct.getPrice() + ",0,null");
+ }
+}
+ | Java | \n은 ```System.lineSeparator()```을 사용해서 다양한 os에 호환이 되도록 만들 수 있어요 |
@@ -0,0 +1,159 @@
+package store.controller;
+
+import store.constant.ProductState;
+import store.model.*;
+import store.util.Reader;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Screen {
+ public static final String PRODUCT_FILE_CATEGORY = "name,price,quantity,promotion\n";
+
+ private final InputView inputView;
+ private final OutputView outputView;
+
+
+ public Screen(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ }
+
+ public void run() {
+ do {
+ Store store = bringProducts();
+ outputView.printStoreMenu(store);
+
+ Orders orders = askProductAndPrice(store);
+ checkProducts(orders, store);
+
+ Receipt receipt = store.getReceipt(askGetMembership());
+ outputView.printReceipt(orders, store, receipt);
+ updateStockResult(store);
+ } while (askAdditionalPurchase());
+ }
+
+ public void checkProducts(Orders orders, Store store) {
+ for (Order order : orders.getOrders()) {
+ ProductState productState = store.getProductState(order);
+ if (productState == ProductState.NO_PROMOTION_PERIOD) {
+ continue;
+ }
+ calculateWhenPromotionPeriod(order, store, productState);
+ }
+ }
+
+ private void calculateWhenPromotionPeriod(Order order, Store store, ProductState productState) {
+ if (productState == ProductState.GET_ONE_FREE) {
+ store.calculateWhenGetOneFreeCase(order, askGetOneFree(order));
+ return;
+ }
+ if (productState == ProductState.BUY_ORIGINAL_PRICE) {
+ store.calculateWhenBuyOriginalPrice(order, askBuyOriginalPrice(order, store.countBuyOriginalPrice(order)));
+ return;
+ }
+ if (productState == ProductState.NOTHING_TO_ASK) {
+ store.calculateWhenNothingToAsk(order);
+ }
+ }
+
+ private Orders askProductAndPrice(Store store) {
+ return Task.repeatUntilValid(() -> {
+ String input = inputView.getProductAndPrice();
+ return makeValidateOrder(input, store);
+ });
+ }
+
+ private boolean askGetOneFree(Order order) {
+ return Task.repeatUntilValid(() -> inputView.getOneMoreFree(order));
+ }
+
+ private boolean askBuyOriginalPrice(Order order, int itemsAtOriginalPriceCount) {
+ return Task.repeatUntilValid(() -> inputView.getPurchaseOrNot(order.getName(), itemsAtOriginalPriceCount));
+ }
+
+ private boolean askGetMembership() {
+ return Task.repeatUntilValid(inputView::getMembershipDiscountOrNot);
+ }
+
+ private boolean askAdditionalPurchase() {
+ return Task.repeatUntilValid(inputView::getAdditionalPurchase);
+ }
+
+ private Orders makeValidateOrder(String input, Store store) {
+ String[] inputProducts = input.split(",", -1);
+ Orders orders = new Orders();
+ orders.addProduct(inputProducts, store);
+ return orders;
+ }
+
+ private Store bringProducts() {
+ Reader reader = new Reader();
+ List<String> lines = reader.readLines("src/main/resources/products.md").stream().skip(1).toList();
+ List<Product> promotionProducts = new ArrayList<>();
+ List<Product> normalProducts = new ArrayList<>();
+ lines.forEach(line -> updateProducts(line, promotionProducts, normalProducts));
+ return makeValidStore(promotionProducts, normalProducts);
+ }
+
+ private void updateProducts(String line, List<Product> promotionProducts, List<Product> normalProducts) {
+ Product product = new Product(line);
+ if (product.isPromotion()) {
+ promotionProducts.add(product);
+ return;
+ }
+ normalProducts.add(product);
+ }
+
+ private Store makeValidStore(List<Product> promotionProducts, List<Product> normalProducts) {
+ Store store = new Store();
+ promotionProducts.forEach(promotion -> {
+ Product normal = getNormalProduct(normalProducts, promotion);
+ normalProducts.remove(normal);
+ store.addProduct(promotion.getName(), new Products(List.of(promotion, normal)));
+ });
+ normalProducts.forEach(normal ->
+ store.addProduct(normal.getName(), new Products(List.of(normal)))
+ );
+ return store;
+ }
+
+ private void updateStockResult(Store store) {
+ try {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+ writer.write(PRODUCT_FILE_CATEGORY);
+ for (Map.Entry<String, Products> mapElement : store.getStoreProducts().entrySet()) {
+ writeProducts(writer, mapElement.getValue());
+ }
+ writer.close();
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private void writeProducts(BufferedWriter writer, Products products) {
+ try {
+ for (Product product : products.getProducts()) {
+ writer.write(product.getName() + "," + product.getPrice() + "," + product.getQuantity() + "," + product.getPromotion() + "\n");
+ }
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private Product getNormalProduct(List<Product> normalProducts, Product promotionProduct) {
+ for (Product normal : normalProducts) {
+ if (normal.getName().equals(promotionProduct.getName())) {
+ return normal;
+ }
+ }
+ return new Product(
+ promotionProduct.getName() + "," + promotionProduct.getPrice() + ",0,null");
+ }
+}
+ | Java | 사용자가 접근할 수 있는 곳에 코드를 나타내는 오류는 안뜨는 것이 좋다고 생각합니다. |
@@ -0,0 +1,159 @@
+package store.controller;
+
+import store.constant.ProductState;
+import store.model.*;
+import store.util.Reader;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Screen {
+ public static final String PRODUCT_FILE_CATEGORY = "name,price,quantity,promotion\n";
+
+ private final InputView inputView;
+ private final OutputView outputView;
+
+
+ public Screen(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ }
+
+ public void run() {
+ do {
+ Store store = bringProducts();
+ outputView.printStoreMenu(store);
+
+ Orders orders = askProductAndPrice(store);
+ checkProducts(orders, store);
+
+ Receipt receipt = store.getReceipt(askGetMembership());
+ outputView.printReceipt(orders, store, receipt);
+ updateStockResult(store);
+ } while (askAdditionalPurchase());
+ }
+
+ public void checkProducts(Orders orders, Store store) {
+ for (Order order : orders.getOrders()) {
+ ProductState productState = store.getProductState(order);
+ if (productState == ProductState.NO_PROMOTION_PERIOD) {
+ continue;
+ }
+ calculateWhenPromotionPeriod(order, store, productState);
+ }
+ }
+
+ private void calculateWhenPromotionPeriod(Order order, Store store, ProductState productState) {
+ if (productState == ProductState.GET_ONE_FREE) {
+ store.calculateWhenGetOneFreeCase(order, askGetOneFree(order));
+ return;
+ }
+ if (productState == ProductState.BUY_ORIGINAL_PRICE) {
+ store.calculateWhenBuyOriginalPrice(order, askBuyOriginalPrice(order, store.countBuyOriginalPrice(order)));
+ return;
+ }
+ if (productState == ProductState.NOTHING_TO_ASK) {
+ store.calculateWhenNothingToAsk(order);
+ }
+ }
+
+ private Orders askProductAndPrice(Store store) {
+ return Task.repeatUntilValid(() -> {
+ String input = inputView.getProductAndPrice();
+ return makeValidateOrder(input, store);
+ });
+ }
+
+ private boolean askGetOneFree(Order order) {
+ return Task.repeatUntilValid(() -> inputView.getOneMoreFree(order));
+ }
+
+ private boolean askBuyOriginalPrice(Order order, int itemsAtOriginalPriceCount) {
+ return Task.repeatUntilValid(() -> inputView.getPurchaseOrNot(order.getName(), itemsAtOriginalPriceCount));
+ }
+
+ private boolean askGetMembership() {
+ return Task.repeatUntilValid(inputView::getMembershipDiscountOrNot);
+ }
+
+ private boolean askAdditionalPurchase() {
+ return Task.repeatUntilValid(inputView::getAdditionalPurchase);
+ }
+
+ private Orders makeValidateOrder(String input, Store store) {
+ String[] inputProducts = input.split(",", -1);
+ Orders orders = new Orders();
+ orders.addProduct(inputProducts, store);
+ return orders;
+ }
+
+ private Store bringProducts() {
+ Reader reader = new Reader();
+ List<String> lines = reader.readLines("src/main/resources/products.md").stream().skip(1).toList();
+ List<Product> promotionProducts = new ArrayList<>();
+ List<Product> normalProducts = new ArrayList<>();
+ lines.forEach(line -> updateProducts(line, promotionProducts, normalProducts));
+ return makeValidStore(promotionProducts, normalProducts);
+ }
+
+ private void updateProducts(String line, List<Product> promotionProducts, List<Product> normalProducts) {
+ Product product = new Product(line);
+ if (product.isPromotion()) {
+ promotionProducts.add(product);
+ return;
+ }
+ normalProducts.add(product);
+ }
+
+ private Store makeValidStore(List<Product> promotionProducts, List<Product> normalProducts) {
+ Store store = new Store();
+ promotionProducts.forEach(promotion -> {
+ Product normal = getNormalProduct(normalProducts, promotion);
+ normalProducts.remove(normal);
+ store.addProduct(promotion.getName(), new Products(List.of(promotion, normal)));
+ });
+ normalProducts.forEach(normal ->
+ store.addProduct(normal.getName(), new Products(List.of(normal)))
+ );
+ return store;
+ }
+
+ private void updateStockResult(Store store) {
+ try {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+ writer.write(PRODUCT_FILE_CATEGORY);
+ for (Map.Entry<String, Products> mapElement : store.getStoreProducts().entrySet()) {
+ writeProducts(writer, mapElement.getValue());
+ }
+ writer.close();
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private void writeProducts(BufferedWriter writer, Products products) {
+ try {
+ for (Product product : products.getProducts()) {
+ writer.write(product.getName() + "," + product.getPrice() + "," + product.getQuantity() + "," + product.getPromotion() + "\n");
+ }
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private Product getNormalProduct(List<Product> normalProducts, Product promotionProduct) {
+ for (Product normal : normalProducts) {
+ if (normal.getName().equals(promotionProduct.getName())) {
+ return normal;
+ }
+ }
+ return new Product(
+ promotionProduct.getName() + "," + promotionProduct.getPrice() + ",0,null");
+ }
+}
+ | Java | ,와 \n은 상수화를 시키는 것이 좋을 것 같습니다. |
@@ -0,0 +1,159 @@
+package store.controller;
+
+import store.constant.ProductState;
+import store.model.*;
+import store.util.Reader;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Screen {
+ public static final String PRODUCT_FILE_CATEGORY = "name,price,quantity,promotion\n";
+
+ private final InputView inputView;
+ private final OutputView outputView;
+
+
+ public Screen(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ }
+
+ public void run() {
+ do {
+ Store store = bringProducts();
+ outputView.printStoreMenu(store);
+
+ Orders orders = askProductAndPrice(store);
+ checkProducts(orders, store);
+
+ Receipt receipt = store.getReceipt(askGetMembership());
+ outputView.printReceipt(orders, store, receipt);
+ updateStockResult(store);
+ } while (askAdditionalPurchase());
+ }
+
+ public void checkProducts(Orders orders, Store store) {
+ for (Order order : orders.getOrders()) {
+ ProductState productState = store.getProductState(order);
+ if (productState == ProductState.NO_PROMOTION_PERIOD) {
+ continue;
+ }
+ calculateWhenPromotionPeriod(order, store, productState);
+ }
+ }
+
+ private void calculateWhenPromotionPeriod(Order order, Store store, ProductState productState) {
+ if (productState == ProductState.GET_ONE_FREE) {
+ store.calculateWhenGetOneFreeCase(order, askGetOneFree(order));
+ return;
+ }
+ if (productState == ProductState.BUY_ORIGINAL_PRICE) {
+ store.calculateWhenBuyOriginalPrice(order, askBuyOriginalPrice(order, store.countBuyOriginalPrice(order)));
+ return;
+ }
+ if (productState == ProductState.NOTHING_TO_ASK) {
+ store.calculateWhenNothingToAsk(order);
+ }
+ }
+
+ private Orders askProductAndPrice(Store store) {
+ return Task.repeatUntilValid(() -> {
+ String input = inputView.getProductAndPrice();
+ return makeValidateOrder(input, store);
+ });
+ }
+
+ private boolean askGetOneFree(Order order) {
+ return Task.repeatUntilValid(() -> inputView.getOneMoreFree(order));
+ }
+
+ private boolean askBuyOriginalPrice(Order order, int itemsAtOriginalPriceCount) {
+ return Task.repeatUntilValid(() -> inputView.getPurchaseOrNot(order.getName(), itemsAtOriginalPriceCount));
+ }
+
+ private boolean askGetMembership() {
+ return Task.repeatUntilValid(inputView::getMembershipDiscountOrNot);
+ }
+
+ private boolean askAdditionalPurchase() {
+ return Task.repeatUntilValid(inputView::getAdditionalPurchase);
+ }
+
+ private Orders makeValidateOrder(String input, Store store) {
+ String[] inputProducts = input.split(",", -1);
+ Orders orders = new Orders();
+ orders.addProduct(inputProducts, store);
+ return orders;
+ }
+
+ private Store bringProducts() {
+ Reader reader = new Reader();
+ List<String> lines = reader.readLines("src/main/resources/products.md").stream().skip(1).toList();
+ List<Product> promotionProducts = new ArrayList<>();
+ List<Product> normalProducts = new ArrayList<>();
+ lines.forEach(line -> updateProducts(line, promotionProducts, normalProducts));
+ return makeValidStore(promotionProducts, normalProducts);
+ }
+
+ private void updateProducts(String line, List<Product> promotionProducts, List<Product> normalProducts) {
+ Product product = new Product(line);
+ if (product.isPromotion()) {
+ promotionProducts.add(product);
+ return;
+ }
+ normalProducts.add(product);
+ }
+
+ private Store makeValidStore(List<Product> promotionProducts, List<Product> normalProducts) {
+ Store store = new Store();
+ promotionProducts.forEach(promotion -> {
+ Product normal = getNormalProduct(normalProducts, promotion);
+ normalProducts.remove(normal);
+ store.addProduct(promotion.getName(), new Products(List.of(promotion, normal)));
+ });
+ normalProducts.forEach(normal ->
+ store.addProduct(normal.getName(), new Products(List.of(normal)))
+ );
+ return store;
+ }
+
+ private void updateStockResult(Store store) {
+ try {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+ writer.write(PRODUCT_FILE_CATEGORY);
+ for (Map.Entry<String, Products> mapElement : store.getStoreProducts().entrySet()) {
+ writeProducts(writer, mapElement.getValue());
+ }
+ writer.close();
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private void writeProducts(BufferedWriter writer, Products products) {
+ try {
+ for (Product product : products.getProducts()) {
+ writer.write(product.getName() + "," + product.getPrice() + "," + product.getQuantity() + "," + product.getPromotion() + "\n");
+ }
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private Product getNormalProduct(List<Product> normalProducts, Product promotionProduct) {
+ for (Product normal : normalProducts) {
+ if (normal.getName().equals(promotionProduct.getName())) {
+ return normal;
+ }
+ }
+ return new Product(
+ promotionProduct.getName() + "," + promotionProduct.getPrice() + ",0,null");
+ }
+}
+ | Java | 맵을 엔트리로 요소를 뽑아오기보다는 키로 뽑아 사용하는 것이 더 가독성이 좋아질 것 같아요 |
@@ -0,0 +1,159 @@
+package store.controller;
+
+import store.constant.ProductState;
+import store.model.*;
+import store.util.Reader;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Screen {
+ public static final String PRODUCT_FILE_CATEGORY = "name,price,quantity,promotion\n";
+
+ private final InputView inputView;
+ private final OutputView outputView;
+
+
+ public Screen(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ }
+
+ public void run() {
+ do {
+ Store store = bringProducts();
+ outputView.printStoreMenu(store);
+
+ Orders orders = askProductAndPrice(store);
+ checkProducts(orders, store);
+
+ Receipt receipt = store.getReceipt(askGetMembership());
+ outputView.printReceipt(orders, store, receipt);
+ updateStockResult(store);
+ } while (askAdditionalPurchase());
+ }
+
+ public void checkProducts(Orders orders, Store store) {
+ for (Order order : orders.getOrders()) {
+ ProductState productState = store.getProductState(order);
+ if (productState == ProductState.NO_PROMOTION_PERIOD) {
+ continue;
+ }
+ calculateWhenPromotionPeriod(order, store, productState);
+ }
+ }
+
+ private void calculateWhenPromotionPeriod(Order order, Store store, ProductState productState) {
+ if (productState == ProductState.GET_ONE_FREE) {
+ store.calculateWhenGetOneFreeCase(order, askGetOneFree(order));
+ return;
+ }
+ if (productState == ProductState.BUY_ORIGINAL_PRICE) {
+ store.calculateWhenBuyOriginalPrice(order, askBuyOriginalPrice(order, store.countBuyOriginalPrice(order)));
+ return;
+ }
+ if (productState == ProductState.NOTHING_TO_ASK) {
+ store.calculateWhenNothingToAsk(order);
+ }
+ }
+
+ private Orders askProductAndPrice(Store store) {
+ return Task.repeatUntilValid(() -> {
+ String input = inputView.getProductAndPrice();
+ return makeValidateOrder(input, store);
+ });
+ }
+
+ private boolean askGetOneFree(Order order) {
+ return Task.repeatUntilValid(() -> inputView.getOneMoreFree(order));
+ }
+
+ private boolean askBuyOriginalPrice(Order order, int itemsAtOriginalPriceCount) {
+ return Task.repeatUntilValid(() -> inputView.getPurchaseOrNot(order.getName(), itemsAtOriginalPriceCount));
+ }
+
+ private boolean askGetMembership() {
+ return Task.repeatUntilValid(inputView::getMembershipDiscountOrNot);
+ }
+
+ private boolean askAdditionalPurchase() {
+ return Task.repeatUntilValid(inputView::getAdditionalPurchase);
+ }
+
+ private Orders makeValidateOrder(String input, Store store) {
+ String[] inputProducts = input.split(",", -1);
+ Orders orders = new Orders();
+ orders.addProduct(inputProducts, store);
+ return orders;
+ }
+
+ private Store bringProducts() {
+ Reader reader = new Reader();
+ List<String> lines = reader.readLines("src/main/resources/products.md").stream().skip(1).toList();
+ List<Product> promotionProducts = new ArrayList<>();
+ List<Product> normalProducts = new ArrayList<>();
+ lines.forEach(line -> updateProducts(line, promotionProducts, normalProducts));
+ return makeValidStore(promotionProducts, normalProducts);
+ }
+
+ private void updateProducts(String line, List<Product> promotionProducts, List<Product> normalProducts) {
+ Product product = new Product(line);
+ if (product.isPromotion()) {
+ promotionProducts.add(product);
+ return;
+ }
+ normalProducts.add(product);
+ }
+
+ private Store makeValidStore(List<Product> promotionProducts, List<Product> normalProducts) {
+ Store store = new Store();
+ promotionProducts.forEach(promotion -> {
+ Product normal = getNormalProduct(normalProducts, promotion);
+ normalProducts.remove(normal);
+ store.addProduct(promotion.getName(), new Products(List.of(promotion, normal)));
+ });
+ normalProducts.forEach(normal ->
+ store.addProduct(normal.getName(), new Products(List.of(normal)))
+ );
+ return store;
+ }
+
+ private void updateStockResult(Store store) {
+ try {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+ writer.write(PRODUCT_FILE_CATEGORY);
+ for (Map.Entry<String, Products> mapElement : store.getStoreProducts().entrySet()) {
+ writeProducts(writer, mapElement.getValue());
+ }
+ writer.close();
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private void writeProducts(BufferedWriter writer, Products products) {
+ try {
+ for (Product product : products.getProducts()) {
+ writer.write(product.getName() + "," + product.getPrice() + "," + product.getQuantity() + "," + product.getPromotion() + "\n");
+ }
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private Product getNormalProduct(List<Product> normalProducts, Product promotionProduct) {
+ for (Product normal : normalProducts) {
+ if (normal.getName().equals(promotionProduct.getName())) {
+ return normal;
+ }
+ }
+ return new Product(
+ promotionProduct.getName() + "," + promotionProduct.getPrice() + ",0,null");
+ }
+}
+ | Java | 개인적으로 forEach를 사용할때 내부함수가 여러 줄인 경우 내부 함수는 따로 메서드로 뽑아내거나 for을 사용하는게 더 나을 것 같습니다. |
@@ -0,0 +1,159 @@
+package store.controller;
+
+import store.constant.ProductState;
+import store.model.*;
+import store.util.Reader;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Screen {
+ public static final String PRODUCT_FILE_CATEGORY = "name,price,quantity,promotion\n";
+
+ private final InputView inputView;
+ private final OutputView outputView;
+
+
+ public Screen(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ }
+
+ public void run() {
+ do {
+ Store store = bringProducts();
+ outputView.printStoreMenu(store);
+
+ Orders orders = askProductAndPrice(store);
+ checkProducts(orders, store);
+
+ Receipt receipt = store.getReceipt(askGetMembership());
+ outputView.printReceipt(orders, store, receipt);
+ updateStockResult(store);
+ } while (askAdditionalPurchase());
+ }
+
+ public void checkProducts(Orders orders, Store store) {
+ for (Order order : orders.getOrders()) {
+ ProductState productState = store.getProductState(order);
+ if (productState == ProductState.NO_PROMOTION_PERIOD) {
+ continue;
+ }
+ calculateWhenPromotionPeriod(order, store, productState);
+ }
+ }
+
+ private void calculateWhenPromotionPeriod(Order order, Store store, ProductState productState) {
+ if (productState == ProductState.GET_ONE_FREE) {
+ store.calculateWhenGetOneFreeCase(order, askGetOneFree(order));
+ return;
+ }
+ if (productState == ProductState.BUY_ORIGINAL_PRICE) {
+ store.calculateWhenBuyOriginalPrice(order, askBuyOriginalPrice(order, store.countBuyOriginalPrice(order)));
+ return;
+ }
+ if (productState == ProductState.NOTHING_TO_ASK) {
+ store.calculateWhenNothingToAsk(order);
+ }
+ }
+
+ private Orders askProductAndPrice(Store store) {
+ return Task.repeatUntilValid(() -> {
+ String input = inputView.getProductAndPrice();
+ return makeValidateOrder(input, store);
+ });
+ }
+
+ private boolean askGetOneFree(Order order) {
+ return Task.repeatUntilValid(() -> inputView.getOneMoreFree(order));
+ }
+
+ private boolean askBuyOriginalPrice(Order order, int itemsAtOriginalPriceCount) {
+ return Task.repeatUntilValid(() -> inputView.getPurchaseOrNot(order.getName(), itemsAtOriginalPriceCount));
+ }
+
+ private boolean askGetMembership() {
+ return Task.repeatUntilValid(inputView::getMembershipDiscountOrNot);
+ }
+
+ private boolean askAdditionalPurchase() {
+ return Task.repeatUntilValid(inputView::getAdditionalPurchase);
+ }
+
+ private Orders makeValidateOrder(String input, Store store) {
+ String[] inputProducts = input.split(",", -1);
+ Orders orders = new Orders();
+ orders.addProduct(inputProducts, store);
+ return orders;
+ }
+
+ private Store bringProducts() {
+ Reader reader = new Reader();
+ List<String> lines = reader.readLines("src/main/resources/products.md").stream().skip(1).toList();
+ List<Product> promotionProducts = new ArrayList<>();
+ List<Product> normalProducts = new ArrayList<>();
+ lines.forEach(line -> updateProducts(line, promotionProducts, normalProducts));
+ return makeValidStore(promotionProducts, normalProducts);
+ }
+
+ private void updateProducts(String line, List<Product> promotionProducts, List<Product> normalProducts) {
+ Product product = new Product(line);
+ if (product.isPromotion()) {
+ promotionProducts.add(product);
+ return;
+ }
+ normalProducts.add(product);
+ }
+
+ private Store makeValidStore(List<Product> promotionProducts, List<Product> normalProducts) {
+ Store store = new Store();
+ promotionProducts.forEach(promotion -> {
+ Product normal = getNormalProduct(normalProducts, promotion);
+ normalProducts.remove(normal);
+ store.addProduct(promotion.getName(), new Products(List.of(promotion, normal)));
+ });
+ normalProducts.forEach(normal ->
+ store.addProduct(normal.getName(), new Products(List.of(normal)))
+ );
+ return store;
+ }
+
+ private void updateStockResult(Store store) {
+ try {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+ writer.write(PRODUCT_FILE_CATEGORY);
+ for (Map.Entry<String, Products> mapElement : store.getStoreProducts().entrySet()) {
+ writeProducts(writer, mapElement.getValue());
+ }
+ writer.close();
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private void writeProducts(BufferedWriter writer, Products products) {
+ try {
+ for (Product product : products.getProducts()) {
+ writer.write(product.getName() + "," + product.getPrice() + "," + product.getQuantity() + "," + product.getPromotion() + "\n");
+ }
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private Product getNormalProduct(List<Product> normalProducts, Product promotionProduct) {
+ for (Product normal : normalProducts) {
+ if (normal.getName().equals(promotionProduct.getName())) {
+ return normal;
+ }
+ }
+ return new Product(
+ promotionProduct.getName() + "," + promotionProduct.getPrice() + ",0,null");
+ }
+}
+ | Java | 파일의 위치가 따로 상수로 지정되어있으면 좋을 것 같습니다. 또한 skip(1)도 1을 상수로 부여하며 이름을 의미있게 지어 다른 사람들이 읽을 때 의미를 전달하면 더 좋을 것 같습니다. |
@@ -0,0 +1,159 @@
+package store.controller;
+
+import store.constant.ProductState;
+import store.model.*;
+import store.util.Reader;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Screen {
+ public static final String PRODUCT_FILE_CATEGORY = "name,price,quantity,promotion\n";
+
+ private final InputView inputView;
+ private final OutputView outputView;
+
+
+ public Screen(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ }
+
+ public void run() {
+ do {
+ Store store = bringProducts();
+ outputView.printStoreMenu(store);
+
+ Orders orders = askProductAndPrice(store);
+ checkProducts(orders, store);
+
+ Receipt receipt = store.getReceipt(askGetMembership());
+ outputView.printReceipt(orders, store, receipt);
+ updateStockResult(store);
+ } while (askAdditionalPurchase());
+ }
+
+ public void checkProducts(Orders orders, Store store) {
+ for (Order order : orders.getOrders()) {
+ ProductState productState = store.getProductState(order);
+ if (productState == ProductState.NO_PROMOTION_PERIOD) {
+ continue;
+ }
+ calculateWhenPromotionPeriod(order, store, productState);
+ }
+ }
+
+ private void calculateWhenPromotionPeriod(Order order, Store store, ProductState productState) {
+ if (productState == ProductState.GET_ONE_FREE) {
+ store.calculateWhenGetOneFreeCase(order, askGetOneFree(order));
+ return;
+ }
+ if (productState == ProductState.BUY_ORIGINAL_PRICE) {
+ store.calculateWhenBuyOriginalPrice(order, askBuyOriginalPrice(order, store.countBuyOriginalPrice(order)));
+ return;
+ }
+ if (productState == ProductState.NOTHING_TO_ASK) {
+ store.calculateWhenNothingToAsk(order);
+ }
+ }
+
+ private Orders askProductAndPrice(Store store) {
+ return Task.repeatUntilValid(() -> {
+ String input = inputView.getProductAndPrice();
+ return makeValidateOrder(input, store);
+ });
+ }
+
+ private boolean askGetOneFree(Order order) {
+ return Task.repeatUntilValid(() -> inputView.getOneMoreFree(order));
+ }
+
+ private boolean askBuyOriginalPrice(Order order, int itemsAtOriginalPriceCount) {
+ return Task.repeatUntilValid(() -> inputView.getPurchaseOrNot(order.getName(), itemsAtOriginalPriceCount));
+ }
+
+ private boolean askGetMembership() {
+ return Task.repeatUntilValid(inputView::getMembershipDiscountOrNot);
+ }
+
+ private boolean askAdditionalPurchase() {
+ return Task.repeatUntilValid(inputView::getAdditionalPurchase);
+ }
+
+ private Orders makeValidateOrder(String input, Store store) {
+ String[] inputProducts = input.split(",", -1);
+ Orders orders = new Orders();
+ orders.addProduct(inputProducts, store);
+ return orders;
+ }
+
+ private Store bringProducts() {
+ Reader reader = new Reader();
+ List<String> lines = reader.readLines("src/main/resources/products.md").stream().skip(1).toList();
+ List<Product> promotionProducts = new ArrayList<>();
+ List<Product> normalProducts = new ArrayList<>();
+ lines.forEach(line -> updateProducts(line, promotionProducts, normalProducts));
+ return makeValidStore(promotionProducts, normalProducts);
+ }
+
+ private void updateProducts(String line, List<Product> promotionProducts, List<Product> normalProducts) {
+ Product product = new Product(line);
+ if (product.isPromotion()) {
+ promotionProducts.add(product);
+ return;
+ }
+ normalProducts.add(product);
+ }
+
+ private Store makeValidStore(List<Product> promotionProducts, List<Product> normalProducts) {
+ Store store = new Store();
+ promotionProducts.forEach(promotion -> {
+ Product normal = getNormalProduct(normalProducts, promotion);
+ normalProducts.remove(normal);
+ store.addProduct(promotion.getName(), new Products(List.of(promotion, normal)));
+ });
+ normalProducts.forEach(normal ->
+ store.addProduct(normal.getName(), new Products(List.of(normal)))
+ );
+ return store;
+ }
+
+ private void updateStockResult(Store store) {
+ try {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+ writer.write(PRODUCT_FILE_CATEGORY);
+ for (Map.Entry<String, Products> mapElement : store.getStoreProducts().entrySet()) {
+ writeProducts(writer, mapElement.getValue());
+ }
+ writer.close();
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private void writeProducts(BufferedWriter writer, Products products) {
+ try {
+ for (Product product : products.getProducts()) {
+ writer.write(product.getName() + "," + product.getPrice() + "," + product.getQuantity() + "," + product.getPromotion() + "\n");
+ }
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private Product getNormalProduct(List<Product> normalProducts, Product promotionProduct) {
+ for (Product normal : normalProducts) {
+ if (normal.getName().equals(promotionProduct.getName())) {
+ return normal;
+ }
+ }
+ return new Product(
+ promotionProduct.getName() + "," + promotionProduct.getPrice() + ",0,null");
+ }
+}
+ | Java | -1은 없어도 괜찮을 것 같습니다. |
@@ -0,0 +1,159 @@
+package store.controller;
+
+import store.constant.ProductState;
+import store.model.*;
+import store.util.Reader;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Screen {
+ public static final String PRODUCT_FILE_CATEGORY = "name,price,quantity,promotion\n";
+
+ private final InputView inputView;
+ private final OutputView outputView;
+
+
+ public Screen(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ }
+
+ public void run() {
+ do {
+ Store store = bringProducts();
+ outputView.printStoreMenu(store);
+
+ Orders orders = askProductAndPrice(store);
+ checkProducts(orders, store);
+
+ Receipt receipt = store.getReceipt(askGetMembership());
+ outputView.printReceipt(orders, store, receipt);
+ updateStockResult(store);
+ } while (askAdditionalPurchase());
+ }
+
+ public void checkProducts(Orders orders, Store store) {
+ for (Order order : orders.getOrders()) {
+ ProductState productState = store.getProductState(order);
+ if (productState == ProductState.NO_PROMOTION_PERIOD) {
+ continue;
+ }
+ calculateWhenPromotionPeriod(order, store, productState);
+ }
+ }
+
+ private void calculateWhenPromotionPeriod(Order order, Store store, ProductState productState) {
+ if (productState == ProductState.GET_ONE_FREE) {
+ store.calculateWhenGetOneFreeCase(order, askGetOneFree(order));
+ return;
+ }
+ if (productState == ProductState.BUY_ORIGINAL_PRICE) {
+ store.calculateWhenBuyOriginalPrice(order, askBuyOriginalPrice(order, store.countBuyOriginalPrice(order)));
+ return;
+ }
+ if (productState == ProductState.NOTHING_TO_ASK) {
+ store.calculateWhenNothingToAsk(order);
+ }
+ }
+
+ private Orders askProductAndPrice(Store store) {
+ return Task.repeatUntilValid(() -> {
+ String input = inputView.getProductAndPrice();
+ return makeValidateOrder(input, store);
+ });
+ }
+
+ private boolean askGetOneFree(Order order) {
+ return Task.repeatUntilValid(() -> inputView.getOneMoreFree(order));
+ }
+
+ private boolean askBuyOriginalPrice(Order order, int itemsAtOriginalPriceCount) {
+ return Task.repeatUntilValid(() -> inputView.getPurchaseOrNot(order.getName(), itemsAtOriginalPriceCount));
+ }
+
+ private boolean askGetMembership() {
+ return Task.repeatUntilValid(inputView::getMembershipDiscountOrNot);
+ }
+
+ private boolean askAdditionalPurchase() {
+ return Task.repeatUntilValid(inputView::getAdditionalPurchase);
+ }
+
+ private Orders makeValidateOrder(String input, Store store) {
+ String[] inputProducts = input.split(",", -1);
+ Orders orders = new Orders();
+ orders.addProduct(inputProducts, store);
+ return orders;
+ }
+
+ private Store bringProducts() {
+ Reader reader = new Reader();
+ List<String> lines = reader.readLines("src/main/resources/products.md").stream().skip(1).toList();
+ List<Product> promotionProducts = new ArrayList<>();
+ List<Product> normalProducts = new ArrayList<>();
+ lines.forEach(line -> updateProducts(line, promotionProducts, normalProducts));
+ return makeValidStore(promotionProducts, normalProducts);
+ }
+
+ private void updateProducts(String line, List<Product> promotionProducts, List<Product> normalProducts) {
+ Product product = new Product(line);
+ if (product.isPromotion()) {
+ promotionProducts.add(product);
+ return;
+ }
+ normalProducts.add(product);
+ }
+
+ private Store makeValidStore(List<Product> promotionProducts, List<Product> normalProducts) {
+ Store store = new Store();
+ promotionProducts.forEach(promotion -> {
+ Product normal = getNormalProduct(normalProducts, promotion);
+ normalProducts.remove(normal);
+ store.addProduct(promotion.getName(), new Products(List.of(promotion, normal)));
+ });
+ normalProducts.forEach(normal ->
+ store.addProduct(normal.getName(), new Products(List.of(normal)))
+ );
+ return store;
+ }
+
+ private void updateStockResult(Store store) {
+ try {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+ writer.write(PRODUCT_FILE_CATEGORY);
+ for (Map.Entry<String, Products> mapElement : store.getStoreProducts().entrySet()) {
+ writeProducts(writer, mapElement.getValue());
+ }
+ writer.close();
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private void writeProducts(BufferedWriter writer, Products products) {
+ try {
+ for (Product product : products.getProducts()) {
+ writer.write(product.getName() + "," + product.getPrice() + "," + product.getQuantity() + "," + product.getPromotion() + "\n");
+ }
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage());
+ }
+ }
+
+ private Product getNormalProduct(List<Product> normalProducts, Product promotionProduct) {
+ for (Product normal : normalProducts) {
+ if (normal.getName().equals(promotionProduct.getName())) {
+ return normal;
+ }
+ }
+ return new Product(
+ promotionProduct.getName() + "," + promotionProduct.getPrice() + ",0,null");
+ }
+}
+ | Java | ```suggestion
if (productState != ProductState.NO_PROMOTION_PERIOD) {
calculateWhenPromotionPeriod(order, store, productState);
}
```
위와 같이 고치는 것이 더 좋을 것 같습니다. |
@@ -0,0 +1,7 @@
+package store.exception;
+
+public class InvalidDuplicateOrder extends IllegalArgumentException {
+ public InvalidDuplicateOrder() {
+ super("[ERROR] 중복되는 상품을 입력했습니다. 다시 입력해주세요.");
+ }
+} | Java | [ERROR]은 에러출력 형식이니 에러를 출력할때 합쳐도 좋을 것 같습니다.
또한 에러 메세지를 한곳에 모아두는게 더 좋을 것 같습니다. enum사용하시면 좋을 것 같습니다. |
@@ -0,0 +1,7 @@
+package store.exception;
+
+public class InvalidDuplicateOrder extends IllegalArgumentException {
+ public InvalidDuplicateOrder() {
+ super("[ERROR] 중복되는 상품을 입력했습니다. 다시 입력해주세요.");
+ }
+} | Java | 하나의 커스텀 Exception을 만들지 않고 여러가지로 구현하신 이유가 있을까요? |
@@ -0,0 +1,19 @@
+package store.model;
+
+public class GiftProduct {
+ private final String name;
+ private final int quantity;
+
+ public GiftProduct(Product promotion, int possibleGiftProducts) {
+ this.name = promotion.getName();
+ this.quantity = possibleGiftProducts / promotion.getPromotionCount();
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public int getQuantity() {
+ return quantity;
+ }
+} | Java | 앞에서 추가적으로 연산하고 다시 원래대로 되돌리는 연산은 비효율적인 것 같습니다... |
@@ -0,0 +1,19 @@
+package store.model;
+
+public class GiftProduct {
+ private final String name;
+ private final int quantity;
+
+ public GiftProduct(Product promotion, int possibleGiftProducts) {
+ this.name = promotion.getName();
+ this.quantity = possibleGiftProducts / promotion.getPromotionCount();
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public int getQuantity() {
+ return quantity;
+ }
+} | Java | 만일 연산이 완료된 상태로 순수 데이터 저장을 위한 것이라면 record를 사용할 수 있으니 이 부분도 참고하시면 좋을 것 같습니다. |
@@ -0,0 +1,65 @@
+package store.model;
+
+import store.util.Parser;
+
+public class Product {
+ private final String name;
+ private final int price;
+ private int quantity;
+ private final String promotion;
+ private final PromotionPolicy promotionPolicy;
+
+ public Product(String line) {
+ String[] product = line.split(",");
+ this.name = product[0];
+ this.price = Parser.parseToInt(product[1]);
+ this.quantity = Parser.parseToInt(product[2]);
+ this.promotion = product[3];
+ promotionPolicy = new PromotionPolicy(promotion);
+ }
+
+ public boolean isPromotionBenefitPossibleLeft(Order order) {
+ int promotionRemainingCount = getNoPromotionBenefit(order.getQuantity());
+ return promotionRemainingCount == getPromotionBuyCount();
+ }
+
+ public void reduceStock(int num) {
+ quantity -= num;
+ }
+
+ public boolean isPromotion() {
+ return !promotion.equals("null");
+ }
+
+ public boolean isPromotionPeriod() {
+ return promotionPolicy.isValidPeriod();
+ }
+
+ public int getNoPromotionBenefit(int num) {
+ return num % getPromotionCount();
+ }
+
+ public int getPromotionCount() {
+ return promotionPolicy.getPromotionCount();
+ }
+
+ public int getPromotionBuyCount() {
+ return promotionPolicy.getPromotionBuyCount();
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public int getPrice() {
+ return price;
+ }
+
+ public int getQuantity() {
+ return quantity;
+ }
+
+ public String getPromotion() {
+ return promotion;
+ }
+} | Java | 저도 이렇게 만드는 것을 생각해봤는데 이 부분이 View와 model의 경계에 있는 부분 같습니다. 저는 view에서 데이터를 정제하여 dto를 통해 전달하는 것도 나쁘지 않다고 생각하는데 hayeoungLee님은 어떻게 생각하시나요? |
@@ -0,0 +1,65 @@
+package store.model;
+
+import store.util.Parser;
+
+public class Product {
+ private final String name;
+ private final int price;
+ private int quantity;
+ private final String promotion;
+ private final PromotionPolicy promotionPolicy;
+
+ public Product(String line) {
+ String[] product = line.split(",");
+ this.name = product[0];
+ this.price = Parser.parseToInt(product[1]);
+ this.quantity = Parser.parseToInt(product[2]);
+ this.promotion = product[3];
+ promotionPolicy = new PromotionPolicy(promotion);
+ }
+
+ public boolean isPromotionBenefitPossibleLeft(Order order) {
+ int promotionRemainingCount = getNoPromotionBenefit(order.getQuantity());
+ return promotionRemainingCount == getPromotionBuyCount();
+ }
+
+ public void reduceStock(int num) {
+ quantity -= num;
+ }
+
+ public boolean isPromotion() {
+ return !promotion.equals("null");
+ }
+
+ public boolean isPromotionPeriod() {
+ return promotionPolicy.isValidPeriod();
+ }
+
+ public int getNoPromotionBenefit(int num) {
+ return num % getPromotionCount();
+ }
+
+ public int getPromotionCount() {
+ return promotionPolicy.getPromotionCount();
+ }
+
+ public int getPromotionBuyCount() {
+ return promotionPolicy.getPromotionBuyCount();
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public int getPrice() {
+ return price;
+ }
+
+ public int getQuantity() {
+ return quantity;
+ }
+
+ public String getPromotion() {
+ return promotion;
+ }
+} | Java | 프로모션이 적용이 되었나라는 질문이니 프로모션 기간인지 확인하는 부분도 있으면 더 좋을 것 같습니다. |
@@ -0,0 +1,86 @@
+package store.model;
+
+import java.util.List;
+
+public class Products {
+ public static final int HAVE_PROMOTION_BENEFIT_SIZE = 2;
+ public static final int HAVE_NO_PROMOTION_BENEFIT_SIZE = 1;
+ List<Product> products;
+
+ public Products(List<Product> products) {
+ this.products = products;
+ }
+
+ public boolean isGetOneFree(Order order) {
+ Product promotion = getPromotionProduct();
+ return isPromotionPeriod() &&
+ isPromotionMoreThanOrder(order, promotion) &&
+ isPromotionBenefitPossibleLeft(order, promotion) &&
+ isPromotionStockEnough(order, promotion);
+ }
+
+ public boolean isBuyOriginalPrice(Order order) {
+ return countBuyOriginalPrice(order) > 0;
+ }
+
+ public boolean isPromotionPeriod() {
+ Product promotion = getPromotionProduct();
+ return promotion.isPromotionPeriod();
+ }
+
+ private boolean isPromotionMoreThanOrder(Order order, Product promotion) {
+ return promotion.getQuantity() > order.getQuantity();
+ }
+
+ private boolean isPromotionBenefitPossibleLeft(Order order, Product promotion) {
+ return promotion.isPromotionBenefitPossibleLeft(order);
+ }
+
+ private boolean isPromotionStockEnough(Order order, Product promotion) {
+ return promotion.getQuantity() >= order.getQuantity() + 1;
+ }
+
+ public int countBuyOriginalPrice(Order order) {
+ Product promotion = getPromotionProduct();
+ if (promotion.isPromotionPeriod() && !isPromotionMoreThanOrder(order, promotion)) {
+ return promotion.getNoPromotionBenefit(promotion.getQuantity()) + order.getQuantity() - promotion.getQuantity();
+ }
+ return 0;
+ }
+
+ public int countReducePromotionWhen(Order order) {
+ return order.getQuantity() - countBuyOriginalPrice(order);
+ }
+
+ public void doNotOrderOriginalPrice(Order order) {
+ order.decreaseQuantity(countBuyOriginalPrice(order));
+ }
+
+ public boolean isOrderQuantityBuyOnlyPromotionStock(Order order) {
+ return countBuyOriginalPrice(order) == order.getQuantity();
+ }
+
+ public Product getPromotionProduct() {
+ if (products.size() == HAVE_PROMOTION_BENEFIT_SIZE) {
+ return products.get(0);
+ }
+ if (products.size() == HAVE_NO_PROMOTION_BENEFIT_SIZE) {
+ return new Product(getNormalProduct().getName() + "," + getNormalProduct().getPrice() + ",0,null");
+ }
+ throw new IllegalArgumentException();
+ }
+
+ public Product getNormalProduct() {
+ if (products.size() == HAVE_PROMOTION_BENEFIT_SIZE) {
+ return products.get(1);
+ }
+ if (products.size() == HAVE_NO_PROMOTION_BENEFIT_SIZE) {
+ return products.get(0);
+ }
+ throw new IllegalArgumentException();
+ }
+
+ public List<Product> getProducts() {
+ return products;
+ }
+} | Java | ```suggestion
return promotion.getQuantity() > order.getQuantity();
```
이렇게 바꾸시는 것이 더 나을것 같습니다. |
@@ -0,0 +1,86 @@
+package store.model;
+
+import java.util.List;
+
+public class Products {
+ public static final int HAVE_PROMOTION_BENEFIT_SIZE = 2;
+ public static final int HAVE_NO_PROMOTION_BENEFIT_SIZE = 1;
+ List<Product> products;
+
+ public Products(List<Product> products) {
+ this.products = products;
+ }
+
+ public boolean isGetOneFree(Order order) {
+ Product promotion = getPromotionProduct();
+ return isPromotionPeriod() &&
+ isPromotionMoreThanOrder(order, promotion) &&
+ isPromotionBenefitPossibleLeft(order, promotion) &&
+ isPromotionStockEnough(order, promotion);
+ }
+
+ public boolean isBuyOriginalPrice(Order order) {
+ return countBuyOriginalPrice(order) > 0;
+ }
+
+ public boolean isPromotionPeriod() {
+ Product promotion = getPromotionProduct();
+ return promotion.isPromotionPeriod();
+ }
+
+ private boolean isPromotionMoreThanOrder(Order order, Product promotion) {
+ return promotion.getQuantity() > order.getQuantity();
+ }
+
+ private boolean isPromotionBenefitPossibleLeft(Order order, Product promotion) {
+ return promotion.isPromotionBenefitPossibleLeft(order);
+ }
+
+ private boolean isPromotionStockEnough(Order order, Product promotion) {
+ return promotion.getQuantity() >= order.getQuantity() + 1;
+ }
+
+ public int countBuyOriginalPrice(Order order) {
+ Product promotion = getPromotionProduct();
+ if (promotion.isPromotionPeriod() && !isPromotionMoreThanOrder(order, promotion)) {
+ return promotion.getNoPromotionBenefit(promotion.getQuantity()) + order.getQuantity() - promotion.getQuantity();
+ }
+ return 0;
+ }
+
+ public int countReducePromotionWhen(Order order) {
+ return order.getQuantity() - countBuyOriginalPrice(order);
+ }
+
+ public void doNotOrderOriginalPrice(Order order) {
+ order.decreaseQuantity(countBuyOriginalPrice(order));
+ }
+
+ public boolean isOrderQuantityBuyOnlyPromotionStock(Order order) {
+ return countBuyOriginalPrice(order) == order.getQuantity();
+ }
+
+ public Product getPromotionProduct() {
+ if (products.size() == HAVE_PROMOTION_BENEFIT_SIZE) {
+ return products.get(0);
+ }
+ if (products.size() == HAVE_NO_PROMOTION_BENEFIT_SIZE) {
+ return new Product(getNormalProduct().getName() + "," + getNormalProduct().getPrice() + ",0,null");
+ }
+ throw new IllegalArgumentException();
+ }
+
+ public Product getNormalProduct() {
+ if (products.size() == HAVE_PROMOTION_BENEFIT_SIZE) {
+ return products.get(1);
+ }
+ if (products.size() == HAVE_NO_PROMOTION_BENEFIT_SIZE) {
+ return products.get(0);
+ }
+ throw new IllegalArgumentException();
+ }
+
+ public List<Product> getProducts() {
+ return products;
+ }
+} | Java | 새로운 클래스를 통해 해당 부분을 메서드로 만든다면 더 좋을 것 같습니다. |
@@ -0,0 +1,86 @@
+package store.model;
+
+import java.util.List;
+
+public class Products {
+ public static final int HAVE_PROMOTION_BENEFIT_SIZE = 2;
+ public static final int HAVE_NO_PROMOTION_BENEFIT_SIZE = 1;
+ List<Product> products;
+
+ public Products(List<Product> products) {
+ this.products = products;
+ }
+
+ public boolean isGetOneFree(Order order) {
+ Product promotion = getPromotionProduct();
+ return isPromotionPeriod() &&
+ isPromotionMoreThanOrder(order, promotion) &&
+ isPromotionBenefitPossibleLeft(order, promotion) &&
+ isPromotionStockEnough(order, promotion);
+ }
+
+ public boolean isBuyOriginalPrice(Order order) {
+ return countBuyOriginalPrice(order) > 0;
+ }
+
+ public boolean isPromotionPeriod() {
+ Product promotion = getPromotionProduct();
+ return promotion.isPromotionPeriod();
+ }
+
+ private boolean isPromotionMoreThanOrder(Order order, Product promotion) {
+ return promotion.getQuantity() > order.getQuantity();
+ }
+
+ private boolean isPromotionBenefitPossibleLeft(Order order, Product promotion) {
+ return promotion.isPromotionBenefitPossibleLeft(order);
+ }
+
+ private boolean isPromotionStockEnough(Order order, Product promotion) {
+ return promotion.getQuantity() >= order.getQuantity() + 1;
+ }
+
+ public int countBuyOriginalPrice(Order order) {
+ Product promotion = getPromotionProduct();
+ if (promotion.isPromotionPeriod() && !isPromotionMoreThanOrder(order, promotion)) {
+ return promotion.getNoPromotionBenefit(promotion.getQuantity()) + order.getQuantity() - promotion.getQuantity();
+ }
+ return 0;
+ }
+
+ public int countReducePromotionWhen(Order order) {
+ return order.getQuantity() - countBuyOriginalPrice(order);
+ }
+
+ public void doNotOrderOriginalPrice(Order order) {
+ order.decreaseQuantity(countBuyOriginalPrice(order));
+ }
+
+ public boolean isOrderQuantityBuyOnlyPromotionStock(Order order) {
+ return countBuyOriginalPrice(order) == order.getQuantity();
+ }
+
+ public Product getPromotionProduct() {
+ if (products.size() == HAVE_PROMOTION_BENEFIT_SIZE) {
+ return products.get(0);
+ }
+ if (products.size() == HAVE_NO_PROMOTION_BENEFIT_SIZE) {
+ return new Product(getNormalProduct().getName() + "," + getNormalProduct().getPrice() + ",0,null");
+ }
+ throw new IllegalArgumentException();
+ }
+
+ public Product getNormalProduct() {
+ if (products.size() == HAVE_PROMOTION_BENEFIT_SIZE) {
+ return products.get(1);
+ }
+ if (products.size() == HAVE_NO_PROMOTION_BENEFIT_SIZE) {
+ return products.get(0);
+ }
+ throw new IllegalArgumentException();
+ }
+
+ public List<Product> getProducts() {
+ return products;
+ }
+} | Java | 새로운 생성자를 만들어 처리한다면 이런 작업이 필요 없을 것 같습니다. |
@@ -0,0 +1,86 @@
+package store.model;
+
+import java.util.List;
+
+public class Products {
+ public static final int HAVE_PROMOTION_BENEFIT_SIZE = 2;
+ public static final int HAVE_NO_PROMOTION_BENEFIT_SIZE = 1;
+ List<Product> products;
+
+ public Products(List<Product> products) {
+ this.products = products;
+ }
+
+ public boolean isGetOneFree(Order order) {
+ Product promotion = getPromotionProduct();
+ return isPromotionPeriod() &&
+ isPromotionMoreThanOrder(order, promotion) &&
+ isPromotionBenefitPossibleLeft(order, promotion) &&
+ isPromotionStockEnough(order, promotion);
+ }
+
+ public boolean isBuyOriginalPrice(Order order) {
+ return countBuyOriginalPrice(order) > 0;
+ }
+
+ public boolean isPromotionPeriod() {
+ Product promotion = getPromotionProduct();
+ return promotion.isPromotionPeriod();
+ }
+
+ private boolean isPromotionMoreThanOrder(Order order, Product promotion) {
+ return promotion.getQuantity() > order.getQuantity();
+ }
+
+ private boolean isPromotionBenefitPossibleLeft(Order order, Product promotion) {
+ return promotion.isPromotionBenefitPossibleLeft(order);
+ }
+
+ private boolean isPromotionStockEnough(Order order, Product promotion) {
+ return promotion.getQuantity() >= order.getQuantity() + 1;
+ }
+
+ public int countBuyOriginalPrice(Order order) {
+ Product promotion = getPromotionProduct();
+ if (promotion.isPromotionPeriod() && !isPromotionMoreThanOrder(order, promotion)) {
+ return promotion.getNoPromotionBenefit(promotion.getQuantity()) + order.getQuantity() - promotion.getQuantity();
+ }
+ return 0;
+ }
+
+ public int countReducePromotionWhen(Order order) {
+ return order.getQuantity() - countBuyOriginalPrice(order);
+ }
+
+ public void doNotOrderOriginalPrice(Order order) {
+ order.decreaseQuantity(countBuyOriginalPrice(order));
+ }
+
+ public boolean isOrderQuantityBuyOnlyPromotionStock(Order order) {
+ return countBuyOriginalPrice(order) == order.getQuantity();
+ }
+
+ public Product getPromotionProduct() {
+ if (products.size() == HAVE_PROMOTION_BENEFIT_SIZE) {
+ return products.get(0);
+ }
+ if (products.size() == HAVE_NO_PROMOTION_BENEFIT_SIZE) {
+ return new Product(getNormalProduct().getName() + "," + getNormalProduct().getPrice() + ",0,null");
+ }
+ throw new IllegalArgumentException();
+ }
+
+ public Product getNormalProduct() {
+ if (products.size() == HAVE_PROMOTION_BENEFIT_SIZE) {
+ return products.get(1);
+ }
+ if (products.size() == HAVE_NO_PROMOTION_BENEFIT_SIZE) {
+ return products.get(0);
+ }
+ throw new IllegalArgumentException();
+ }
+
+ public List<Product> getProducts() {
+ return products;
+ }
+} | Java | 1, 0에 해당하는 인덱스가 어떤 제품의 인덱스인지 표시할 상수를 작성하면 더 좋을 것 같습니다. |
@@ -0,0 +1,60 @@
+package store.model;
+
+import camp.nextstep.edu.missionutils.DateTimes;
+import store.util.Reader;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.List;
+
+public class PromotionPolicy {
+ private int promotionBuyCount;
+ private int promotionGetCount;
+ private String startDate;
+ private String endDate;
+
+ public PromotionPolicy(String productPromotion) {
+ promotionBuyCount = 0;
+ promotionGetCount = 0;
+ startDate = "9999-12-31";
+ endDate = "9999-12-31";
+ initPromotionInfo(productPromotion);
+ }
+
+ private void initPromotionInfo(String productPromotion) {
+ Reader reader = new Reader();
+ List<String> lines = reader.readLines("src/main/resources/promotions.md").stream().skip(1).toList();
+ lines.forEach(line -> updatePolicy(line, productPromotion));
+ }
+
+ private void updatePolicy(String line, String productPromotion) {
+ String[] promotionInfo = line.split(",");
+ String promotionName = promotionInfo[0];
+ if (promotionName.equals(productPromotion)) {
+ promotionBuyCount = Integer.parseInt(promotionInfo[1]);
+ promotionGetCount = Integer.parseInt(promotionInfo[2]);
+ startDate = promotionInfo[3];
+ endDate = promotionInfo[4];
+ }
+ }
+
+ public boolean isValidPeriod() {
+ LocalDateTime targetTime = DateTimes.now();
+
+ String[] startInfo = startDate.split("-");
+ String[] endInfo = endDate.split("-");
+
+ LocalDate targetDate = LocalDate.of(targetTime.getYear(), targetTime.getMonth(), targetTime.getDayOfMonth());
+ LocalDate startDate = LocalDate.of(Integer.parseInt(startInfo[0]), Integer.parseInt(startInfo[1]), Integer.parseInt(startInfo[2]));
+ LocalDate endDate = LocalDate.of(Integer.parseInt(endInfo[0]), Integer.parseInt(endInfo[1]), Integer.parseInt(endInfo[2]));
+ return !targetDate.isBefore(startDate) && !targetDate.isAfter(endDate);
+ }
+
+ public int getPromotionCount() {
+ return promotionBuyCount + promotionGetCount;
+ }
+
+ public int getPromotionBuyCount() {
+ return promotionBuyCount;
+ }
+} | Java | LocalDate.parse()를 사용하면 더 쉽게 바꿀 수 있으니 이를 참고하시면 좋을 것 같습니다. |
@@ -0,0 +1,113 @@
+package store.model;
+
+import store.constant.ProductState;
+import store.exception.InvalidNonExistOrder;
+import store.strategy.*;
+import store.strategy.PromotionPeriod.BuyOriginalPrice;
+import store.strategy.PromotionPeriod.GetOneFree;
+import store.strategy.PromotionPeriod.NothingToAsk;
+
+import java.util.LinkedHashMap;
+
+public class Store {
+ private final LinkedHashMap<String, Products> storeProducts;
+ private final Receipt receipt;
+
+ public Store() {
+ storeProducts = new LinkedHashMap<>();
+ receipt = new Receipt();
+ }
+
+ public void calculateOrder(Order order, StockManager stockManager, boolean answer) {
+ Products products = getProducts(order.getName());
+ Product normal = products.getNormalProduct();
+ Product promotion = products.getPromotionProduct();
+ int reduceNormal = stockManager.calculateNormalReduction(order, products, answer);
+ int reducePromotion = stockManager.calculatePromotionReduction(order, products, answer);
+
+ reduceStock(normal, reduceNormal);
+ reduceStock(promotion, reducePromotion);
+ receipt.updateTotalAndDiscount(order, normal, stockManager.getCanGetDiscount());
+ receipt.updateGiftProducts(promotion, reducePromotion);
+ }
+
+ public boolean executeWhenNotPromotionPeriod(Order order) {
+ Products products = getProducts(order.getName());
+ if (products.isPromotionPeriod()) {
+ return false;
+ }
+ calculateOrder(order, new NotPromotionPeriod(), true);
+ return true;
+ }
+
+ public ProductState getProductState(Order order) {
+ if (executeWhenNotPromotionPeriod(order)) {
+ return ProductState.NO_PROMOTION_PERIOD;
+ }
+ if (checkGetOneFree(order)) {
+ return ProductState.GET_ONE_FREE;
+ }
+ if (checkBuyOriginalPrice(order)) {
+ return ProductState.BUY_ORIGINAL_PRICE;
+ }
+ return ProductState.NOTHING_TO_ASK;
+ }
+
+ public boolean checkGetOneFree(Order order) {
+ Products products = getProducts(order.getName());
+ return products.isGetOneFree(order);
+ }
+
+ public void calculateWhenGetOneFreeCase(Order order, boolean isGetFree) {
+ calculateOrder(order, new GetOneFree(), isGetFree);
+ }
+
+ public boolean checkBuyOriginalPrice(Order order) {
+ Products products = getProducts(order.getName());
+ return products.isBuyOriginalPrice(order);
+ }
+
+ public void calculateWhenBuyOriginalPrice(Order order, boolean getOriginalPrice) {
+ Products products = getProducts(order.getName());
+ calculateOrder(order, new BuyOriginalPrice(order, products), getOriginalPrice);
+ }
+
+ public void calculateWhenNothingToAsk(Order order) {
+ calculateOrder(order, new NothingToAsk(), true);
+ }
+
+ public Receipt getReceipt(boolean isGetDiscount) {
+ if (!isGetDiscount) {
+ receipt.getNoMembershipDiscount();
+ }
+ return receipt;
+ }
+
+ public int countBuyOriginalPrice(Order order) {
+ Products products = getProducts(order.getName());
+ return products.countBuyOriginalPrice(order);
+ }
+
+ private void reduceStock(Product product, int countReduce) {
+ product.reduceStock(countReduce);
+ }
+
+ public void addProduct(String name, Products products) {
+ storeProducts.put(name, products);
+ }
+
+ public LinkedHashMap<String, Products> getStoreProducts() {
+ return storeProducts;
+ }
+
+ public Products getParticularStoreProducts(String name) {
+ if (storeProducts.get(name) == null) {
+ throw new InvalidNonExistOrder();
+ }
+ return storeProducts.get(name);
+ }
+
+ public Products getProducts(String name) {
+ return storeProducts.get(name);
+ }
+} | Java | 이 메서드는 외부에서 실행도 되지않아 private을 사용하는게 더 나을 것 같습니다. 또한 private의 경우 사용되는 public 밑에 위치시키면 읽기에 더 편할 것 같습니다. |
@@ -0,0 +1,45 @@
+package store.strategy.PromotionPeriod;
+
+import store.model.Order;
+import store.model.Product;
+import store.model.Products;
+import store.strategy.StockManager;
+
+public class BuyOriginalPrice implements StockManager {
+ private final boolean canGetDiscount;
+
+ public BuyOriginalPrice(Order order, Products products) {
+ this.canGetDiscount = products.isOrderQuantityBuyOnlyPromotionStock(order);
+ }
+
+ @Override
+ public int calculateNormalReduction(Order order, Products products, boolean getOriginalPrice) {
+ Product promotion = products.getPromotionProduct();
+
+ int reduceNormal = 0;
+ if (promotion.getQuantity() < order.getQuantity()) {
+ reduceNormal = order.getQuantity() - promotion.getQuantity();
+ }
+ if (!getOriginalPrice) {
+ reduceNormal = 0;
+ }
+ return reduceNormal;
+ }
+
+ @Override
+ public int calculatePromotionReduction(Order order, Products products, boolean getOriginalPrice) {
+ Product promotion = products.getPromotionProduct();
+
+ int reducePromotion = promotion.getQuantity();
+ if (!getOriginalPrice) {
+ reducePromotion = products.countReducePromotionWhen(order);
+ products.doNotOrderOriginalPrice(order);
+ }
+ return reducePromotion;
+ }
+
+ @Override
+ public boolean getCanGetDiscount() {
+ return canGetDiscount;
+ }
+} | Java | 이렇게 여러가지로 분류되는 것이라면 상속도 좋지만 enum은 어떤가요? |
@@ -0,0 +1,15 @@
+package store.util;
+
+public interface Task<T> {
+ static <T> T repeatUntilValid(Task<T> task) {
+ while (true) {
+ try {
+ return task.run();
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ T run();
+} | Java | 이게 반복하는 부분이였네요 Supplier를 사용하신다면 더 편하게 할 수 있을 것 같습니다. |
@@ -0,0 +1,108 @@
+package repository;
+
+import domain.Product;
+import domain.PromotionType;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import java.util.Optional;
+
+public class ProductRepository {
+ public static final String PRODUCTS_FILE_PATH = "src/main/resources/products.md";
+ public static final String FILE_LOADING_ERROR_MESSAGE = "[ERROR] 파일 로딩 중 오류 발생";
+ public static final String DELIMITER = ",";
+ public static final int NAME_INDEX = 0;
+ public static final int PRICE_INDEX = 1;
+ public static final int QUANTITY_INDEX = 2;
+ public static final int PROMOTION_INDEX = 3;
+
+ private final List<Product> products = new ArrayList<>();
+ private final PromotionRepository promotionRepository;
+
+ public ProductRepository(PromotionRepository promotionRepository) {
+ this.promotionRepository = promotionRepository;
+ loadProducts();
+ }
+
+ private void loadProducts() {
+ try (BufferedReader reader = new BufferedReader(new FileReader(PRODUCTS_FILE_PATH))) {
+ skipHeader(reader);
+ processProductLines(reader);
+ } catch (IOException e) {
+ System.out.println(FILE_LOADING_ERROR_MESSAGE);
+ }
+ }
+
+ private void processProductLines(BufferedReader reader) throws IOException {
+ String line;
+ while ((line = reader.readLine()) != null) {
+ if (!line.trim().isEmpty()) {
+ processProductLine(line);
+ }
+ }
+ }
+
+ private void processProductLine(String line) {
+ String[] parts = line.split(DELIMITER);
+ String name = parts[NAME_INDEX].trim();
+ int price = Integer.parseInt(parts[PRICE_INDEX].trim());
+ int quantity = Integer.parseInt(parts[QUANTITY_INDEX].trim());
+ String promotion = parts[PROMOTION_INDEX].trim();
+
+ PromotionType promotionType = getPromotionType(promotion);
+ boolean isPromo = (promotionType != PromotionType.NONE);
+
+ addOrUpdateProduct(name, price, quantity, promotion, promotionType, isPromo);
+ }
+
+ private void addOrUpdateProduct(String name, int price, int quantity, String promotion,
+ PromotionType promotionType, boolean isPromo) {
+ findExistingProduct(name).ifPresentOrElse(
+ product -> updateProductQuantity(product, quantity, isPromo),
+ () -> addNewProduct(name, price, quantity, promotion, promotionType, isPromo)
+ );
+ }
+
+ private void updateProductQuantity(Product product, int quantity, boolean isPromo) {
+ if (isPromo) {
+ product.addPromotionQuantity(quantity);
+ return;
+ }
+ product.addGeneralQuantity(quantity);
+ }
+
+ private void addNewProduct(String name, int price, int quantity, String promotion, PromotionType promotionType,
+ boolean isPromo) {
+ Product newProduct = new Product(name, price, quantity, promotion, promotionType, isPromo);
+ products.add(newProduct);
+ }
+
+ private Optional<Product> findExistingProduct(String name) {
+ return products.stream()
+ .filter(p -> Objects.equals(p.getName(), name))
+ .findFirst();
+ }
+
+ private PromotionType getPromotionType(String promotion) {
+ return promotionRepository.getPromotionTypeByName(promotion)
+ .orElse(PromotionType.NONE);
+ }
+
+ private void skipHeader(BufferedReader reader) throws IOException {
+ reader.readLine();
+ }
+
+ public List<Product> getProducts() {
+ return products;
+ }
+
+ public Optional<Product> findProductByName(String productName) {
+ return products.stream()
+ .filter(product -> Objects.equals(product.getName(), productName))
+ .findFirst();
+ }
+} | Java | 보통 이런 레파지토리 형태는 Map 자료형을 많이 사용하는데요
List 자료형을 사용하신 의도가 궁금해요 ㅎㅎ! |
@@ -0,0 +1,84 @@
+package service;
+
+import java.util.ArrayList;
+import repository.ProductRepository;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class InputHandler {
+ private final static String INVALID_INPUT_FORMAT = "[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.";
+ private static final Pattern INPUT_PATTERN = Pattern.compile("\\[(.+)-([0-9]+)]");
+ public static final String COMMA_PATTERN = ",";
+ public static final String PAIR_PATTERN = "\\[.+?]";
+ public static final String DELIMITER = ",";
+
+ private final ProductRepository productRepository;
+
+ public InputHandler(ProductRepository productRepository) {
+ this.productRepository = productRepository;
+ }
+
+ public List<RequestedProduct> processInput(String items) {
+ validateInputFormat(items);
+ return parseRequestedProductList(items);
+ }
+
+ private void validateInputFormat(String items) {
+ if (items == null || items.isBlank()) {
+ throw new IllegalArgumentException(INVALID_INPUT_FORMAT);
+ }
+ int pairCount = countPattern(items, PAIR_PATTERN);
+ int commaCount = countPattern(items, COMMA_PATTERN);
+
+ if (pairCount > 1 && commaCount != pairCount - 1) {
+ throw new IllegalArgumentException(INVALID_INPUT_FORMAT);
+ }
+ }
+
+ private int countPattern(String input, String pattern) {
+ Matcher matcher = Pattern.compile(pattern).matcher(input);
+ int count = 0;
+ while (matcher.find()) {
+ count++;
+ }
+ return count;
+ }
+
+ private List<RequestedProduct> parseRequestedProductList(String items) {
+ Map<String, Integer> productMap = parseProductMap(items);
+ return createRequestedProduct(productMap);
+ }
+
+ private List<RequestedProduct> createRequestedProduct(Map<String, Integer> productMap) {
+ List<RequestedProduct> requestedProductList = new ArrayList<>();
+ for (Map.Entry<String, Integer> entry : productMap.entrySet()) {
+ RequestedProduct requestedProduct = new RequestedProduct(entry.getKey(), entry.getValue(),
+ productRepository);
+ requestedProductList.add(requestedProduct);
+ }
+ return requestedProductList;
+ }
+
+ private Map<String, Integer> parseProductMap(String items) {
+ Map<String, Integer> productMap = new LinkedHashMap<>();
+ for (String item : items.split(DELIMITER)) {
+ Matcher matcher = validateAndMatchInput(item);
+ String productName = matcher.group(1);
+ int productAmount = Integer.parseInt(matcher.group(2));
+ productMap.put(productName, productMap.getOrDefault(productName, 0) + productAmount);
+ }
+ return productMap;
+ }
+
+ private Matcher validateAndMatchInput(String item) {
+ Matcher matcher = INPUT_PATTERN.matcher(item);
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException(INVALID_INPUT_FORMAT);
+ }
+ return matcher;
+ }
+} | Java | 정규표현식과 보면 수량이 0개인 경우도 통과 되는걸로 보이는데요
혹시 0개도 허용하신 의도가 있으실까요 ?? |
@@ -0,0 +1,144 @@
+package service;
+
+import domain.Membership;
+import domain.Product;
+import domain.PromotionType;
+import domain.PurchaseProduct;
+import domain.Receipt;
+import java.util.List;
+import repository.ProductRepository;
+import view.InputView;
+
+public class OrderService {
+ public static final String PRODUCT_NOT_FOUND = "[ERROR] 존재하지 않는 상품입니다.";
+ public static final String CONFIRM_FREE_ITEM_ADDITION = "Y";
+ public static final String CONFIRM_PURCHASE_WITHOUT_PROMOTION = "N";
+ public static final String CONFIRM_USE_MEMBERSHIP = "Y";
+
+ private final ProductRepository productRepository;
+ private final Membership membership;
+
+ public OrderService(ProductRepository productRepository, Membership membership) {
+ this.productRepository = productRepository;
+ this.membership = membership;
+ }
+
+ public Receipt createOrder(List<RequestedProduct> requestedProducts) {
+ Receipt receipt = new Receipt();
+ for (RequestedProduct requestedProduct : requestedProducts) {
+ processRequestedProduct(requestedProduct, receipt);
+ }
+ applyMembershipDiscount(receipt);
+ return receipt;
+ }
+
+ private void applyMembershipDiscount(Receipt receipt) {
+ if (InputView.confirmUseMembership().equals(CONFIRM_USE_MEMBERSHIP)) {
+ receipt.useMembership(membership);
+ }
+ }
+
+ private void processRequestedProduct(RequestedProduct requestedProduct, Receipt receipt) {
+ Product stockProduct = findStockProduct(requestedProduct.getProductName());
+ PurchaseProduct totalProduct = createPurchaseProduct(requestedProduct);
+
+ if (stockProduct.hasPromo()) {
+ handlePromotion(stockProduct, totalProduct, requestedProduct.getQuantity(), receipt);
+ return;
+ }
+ applyGeneralItem(stockProduct, totalProduct, receipt);
+ }
+
+ private void applyGeneralItem(Product stockProduct, PurchaseProduct totalProduct, Receipt receipt) {
+ receipt.applyGeneralItem(totalProduct);
+ stockProduct.reduceGeneralQuantity(totalProduct.getQuantity());
+ }
+
+ private void handlePromotion(Product stockProduct, PurchaseProduct totalProduct, int quantity, Receipt receipt) {
+ int promotionQuantity = stockProduct.getPromotionQuantity();
+ PromotionType promotionType = stockProduct.getPromotionType();
+ int buyCount = promotionType.getBuyCount();
+
+ if(promotionQuantity<=buyCount){
+ applyGeneralItem(stockProduct,totalProduct,receipt);
+ return;
+ }
+ int divisor = promotionType.getDivisor();
+ if (isAvailableForFreeItem(quantity, divisor, promotionQuantity)) {
+ quantity = addFreeItem(totalProduct, quantity);
+ }
+ if (promotionQuantity >= quantity) {
+ applyPromotion(stockProduct, totalProduct, quantity, receipt, divisor);
+ return;
+ }
+ handleInsufficientPromotionStock(stockProduct, totalProduct, promotionQuantity, quantity, receipt, divisor);
+ }
+
+ private void handleInsufficientPromotionStock(Product stockProduct, PurchaseProduct totalProduct,
+ int promotionQuantity, int quantity, Receipt receipt, int divisor) {
+ int usedTotalPromoProduct = (promotionQuantity / divisor) * divisor;
+ stockProduct.reducePromotionQuantity(usedTotalPromoProduct);
+
+ PurchaseProduct promoProduct = createPromoProduct(stockProduct, usedTotalPromoProduct, divisor);
+ int restPromoQuantity = promotionQuantity - usedTotalPromoProduct;
+ stockProduct.reducePromotionQuantity(restPromoQuantity);
+ stockProduct.addGeneralQuantity(restPromoQuantity);
+
+ int insufficientQuantity = quantity - usedTotalPromoProduct;
+ adjustForInsufficientQuantity(stockProduct, totalProduct, insufficientQuantity);
+
+ if (promoProduct != null) {
+ receipt.applyPromoItem(promoProduct, divisor);
+ }
+ receipt.applyGeneralItem(totalProduct);
+ }
+
+ private void adjustForInsufficientQuantity(Product stockProduct, PurchaseProduct totalProduct,
+ int insufficientQuantity) {
+ if (InputView.confirmPurchaseWithoutPromotion(totalProduct.getName(), insufficientQuantity)
+ .equals(CONFIRM_PURCHASE_WITHOUT_PROMOTION)) {
+ totalProduct.subtractQuantity(insufficientQuantity);
+ return;
+ }
+ stockProduct.reduceGeneralQuantity(insufficientQuantity);
+ }
+
+ private PurchaseProduct createPromoProduct(Product stockProduct, int usedTotalPromoProduct, int divisor) {
+ if (usedTotalPromoProduct == 0) {
+ return null;
+ }
+ return new PurchaseProduct(stockProduct.getName(), usedTotalPromoProduct / divisor, stockProduct.getPrice());
+ }
+
+
+ private void applyPromotion(Product stockProduct, PurchaseProduct totalProduct, int quantity, Receipt receipt,
+ int divisor) {
+ PurchaseProduct promoProduct = new PurchaseProduct(totalProduct.getName(), quantity / divisor,
+ totalProduct.getPrice());
+ stockProduct.reducePromotionQuantity(quantity);
+ receipt.applyPromoItem(promoProduct, divisor);
+ receipt.applyGeneralItem(totalProduct);
+ }
+
+ private boolean isAvailableForFreeItem(int quantity, int divisor, int promotionQuantity) {
+ return quantity % divisor == divisor - 1 && promotionQuantity >= quantity + 1;
+ }
+
+ private int addFreeItem(PurchaseProduct totalProduct, int quantity) {
+ if (InputView.confirmFreeItemAddition(totalProduct.getName()).equals(CONFIRM_FREE_ITEM_ADDITION)) {
+ totalProduct.addGiveawayQuantity();
+ quantity += 1;
+ }
+ return quantity;
+ }
+
+ private PurchaseProduct createPurchaseProduct(RequestedProduct requestedProduct) {
+ return new PurchaseProduct(requestedProduct.getProductName(), requestedProduct.getQuantity(),
+ requestedProduct.getPrice());
+ }
+
+ private Product findStockProduct(String name) {
+ return productRepository.findProductByName(name).orElseThrow(() -> new IllegalArgumentException(
+ PRODUCT_NOT_FOUND));
+ }
+} | Java | 해당 클래스를 보면 상품, 프로모션, 멤버십의 책임을 모두 갖고 있는데요
책임이 많다 보니까 private 메서드도 많아지고, 코드 라인도 120줄이 넘어가네요
그리고 서비스도 View에 의존하고 있구요
그래서 상품, 프로모션, 멤버십 이 3가지 서비스로 쪼개면 어떨까해요~
범석님 생각은 어떠세요?? |
@@ -0,0 +1,73 @@
+package view;
+
+import camp.nextstep.edu.missionutils.Console;
+
+public class InputView {
+ private static final String[] YES_OPTIONS = {"Y", "y"};
+ private static final String[] NO_OPTIONS = {"N", "n"};
+
+ private static final String ITEM_INPUT_PROMPT = "구매하실 상품명과 수량을 입력해 주세요. (예: [사이다-2],[감자칩-1])";
+ private static final String CONFIRM_FREE_ITEM_ADDITION_PROMPT = "현재 %s은(는) 1개를 무료로 더 받을 수 있습니다. 추가하시겠습니까? (Y/N)";
+ private static final String CONFIRM_PURCHASE_WITHOUT_PROMOTION_PROMPT = "현재 %s %d개는 프로모션 할인이 적용되지 않습니다. 그래도 구매하시겠습니까? (Y/N)";
+ private static final String CONFIRM_USE_MEMBERSHIP_PROMPT = "멤버십 할인을 받으시겠습니까? (Y/N)";
+ private static final String CONFIRM_ADDITIONAL_PURCHASE_PROMPT = "감사합니다. 구매하고 싶은 다른 상품이 있나요? (Y/N)";
+ private static final String ERROR_INVALID_INPUT = "[ERROR] 올바른 값을 입력해 주세요. (Y/N)";
+
+ public static String readItem() {
+ System.out.print(System.lineSeparator());
+ System.out.println(ITEM_INPUT_PROMPT);
+ return Console.readLine();
+ }
+
+ public static String confirmFreeItemAddition(String productName) {
+ System.out.print(System.lineSeparator());
+ System.out.printf(CONFIRM_FREE_ITEM_ADDITION_PROMPT + "%n", productName);
+ return validateYesOrNo();
+ }
+
+ public static String confirmPurchaseWithoutPromotion(String productName, int quantity) {
+ System.out.print(System.lineSeparator());
+ System.out.printf(CONFIRM_PURCHASE_WITHOUT_PROMOTION_PROMPT + "%n", productName, quantity);
+ return validateYesOrNo();
+ }
+
+ public static String confirmUseMembership() {
+ System.out.print(System.lineSeparator());
+ System.out.println(CONFIRM_USE_MEMBERSHIP_PROMPT);
+ return validateYesOrNo();
+ }
+
+ public static String confirmAdditionalPurchase() {
+ System.out.print(System.lineSeparator());
+ System.out.println(CONFIRM_ADDITIONAL_PURCHASE_PROMPT);
+ return validateYesOrNo();
+ }
+
+ private static String validateYesOrNo() {
+ while (true) {
+ String input = Console.readLine().trim();
+ if (isYes(input) || isNo(input)) {
+ return input.toUpperCase();
+ }
+ System.out.println(ERROR_INVALID_INPUT);
+ }
+ }
+
+ private static boolean isYes(String input) {
+ for (String yesOption : YES_OPTIONS) {
+ if (yesOption.equals(input)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static boolean isNo(String input) {
+ for (String noOption : NO_OPTIONS) {
+ if (noOption.equals(input)) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
\ No newline at end of file | Java | 사용자의 응답을 판단하는것도 비즈니스 로직중 하나라고 생각을 해요
왜냐하면 응답에 따라서 프로모션, 멤버십 혜택등이 달라지니까요
그래서 요부분은 서비스에서 담당하는게 좋지 않을까 생각해요
범석님 의견은 어떠세요 ?? |
@@ -0,0 +1,95 @@
+package view;
+
+import domain.Product;
+import domain.PromotionType;
+import domain.PurchaseProduct;
+import java.text.NumberFormat;
+import java.util.List;
+
+public class OutputView {
+ private static final NumberFormat currencyFormat = NumberFormat.getInstance();
+
+ public static final String GREETING_MESSAGE = "안녕하세요. W편의점입니다.%n현재 보유하고 있는 상품입니다.%n%n";
+ public static final String RECEIPT_HEADER = "\n===========W 편의점=============";
+ public static final String PROMOTION_HEADER = "===========증 정=============";
+ public static final String RECEIPT_DIVIDER = "==============================";
+ public static final String TOTAL_AMOUNT = "총구매액";
+ public static final String PROMOTION_DISCOUNT = "행사할인";
+ public static final String MEMBERSHIP_DISCOUNT = "멤버십할인";
+ public static final String FINAL_AMOUNT = "내실돈";
+
+ public static void printProducts(List<Product> products) {
+ greetingMessage();
+ for (Product product : products) {
+ printProductByPromotion(product);
+ }
+ }
+
+ private static void printProductByPromotion(Product product) {
+ String formattedPrice = formatCurrency(product.getPrice());
+ if (product.getPromotionType() != PromotionType.NONE) {
+ printPromotionProduct(product, formattedPrice);
+ }
+ printGeneralProduct(product, formattedPrice);
+ }
+
+ private static void greetingMessage() {
+ System.out.print(System.lineSeparator());
+ System.out.printf(GREETING_MESSAGE);
+ }
+
+ private static void printPromotionProduct(Product product, String formattedPrice) {
+ if (product.getPromotionQuantity() > 0) {
+ String formattedPromoQuantity = formatCurrency(product.getPromotionQuantity());
+ System.out.printf("- %s %s원 %s개 %s%n", product.getName(), formattedPrice, formattedPromoQuantity,
+ product.getPromotionName());
+ return;
+ }
+ System.out.printf("- %s %s원 재고 없음 %s%n", product.getName(), formattedPrice,
+ product.getPromotionName());
+ }
+
+ private static void printGeneralProduct(Product product, String formattedPrice) {
+ if (product.getGeneralQuantity() > 0) {
+ String formattedGeneralQuantity = formatCurrency(product.getGeneralQuantity());
+ System.out.printf("- %s %s원 %s개%n", product.getName(), formattedPrice, formattedGeneralQuantity);
+ return;
+ }
+ System.out.printf("- %s %s원 재고 없음%n", product.getName(), formattedPrice);
+ }
+
+ public static void printReceipt(List<PurchaseProduct> purchasedItems) {
+ System.out.println(RECEIPT_HEADER);
+ System.out.printf("%-14s %-6s %-6s%n", "상품명", "수량", "금액");
+
+ for (PurchaseProduct item : purchasedItems) {
+ int totalPrice = item.getPrice() * item.getQuantity();
+ System.out.printf("%-14s %-6d %-6s%n", item.getName(), item.getQuantity(), formatCurrency(totalPrice));
+ }
+ }
+
+ public static void printPromotionReceipt(List<PurchaseProduct> promoItems) {
+ System.out.println(PROMOTION_HEADER);
+ for (PurchaseProduct item : promoItems) {
+ System.out.printf("%-13s %-6s%n", item.getName(), item.getQuantity());
+ }
+ }
+
+ public static void printReceiptSummary(int totalAmount, int totalQuantity, int promotionDiscount,
+ int membershipDiscount) {
+ System.out.println(RECEIPT_DIVIDER);
+ System.out.printf("%-14s %-6d %-6s%n", TOTAL_AMOUNT, totalQuantity, formatCurrency(totalAmount));
+ System.out.printf("%-20s %-6s%n", PROMOTION_DISCOUNT, formatCurrencyWithMinus(promotionDiscount));
+ System.out.printf("%-20s %-6s%n", MEMBERSHIP_DISCOUNT, formatCurrencyWithMinus(membershipDiscount));
+ System.out.printf("%-20s %-6s%n", FINAL_AMOUNT,
+ formatCurrency(totalAmount - promotionDiscount - membershipDiscount));
+ }
+
+ private static String formatCurrency(int value) {
+ return currencyFormat.format(value);
+ }
+
+ private static String formatCurrencyWithMinus(int amount) {
+ return "-" + formatCurrency(amount);
+ }
+} | Java | 사소한거지만, 출력문은 커널 영역에서 실행되는 작업이기 때문에 호출될 때마다 컨텍스트 스위칭이 발생해요
그래서 하나의 메세지로 만들어서 한번에 출력하는게 좋지 않을까해요~ |
@@ -0,0 +1,32 @@
+package domain;
+
+public enum PromotionType {
+ NONE(1, 0),
+ BUY_ONE_GET_ONE(1, 1),
+ BUY_TWO_GET_ONE(2, 1);
+
+ private final int buyCount;
+ private final int giveawayCount;
+
+ PromotionType(int buyCount, int giveawayCount) {
+ this.buyCount = buyCount;
+ this.giveawayCount = giveawayCount;
+ }
+
+ public int getDivisor() {
+ return this.buyCount + this.giveawayCount;
+ }
+
+ public int getBuyCount() {
+ return this.buyCount;
+ }
+
+ public static PromotionType fromBuyAndGet(int buy, int get) {
+ for (PromotionType type : PromotionType.values()) {
+ if (type.buyCount == buy && type.giveawayCount == get) {
+ return type;
+ }
+ }
+ return NONE;
+ }
+}
\ No newline at end of file | Java | 프로모션 타입을 미리 정하신 이유가 궁금합니다.
프로모션 이름은 같고 내용이 달라질 수 있으니까요. |
@@ -0,0 +1,108 @@
+package repository;
+
+import domain.Product;
+import domain.PromotionType;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import java.util.Optional;
+
+public class ProductRepository {
+ public static final String PRODUCTS_FILE_PATH = "src/main/resources/products.md";
+ public static final String FILE_LOADING_ERROR_MESSAGE = "[ERROR] 파일 로딩 중 오류 발생";
+ public static final String DELIMITER = ",";
+ public static final int NAME_INDEX = 0;
+ public static final int PRICE_INDEX = 1;
+ public static final int QUANTITY_INDEX = 2;
+ public static final int PROMOTION_INDEX = 3;
+
+ private final List<Product> products = new ArrayList<>();
+ private final PromotionRepository promotionRepository;
+
+ public ProductRepository(PromotionRepository promotionRepository) {
+ this.promotionRepository = promotionRepository;
+ loadProducts();
+ }
+
+ private void loadProducts() {
+ try (BufferedReader reader = new BufferedReader(new FileReader(PRODUCTS_FILE_PATH))) {
+ skipHeader(reader);
+ processProductLines(reader);
+ } catch (IOException e) {
+ System.out.println(FILE_LOADING_ERROR_MESSAGE);
+ }
+ }
+
+ private void processProductLines(BufferedReader reader) throws IOException {
+ String line;
+ while ((line = reader.readLine()) != null) {
+ if (!line.trim().isEmpty()) {
+ processProductLine(line);
+ }
+ }
+ }
+
+ private void processProductLine(String line) {
+ String[] parts = line.split(DELIMITER);
+ String name = parts[NAME_INDEX].trim();
+ int price = Integer.parseInt(parts[PRICE_INDEX].trim());
+ int quantity = Integer.parseInt(parts[QUANTITY_INDEX].trim());
+ String promotion = parts[PROMOTION_INDEX].trim();
+
+ PromotionType promotionType = getPromotionType(promotion);
+ boolean isPromo = (promotionType != PromotionType.NONE);
+
+ addOrUpdateProduct(name, price, quantity, promotion, promotionType, isPromo);
+ }
+
+ private void addOrUpdateProduct(String name, int price, int quantity, String promotion,
+ PromotionType promotionType, boolean isPromo) {
+ findExistingProduct(name).ifPresentOrElse(
+ product -> updateProductQuantity(product, quantity, isPromo),
+ () -> addNewProduct(name, price, quantity, promotion, promotionType, isPromo)
+ );
+ }
+
+ private void updateProductQuantity(Product product, int quantity, boolean isPromo) {
+ if (isPromo) {
+ product.addPromotionQuantity(quantity);
+ return;
+ }
+ product.addGeneralQuantity(quantity);
+ }
+
+ private void addNewProduct(String name, int price, int quantity, String promotion, PromotionType promotionType,
+ boolean isPromo) {
+ Product newProduct = new Product(name, price, quantity, promotion, promotionType, isPromo);
+ products.add(newProduct);
+ }
+
+ private Optional<Product> findExistingProduct(String name) {
+ return products.stream()
+ .filter(p -> Objects.equals(p.getName(), name))
+ .findFirst();
+ }
+
+ private PromotionType getPromotionType(String promotion) {
+ return promotionRepository.getPromotionTypeByName(promotion)
+ .orElse(PromotionType.NONE);
+ }
+
+ private void skipHeader(BufferedReader reader) throws IOException {
+ reader.readLine();
+ }
+
+ public List<Product> getProducts() {
+ return products;
+ }
+
+ public Optional<Product> findProductByName(String productName) {
+ return products.stream()
+ .filter(product -> Objects.equals(product.getName(), productName))
+ .findFirst();
+ }
+} | Java | 위 skipHeader는 PromotionRepository에서도 사용하시는 걸로 이해했습니다.
그렇다면 따로 util로 구분해서 사용하는 방법도 고려해보시는 것을 추천드립니다. |
@@ -0,0 +1,61 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import view.OutputView;
+
+public class Receipt {
+ private static final int INITIAL_AMOUNT = 0;
+ private static final int INITIAL_QUANTITY = 0;
+
+ private final List<PurchaseProduct> purchasedItems;
+ private final List<PurchaseProduct> promoItems;
+ private int totalAmount;
+ private int promotionDiscount;
+ private int membershipDiscount;
+ private int totalGeneralAmount;
+ private int totalQuantity;
+
+ public Receipt() {
+ this.purchasedItems = new ArrayList<>();
+ this.promoItems = new ArrayList<>();
+ this.totalAmount = INITIAL_AMOUNT;
+ this.promotionDiscount = INITIAL_AMOUNT;
+ this.membershipDiscount = INITIAL_AMOUNT;
+ this.totalGeneralAmount = INITIAL_AMOUNT;
+ this.totalQuantity = INITIAL_QUANTITY;
+
+ }
+
+ public void applyPromoItem(PurchaseProduct promoProduct, int divisor) {
+ promoItems.add(promoProduct);
+ int promoAmount = calculateAmount(promoProduct);
+ promotionDiscount += promoAmount;
+ totalGeneralAmount -= promoAmount * divisor;
+ }
+
+ public void applyGeneralItem(PurchaseProduct purchaseProduct) {
+ purchasedItems.add(purchaseProduct);
+ int purchaseAmount = calculateAmount(purchaseProduct);
+ totalAmount += purchaseAmount;
+ totalGeneralAmount += purchaseAmount;
+ totalQuantity += purchaseProduct.getQuantity();
+ }
+
+ public int calculateAmount(PurchaseProduct product) {
+ return product.getPrice() * product.getQuantity();
+ }
+
+
+ public void useMembership(Membership membership) {
+ membershipDiscount = membership.useMembership(totalGeneralAmount);
+ }
+
+ public void print() {
+ OutputView.printReceipt(purchasedItems);
+ if (!promoItems.isEmpty()) {
+ OutputView.printPromotionReceipt(promoItems);
+ }
+ OutputView.printReceiptSummary(totalAmount, totalQuantity, promotionDiscount, membershipDiscount);
+ }
+} | Java | 도메인 객체에서 바로 View를 호출하는 것은 Layer를 나눈 의미가 사라진다고 생각해요.
Controller에서 이 기능을 위임시키는 방법도 있으니 한번 고려해보시는 것을 추천드립니다. |
@@ -0,0 +1,75 @@
+package store.view;
+
+import store.model.GiftProduct;
+import store.model.Product;
+import store.model.receipt.AmountInfo;
+import store.model.receipt.GiftProducts;
+import store.model.receipt.PurchaseProducts;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class OutputView {
+ public void printStoreMenu() throws IOException {
+ System.out.println("""
+ 안녕하세요. W편의점입니다.
+ 현재 보유하고 있는 상품입니다.
+ """);
+
+ BufferedReader reader = new BufferedReader(new FileReader("src/main/resources/products.md"));
+ String product;
+
+ reader.readLine();
+
+ while ((product = reader.readLine()) != null) {
+ String[] str = product.split(",");
+ System.out.printf("- %s %s원 %s %s", str[0], String.format("%,d", Integer.parseInt(str[1])), changeNoStock(str[2]), changeNull(str[3]));
+ System.out.println();
+ }
+ reader.close();
+ }
+
+ public void printPurchaseProduct(PurchaseProducts purchaseProducts) {
+ System.out.println("==============W 편의점================");
+ System.out.println("상품명\t\t\t\t수량\t\t금액");
+ for (Product product : purchaseProducts.getPurchaseProducts()) {
+ System.out.printf("%-4s\t\t\t\t%s\t\t%s\n", product.getName(), product.getQuantity(), String.format("%,d", product.getQuantity() * product.getPrice()));
+ }
+ }
+
+ public void printGiftProducts(GiftProducts giftProducts) {
+ System.out.println("=============증\t\t정===============");
+ for (GiftProduct giftProduct : giftProducts.getGiftProducts()) {
+ System.out.printf("%-4s\t\t\t\t%d", giftProduct.getName(), giftProduct.getQuantity());
+ System.out.println();
+ }
+ }
+
+ public void printAmountInfo(AmountInfo amountInfo) {
+ System.out.println("====================================");
+ System.out.printf("총구매액\t\t\t\t%s\t\t%s", amountInfo.getTotalPurchaseCount(), String.format("%,d", amountInfo.getTotalPurchaseAmount()));
+ System.out.println();
+ System.out.printf("행사할인\t\t\t\t\t\t%s", String.format("-%,d", amountInfo.getPromotionDiscount()));
+ System.out.println();
+ System.out.printf("멤버십할인\t\t\t\t\t\t%s", String.format("-%,d", amountInfo.getMembershipDiscount()));
+ System.out.println();
+ System.out.printf("내실돈\t\t\t\t\t\t%s", String.format("%,d", amountInfo.getPayment()));
+ System.out.println();
+ }
+
+ private String changeNull(String input) {
+ if (input.equals("null")) {
+ return "";
+ }
+ return input;
+ }
+
+ private String changeNoStock(String input) {
+ if (input.equals("0")) {
+ return "재고 없음";
+ }
+ input = String.format("%,d", Integer.parseInt(input));
+ return input + "개";
+ }
+} | Java | ``StockManageService``에서도 md파일에 접근하고 있고, ``OutputView``에서도 md파일에 접근하고 있네요.
개인적으로 저는 이번 미션을 진행하면서 md파일 = 데이터베이스 라고 생각하고 코드를 작성했는데, 만약 저와 같은 접근이라면 뷰에서 데이터베이스에 접근하는 것이 옳은 방법일까요?🤔
하영님께서는 md파일을 어떻게 생각하시고 접근하셨을까요? |
@@ -0,0 +1,39 @@
+package store.model.receipt;
+
+import store.model.Product;
+
+import java.io.IOException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PurchaseProducts {
+ private final List<Product> purchaseProducts;
+
+ public PurchaseProducts(String input) throws IOException {
+ purchaseProducts = new ArrayList<>();
+ validate(input);
+ }
+
+ private void validate(String input) throws IOException {
+ String[] inputProducts = input.split(",", -1);
+ for (String product : inputProducts) {
+ Product pro = new Product(product);
+ validate(pro);
+ purchaseProducts.add(pro);
+ }
+ }
+
+ private void validate(Product product){
+ String target = product.getName();
+ for (Product pro : purchaseProducts) {
+ if (pro.getName().equals(target)) {
+ throw new IllegalArgumentException("[ERROR] 중복되는 상품 이름이 있습니다.");
+ }
+ }
+ }
+
+ public List<Product> getPurchaseProducts() {
+ return purchaseProducts;
+ }
+} | Java | ```suggestion
Product product = new Product(inputProduct);
```
이렇게 네이밍한다면 헷갈리지도 않고 ``pro``라고 줄일지 않아도 되지 않아서 좋을 것 같아요! |
@@ -0,0 +1,39 @@
+package store.model.receipt;
+
+import store.model.Product;
+
+import java.io.IOException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PurchaseProducts {
+ private final List<Product> purchaseProducts;
+
+ public PurchaseProducts(String input) throws IOException {
+ purchaseProducts = new ArrayList<>();
+ validate(input);
+ }
+
+ private void validate(String input) throws IOException {
+ String[] inputProducts = input.split(",", -1);
+ for (String product : inputProducts) {
+ Product pro = new Product(product);
+ validate(pro);
+ purchaseProducts.add(pro);
+ }
+ }
+
+ private void validate(Product product){
+ String target = product.getName();
+ for (Product pro : purchaseProducts) {
+ if (pro.getName().equals(target)) {
+ throw new IllegalArgumentException("[ERROR] 중복되는 상품 이름이 있습니다.");
+ }
+ }
+ }
+
+ public List<Product> getPurchaseProducts() {
+ return purchaseProducts;
+ }
+} | Java | 매개변수로 ``input``을 받는 ``validate``와 ``product``를 받는 ``validate``를 동일한 메서드명으로 명명하신 것에 의도가 있으셨을까요?
리뷰이 입장에서는 ``validateInput``, ``validateDuplicate``와 같은 메서드명이었다면 오잉? 같은 왜 같은 메서드명이지? 라는 생각이 들지 않았을 것 같아서요! |
@@ -0,0 +1,240 @@
+package store.model;
+
+import camp.nextstep.edu.missionutils.DateTimes;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+public class Product {
+ private final String name;
+ private int quantity;
+ private int price;
+ private int promotionStockCount;
+ private int normalStockCount;
+ private String promotion;
+ private int promotionCount;
+ private int promotionBuyCount;
+ private int promotionGetCount;
+ private int justPromotionStockCount;
+
+ public Product(String product) throws IOException {
+ initCount();
+ String[] productInfo = validate(product);
+ name = productInfo[0];
+ quantity = Integer.parseInt(productInfo[1]);
+ }
+
+ private void initCount() {
+ promotionStockCount = 0;
+ normalStockCount = 0;
+ promotion = "null";
+ promotionCount = 0;
+ promotionBuyCount = 0;
+ promotionGetCount = 0;
+ }
+
+ private String[] validate(String product) throws IOException {
+ if (product.isBlank() | product.isEmpty()) {
+ throw new IllegalArgumentException("[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.");
+ }
+
+ product = product.replaceAll("\\s", "");
+
+ if (!(product.charAt(0) == '[' && product.charAt(product.length() - 1) == ']' && product.contains("-"))) {
+ throw new IllegalArgumentException("[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.");
+ }
+
+ product = product.substring(1, product.length() - 1);
+ String[] oneProduct = product.split("-", -1);
+
+ for (String one : oneProduct) {
+ if (one.isBlank() | one.isEmpty()) {
+ throw new IllegalArgumentException("[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.");
+ }
+ }
+
+ try {
+ Integer.parseInt(oneProduct[1]);
+ } catch (IllegalArgumentException e) {
+ throw new IllegalArgumentException("[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.");
+ }
+
+ if (Integer.parseInt(oneProduct[1]) <= 0) {
+ throw new IllegalArgumentException("[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.");
+ }
+
+ if (!isExistProduct(oneProduct[0])) {
+ throw new IllegalArgumentException("[ERROR] 존재하지 않는 상품입니다. 다시 입력해 주세요.");
+ }
+
+ if (isStockLack(oneProduct)) {
+ throw new IllegalArgumentException("[ERROR] 재고 수량을 초과하여 구매할 수 없습니다. 다시 입력해 주세요.");
+ }
+ return oneProduct;
+ }
+
+ private boolean isExistProduct(String productName) throws IOException {
+ BufferedReader reader = new BufferedReader(new FileReader("src/main/resources/products.md"));
+ String food;
+ reader.readLine();
+
+ while ((food = reader.readLine()) != null) {
+ String foodName = food.split(",")[0];
+ String foodPrice = food.split(",")[1];
+
+ if (foodName.equals(productName)) {
+ price = Integer.parseInt(foodPrice);
+ reader.close();
+ return true;
+ }
+ }
+ reader.close();
+ return false;
+ }
+
+ private boolean isStockLack(String[] productInfo) throws IOException {
+ BufferedReader reader = new BufferedReader(new FileReader("src/main/resources/products.md"));
+ String food;
+ reader.readLine();
+
+ while ((food = reader.readLine()) != null) {
+ String foodName = food.split(",")[0];
+ String foodQuantity = food.split(",")[2];
+ String foodPromotion = food.split(",")[3];
+
+ if (foodName.equals(productInfo[0]) & !foodPromotion.equals("null")) {
+ promotionCount = getPromotionCount(foodPromotion); // 0이라는 것은 프로모션 기간이 아님
+ promotion = foodPromotion; //프로모션 제품
+ if (promotionCount != 0) {
+ promotionStockCount += Integer.parseInt(foodQuantity);
+ }
+ justPromotionStockCount = Integer.parseInt(foodQuantity);
+ }
+ if (foodName.equals(productInfo[0]) & foodPromotion.equals("null")) {
+ normalStockCount += Integer.parseInt(foodQuantity);
+ }
+ }
+ if (justPromotionStockCount + normalStockCount < Integer.parseInt(productInfo[1])) {
+ reader.close();
+ return true;
+ }
+ reader.close();
+ return false;
+ }
+
+ public boolean isAvailableOnlyPromotion() {
+ return promotionStockCount > quantity;
+ }
+
+ public boolean isSameWithQuantity() {
+ return promotionStockCount == quantity;
+ }
+
+ public int countPromotionDisable() {
+ int count = decreasePromotionStock() + decreaseNormalStock();
+ if (count >= promotionBuyCount) {
+ return count;
+ }
+ return 0;
+ }
+
+ public int buyOnlyPromotion() {
+ quantity = promotionStockCount - decreasePromotionStock();
+ return quantity;
+ }
+
+ public int decreasePromotionStock() {
+ if (promotionCount == 0) return 0;
+ return promotionStockCount % promotionCount;
+ }
+
+ public int decreaseNormalStock() {
+ return quantity - promotionStockCount;
+ }
+
+ public int getGiftCount() {
+ if (promotionCount == 0) return 0;
+ if (isAvailableOnlyPromotion()) {
+ return (quantity / promotionCount);
+ }
+ return (promotionStockCount / promotionCount);
+ }
+
+ public boolean canReceiveMoreFreeGift() {
+ if (promotionCount == 0) return false;
+ int remainProduct = quantity % promotionCount;
+ if (remainProduct == (promotionBuyCount)) {
+ return (promotionStockCount - quantity) >= promotionGetCount;
+ }
+ return false;
+ }
+
+ public int getPromotionCount(String promotionName) throws IOException {
+ BufferedReader reader = new BufferedReader(new FileReader("src/main/resources/promotions.md"));
+ String readPromotion;
+
+ reader.readLine();
+
+ while ((readPromotion = reader.readLine()) != null) {
+ String[] promotionInfo = readPromotion.split(",");
+ if (promotionInfo[0].equals(promotionName) & isValidateDate(promotionInfo[3], promotionInfo[4])) {
+ promotionBuyCount = Integer.parseInt(promotionInfo[1]);
+ promotionGetCount = Integer.parseInt(promotionInfo[2]);
+ reader.close();
+ return promotionBuyCount + promotionGetCount;
+ }
+ }
+ reader.close();
+ return 0;
+ }
+
+ private boolean isValidateDate(String start, String end) {
+ LocalDateTime targetTime = DateTimes.now();
+
+ String[] startInfo = start.split("-");
+ String[] endInfo = end.split("-");
+
+ LocalDate targetDate = LocalDate.of(targetTime.getYear(), targetTime.getMonth(), targetTime.getDayOfMonth());
+ LocalDate startDate = LocalDate.of(Integer.parseInt(startInfo[0]), Integer.parseInt(startInfo[1]), Integer.parseInt(startInfo[2]));
+ LocalDate endDate = LocalDate.of(Integer.parseInt(endInfo[0]), Integer.parseInt(endInfo[1]), Integer.parseInt(endInfo[2]));
+ return !targetDate.isBefore(startDate) && !targetDate.isAfter(endDate);
+ }
+
+ public boolean isPromotionProduct() {
+ return !promotion.equals("null");
+ }
+ public boolean isPromotionDuration(){
+ return promotionCount!=0;
+ }
+
+ public void increaseQuantity(int promotionGetCount) {
+ quantity += promotionGetCount;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public int getQuantity() {
+ return quantity;
+ }
+
+ public int getPrice() {
+ return price;
+ }
+
+ public int getPromotionStockCount() {
+ return promotionStockCount;
+ }
+
+ public int getPromotionGetCount() {
+ return promotionGetCount;
+ }
+
+ public int getNormalStockCount(){
+ return normalStockCount;
+ }
+} | Java | 중복되는 문구는 클래스 내부에서 private static 으로 선언하여 관리, 사용해주시는 건 어떨까요? |
@@ -0,0 +1,201 @@
+package store.controller;
+
+import store.model.Product;
+import store.model.receipt.PurchaseProducts;
+import store.service.ReceiptService;
+import store.service.StockManageService;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.IOException;
+
+public class StoreController {
+ private final InputView inputView;
+ private final OutputView outputView;
+
+ private boolean nextPlay;
+ private PurchaseProducts purchaseProducts;
+ private ReceiptService receiptService;
+ private StockManageService stockManageService;
+
+ private int countPurchasePromotion;
+ private int countPurchaseNormal;
+ private int giftCount;
+ private boolean getBenefit;
+
+ public StoreController(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ nextPlay = true;
+ }
+
+ public void run() throws IOException {
+ while (nextPlay) {
+ play();
+ }
+ }
+
+ private void play() throws IOException {
+ generateService();
+ stockManageService.bringStock();
+
+ outputView.printStoreMenu();
+ repeatUntilProductAndPriceValid();
+ calculateProducts();
+ printReceipt();
+
+ if (!repeatUntilAdditionalPlayValid()) {
+ nextPlay = false;
+ }
+ }
+
+ private void calculateProducts() {
+ for (Product product : purchaseProducts.getPurchaseProducts()) {
+ initCount(product);
+ calculateCount(product);
+
+ stockManageService.manageStock(countPurchaseNormal, countPurchasePromotion, product);
+
+ int stockCount = countPurchasePromotion + countPurchaseNormal;
+
+ receiptService.make(stockCount, giftCount, product, getBenefit);
+ }
+ }
+
+ private void calculateCount(Product product) {
+ if (!product.isPromotionDuration()) { //프로모션 기간이 아닐 때
+ if (product.isPromotionProduct()) {
+ getBenefit = false;
+ }
+
+ if (product.getNormalStockCount() >= product.getQuantity()) {
+ countPurchaseNormal = product.getQuantity();
+ return;
+ }
+ countPurchaseNormal = product.getNormalStockCount();
+ countPurchasePromotion = product.getQuantity() - countPurchaseNormal;
+ return;
+ }
+
+ if (product.isAvailableOnlyPromotion()) {
+ calculateCaseOne(product);
+ return;
+ }
+
+ if (product.isSameWithQuantity()) {
+ calculateCaseTwo(product);
+ return;
+ }
+
+ calculateCaseThree(product);
+ }
+
+ private void calculateCaseThree(Product product) {
+ countPurchasePromotion = product.getPromotionStockCount();
+ countPurchaseNormal = product.getQuantity() - countPurchasePromotion;
+
+ if (product.countPromotionDisable() > 0 & product.isPromotionProduct()) {
+ if (!repeatUntilPurchaseValid(product)) {
+ countPurchasePromotion = product.buyOnlyPromotion();
+ countPurchaseNormal = 0;
+ }
+ getBenefit = false;
+ }
+ }
+
+ private void calculateCaseTwo(Product product) {
+ countPurchasePromotion = product.getQuantity();
+
+ if (product.countPromotionDisable() > 0 & product.isPromotionProduct()) {
+ if (!repeatUntilPurchaseValid(product)) {
+ countPurchasePromotion = product.buyOnlyPromotion();
+ }
+ getBenefit = false;
+ }
+ }
+
+ private void calculateCaseOne(Product product) {
+ countPurchasePromotion = product.getQuantity();
+
+ if (product.canReceiveMoreFreeGift()) { //프로모션 기간, 프로모션 적용 가능
+ if (repeatUntilOneMoreFreeValid(product)) {
+ countPurchasePromotion += product.getPromotionGetCount();
+ giftCount += product.getPromotionGetCount();
+ product.increaseQuantity(product.getPromotionGetCount());
+ return;
+ }
+ getBenefit = false;
+ }
+ }
+
+ private void generateService() {
+ receiptService = new ReceiptService();
+ stockManageService = new StockManageService();
+ }
+
+ private void initCount(Product product) {
+ getBenefit = true;
+ countPurchasePromotion = 0;
+ countPurchaseNormal = 0;
+ giftCount = product.getGiftCount();
+ }
+
+ private void repeatUntilProductAndPriceValid() {
+ while (true) {
+ try {
+ purchaseProducts = new PurchaseProducts(inputView.getProductAndPrice());
+ return;
+ } catch (IllegalArgumentException | IOException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private boolean repeatUntilPurchaseValid(Product product) {
+ while (true) {
+ try {
+ return inputView.getPurchaseOrNot(product.getName(), product.countPromotionDisable());
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private boolean repeatUntilOneMoreFreeValid(Product product) {
+ while (true) {
+ try {
+ return inputView.getOneMoreFree(product);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private boolean repeatUntilMembershipDiscountValid() {
+ while (true) {
+ try {
+ return inputView.getMembershipDiscountOrNot();
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private boolean repeatUntilAdditionalPlayValid() {
+ while (true) {
+ try {
+ return inputView.getAdditionalPurchase();
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private void printReceipt() throws IOException {
+ receiptService.calculateDiscount(repeatUntilMembershipDiscountValid());
+ outputView.printPurchaseProduct(purchaseProducts);
+ outputView.printGiftProducts(receiptService.getGiftProducts());
+ outputView.printAmountInfo(receiptService.getAmountInfo());
+ stockManageService.reflectStock();
+ }
+} | Java | ``repeatUntil`` 메서드가 같은 패턴으로 반복되고 있어 코드 중복이 많게 느껴져요.
저도 3주 차 로또 미션 구현하면서 반복을 어떻게 하면 없앨 수 있을까 많이 찾아보다가 함수형 인터페이스를 접하게 됐는데요!
[람다식, 메서드 참조를 이용하여 예외 발생시 성공할 때 까지 반복 구현 - 함수형 인터페이스](https://dev-dongmoo.tistory.com/14)
위 블로그 포스팅이 참고가 될 수 있을 것 같아요☺️ |
@@ -0,0 +1,71 @@
+package store.model.receipt;
+
+import store.global.MembershipDiscount;
+import store.model.Product;
+
+import java.text.DecimalFormat;
+
+public class AmountInfo {
+ private int totalPurchaseAmount;
+ private int totalPurchaseCount;
+ private int promotionDiscount;
+ private int membershipDiscount;
+
+ public AmountInfo() {
+ init();
+ }
+
+ private void init() {
+ totalPurchaseAmount = 0;
+ totalPurchaseCount = 0;
+ promotionDiscount = 0;
+ membershipDiscount = 0;
+ }
+
+ public void increaseTotal(int quantity, int price) {
+ totalPurchaseCount += quantity;
+ totalPurchaseAmount += quantity * price;
+ }
+
+ public void calculatePromotionDiscount(Product product, int giftCount) {
+ promotionDiscount += product.getPrice() * giftCount;
+ }
+
+ public void calculateMembershipDiscount(boolean isMembershipDiscount) {
+ if (!isMembershipDiscount) {
+ membershipDiscount = 0;
+ return;
+ }
+
+ DecimalFormat df = new DecimalFormat("#");
+ membershipDiscount = Integer.parseInt(df.format(membershipDiscount * MembershipDiscount.DISCOUNT_RATE.getValue()));
+
+ membershipDiscount = Math.min(membershipDiscount, (int)MembershipDiscount.MAX_DISCOUNT.getValue());
+ }
+
+ public void increaseMembershipDiscount(Product product, int giftCount, boolean getBenefit) {
+ if (giftCount == 0 & getBenefit) {
+ membershipDiscount += product.getPrice() * product.getQuantity();
+ }
+ }
+
+ public int getPayment() {
+ return totalPurchaseAmount - (promotionDiscount + membershipDiscount);
+ }
+
+ public int getTotalPurchaseAmount() {
+ return totalPurchaseAmount;
+ }
+
+ public int getTotalPurchaseCount() {
+ return totalPurchaseCount;
+ }
+
+ public int getPromotionDiscount() {
+ return promotionDiscount;
+ }
+
+ public int getMembershipDiscount() {
+ return membershipDiscount;
+ }
+} | Java | 생성자 내부에서 0으로 초기화해주시지 않고 ``init()`` 메서드로 초기화해주신 이유가 있을까요~? |
@@ -0,0 +1,71 @@
+package store.model.receipt;
+
+import store.global.MembershipDiscount;
+import store.model.Product;
+
+import java.text.DecimalFormat;
+
+public class AmountInfo {
+ private int totalPurchaseAmount;
+ private int totalPurchaseCount;
+ private int promotionDiscount;
+ private int membershipDiscount;
+
+ public AmountInfo() {
+ init();
+ }
+
+ private void init() {
+ totalPurchaseAmount = 0;
+ totalPurchaseCount = 0;
+ promotionDiscount = 0;
+ membershipDiscount = 0;
+ }
+
+ public void increaseTotal(int quantity, int price) {
+ totalPurchaseCount += quantity;
+ totalPurchaseAmount += quantity * price;
+ }
+
+ public void calculatePromotionDiscount(Product product, int giftCount) {
+ promotionDiscount += product.getPrice() * giftCount;
+ }
+
+ public void calculateMembershipDiscount(boolean isMembershipDiscount) {
+ if (!isMembershipDiscount) {
+ membershipDiscount = 0;
+ return;
+ }
+
+ DecimalFormat df = new DecimalFormat("#");
+ membershipDiscount = Integer.parseInt(df.format(membershipDiscount * MembershipDiscount.DISCOUNT_RATE.getValue()));
+
+ membershipDiscount = Math.min(membershipDiscount, (int)MembershipDiscount.MAX_DISCOUNT.getValue());
+ }
+
+ public void increaseMembershipDiscount(Product product, int giftCount, boolean getBenefit) {
+ if (giftCount == 0 & getBenefit) {
+ membershipDiscount += product.getPrice() * product.getQuantity();
+ }
+ }
+
+ public int getPayment() {
+ return totalPurchaseAmount - (promotionDiscount + membershipDiscount);
+ }
+
+ public int getTotalPurchaseAmount() {
+ return totalPurchaseAmount;
+ }
+
+ public int getTotalPurchaseCount() {
+ return totalPurchaseCount;
+ }
+
+ public int getPromotionDiscount() {
+ return promotionDiscount;
+ }
+
+ public int getMembershipDiscount() {
+ return membershipDiscount;
+ }
+} | Java | ``membershipDiscount``에 대한 계산 로직을 ``MembershipDiscount`` Enum 내부로 옮기는 방법을 고려해보시는 것은 어떨까요? |
@@ -0,0 +1,75 @@
+package store.view;
+
+import store.model.GiftProduct;
+import store.model.Product;
+import store.model.receipt.AmountInfo;
+import store.model.receipt.GiftProducts;
+import store.model.receipt.PurchaseProducts;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class OutputView {
+ public void printStoreMenu() throws IOException {
+ System.out.println("""
+ 안녕하세요. W편의점입니다.
+ 현재 보유하고 있는 상품입니다.
+ """);
+
+ BufferedReader reader = new BufferedReader(new FileReader("src/main/resources/products.md"));
+ String product;
+
+ reader.readLine();
+
+ while ((product = reader.readLine()) != null) {
+ String[] str = product.split(",");
+ System.out.printf("- %s %s원 %s %s", str[0], String.format("%,d", Integer.parseInt(str[1])), changeNoStock(str[2]), changeNull(str[3]));
+ System.out.println();
+ }
+ reader.close();
+ }
+
+ public void printPurchaseProduct(PurchaseProducts purchaseProducts) {
+ System.out.println("==============W 편의점================");
+ System.out.println("상품명\t\t\t\t수량\t\t금액");
+ for (Product product : purchaseProducts.getPurchaseProducts()) {
+ System.out.printf("%-4s\t\t\t\t%s\t\t%s\n", product.getName(), product.getQuantity(), String.format("%,d", product.getQuantity() * product.getPrice()));
+ }
+ }
+
+ public void printGiftProducts(GiftProducts giftProducts) {
+ System.out.println("=============증\t\t정===============");
+ for (GiftProduct giftProduct : giftProducts.getGiftProducts()) {
+ System.out.printf("%-4s\t\t\t\t%d", giftProduct.getName(), giftProduct.getQuantity());
+ System.out.println();
+ }
+ }
+
+ public void printAmountInfo(AmountInfo amountInfo) {
+ System.out.println("====================================");
+ System.out.printf("총구매액\t\t\t\t%s\t\t%s", amountInfo.getTotalPurchaseCount(), String.format("%,d", amountInfo.getTotalPurchaseAmount()));
+ System.out.println();
+ System.out.printf("행사할인\t\t\t\t\t\t%s", String.format("-%,d", amountInfo.getPromotionDiscount()));
+ System.out.println();
+ System.out.printf("멤버십할인\t\t\t\t\t\t%s", String.format("-%,d", amountInfo.getMembershipDiscount()));
+ System.out.println();
+ System.out.printf("내실돈\t\t\t\t\t\t%s", String.format("%,d", amountInfo.getPayment()));
+ System.out.println();
+ }
+
+ private String changeNull(String input) {
+ if (input.equals("null")) {
+ return "";
+ }
+ return input;
+ }
+
+ private String changeNoStock(String input) {
+ if (input.equals("0")) {
+ return "재고 없음";
+ }
+ input = String.format("%,d", Integer.parseInt(input));
+ return input + "개";
+ }
+} | Java | ```suggestion
System.out.printf("행사할인\t\t\t\t\t\t-%,d", amountInfo.getPromotionDiscount());
```
이렇게 사용하면 ``System.out.printf()``와 ``String.format()``를 함께 사용하지 않고도 출력할 수 있지 않을까요? |
@@ -1 +1,176 @@
-# java-convenience-store-precourse
+## 👉 입력
+
+- 입력값 전체 공통 예외처리
+ - [x] 빈값 또는 null값 입력시
+
+- **구매할 상품과 수량**
+ - 상품명,수량은 하이픈(-)으로
+ - 개별 상품은 대괄호([])로 묶어 쉼표(,)로 구분
+ - `구매하실 상품명과 수량을 입력해 주세요. (예: [사이다-2],[감자칩-1])`
+ - 예외처리
+ - `,`으로 split한 후 각각에 대해서…
+ - [x] []이 ‘양쪽 끝에’ 각각 없으면
+ - [x] -이 없으면
+
+ → 빈문자열인지도 함께 확인이 가능
+
+ - -으로 split한 후 각각에 대해서…
+ - [x] (스스로 판단한 내용) 상품 이름 중복 입력시
+ - [x] 판매 상품이 아니면
+ - [x] 재고 수량을 초과했으면
+ - 프로모션 재고가 부족할 경우에는 일반 재고를 사용함
+ - [x] 수량을 숫자 아닌 자료형으로 입력하면
+ - [x] 수량을 0이하 입력하면
+
+- Y/N 공통 예외처리
+ - [x] `Y` 또는 `N` 이 아닌 값을 입력했을 때
+- **증정 받을 수 있는 상품 추가 여부**
+ - 프로모션이 적용이 가능한 상품에 대해 고객이 해당 수량보다 적게 가져온 경우,
+ - 그 수량만큼 추가 여부를 입력받기
+ - `현재 {상품명}은(는) 1개를 무료로 더 받을 수 있습니다. 추가하시겠습니까? (Y/N)`
+- **정가로 결제할지에 대한 여부**
+ - 프로모션 재고가 부족하여 일부 수량을 프로모션 혜택 없이 결제해야 하는 경우,
+ - 일부 수량에 대해 정가로 결제할지 여부를 입력받기
+ - `현재 {상품명} {수량}개는 프로모션 할인이 적용되지 않습니다. 그래도 구매하시겠습니까? (Y/N)`
+ - 스스로 판단한 내용
+ - `N`를 입력시 : 구매를 아예 하지 않음
+- **멤버십 할인 적용 여부**
+ - `멤버십 할인을 받으시겠습니까? (Y/N)`
+ - 멤버십 회원은 프로모션 미적용 금액의 30%를 할인받는다.
+ - 프로모션 적용 후 남은 금액에 대해 멤버십 할인을 적용한다.
+ - 멤버십 할인의 최대 한도는 8,000원이다.
+- **추가 구매 여부**
+ - `감사합니다. 구매하고 싶은 다른 상품이 있나요? (Y/N)`
+
+## 👉 출력
+
+- 환영 인사와 함께 상품명, 가격, 프로모션 이름, 재고를 안내한다. 만약 재고가 0개라면 `재고 없음`을 출력
+ - **천단위 쉼표 찍기**
+ - 예외처리
+ - 모든 재고가 재고없음이면 프로그램 종료
+
+ ```java
+ 안녕하세요. W편의점입니다.
+ 현재 보유하고 있는 상품입니다.
+
+ - 콜라 1,000원 10개 탄산2+1
+ - 콜라 1,000원 10개
+ - 사이다 1,000원 8개 탄산2+1
+ - 사이다 1,000원 7개
+ - 오렌지주스 1,800원 9개 MD추천상품
+ - 오렌지주스 1,800원 재고 없음
+ - 탄산수 1,200원 5개 탄산2+1
+ - 탄산수 1,200원 재고 없음
+ - 물 500원 10개
+ - 비타민워터 1,500원 6개
+ - 감자칩 1,500원 5개 반짝할인
+ - 감자칩 1,500원 5개
+ - 초코바 1,200원 5개 MD추천상품
+ - 초코바 1,200원 5개
+ - 에너지바 2,000원 5개
+ - 정식도시락 6,400원 8개
+ - 컵라면 1,700원 1개 MD추천상품
+ - 컵라면 1,700원 10개
+ ```
+
+
+- 구매 상품 내역, 증정 상품 내역, 금액 정보를 출력
+ - **천단위 쉼표 찍기**
+
+ ```java
+ ==============W 편의점================
+ 상품명 수량 금액
+ 콜라 3 3,000
+ 에너지바 5 10,000
+ =============증 정===============
+ 콜라 1
+ ====================================
+ 총구매액 8 13,000
+ 행사할인 -1,000
+ 멤버십할인 -3,000
+ 내실돈 9,000
+ ```
+
+
+- 에러 메시지
+ - 사용자가 잘못된 값을 입력했을 때, **"[ERROR]"로 시작**하는 오류 메시지와 함께 상황에 맞는 안내를 출력한다.
+ - 구매할 상품과 수량 형식이 올바르지 않은 경우: `[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.`
+ - 존재하지 않는 상품을 입력한 경우: `[ERROR] 존재하지 않는 상품입니다. 다시 입력해 주세요.`
+ - 구매 수량이 재고 수량을 초과한 경우: `[ERROR] 재고 수량을 초과하여 구매할 수 없습니다. 다시 입력해 주세요.`
+ - 기타 잘못된 입력의 경우: `[ERROR] 잘못된 입력입니다. 다시 입력해 주세요.`
+
+- 사용자가 잘못된 값을 입력할 경우 `IllegalArgumentException`를 발생시키고, "[ERROR]"로 시작하는 에러 메시지를 출력 후 그 부분부터 입력을 다시 받는다.
+ - `Exception`이 아닌 `IllegalArgumentException`, `IllegalStateException` 등과 같은 명확한 유형을 처리한다.
+
+## 👉 로직
+- 사용자가 입력한 상품 종류 1개에 대한 구매 개수 = n
+- n과 다르게 실제로 사용자가 가지고 가는 상품은 “결제한다”고 표현했습니다.
+
+
+- **프로모션 기간 아님** → 일반 재고 우선 감소 + 나머지는 프로모션 재고 감소,
+ - 프로모션 제품의 경우 → 멤버십 할인 없음
+ - 일반재고 ≥ n, 일반재고 < n 나눠서 일반재고/프로모션 재고 “결재”함
+
+
+- **프로모션 기간** → 프로모션 재고 우선 감소
+
+- case1) 프로모션 재고 > n
+ - 프로모션 재고만으로 제품을 충분히 구매할 수 있는 경우
+ - 이때 “결제”하는 프로모션 재고의 수는 n개
+ - 프로모션 적용이 가능한 상품에 대해, 고객이 해당 수량보다 적게 가져온 경우
+ - 프로모션 제품인지, 추가 가능할 정도로 프로모션 재고가 충분한지 검사 후, 추가 여부 묻기
+ - 추가함 → “결제”하는 프로모션 재고의 수/증정품 수/결제한 상품의 수량을 늘림, 멤버십 할인 받지 않음
+ - 추가하지 않음 → 멤버십 할인 받지 않음
+
+
+- case2) 프로모션 재고 == n
+ - “결제”해야 하는 프로모션 재고의 수는 n개
+ - 프로모션 적용이 가능한 상품에 대해,
+ - 프로모션 혜택 없이 결제해야 하는 상품의 개수라면
+ - 일부 수량에 대해 정가로 결제할지 여부를 입력받음
+ - 정가 결제하지 않음 → “결제” 금액 0원, 멤버십 할인 받지 않음
+ - 정가로 결제함 → “결제”해야하는 프로모션 재고의 수 == n, 멤버십 할인 받지 않음
+
+
+- case3) 프로모션 재고 < n
+ - 프로모션 재고가 부족한 경우
+ - 프로모션 적용이 가능한 상품에 대해,
+ - 프로모션 혜택 없이 결제해야 하는 상품의 개수만큼 남았다면
+ - 일부 수량에 대해 정가로 결제할지 여부를 입력받음
+ - 정가 결제하지 않음 → “결제”해야하는 프로모션 재고의 수 == 프로모션 혜택 적용 가능한 개수만, 일반재고 “결제” 아무것도 안함, 멤버십 할인 받지 않음
+ - 정가로 결제함 → 프로모션 재고 모두 “결제”, 나머지는 일반재고에서 “결제”, 멤버십 할인 받지 않음
+ - 프로모션 상품이 아닌 경우
+ - 프로모션 제품 모두 “결제” 후 나머지는 일반 재고에서 “결제”, 멤버십 할인 받음
+
+
+
+## 👉 추가 라이브러리
+
+- `camp.nextstep.edu.missionutils`에서 제공하는 `DateTimes` 및 `Console` API를 사용하여 구현해야 한다.
+ - 현재 날짜와 시간을 가져오려면 `camp.nextstep.edu.missionutils.DateTimes`의 `now()`를 활용한다.
+ - 사용자가 입력하는 값은 `camp.nextstep.edu.missionutils.Console`의 `readLine()`을 활용한다.
+
+- 테스트할 때 `products.md`
+
+```java
+name,price,quantity,promotion
+콜라,1000,10,탄산2+1
+콜라,1000,10,null
+사이다,1000,8,탄산2+1
+사이다,1000,7,null
+오렌지주스,1800,9,MD추천상품
+오렌지주스,1800,0,null
+탄산수,1200,5,탄산2+1
+탄산수,1200,0,null
+물,500,10,null
+비타민워터,1500,6,null
+감자칩,1500,5,반짝할인
+감자칩,1500,5,null
+초코바,1200,5,MD추천상품
+초코바,1200,5,null
+에너지바,2000,5,null
+정식도시락,6400,8,null
+컵라면,1700,1,MD추천상품
+컵라면,1700,10,null
+
+``` | Unknown | 꼼꼼하고 가독성이 좋은 README가 인상적입니다!
정말 잘 정리하신 거 같아요! |
@@ -0,0 +1,67 @@
+package store.service;
+
+import store.model.Product;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class StockManageService {
+ private final List<String> foods;
+
+ public StockManageService() {
+ foods = new ArrayList<>();
+ }
+
+ public void bringStock() throws IOException {
+ BufferedReader reader = new BufferedReader(new FileReader("src/main/resources/products.md"));
+ String line;
+ boolean noStock = true;
+
+ while ((line = reader.readLine()) != null) {
+ foods.add(line);
+ if (!line.split(",")[2].equals("0") & !line.split(",")[2].equals("quantity")) {
+ noStock = false;
+ }
+ }
+ reader.close();
+
+ if (noStock) {
+ throw new IllegalArgumentException("[ERROR] 재고가 없습니다.");
+ }
+ }
+
+ public void manageStock(int countPurchaseNormal, int countPurchasePromotion, Product product) {
+ String targetName = product.getName();
+
+ for (int i = 0; i < foods.size(); i++) {
+ String[] food = foods.get(i).split(",");
+ if (food[0].equals(targetName)) {
+ int newStock = updateStock(food, countPurchaseNormal, countPurchasePromotion);
+ String updateStock = food[0] + "," + food[1] + "," + newStock + "," + food[3];
+ foods.set(i, updateStock);
+ }
+ }
+ }
+
+ private int updateStock(String[] food, int countPurchaseNormal, int countPurchasePromotion) {
+ int currentSock = Integer.parseInt(food[2]);
+ if (food[3].equals("null")) {
+ return currentSock - countPurchaseNormal;
+ }
+ return currentSock - countPurchasePromotion;
+ }
+
+ public void reflectStock() throws IOException {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+
+ for (String updatedLine : foods) {
+ writer.write(updatedLine + "\r\n");
+ }
+ writer.close();
+ }
+} | Java | 조건문이 의미를 알기 어려운 거 같아요!
메서드로 분리해보시는 건 어떨까요? |
@@ -0,0 +1,67 @@
+package store.service;
+
+import store.model.Product;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class StockManageService {
+ private final List<String> foods;
+
+ public StockManageService() {
+ foods = new ArrayList<>();
+ }
+
+ public void bringStock() throws IOException {
+ BufferedReader reader = new BufferedReader(new FileReader("src/main/resources/products.md"));
+ String line;
+ boolean noStock = true;
+
+ while ((line = reader.readLine()) != null) {
+ foods.add(line);
+ if (!line.split(",")[2].equals("0") & !line.split(",")[2].equals("quantity")) {
+ noStock = false;
+ }
+ }
+ reader.close();
+
+ if (noStock) {
+ throw new IllegalArgumentException("[ERROR] 재고가 없습니다.");
+ }
+ }
+
+ public void manageStock(int countPurchaseNormal, int countPurchasePromotion, Product product) {
+ String targetName = product.getName();
+
+ for (int i = 0; i < foods.size(); i++) {
+ String[] food = foods.get(i).split(",");
+ if (food[0].equals(targetName)) {
+ int newStock = updateStock(food, countPurchaseNormal, countPurchasePromotion);
+ String updateStock = food[0] + "," + food[1] + "," + newStock + "," + food[3];
+ foods.set(i, updateStock);
+ }
+ }
+ }
+
+ private int updateStock(String[] food, int countPurchaseNormal, int countPurchasePromotion) {
+ int currentSock = Integer.parseInt(food[2]);
+ if (food[3].equals("null")) {
+ return currentSock - countPurchaseNormal;
+ }
+ return currentSock - countPurchasePromotion;
+ }
+
+ public void reflectStock() throws IOException {
+ BufferedWriter writer = new BufferedWriter(new FileWriter("src/main/resources/products.md", false));
+
+ for (String updatedLine : foods) {
+ writer.write(updatedLine + "\r\n");
+ }
+ writer.close();
+ }
+} | Java | 남은 재고를 다시 파일에 작성하셨군요! 인상적입니다!
`CRLF(\r\n)`는 운영체제에 종속적인 거 같아요!
`System.lineSeparator()`를 사용해보시는 걸 추천드려요! |
@@ -0,0 +1,201 @@
+package store.controller;
+
+import store.model.Product;
+import store.model.receipt.PurchaseProducts;
+import store.service.ReceiptService;
+import store.service.StockManageService;
+import store.view.InputView;
+import store.view.OutputView;
+
+import java.io.IOException;
+
+public class StoreController {
+ private final InputView inputView;
+ private final OutputView outputView;
+
+ private boolean nextPlay;
+ private PurchaseProducts purchaseProducts;
+ private ReceiptService receiptService;
+ private StockManageService stockManageService;
+
+ private int countPurchasePromotion;
+ private int countPurchaseNormal;
+ private int giftCount;
+ private boolean getBenefit;
+
+ public StoreController(InputView inputView, OutputView outputView) {
+ this.inputView = inputView;
+ this.outputView = outputView;
+ nextPlay = true;
+ }
+
+ public void run() throws IOException {
+ while (nextPlay) {
+ play();
+ }
+ }
+
+ private void play() throws IOException {
+ generateService();
+ stockManageService.bringStock();
+
+ outputView.printStoreMenu();
+ repeatUntilProductAndPriceValid();
+ calculateProducts();
+ printReceipt();
+
+ if (!repeatUntilAdditionalPlayValid()) {
+ nextPlay = false;
+ }
+ }
+
+ private void calculateProducts() {
+ for (Product product : purchaseProducts.getPurchaseProducts()) {
+ initCount(product);
+ calculateCount(product);
+
+ stockManageService.manageStock(countPurchaseNormal, countPurchasePromotion, product);
+
+ int stockCount = countPurchasePromotion + countPurchaseNormal;
+
+ receiptService.make(stockCount, giftCount, product, getBenefit);
+ }
+ }
+
+ private void calculateCount(Product product) {
+ if (!product.isPromotionDuration()) { //프로모션 기간이 아닐 때
+ if (product.isPromotionProduct()) {
+ getBenefit = false;
+ }
+
+ if (product.getNormalStockCount() >= product.getQuantity()) {
+ countPurchaseNormal = product.getQuantity();
+ return;
+ }
+ countPurchaseNormal = product.getNormalStockCount();
+ countPurchasePromotion = product.getQuantity() - countPurchaseNormal;
+ return;
+ }
+
+ if (product.isAvailableOnlyPromotion()) {
+ calculateCaseOne(product);
+ return;
+ }
+
+ if (product.isSameWithQuantity()) {
+ calculateCaseTwo(product);
+ return;
+ }
+
+ calculateCaseThree(product);
+ }
+
+ private void calculateCaseThree(Product product) {
+ countPurchasePromotion = product.getPromotionStockCount();
+ countPurchaseNormal = product.getQuantity() - countPurchasePromotion;
+
+ if (product.countPromotionDisable() > 0 & product.isPromotionProduct()) {
+ if (!repeatUntilPurchaseValid(product)) {
+ countPurchasePromotion = product.buyOnlyPromotion();
+ countPurchaseNormal = 0;
+ }
+ getBenefit = false;
+ }
+ }
+
+ private void calculateCaseTwo(Product product) {
+ countPurchasePromotion = product.getQuantity();
+
+ if (product.countPromotionDisable() > 0 & product.isPromotionProduct()) {
+ if (!repeatUntilPurchaseValid(product)) {
+ countPurchasePromotion = product.buyOnlyPromotion();
+ }
+ getBenefit = false;
+ }
+ }
+
+ private void calculateCaseOne(Product product) {
+ countPurchasePromotion = product.getQuantity();
+
+ if (product.canReceiveMoreFreeGift()) { //프로모션 기간, 프로모션 적용 가능
+ if (repeatUntilOneMoreFreeValid(product)) {
+ countPurchasePromotion += product.getPromotionGetCount();
+ giftCount += product.getPromotionGetCount();
+ product.increaseQuantity(product.getPromotionGetCount());
+ return;
+ }
+ getBenefit = false;
+ }
+ }
+
+ private void generateService() {
+ receiptService = new ReceiptService();
+ stockManageService = new StockManageService();
+ }
+
+ private void initCount(Product product) {
+ getBenefit = true;
+ countPurchasePromotion = 0;
+ countPurchaseNormal = 0;
+ giftCount = product.getGiftCount();
+ }
+
+ private void repeatUntilProductAndPriceValid() {
+ while (true) {
+ try {
+ purchaseProducts = new PurchaseProducts(inputView.getProductAndPrice());
+ return;
+ } catch (IllegalArgumentException | IOException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private boolean repeatUntilPurchaseValid(Product product) {
+ while (true) {
+ try {
+ return inputView.getPurchaseOrNot(product.getName(), product.countPromotionDisable());
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private boolean repeatUntilOneMoreFreeValid(Product product) {
+ while (true) {
+ try {
+ return inputView.getOneMoreFree(product);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private boolean repeatUntilMembershipDiscountValid() {
+ while (true) {
+ try {
+ return inputView.getMembershipDiscountOrNot();
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private boolean repeatUntilAdditionalPlayValid() {
+ while (true) {
+ try {
+ return inputView.getAdditionalPurchase();
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+
+ private void printReceipt() throws IOException {
+ receiptService.calculateDiscount(repeatUntilMembershipDiscountValid());
+ outputView.printPurchaseProduct(purchaseProducts);
+ outputView.printGiftProducts(receiptService.getGiftProducts());
+ outputView.printAmountInfo(receiptService.getAmountInfo());
+ stockManageService.reflectStock();
+ }
+} | Java | 개인적으로, `calculateCaseOne`, `calculateCaseTwo`, `calculateCaseThree`보다는 어떤 케이스를 다루는지 메서드명에 명시해주시면 더 직관적일 거 같아요! |
@@ -0,0 +1,39 @@
+package store.model.receipt;
+
+import store.model.Product;
+
+import java.io.IOException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PurchaseProducts {
+ private final List<Product> purchaseProducts;
+
+ public PurchaseProducts(String input) throws IOException {
+ purchaseProducts = new ArrayList<>();
+ validate(input);
+ }
+
+ private void validate(String input) throws IOException {
+ String[] inputProducts = input.split(",", -1);
+ for (String product : inputProducts) {
+ Product pro = new Product(product);
+ validate(pro);
+ purchaseProducts.add(pro);
+ }
+ }
+
+ private void validate(Product product){
+ String target = product.getName();
+ for (Product pro : purchaseProducts) {
+ if (pro.getName().equals(target)) {
+ throw new IllegalArgumentException("[ERROR] 중복되는 상품 이름이 있습니다.");
+ }
+ }
+ }
+
+ public List<Product> getPurchaseProducts() {
+ return purchaseProducts;
+ }
+} | Java | 이중 for문으로 확인하면, 시간이 좀 걸릴 수 있을 거 같아요!
`Set`이나 `stream`을 활용해보시면 좋을 거 같아요! |
@@ -0,0 +1,36 @@
+package store;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EmptySource;
+import org.junit.jupiter.params.provider.ValueSource;
+import store.model.Product;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class ProductTest {
+ @DisplayName("올바르지 않은 제품 형식을 입력하면 예외가 발생한다.")
+ @EmptySource //null 검사를 해야 하나?
+ @ParameterizedTest
+ @ValueSource(strings = {"[", "]", "[-", "-]", "[-]", "[감자칩-]", "[-3]",""," "})
+ void throwWhenInvalidProductForm(String input) {
+ assertThatThrownBy(() -> new Product(input))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ @DisplayName("존재하지 않는 제품 이름을 입력하면 예외가 발생한다.")
+ @ParameterizedTest
+ @ValueSource(strings = {"[포르쉐-3]"})
+ void throwWhenInvalidProductName(String input) {
+ assertThatThrownBy(() -> new Product(input))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ @DisplayName("올바르지 않은 제품 수량을 입력하면 예외가 발생한다.")
+ @ParameterizedTest
+ @ValueSource(strings = {"[감자칩-감]", "[감자칩-0]", "[감자칩-1000]"})
+ void throwWhenInvalidProductQuantity(String input) {
+ assertThatThrownBy(() -> new Product(input))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+} | Java | 꼼꼼한 테스트가 인상적입니다!
개인적으로, 예외 테스트는 예외 메시지까지 판별해야 더 정확하다고 생각합니다!
예외 메시지를 상수화하시면, 테스트에도 사용할 수 있어서 좋을 거 같아요! |
@@ -0,0 +1,58 @@
+package store.view;
+
+import static store.global.InputConstant.BUY_PRODUCT_MESSAGE;
+import static store.global.InputConstant.ENDING_MESSAGE;
+import static store.global.InputConstant.MEMBERSHIP_MESSAGE;
+import static store.global.InputConstant.NOTICE_FOR_FREE_STOCK;
+import static store.global.InputConstant.NOTICE_FOR_FREE_STOCK_MESSAGE;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class InputView {
+
+ private InputView() {
+
+ }
+
+ public static List<String> getLines(BufferedReader br) throws IOException {
+ List<String> lines = new ArrayList<>();
+ String line;
+ while ((line = getLine(br)) != null) {
+ lines.add(line);
+ }
+ return lines;
+ }
+
+ public static String getLine(BufferedReader br) throws IOException {
+ return br.readLine();
+ }
+
+ public static String getBuyProductMessage(Scanner sc) {
+ System.out.println(BUY_PRODUCT_MESSAGE);
+ return sc.nextLine();
+ }
+
+ public static String getMembershipMessage(Scanner sc) {
+ System.out.println(MEMBERSHIP_MESSAGE);
+ return sc.nextLine();
+ }
+
+ public static String getEndingMessage(Scanner sc) {
+ System.out.println(ENDING_MESSAGE);
+ return sc.nextLine();
+ }
+
+ public static String getMoreFreeStock(Scanner sc, String name, int freeStock) {
+ System.out.printf(NOTICE_FOR_FREE_STOCK_MESSAGE, name, freeStock);
+ return sc.nextLine();
+ }
+
+ public static String getAgreeBuyWithNoPromotion(Scanner sc, String name, int stock) {
+ System.out.printf(NOTICE_FOR_FREE_STOCK, name, stock);
+ return sc.nextLine();
+ }
+} | Java | `사용자가 입력하는 값은 camp.nextstep.edu.missionutils.Console의 readLine()을 활용한다.`라는 프로그래밍 요구사항이 있어서 Scanner를 사용하면 안될 것 같습니다! |
@@ -0,0 +1,178 @@
+package store.controller;
+
+import static store.global.InputConstant.YES_INPUT_BIG;
+import static store.utils.Validator.isUserContinuing;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import store.controller.product.ItemController;
+import store.controller.product.PromotionItemController;
+import store.domain.Item;
+import store.domain.Receipt;
+import store.domain.Stock;
+import store.domain.Store;
+import store.domain.promotion.Promotion;
+import store.utils.Parser;
+import store.utils.Validator;
+import store.view.FileInput;
+import store.view.InputView;
+import store.view.OutputView;
+
+public class FrontController {
+
+ private final PromotionItemController promotionItemController;
+ private final ItemController itemController;
+ private final PromotionController promotionController;
+ private StoreController storeController;
+ private ReceiptController receiptController;
+
+ public FrontController(ItemController itemController, PromotionItemController promotionItemController,
+ PromotionController promotionController) {
+ this.promotionItemController = promotionItemController;
+ this.itemController = itemController;
+ this.promotionController = promotionController;
+ }
+
+ // 프로그램 실행 메서드
+ public void run() throws IOException {
+ Store store = initializeStore();
+ storeController = new StoreController(itemController, store, promotionItemController);
+ Scanner scanner = new Scanner(System.in);
+
+ String isContinue = YES_INPUT_BIG;
+ itemController.checkItems(store.getItems(), store);
+
+ while (isUserContinuing(isContinue)) {
+ isContinue = processPurchaseInStore(store, scanner);
+ }
+ }
+
+ // 초기화 관련 메서드
+ private Store initializeStore() throws IOException {
+ List<Promotion> promotions = getPromotions();
+ List<Item> items = getItems(promotions);
+ return new Store(items);
+ }
+
+ // 구매 프로세스 처리 메서드
+ private String processPurchaseInStore(Store store, Scanner scanner) {
+ printStoreInfo(store);
+
+ Map<String, Stock> itemAndStock = getStringStockMap(scanner, store);
+ String membershipInput = getMembership(scanner);
+
+ List<Item> purchasedItems = storeController.buyProcess(itemAndStock);
+
+ Receipt receipt = new Receipt(purchasedItems, false);
+ this.receiptController = new ReceiptController(receipt);
+
+ receiptMagic(store, scanner, receipt, membershipInput);
+ return isContinue(scanner);
+ }
+
+ // 반복 확인 메서드
+ private String isContinue(Scanner scanner) {
+ try {
+ String isContinue;
+ isContinue = InputView.getEndingMessage(scanner);
+ Validator.YesOrNoValidator(isContinue);
+ return isContinue;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return isContinue(scanner);
+ }
+ }
+
+ // 영수증 관련 메서드
+ private void receiptMagic(Store store, Scanner scanner, Receipt receipt, String membershipInput) {
+ receiptController.notifyStockForFree(store, scanner);
+ receiptController.notifyPurchasedInfo(store, scanner);
+ receipt.calculatePrice();
+
+ if (isUserContinuing(membershipInput)) {
+ receiptController.checkMembership();
+ }
+ OutputView.printReceipt(receipt);
+ }
+
+ // 프로모션 정보 초기화 메서드
+ private List<Promotion> getPromotions() throws IOException {
+ BufferedReader br = FileInput.FileInputSetting(FileInput.PROMOTION_FILE_NAME);
+ List<String> promotionStrings = InputView.getLines(br);
+ return promotionController.setPromotions(promotionStrings);
+ }
+
+ private List<Item> getItems(List<Promotion> promotions) throws IOException {
+ BufferedReader br = FileInput.FileInputSetting(FileInput.ITEM_FILE_NAME);
+ List<String> itemStrings = InputView.getLines(br);
+ return itemController.setItems(itemStrings, promotions);
+ }
+
+ // 재고 및 구매 항목 관련 메서드
+ private Map<String, Stock> getStringStockMap(Scanner scanner, Store store) {
+ try {
+ Map<String, Stock> itemAndStock = getStringStockMap(scanner);
+ invalidStockValidator(itemAndStock, store);
+ return itemAndStock;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return getStringStockMap(scanner, store);
+ }
+ }
+
+ private Map<String, Stock> getStringStockMap(Scanner scanner) {
+ String itemInput = InputView.getBuyProductMessage(scanner);
+ Validator.buyInputFormatValidator(itemInput);
+ return getStringStockMap(itemInput);
+ }
+
+ private void invalidStockValidator(Map<String, Stock> itemAndStock, Store store) {
+ itemAndStock.forEach((name, stock) -> {
+ Item item = store.findProduct(name);
+ Item promotionItem = store.findPromotionProduct(name);
+ storeController.isValidName(name);
+ storeController.isValidStock(stock, item, promotionItem);
+ });
+ }
+
+ private Map<String, Stock> getStringStockMap(String itemInput) {
+ List<String> splitItemInput = Parser.splitWithCommaDelimiter(itemInput);
+ List<String> itemNames = new ArrayList<>();
+ Map<String, Stock> itemAndStock = new HashMap<>();
+
+ for (String itemInfo : splitItemInput) {
+ Parser.itemAndStockParser(itemInfo, itemAndStock);
+ itemNames.add(Parser.splitWithBarDelimiter(itemInfo).getFirst());
+ }
+ Validator.duplicatedNameValidator(itemNames);
+ return itemAndStock;
+ }
+
+ // 멤버십 확인 메서드
+ private String getMembership(Scanner scanner) {
+ try {
+ return isUseMembership(scanner);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return getMembership(scanner);
+ }
+ }
+
+ private String isUseMembership(Scanner scanner) {
+ String membershipInput = InputView.getMembershipMessage(scanner);
+ Validator.YesOrNoValidator(membershipInput);
+ return membershipInput;
+ }
+
+ // 스토어 정보 출력 메서드
+ private void printStoreInfo(Store store) {
+ OutputView.printGreeting();
+ OutputView.printStoreInformation(store);
+ }
+
+} | Java | 주석을 메서드를 설명하기 위해 추가하셨는데, 메서드명이 이미 주석의 역할을 대신하고 있기 때문에 주석 사용을 지양하는 것이 좋은 것으로 알고 있습니다! |
@@ -0,0 +1,178 @@
+package store.controller;
+
+import static store.global.InputConstant.YES_INPUT_BIG;
+import static store.utils.Validator.isUserContinuing;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import store.controller.product.ItemController;
+import store.controller.product.PromotionItemController;
+import store.domain.Item;
+import store.domain.Receipt;
+import store.domain.Stock;
+import store.domain.Store;
+import store.domain.promotion.Promotion;
+import store.utils.Parser;
+import store.utils.Validator;
+import store.view.FileInput;
+import store.view.InputView;
+import store.view.OutputView;
+
+public class FrontController {
+
+ private final PromotionItemController promotionItemController;
+ private final ItemController itemController;
+ private final PromotionController promotionController;
+ private StoreController storeController;
+ private ReceiptController receiptController;
+
+ public FrontController(ItemController itemController, PromotionItemController promotionItemController,
+ PromotionController promotionController) {
+ this.promotionItemController = promotionItemController;
+ this.itemController = itemController;
+ this.promotionController = promotionController;
+ }
+
+ // 프로그램 실행 메서드
+ public void run() throws IOException {
+ Store store = initializeStore();
+ storeController = new StoreController(itemController, store, promotionItemController);
+ Scanner scanner = new Scanner(System.in);
+
+ String isContinue = YES_INPUT_BIG;
+ itemController.checkItems(store.getItems(), store);
+
+ while (isUserContinuing(isContinue)) {
+ isContinue = processPurchaseInStore(store, scanner);
+ }
+ }
+
+ // 초기화 관련 메서드
+ private Store initializeStore() throws IOException {
+ List<Promotion> promotions = getPromotions();
+ List<Item> items = getItems(promotions);
+ return new Store(items);
+ }
+
+ // 구매 프로세스 처리 메서드
+ private String processPurchaseInStore(Store store, Scanner scanner) {
+ printStoreInfo(store);
+
+ Map<String, Stock> itemAndStock = getStringStockMap(scanner, store);
+ String membershipInput = getMembership(scanner);
+
+ List<Item> purchasedItems = storeController.buyProcess(itemAndStock);
+
+ Receipt receipt = new Receipt(purchasedItems, false);
+ this.receiptController = new ReceiptController(receipt);
+
+ receiptMagic(store, scanner, receipt, membershipInput);
+ return isContinue(scanner);
+ }
+
+ // 반복 확인 메서드
+ private String isContinue(Scanner scanner) {
+ try {
+ String isContinue;
+ isContinue = InputView.getEndingMessage(scanner);
+ Validator.YesOrNoValidator(isContinue);
+ return isContinue;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return isContinue(scanner);
+ }
+ }
+
+ // 영수증 관련 메서드
+ private void receiptMagic(Store store, Scanner scanner, Receipt receipt, String membershipInput) {
+ receiptController.notifyStockForFree(store, scanner);
+ receiptController.notifyPurchasedInfo(store, scanner);
+ receipt.calculatePrice();
+
+ if (isUserContinuing(membershipInput)) {
+ receiptController.checkMembership();
+ }
+ OutputView.printReceipt(receipt);
+ }
+
+ // 프로모션 정보 초기화 메서드
+ private List<Promotion> getPromotions() throws IOException {
+ BufferedReader br = FileInput.FileInputSetting(FileInput.PROMOTION_FILE_NAME);
+ List<String> promotionStrings = InputView.getLines(br);
+ return promotionController.setPromotions(promotionStrings);
+ }
+
+ private List<Item> getItems(List<Promotion> promotions) throws IOException {
+ BufferedReader br = FileInput.FileInputSetting(FileInput.ITEM_FILE_NAME);
+ List<String> itemStrings = InputView.getLines(br);
+ return itemController.setItems(itemStrings, promotions);
+ }
+
+ // 재고 및 구매 항목 관련 메서드
+ private Map<String, Stock> getStringStockMap(Scanner scanner, Store store) {
+ try {
+ Map<String, Stock> itemAndStock = getStringStockMap(scanner);
+ invalidStockValidator(itemAndStock, store);
+ return itemAndStock;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return getStringStockMap(scanner, store);
+ }
+ }
+
+ private Map<String, Stock> getStringStockMap(Scanner scanner) {
+ String itemInput = InputView.getBuyProductMessage(scanner);
+ Validator.buyInputFormatValidator(itemInput);
+ return getStringStockMap(itemInput);
+ }
+
+ private void invalidStockValidator(Map<String, Stock> itemAndStock, Store store) {
+ itemAndStock.forEach((name, stock) -> {
+ Item item = store.findProduct(name);
+ Item promotionItem = store.findPromotionProduct(name);
+ storeController.isValidName(name);
+ storeController.isValidStock(stock, item, promotionItem);
+ });
+ }
+
+ private Map<String, Stock> getStringStockMap(String itemInput) {
+ List<String> splitItemInput = Parser.splitWithCommaDelimiter(itemInput);
+ List<String> itemNames = new ArrayList<>();
+ Map<String, Stock> itemAndStock = new HashMap<>();
+
+ for (String itemInfo : splitItemInput) {
+ Parser.itemAndStockParser(itemInfo, itemAndStock);
+ itemNames.add(Parser.splitWithBarDelimiter(itemInfo).getFirst());
+ }
+ Validator.duplicatedNameValidator(itemNames);
+ return itemAndStock;
+ }
+
+ // 멤버십 확인 메서드
+ private String getMembership(Scanner scanner) {
+ try {
+ return isUseMembership(scanner);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return getMembership(scanner);
+ }
+ }
+
+ private String isUseMembership(Scanner scanner) {
+ String membershipInput = InputView.getMembershipMessage(scanner);
+ Validator.YesOrNoValidator(membershipInput);
+ return membershipInput;
+ }
+
+ // 스토어 정보 출력 메서드
+ private void printStoreInfo(Store store) {
+ OutputView.printGreeting();
+ OutputView.printStoreInformation(store);
+ }
+
+} | Java | magic이라는 단어를 사용하신 이유가 있을까요? |
@@ -0,0 +1,38 @@
+package store.domain.promotion;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+public class Promotion {
+
+ private final String name;
+ private final Range range;
+ private final BuyGet buyGet;
+
+ public Promotion(String name, BuyGet buyGet, Range range) {
+ this.buyGet = buyGet;
+ this.name = name;
+ this.range = range;
+ }
+
+ public boolean checkDate(LocalDateTime now) {
+ LocalDate date = now.toLocalDate();
+ return range.isValidRange(date);
+ }
+
+ public int calculateFreeStock(int stock) {
+ return buyGet.calculateGetStock(stock);
+ }
+
+ public int getTotalBuyStock(int totalStock, int currentStock) {
+ return buyGet.calculateBuyStock(totalStock, currentStock);
+ }
+
+ public int getBuyStock() {
+ return buyGet.getBuyStock();
+ }
+
+ public String getName() {
+ return name;
+ }
+} | Java | BuyGet과 Range로 분리한 이유가 궁금합니다! |
@@ -0,0 +1,151 @@
+package store.controller;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+import store.domain.Item;
+import store.domain.Receipt;
+import store.domain.Store;
+import store.utils.Validator;
+import store.view.InputView;
+
+import static store.global.InputConstant.NO_INPUT_BIG;
+import static store.global.InputConstant.YES_INPUT_BIG;
+import static store.utils.Validator.isUserContinuingWithNo;
+
+public class ReceiptController {
+
+ private final Receipt receipt;
+
+ public ReceiptController(Receipt receipt) {
+ this.receipt = receipt;
+ }
+
+ public void notifyStockForFree(Store store, Scanner scanner) {
+ List<Item> newItems = new ArrayList<>(receipt.getProducts());
+ for (Item item : newItems) {
+ if (!item.getFree() && item.getPromotion() != null) {
+ isCanGetFreeStock(store, item, scanner);
+ }
+ }
+ }
+
+ public void notifyPurchasedInfo(Store store, Scanner scanner) {
+ for (Item item : receipt.getProducts()) {
+ if (!item.getFree()) {
+ checkPromotions(scanner, store, item);
+ }
+ }
+ }
+
+ public void checkMembership() {
+ for (Item item : receipt.getProducts()) {
+ if (!item.getFree()) {
+ Item promotionItem = receipt.findPromotionProductWithNull(item);
+ compareBuyGet(item, promotionItem);
+ }
+ }
+ }
+
+ private void isCanGetFreeStock(Store store, Item normalItem, Scanner sc) {
+ Item promotionItem = receipt.findPromotionProduct(normalItem);
+ Item promotionItemInStore = store.findPromotionProduct(normalItem.getName());
+ Item itemInStore = store.findProduct(normalItem.getName());
+ if (promotionItemInStore == null) {
+ return;
+ }
+
+ getFreeStock(normalItem, sc, promotionItem, promotionItemInStore, NO_INPUT_BIG, itemInStore);
+ }
+
+ private void getFreeStock(Item normalItem, Scanner sc, Item promotionItem, Item promotionItemInStore,
+ String yesOrNO,
+ Item itemInStore) {
+ int moreFreeStock = getMoreFreeStock(normalItem, promotionItem, promotionItemInStore);
+ if (moreFreeStock > 0) {
+ yesOrNO = InputView.getMoreFreeStock(sc, normalItem.getName(), 1);
+ }
+
+ updateStock(yesOrNO, promotionItem, promotionItemInStore, moreFreeStock, itemInStore);
+ }
+
+ private int getMoreFreeStock(Item normalItem, Item promotionItem, Item promotionItemInStore) {
+ int currentStock = normalItem.getStockCount();
+ int currentFreeStock = promotionItem.getStockCount();
+ int currentPromotionStock = promotionItem.getBuyStockByFreeStock(currentFreeStock);
+
+ return promotionItemInStore.getTotalBuyStock(currentStock - currentPromotionStock + 1,
+ promotionItemInStore.getStockCount());
+ }
+
+ private void updateStock(String yesOrNO, Item promotionItem, Item promotionItemInStore, int moreFreeStock,
+ Item itemInStore) {
+ if (Validator.isUserContinuing(yesOrNO)) {
+ promotionItem.addStock(1);
+ promotionItemInStore.updateStock(1 + moreFreeStock);
+ itemInStore.addStock(moreFreeStock);
+ }
+ }
+
+ private void checkPromotions(Scanner sc, Store store, Item item) {
+ Item promotionItemInStore = store.findPromotionProduct(item.getName());
+ Item freeItem = receipt.findPromotionProductWithNull(item);
+
+ if (promotionItemInStore == null || freeItem == null) {
+ return;
+ }
+
+ isNoPromotionItems(sc, store, item, promotionItemInStore, freeItem, YES_INPUT_BIG);
+ }
+
+ private void isNoPromotionItems(Scanner sc, Store store, Item item, Item promotionItemInStore, Item freeItem,
+ String isPurchase) {
+ int getCount = promotionItemInStore.getBuyStock();
+ int freeStock = freeItem.getStockCount();
+ int currentBuyStockByPromotion = item.getBuyStockByFreeStock(freeStock);
+ int currentBuyStockWithNoPromotion = item.getStockCount() - currentBuyStockByPromotion;
+
+ if (getCount <= currentBuyStockWithNoPromotion) {
+ isPurchase = InputView.getAgreeBuyWithNoPromotion(sc, item.getName(), currentBuyStockWithNoPromotion);
+ }
+ refundProcess(store, item, isPurchase, currentBuyStockWithNoPromotion);
+ }
+
+ private void refundProcess(Store store, Item item, String isPurchase, int currentBuyStockWithNoPromotion) {
+ if (isUserContinuingWithNo(isPurchase)) {
+ notPurchase(store, item, currentBuyStockWithNoPromotion);
+ }
+ }
+
+ private void notPurchase(Store store, Item item, int stock) {
+ Item promotionItemInStore = store.findPromotionProduct(item.getName());
+ Item itemInStore = store.findProduct(item.getName());
+
+ stock = calculateUpdateStock(item, stock, itemInStore);
+
+ if (stock > 0) {
+ promotionItemInStore.addStock(stock);
+ item.updateStock(stock);
+ }
+ }
+
+ private int calculateUpdateStock(Item item, int stock, Item itemInStore) {
+ int totalItemInStore = itemInStore.getTotalStock();
+
+ int refundStock = Math.min(stock, totalItemInStore - itemInStore.getStockCount());
+ itemInStore.addStock(refundStock);
+ item.updateStock(refundStock);
+ stock -= refundStock;
+ return stock;
+ }
+
+ private void compareBuyGet(Item item, Item promotionItem) {
+ if (promotionItem == null) {
+ receipt.setMembership(true);
+ return;
+ }
+ if (item.getStockCount() != item.getBuyStockByFreeStock(promotionItem.getStockCount())) {
+ receipt.setMembership(true);
+ }
+ }
+} | Java | 제가 보기에 2+1, 1+1처럼 무조건 Get이 1인 상황을 가정하고 currentPromotionStock + 1을 한 것 같습니다! 프로모션이 달라질 수 있기 때문에 BuyGet 클래스의 get 값을 더해주는 게 더 좋지 않을까 싶어요! |
@@ -0,0 +1,178 @@
+package store.controller;
+
+import static store.global.InputConstant.YES_INPUT_BIG;
+import static store.utils.Validator.isUserContinuing;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import store.controller.product.ItemController;
+import store.controller.product.PromotionItemController;
+import store.domain.Item;
+import store.domain.Receipt;
+import store.domain.Stock;
+import store.domain.Store;
+import store.domain.promotion.Promotion;
+import store.utils.Parser;
+import store.utils.Validator;
+import store.view.FileInput;
+import store.view.InputView;
+import store.view.OutputView;
+
+public class FrontController {
+
+ private final PromotionItemController promotionItemController;
+ private final ItemController itemController;
+ private final PromotionController promotionController;
+ private StoreController storeController;
+ private ReceiptController receiptController;
+
+ public FrontController(ItemController itemController, PromotionItemController promotionItemController,
+ PromotionController promotionController) {
+ this.promotionItemController = promotionItemController;
+ this.itemController = itemController;
+ this.promotionController = promotionController;
+ }
+
+ // 프로그램 실행 메서드
+ public void run() throws IOException {
+ Store store = initializeStore();
+ storeController = new StoreController(itemController, store, promotionItemController);
+ Scanner scanner = new Scanner(System.in);
+
+ String isContinue = YES_INPUT_BIG;
+ itemController.checkItems(store.getItems(), store);
+
+ while (isUserContinuing(isContinue)) {
+ isContinue = processPurchaseInStore(store, scanner);
+ }
+ }
+
+ // 초기화 관련 메서드
+ private Store initializeStore() throws IOException {
+ List<Promotion> promotions = getPromotions();
+ List<Item> items = getItems(promotions);
+ return new Store(items);
+ }
+
+ // 구매 프로세스 처리 메서드
+ private String processPurchaseInStore(Store store, Scanner scanner) {
+ printStoreInfo(store);
+
+ Map<String, Stock> itemAndStock = getStringStockMap(scanner, store);
+ String membershipInput = getMembership(scanner);
+
+ List<Item> purchasedItems = storeController.buyProcess(itemAndStock);
+
+ Receipt receipt = new Receipt(purchasedItems, false);
+ this.receiptController = new ReceiptController(receipt);
+
+ receiptMagic(store, scanner, receipt, membershipInput);
+ return isContinue(scanner);
+ }
+
+ // 반복 확인 메서드
+ private String isContinue(Scanner scanner) {
+ try {
+ String isContinue;
+ isContinue = InputView.getEndingMessage(scanner);
+ Validator.YesOrNoValidator(isContinue);
+ return isContinue;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return isContinue(scanner);
+ }
+ }
+
+ // 영수증 관련 메서드
+ private void receiptMagic(Store store, Scanner scanner, Receipt receipt, String membershipInput) {
+ receiptController.notifyStockForFree(store, scanner);
+ receiptController.notifyPurchasedInfo(store, scanner);
+ receipt.calculatePrice();
+
+ if (isUserContinuing(membershipInput)) {
+ receiptController.checkMembership();
+ }
+ OutputView.printReceipt(receipt);
+ }
+
+ // 프로모션 정보 초기화 메서드
+ private List<Promotion> getPromotions() throws IOException {
+ BufferedReader br = FileInput.FileInputSetting(FileInput.PROMOTION_FILE_NAME);
+ List<String> promotionStrings = InputView.getLines(br);
+ return promotionController.setPromotions(promotionStrings);
+ }
+
+ private List<Item> getItems(List<Promotion> promotions) throws IOException {
+ BufferedReader br = FileInput.FileInputSetting(FileInput.ITEM_FILE_NAME);
+ List<String> itemStrings = InputView.getLines(br);
+ return itemController.setItems(itemStrings, promotions);
+ }
+
+ // 재고 및 구매 항목 관련 메서드
+ private Map<String, Stock> getStringStockMap(Scanner scanner, Store store) {
+ try {
+ Map<String, Stock> itemAndStock = getStringStockMap(scanner);
+ invalidStockValidator(itemAndStock, store);
+ return itemAndStock;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return getStringStockMap(scanner, store);
+ }
+ }
+
+ private Map<String, Stock> getStringStockMap(Scanner scanner) {
+ String itemInput = InputView.getBuyProductMessage(scanner);
+ Validator.buyInputFormatValidator(itemInput);
+ return getStringStockMap(itemInput);
+ }
+
+ private void invalidStockValidator(Map<String, Stock> itemAndStock, Store store) {
+ itemAndStock.forEach((name, stock) -> {
+ Item item = store.findProduct(name);
+ Item promotionItem = store.findPromotionProduct(name);
+ storeController.isValidName(name);
+ storeController.isValidStock(stock, item, promotionItem);
+ });
+ }
+
+ private Map<String, Stock> getStringStockMap(String itemInput) {
+ List<String> splitItemInput = Parser.splitWithCommaDelimiter(itemInput);
+ List<String> itemNames = new ArrayList<>();
+ Map<String, Stock> itemAndStock = new HashMap<>();
+
+ for (String itemInfo : splitItemInput) {
+ Parser.itemAndStockParser(itemInfo, itemAndStock);
+ itemNames.add(Parser.splitWithBarDelimiter(itemInfo).getFirst());
+ }
+ Validator.duplicatedNameValidator(itemNames);
+ return itemAndStock;
+ }
+
+ // 멤버십 확인 메서드
+ private String getMembership(Scanner scanner) {
+ try {
+ return isUseMembership(scanner);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return getMembership(scanner);
+ }
+ }
+
+ private String isUseMembership(Scanner scanner) {
+ String membershipInput = InputView.getMembershipMessage(scanner);
+ Validator.YesOrNoValidator(membershipInput);
+ return membershipInput;
+ }
+
+ // 스토어 정보 출력 메서드
+ private void printStoreInfo(Store store) {
+ OutputView.printGreeting();
+ OutputView.printStoreInformation(store);
+ }
+
+} | Java | 컨트롤러에서 Validator를 수행하는 것 보다 따로 분리해서 역할 분담하는 것이 좋을 것 같습니다! 희훈님의 생각이 궁금합니다. |
@@ -0,0 +1,94 @@
+package store.controller;
+
+import static store.domain.Item.isItemExists;
+import static store.domain.Store.addPurchaseProduct;
+import static store.global.ErrorMessages.INVALID_INPUT_STOCK;
+import static store.global.ErrorMessages.PRODUCT_NOT_FOUND;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import store.controller.product.ItemController;
+import store.controller.product.PromotionItemController;
+import store.domain.Item;
+import store.domain.Stock;
+import store.domain.Store;
+
+public class StoreController {
+
+ private final Store store;
+ private final ItemController itemController;
+ private final PromotionItemController promotionItemController;
+
+ public StoreController(ItemController itemController, Store store,
+ PromotionItemController promotionItemController) {
+ this.itemController = itemController;
+ this.store = store;
+ this.promotionItemController = promotionItemController;
+ }
+
+ public List<Item> buyProcess(Map<String, Stock> shoppingCarts) {
+ List<Item> purchasedItems = new ArrayList<>();
+
+ shoppingCarts.forEach((product, stock) -> {
+ Item nomalItem = store.findProduct(product);
+ Item promotionalItem = store.findPromotionProduct(product);
+
+ isValidItemAndStock(stock, nomalItem, promotionalItem);
+ process(stock, promotionalItem, purchasedItems, nomalItem);
+ });
+ return purchasedItems;
+ }
+
+ public void isValidStock(Stock stock, Item promotionalItem, Item normalItem) {
+ int promotionStockCount = Optional.ofNullable(store.getProductStock(promotionalItem))
+ .map(Stock::getStock)
+ .orElse(0);
+ int normalStockCount = Optional.ofNullable(store.getProductStock(normalItem))
+ .map(Stock::getStock)
+ .orElse(0);
+
+ if (promotionStockCount + normalStockCount < stock.getStock()) {
+ throw new IllegalArgumentException(INVALID_INPUT_STOCK.getMessage());
+ }
+ }
+
+ public void isValidName(String name) {
+ boolean flag = false;
+ for(Item item : store.getItems()){
+ if (item.getName().equals(name)) {
+ flag = true;
+ break;
+ }
+ }
+ if (!flag) {
+ throw new IllegalArgumentException(PRODUCT_NOT_FOUND.getMessage());
+ }
+ }
+
+ private void process(Stock stock, Item promotionalItem, List<Item> purchasedItems, Item nomalItem) {
+ Item item = purchaseProcess(stock, promotionalItem, purchasedItems, nomalItem);
+ addPurchaseProduct(purchasedItems, item);
+ }
+
+ private void isValidItemAndStock(Stock stock, Item nomalItem, Item promotionalItem) {
+ isItemExists(nomalItem, promotionalItem);
+ isValidStock(stock, promotionalItem, nomalItem);
+ }
+
+ private Item purchaseProcess(Stock stock, Item promotionalItem, List<Item> purchasedItems, Item nomalItem) {
+ Item item = processPromotionItems(stock, promotionalItem, purchasedItems, nomalItem);
+ itemController.processItems(stock, item, nomalItem, purchasedItems);
+ return item;
+ }
+
+ private Item processPromotionItems(Stock stock, Item promotionalItem, List<Item> purchasedItems, Item nomalItem) {
+ Item item = promotionItemController.processPromotionItem(stock, promotionalItem, purchasedItems, store);
+
+ if (item == null) {
+ item = new Item(nomalItem, new Stock(0), Boolean.FALSE);
+ }
+ return item;
+ }
+} | Java | Boolean을 래퍼 클래스를 사용해서 지정해준 이유가 있을까요? |
@@ -0,0 +1,70 @@
+package store.controller.product;
+
+import static java.lang.Boolean.FALSE;
+import static java.lang.Boolean.TRUE;
+import static store.domain.Store.addFreeProduct;
+
+import camp.nextstep.edu.missionutils.DateTimes;
+import java.util.List;
+import store.domain.Item;
+import store.domain.Stock;
+import store.domain.Store;
+
+public class PromotionItemController {
+
+ public Item processPromotionItem(Stock stock, Item promotionalItem, List<Item> purchasedItems, Store store) {
+ Stock stockFreeItem = new Stock(0);
+ Stock stockForPay = new Stock(0);
+ Item purchasedItem = null;
+ if (promotionalItem == null) {
+ return null;
+ }
+ if (promotionalItem.checkDate(DateTimes.now())) {
+ Item item = store.buyPromoItemNoDiscount(stock, promotionalItem, purchasedItems);
+ if (item != null) {
+ return item;
+ }
+ purchasedItem = processPromotionItems(stock, promotionalItem, purchasedItems, stockFreeItem, stockForPay);
+ }
+
+ return purchasedItem;
+ }
+
+ public static int processRemainingPromotionStock(Item promotionalItem, Stock remainStock) {
+ return Math.min(promotionalItem.getStockCount(), remainStock.getStock());
+ }
+
+ private Item processPromotionItems(Stock stock, Item promotionalItem, List<Item> purchasedItems, Stock stockFreeItem,
+ Stock stockForPay) {
+ Item purchasedItem;
+ promotionProcess(stock, promotionalItem, stockFreeItem, stockForPay);
+ purchasedItem = new Item(promotionalItem, stockForPay, FALSE);
+ addFreeProduct(stockFreeItem, promotionalItem, purchasedItems, TRUE);
+ return purchasedItem;
+ }
+
+ private static void promotionProcess(Stock stock, Item promotionalItem, Stock stockFreeItem, Stock stockForPay) {
+ int stockForPromotionItem = promotionalItem.getTotalBuyStock(stock.getStock(), promotionalItem.getStockCount());
+ int freeStock = promotionalItem.calculateFreeStock(stockForPromotionItem);
+
+ updatePromotionItems(promotionalItem, stockFreeItem, stockForPay, freeStock, stockForPromotionItem);
+
+ stock.minus(stockForPromotionItem + freeStock);
+ int remainingStock = updateRemainItem(stock, promotionalItem, stockForPay);
+ stock.minus(remainingStock);
+ }
+
+ private static int updateRemainItem(Stock stock, Item promotionalItem, Stock stockForPay) {
+ int remainingStock = processRemainingPromotionStock(promotionalItem, stock);
+ promotionalItem.updateStock(remainingStock);
+ stockForPay.plus(remainingStock);
+ return remainingStock;
+ }
+
+ private static void updatePromotionItems(Item promotionalItem, Stock stockFreeItem, Stock stockForPay, int freeStock,
+ int stockForPromotionItem) {
+ stockFreeItem.plus(freeStock);
+ stockForPay.plus(stockForPromotionItem);
+ promotionalItem.updateStock(stockForPromotionItem + freeStock);
+ }
+} | Java | 프로그래밍 요구사항에 메서드 라인 제약이 있기 때문에 요구사항은 만족되어야 할 것 같습니다! |
@@ -0,0 +1,110 @@
+package store.domain;
+
+import java.util.List;
+
+
+public class Receipt {
+
+ private final List<Item> items;
+ private int totalPrice;
+ private int promotionPrice;
+ private boolean membership;
+ private int membershipPrice;
+
+ public Receipt(List<Item> items, boolean membership) {
+ this.items = items;
+ this.membership = membership;
+ }
+
+ public Item findPromotionProduct(Item promotionItem) {
+ for (Item item : items) {
+ if (item.getName().equals(promotionItem.getName()) && (item.getFree())) {
+ return item;
+ }
+ }
+ Item newItem = new Item(promotionItem, new Stock(0), true);
+ items.add(newItem);
+ return newItem;
+ }
+
+ public void setMembership(boolean membership) {
+ this.membership = membership;
+ }
+
+ public Item findPromotionProductWithNull(Item promotionItem) {
+ for (Item item : items) {
+ if (item.getName().equals(promotionItem.getName()) && (item.getPromotion() != null)) {
+ return item;
+ }
+ }
+ return null;
+ }
+
+ public void calculatePrice() {
+ for (Item item : items) {
+ totalPrice += item.calculatePrice();
+ if (item.getFree()) {
+ promotionPrice += item.calculatePrice();
+ }
+ }
+ }
+
+ public int calculateStock(Item target) {
+ int count = 0;
+ for (Item item : items) {
+ if (item.getName().equals(target.getName())) {
+ count += item.getStockCount();
+ }
+ }
+ return count;
+ }
+
+ public int totalStock() {
+ int total = 0;
+ for (Item item : items) {
+ total += item.getStockCount();
+ }
+ return total;
+ }
+
+ public boolean getMembership() {
+ return membership;
+ }
+
+ public List<Item> getProducts() {
+ return items;
+ }
+
+ public int getPromotionPrice() {
+ return promotionPrice;
+ }
+
+ public int getTotalPrice() {
+ return totalPrice;
+ }
+
+ public int getMembershipPrice() {
+ return membershipPrice;
+ }
+
+ public Integer applyMembership() {
+ System.out.println();
+ int discountPrice = 0;
+ for (Item item : items) {
+ if (item.getFree()) {
+ int buyStock = item.getBuyStockByFreeStock(item.getStockCount());
+ discountPrice += buyStock * item.getPrice();
+ }
+ }
+ if (getMembership()) {
+ return calculateMembershipPrice(discountPrice);
+ }
+ return 0;
+ }
+
+ public int calculateMembershipPrice(int discountPrice) {
+ membershipPrice = Math.min((int) ((totalPrice - promotionPrice - discountPrice) * 0.3), 8000);
+ return membershipPrice;
+ }
+
+} | Java | 이 메서드에서 개행처리를 하는 건 좋지 않은 것 같습니다! 그리고 메서드 라인 요구사항을 지켜야 합니다! |
@@ -0,0 +1,62 @@
+package store.domain;
+
+import static store.global.ErrorMessages.INVALID_STATE_ERROR;
+
+import java.util.Objects;
+
+public class Stock {
+
+ private int stock;
+
+ public Stock(int stock) {
+ validate(stock);
+ this.stock = stock;
+ }
+
+ public int getStock() {
+ return stock;
+ }
+
+ public boolean compare(int stock) {
+ return this.stock >= stock;
+ }
+
+ public void minus(int stock) {
+ updateValidate(stock);
+ this.stock -= stock;
+ }
+
+ public void plus(int stock) {
+ this.stock += stock;
+ }
+
+ private void validate(int stock) {
+ if (stock < 0) {
+ throw new IllegalStateException(INVALID_STATE_ERROR.getMessage());
+ }
+ }
+
+ private void updateValidate(int stock) {
+ if (stock > this.stock) {
+ throw new IllegalStateException(INVALID_STATE_ERROR.getMessage());
+ }
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ Stock stock1 = (Stock) o;
+ return stock == stock1.stock;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(stock);
+ }
+}
+ | Java | 이 부분을 따로 Override하신 이유가 궁금해요! |
@@ -0,0 +1,25 @@
+package store.view;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+public class FileInput {
+
+ private FileInput() {
+
+ }
+
+ public static final String ITEM_FILE_NAME = "products.md";
+ public static final String PROMOTION_FILE_NAME = "promotions.md";
+
+ public static BufferedReader FileInputSetting(String fileName) {
+ InputStream inputStream = FileInput.class.getClassLoader().getResourceAsStream(fileName);
+
+ if (inputStream == null) {
+ throw new IllegalStateException("File not found: products.md");
+ }
+
+ return new BufferedReader(new InputStreamReader(inputStream));
+ }
+} | Java | 이 부분 예외 메세지의 경우도 상수에서 가져와야 할 것 같습니다! |
@@ -0,0 +1,58 @@
+package store.view;
+
+import static store.global.InputConstant.BUY_PRODUCT_MESSAGE;
+import static store.global.InputConstant.ENDING_MESSAGE;
+import static store.global.InputConstant.MEMBERSHIP_MESSAGE;
+import static store.global.InputConstant.NOTICE_FOR_FREE_STOCK;
+import static store.global.InputConstant.NOTICE_FOR_FREE_STOCK_MESSAGE;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class InputView {
+
+ private InputView() {
+
+ }
+
+ public static List<String> getLines(BufferedReader br) throws IOException {
+ List<String> lines = new ArrayList<>();
+ String line;
+ while ((line = getLine(br)) != null) {
+ lines.add(line);
+ }
+ return lines;
+ }
+
+ public static String getLine(BufferedReader br) throws IOException {
+ return br.readLine();
+ }
+
+ public static String getBuyProductMessage(Scanner sc) {
+ System.out.println(BUY_PRODUCT_MESSAGE);
+ return sc.nextLine();
+ }
+
+ public static String getMembershipMessage(Scanner sc) {
+ System.out.println(MEMBERSHIP_MESSAGE);
+ return sc.nextLine();
+ }
+
+ public static String getEndingMessage(Scanner sc) {
+ System.out.println(ENDING_MESSAGE);
+ return sc.nextLine();
+ }
+
+ public static String getMoreFreeStock(Scanner sc, String name, int freeStock) {
+ System.out.printf(NOTICE_FOR_FREE_STOCK_MESSAGE, name, freeStock);
+ return sc.nextLine();
+ }
+
+ public static String getAgreeBuyWithNoPromotion(Scanner sc, String name, int stock) {
+ System.out.printf(NOTICE_FOR_FREE_STOCK, name, stock);
+ return sc.nextLine();
+ }
+} | Java | 제가 입출력을 제일 마지막에 구현해서 정신없이 뺐네요 ㅜㅜㅜ 감사합니다 !! |
@@ -0,0 +1,178 @@
+package store.controller;
+
+import static store.global.InputConstant.YES_INPUT_BIG;
+import static store.utils.Validator.isUserContinuing;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import store.controller.product.ItemController;
+import store.controller.product.PromotionItemController;
+import store.domain.Item;
+import store.domain.Receipt;
+import store.domain.Stock;
+import store.domain.Store;
+import store.domain.promotion.Promotion;
+import store.utils.Parser;
+import store.utils.Validator;
+import store.view.FileInput;
+import store.view.InputView;
+import store.view.OutputView;
+
+public class FrontController {
+
+ private final PromotionItemController promotionItemController;
+ private final ItemController itemController;
+ private final PromotionController promotionController;
+ private StoreController storeController;
+ private ReceiptController receiptController;
+
+ public FrontController(ItemController itemController, PromotionItemController promotionItemController,
+ PromotionController promotionController) {
+ this.promotionItemController = promotionItemController;
+ this.itemController = itemController;
+ this.promotionController = promotionController;
+ }
+
+ // 프로그램 실행 메서드
+ public void run() throws IOException {
+ Store store = initializeStore();
+ storeController = new StoreController(itemController, store, promotionItemController);
+ Scanner scanner = new Scanner(System.in);
+
+ String isContinue = YES_INPUT_BIG;
+ itemController.checkItems(store.getItems(), store);
+
+ while (isUserContinuing(isContinue)) {
+ isContinue = processPurchaseInStore(store, scanner);
+ }
+ }
+
+ // 초기화 관련 메서드
+ private Store initializeStore() throws IOException {
+ List<Promotion> promotions = getPromotions();
+ List<Item> items = getItems(promotions);
+ return new Store(items);
+ }
+
+ // 구매 프로세스 처리 메서드
+ private String processPurchaseInStore(Store store, Scanner scanner) {
+ printStoreInfo(store);
+
+ Map<String, Stock> itemAndStock = getStringStockMap(scanner, store);
+ String membershipInput = getMembership(scanner);
+
+ List<Item> purchasedItems = storeController.buyProcess(itemAndStock);
+
+ Receipt receipt = new Receipt(purchasedItems, false);
+ this.receiptController = new ReceiptController(receipt);
+
+ receiptMagic(store, scanner, receipt, membershipInput);
+ return isContinue(scanner);
+ }
+
+ // 반복 확인 메서드
+ private String isContinue(Scanner scanner) {
+ try {
+ String isContinue;
+ isContinue = InputView.getEndingMessage(scanner);
+ Validator.YesOrNoValidator(isContinue);
+ return isContinue;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return isContinue(scanner);
+ }
+ }
+
+ // 영수증 관련 메서드
+ private void receiptMagic(Store store, Scanner scanner, Receipt receipt, String membershipInput) {
+ receiptController.notifyStockForFree(store, scanner);
+ receiptController.notifyPurchasedInfo(store, scanner);
+ receipt.calculatePrice();
+
+ if (isUserContinuing(membershipInput)) {
+ receiptController.checkMembership();
+ }
+ OutputView.printReceipt(receipt);
+ }
+
+ // 프로모션 정보 초기화 메서드
+ private List<Promotion> getPromotions() throws IOException {
+ BufferedReader br = FileInput.FileInputSetting(FileInput.PROMOTION_FILE_NAME);
+ List<String> promotionStrings = InputView.getLines(br);
+ return promotionController.setPromotions(promotionStrings);
+ }
+
+ private List<Item> getItems(List<Promotion> promotions) throws IOException {
+ BufferedReader br = FileInput.FileInputSetting(FileInput.ITEM_FILE_NAME);
+ List<String> itemStrings = InputView.getLines(br);
+ return itemController.setItems(itemStrings, promotions);
+ }
+
+ // 재고 및 구매 항목 관련 메서드
+ private Map<String, Stock> getStringStockMap(Scanner scanner, Store store) {
+ try {
+ Map<String, Stock> itemAndStock = getStringStockMap(scanner);
+ invalidStockValidator(itemAndStock, store);
+ return itemAndStock;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return getStringStockMap(scanner, store);
+ }
+ }
+
+ private Map<String, Stock> getStringStockMap(Scanner scanner) {
+ String itemInput = InputView.getBuyProductMessage(scanner);
+ Validator.buyInputFormatValidator(itemInput);
+ return getStringStockMap(itemInput);
+ }
+
+ private void invalidStockValidator(Map<String, Stock> itemAndStock, Store store) {
+ itemAndStock.forEach((name, stock) -> {
+ Item item = store.findProduct(name);
+ Item promotionItem = store.findPromotionProduct(name);
+ storeController.isValidName(name);
+ storeController.isValidStock(stock, item, promotionItem);
+ });
+ }
+
+ private Map<String, Stock> getStringStockMap(String itemInput) {
+ List<String> splitItemInput = Parser.splitWithCommaDelimiter(itemInput);
+ List<String> itemNames = new ArrayList<>();
+ Map<String, Stock> itemAndStock = new HashMap<>();
+
+ for (String itemInfo : splitItemInput) {
+ Parser.itemAndStockParser(itemInfo, itemAndStock);
+ itemNames.add(Parser.splitWithBarDelimiter(itemInfo).getFirst());
+ }
+ Validator.duplicatedNameValidator(itemNames);
+ return itemAndStock;
+ }
+
+ // 멤버십 확인 메서드
+ private String getMembership(Scanner scanner) {
+ try {
+ return isUseMembership(scanner);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return getMembership(scanner);
+ }
+ }
+
+ private String isUseMembership(Scanner scanner) {
+ String membershipInput = InputView.getMembershipMessage(scanner);
+ Validator.YesOrNoValidator(membershipInput);
+ return membershipInput;
+ }
+
+ // 스토어 정보 출력 메서드
+ private void printStoreInfo(Store store) {
+ OutputView.printGreeting();
+ OutputView.printStoreInformation(store);
+ }
+
+} | Java | 메서드가 너무 많아서 흐름 잡는 용도로 작성했는데, 어떻게 생각하시나요 ? |
@@ -0,0 +1,178 @@
+package store.controller;
+
+import static store.global.InputConstant.YES_INPUT_BIG;
+import static store.utils.Validator.isUserContinuing;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import store.controller.product.ItemController;
+import store.controller.product.PromotionItemController;
+import store.domain.Item;
+import store.domain.Receipt;
+import store.domain.Stock;
+import store.domain.Store;
+import store.domain.promotion.Promotion;
+import store.utils.Parser;
+import store.utils.Validator;
+import store.view.FileInput;
+import store.view.InputView;
+import store.view.OutputView;
+
+public class FrontController {
+
+ private final PromotionItemController promotionItemController;
+ private final ItemController itemController;
+ private final PromotionController promotionController;
+ private StoreController storeController;
+ private ReceiptController receiptController;
+
+ public FrontController(ItemController itemController, PromotionItemController promotionItemController,
+ PromotionController promotionController) {
+ this.promotionItemController = promotionItemController;
+ this.itemController = itemController;
+ this.promotionController = promotionController;
+ }
+
+ // 프로그램 실행 메서드
+ public void run() throws IOException {
+ Store store = initializeStore();
+ storeController = new StoreController(itemController, store, promotionItemController);
+ Scanner scanner = new Scanner(System.in);
+
+ String isContinue = YES_INPUT_BIG;
+ itemController.checkItems(store.getItems(), store);
+
+ while (isUserContinuing(isContinue)) {
+ isContinue = processPurchaseInStore(store, scanner);
+ }
+ }
+
+ // 초기화 관련 메서드
+ private Store initializeStore() throws IOException {
+ List<Promotion> promotions = getPromotions();
+ List<Item> items = getItems(promotions);
+ return new Store(items);
+ }
+
+ // 구매 프로세스 처리 메서드
+ private String processPurchaseInStore(Store store, Scanner scanner) {
+ printStoreInfo(store);
+
+ Map<String, Stock> itemAndStock = getStringStockMap(scanner, store);
+ String membershipInput = getMembership(scanner);
+
+ List<Item> purchasedItems = storeController.buyProcess(itemAndStock);
+
+ Receipt receipt = new Receipt(purchasedItems, false);
+ this.receiptController = new ReceiptController(receipt);
+
+ receiptMagic(store, scanner, receipt, membershipInput);
+ return isContinue(scanner);
+ }
+
+ // 반복 확인 메서드
+ private String isContinue(Scanner scanner) {
+ try {
+ String isContinue;
+ isContinue = InputView.getEndingMessage(scanner);
+ Validator.YesOrNoValidator(isContinue);
+ return isContinue;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return isContinue(scanner);
+ }
+ }
+
+ // 영수증 관련 메서드
+ private void receiptMagic(Store store, Scanner scanner, Receipt receipt, String membershipInput) {
+ receiptController.notifyStockForFree(store, scanner);
+ receiptController.notifyPurchasedInfo(store, scanner);
+ receipt.calculatePrice();
+
+ if (isUserContinuing(membershipInput)) {
+ receiptController.checkMembership();
+ }
+ OutputView.printReceipt(receipt);
+ }
+
+ // 프로모션 정보 초기화 메서드
+ private List<Promotion> getPromotions() throws IOException {
+ BufferedReader br = FileInput.FileInputSetting(FileInput.PROMOTION_FILE_NAME);
+ List<String> promotionStrings = InputView.getLines(br);
+ return promotionController.setPromotions(promotionStrings);
+ }
+
+ private List<Item> getItems(List<Promotion> promotions) throws IOException {
+ BufferedReader br = FileInput.FileInputSetting(FileInput.ITEM_FILE_NAME);
+ List<String> itemStrings = InputView.getLines(br);
+ return itemController.setItems(itemStrings, promotions);
+ }
+
+ // 재고 및 구매 항목 관련 메서드
+ private Map<String, Stock> getStringStockMap(Scanner scanner, Store store) {
+ try {
+ Map<String, Stock> itemAndStock = getStringStockMap(scanner);
+ invalidStockValidator(itemAndStock, store);
+ return itemAndStock;
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return getStringStockMap(scanner, store);
+ }
+ }
+
+ private Map<String, Stock> getStringStockMap(Scanner scanner) {
+ String itemInput = InputView.getBuyProductMessage(scanner);
+ Validator.buyInputFormatValidator(itemInput);
+ return getStringStockMap(itemInput);
+ }
+
+ private void invalidStockValidator(Map<String, Stock> itemAndStock, Store store) {
+ itemAndStock.forEach((name, stock) -> {
+ Item item = store.findProduct(name);
+ Item promotionItem = store.findPromotionProduct(name);
+ storeController.isValidName(name);
+ storeController.isValidStock(stock, item, promotionItem);
+ });
+ }
+
+ private Map<String, Stock> getStringStockMap(String itemInput) {
+ List<String> splitItemInput = Parser.splitWithCommaDelimiter(itemInput);
+ List<String> itemNames = new ArrayList<>();
+ Map<String, Stock> itemAndStock = new HashMap<>();
+
+ for (String itemInfo : splitItemInput) {
+ Parser.itemAndStockParser(itemInfo, itemAndStock);
+ itemNames.add(Parser.splitWithBarDelimiter(itemInfo).getFirst());
+ }
+ Validator.duplicatedNameValidator(itemNames);
+ return itemAndStock;
+ }
+
+ // 멤버십 확인 메서드
+ private String getMembership(Scanner scanner) {
+ try {
+ return isUseMembership(scanner);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return getMembership(scanner);
+ }
+ }
+
+ private String isUseMembership(Scanner scanner) {
+ String membershipInput = InputView.getMembershipMessage(scanner);
+ Validator.YesOrNoValidator(membershipInput);
+ return membershipInput;
+ }
+
+ // 스토어 정보 출력 메서드
+ private void printStoreInfo(Store store) {
+ OutputView.printGreeting();
+ OutputView.printStoreInformation(store);
+ }
+
+} | Java | 아 수정 예정이었는데.. 까먹었습니다 ㅋㅋ...
코딩하다 메서드 명이 생각이 안나서 임의로 작성해둔 것이에요 |
@@ -0,0 +1,38 @@
+package store.domain.promotion;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+public class Promotion {
+
+ private final String name;
+ private final Range range;
+ private final BuyGet buyGet;
+
+ public Promotion(String name, BuyGet buyGet, Range range) {
+ this.buyGet = buyGet;
+ this.name = name;
+ this.range = range;
+ }
+
+ public boolean checkDate(LocalDateTime now) {
+ LocalDate date = now.toLocalDate();
+ return range.isValidRange(date);
+ }
+
+ public int calculateFreeStock(int stock) {
+ return buyGet.calculateGetStock(stock);
+ }
+
+ public int getTotalBuyStock(int totalStock, int currentStock) {
+ return buyGet.calculateBuyStock(totalStock, currentStock);
+ }
+
+ public int getBuyStock() {
+ return buyGet.getBuyStock();
+ }
+
+ public String getName() {
+ return name;
+ }
+} | Java | 수정이 잦은 필드가 이고, 필드를 메서드마다 계속 전달하는 방식이 비효율적이라고 느껴서 필드를 관리하는 클래스를 따로 만들어 필드의 수정과 관리를 클래스 내부에서 처리하게 하고 인자로 전달 안해도 되게 했어요 ! |
@@ -0,0 +1,151 @@
+package store.controller;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+import store.domain.Item;
+import store.domain.Receipt;
+import store.domain.Store;
+import store.utils.Validator;
+import store.view.InputView;
+
+import static store.global.InputConstant.NO_INPUT_BIG;
+import static store.global.InputConstant.YES_INPUT_BIG;
+import static store.utils.Validator.isUserContinuingWithNo;
+
+public class ReceiptController {
+
+ private final Receipt receipt;
+
+ public ReceiptController(Receipt receipt) {
+ this.receipt = receipt;
+ }
+
+ public void notifyStockForFree(Store store, Scanner scanner) {
+ List<Item> newItems = new ArrayList<>(receipt.getProducts());
+ for (Item item : newItems) {
+ if (!item.getFree() && item.getPromotion() != null) {
+ isCanGetFreeStock(store, item, scanner);
+ }
+ }
+ }
+
+ public void notifyPurchasedInfo(Store store, Scanner scanner) {
+ for (Item item : receipt.getProducts()) {
+ if (!item.getFree()) {
+ checkPromotions(scanner, store, item);
+ }
+ }
+ }
+
+ public void checkMembership() {
+ for (Item item : receipt.getProducts()) {
+ if (!item.getFree()) {
+ Item promotionItem = receipt.findPromotionProductWithNull(item);
+ compareBuyGet(item, promotionItem);
+ }
+ }
+ }
+
+ private void isCanGetFreeStock(Store store, Item normalItem, Scanner sc) {
+ Item promotionItem = receipt.findPromotionProduct(normalItem);
+ Item promotionItemInStore = store.findPromotionProduct(normalItem.getName());
+ Item itemInStore = store.findProduct(normalItem.getName());
+ if (promotionItemInStore == null) {
+ return;
+ }
+
+ getFreeStock(normalItem, sc, promotionItem, promotionItemInStore, NO_INPUT_BIG, itemInStore);
+ }
+
+ private void getFreeStock(Item normalItem, Scanner sc, Item promotionItem, Item promotionItemInStore,
+ String yesOrNO,
+ Item itemInStore) {
+ int moreFreeStock = getMoreFreeStock(normalItem, promotionItem, promotionItemInStore);
+ if (moreFreeStock > 0) {
+ yesOrNO = InputView.getMoreFreeStock(sc, normalItem.getName(), 1);
+ }
+
+ updateStock(yesOrNO, promotionItem, promotionItemInStore, moreFreeStock, itemInStore);
+ }
+
+ private int getMoreFreeStock(Item normalItem, Item promotionItem, Item promotionItemInStore) {
+ int currentStock = normalItem.getStockCount();
+ int currentFreeStock = promotionItem.getStockCount();
+ int currentPromotionStock = promotionItem.getBuyStockByFreeStock(currentFreeStock);
+
+ return promotionItemInStore.getTotalBuyStock(currentStock - currentPromotionStock + 1,
+ promotionItemInStore.getStockCount());
+ }
+
+ private void updateStock(String yesOrNO, Item promotionItem, Item promotionItemInStore, int moreFreeStock,
+ Item itemInStore) {
+ if (Validator.isUserContinuing(yesOrNO)) {
+ promotionItem.addStock(1);
+ promotionItemInStore.updateStock(1 + moreFreeStock);
+ itemInStore.addStock(moreFreeStock);
+ }
+ }
+
+ private void checkPromotions(Scanner sc, Store store, Item item) {
+ Item promotionItemInStore = store.findPromotionProduct(item.getName());
+ Item freeItem = receipt.findPromotionProductWithNull(item);
+
+ if (promotionItemInStore == null || freeItem == null) {
+ return;
+ }
+
+ isNoPromotionItems(sc, store, item, promotionItemInStore, freeItem, YES_INPUT_BIG);
+ }
+
+ private void isNoPromotionItems(Scanner sc, Store store, Item item, Item promotionItemInStore, Item freeItem,
+ String isPurchase) {
+ int getCount = promotionItemInStore.getBuyStock();
+ int freeStock = freeItem.getStockCount();
+ int currentBuyStockByPromotion = item.getBuyStockByFreeStock(freeStock);
+ int currentBuyStockWithNoPromotion = item.getStockCount() - currentBuyStockByPromotion;
+
+ if (getCount <= currentBuyStockWithNoPromotion) {
+ isPurchase = InputView.getAgreeBuyWithNoPromotion(sc, item.getName(), currentBuyStockWithNoPromotion);
+ }
+ refundProcess(store, item, isPurchase, currentBuyStockWithNoPromotion);
+ }
+
+ private void refundProcess(Store store, Item item, String isPurchase, int currentBuyStockWithNoPromotion) {
+ if (isUserContinuingWithNo(isPurchase)) {
+ notPurchase(store, item, currentBuyStockWithNoPromotion);
+ }
+ }
+
+ private void notPurchase(Store store, Item item, int stock) {
+ Item promotionItemInStore = store.findPromotionProduct(item.getName());
+ Item itemInStore = store.findProduct(item.getName());
+
+ stock = calculateUpdateStock(item, stock, itemInStore);
+
+ if (stock > 0) {
+ promotionItemInStore.addStock(stock);
+ item.updateStock(stock);
+ }
+ }
+
+ private int calculateUpdateStock(Item item, int stock, Item itemInStore) {
+ int totalItemInStore = itemInStore.getTotalStock();
+
+ int refundStock = Math.min(stock, totalItemInStore - itemInStore.getStockCount());
+ itemInStore.addStock(refundStock);
+ item.updateStock(refundStock);
+ stock -= refundStock;
+ return stock;
+ }
+
+ private void compareBuyGet(Item item, Item promotionItem) {
+ if (promotionItem == null) {
+ receipt.setMembership(true);
+ return;
+ }
+ if (item.getStockCount() != item.getBuyStockByFreeStock(promotionItem.getStockCount())) {
+ receipt.setMembership(true);
+ }
+ }
+} | Java | 맞습니다 ! 과제 요구사항 보다가 임시적으로 해둔 것을 변경하지 않았네요.. 감사합니다 |
@@ -0,0 +1,70 @@
+package store.controller.product;
+
+import static java.lang.Boolean.FALSE;
+import static java.lang.Boolean.TRUE;
+import static store.domain.Store.addFreeProduct;
+
+import camp.nextstep.edu.missionutils.DateTimes;
+import java.util.List;
+import store.domain.Item;
+import store.domain.Stock;
+import store.domain.Store;
+
+public class PromotionItemController {
+
+ public Item processPromotionItem(Stock stock, Item promotionalItem, List<Item> purchasedItems, Store store) {
+ Stock stockFreeItem = new Stock(0);
+ Stock stockForPay = new Stock(0);
+ Item purchasedItem = null;
+ if (promotionalItem == null) {
+ return null;
+ }
+ if (promotionalItem.checkDate(DateTimes.now())) {
+ Item item = store.buyPromoItemNoDiscount(stock, promotionalItem, purchasedItems);
+ if (item != null) {
+ return item;
+ }
+ purchasedItem = processPromotionItems(stock, promotionalItem, purchasedItems, stockFreeItem, stockForPay);
+ }
+
+ return purchasedItem;
+ }
+
+ public static int processRemainingPromotionStock(Item promotionalItem, Stock remainStock) {
+ return Math.min(promotionalItem.getStockCount(), remainStock.getStock());
+ }
+
+ private Item processPromotionItems(Stock stock, Item promotionalItem, List<Item> purchasedItems, Stock stockFreeItem,
+ Stock stockForPay) {
+ Item purchasedItem;
+ promotionProcess(stock, promotionalItem, stockFreeItem, stockForPay);
+ purchasedItem = new Item(promotionalItem, stockForPay, FALSE);
+ addFreeProduct(stockFreeItem, promotionalItem, purchasedItems, TRUE);
+ return purchasedItem;
+ }
+
+ private static void promotionProcess(Stock stock, Item promotionalItem, Stock stockFreeItem, Stock stockForPay) {
+ int stockForPromotionItem = promotionalItem.getTotalBuyStock(stock.getStock(), promotionalItem.getStockCount());
+ int freeStock = promotionalItem.calculateFreeStock(stockForPromotionItem);
+
+ updatePromotionItems(promotionalItem, stockFreeItem, stockForPay, freeStock, stockForPromotionItem);
+
+ stock.minus(stockForPromotionItem + freeStock);
+ int remainingStock = updateRemainItem(stock, promotionalItem, stockForPay);
+ stock.minus(remainingStock);
+ }
+
+ private static int updateRemainItem(Stock stock, Item promotionalItem, Stock stockForPay) {
+ int remainingStock = processRemainingPromotionStock(promotionalItem, stock);
+ promotionalItem.updateStock(remainingStock);
+ stockForPay.plus(remainingStock);
+ return remainingStock;
+ }
+
+ private static void updatePromotionItems(Item promotionalItem, Stock stockFreeItem, Stock stockForPay, int freeStock,
+ int stockForPromotionItem) {
+ stockFreeItem.plus(freeStock);
+ stockForPay.plus(stockForPromotionItem);
+ promotionalItem.updateStock(stockForPromotionItem + freeStock);
+ }
+} | Java | 항상 세세히 봐주셔서 감사합니다..ㅎㅎ
체크을 못했네요.. ㅠㅠㅠ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.