code stringlengths 41 34.3k | lang stringclasses 8
values | review stringlengths 1 4.74k |
|---|---|---|
@@ -0,0 +1,71 @@
+package store.model;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+import static camp.nextstep.edu.missionutils.DateTimes.now;
+
+public class Promotion {
+ private final String name;
+ private final Integer buy;
+ private final Integer get;
+ private final LocalDate startDate;
+ private final LocalDate endDate;
+
+ public Promotion(List<String> promotionInfo) {
+ final Integer INDEX_NAME = 0;
+ final Integer INDEX_BUY = 1;
+ final Integer INDEX_GET = 2;
+ final Integer INDEX_START_DATE = 3;
+ final Integer INDEX_END_DATE = 4;
+
+ this.name = promotionInfo.get(INDEX_NAME);
+ this.buy = getNumber(promotionInfo.get(INDEX_BUY));
+ this.get = getNumber(promotionInfo.get(INDEX_GET));
+ this.startDate = LocalDate.parse(promotionInfo.get(INDEX_START_DATE), DateTimeFormatter.ISO_DATE);
+ this.endDate = LocalDate.parse(promotionInfo.get(INDEX_END_DATE), DateTimeFormatter.ISO_DATE);
+ validateDate();
+ }
+
+ public String getName() {
+ return this.name;
+ }
+
+ public Integer getFreeProductCount(Integer count) {
+ return count / (get + buy) * get;
+ }
+
+ public Integer getDiscountedProductCount(Integer count) {
+ return (count / (get + buy)) * (get + buy);
+ }
+
+ public Integer getAdditionalFreeProductCount(Integer count){
+ if(count - getDiscountedProductCount(count) == buy){
+ return get;
+ }
+ return 0;
+ }
+
+ public Boolean inPeriod() {
+ LocalDate now = now().toLocalDate();
+ return ((!now.isBefore(startDate)) && (!now.isAfter(endDate)));
+ }
+
+ private Integer getNumber(String context) {
+ validateOnlyNumber(context);
+ return Integer.parseInt(context);
+ }
+
+ private void validateOnlyNumber(String context) {
+ if (!context.matches("^[0-9]+$")) {
+ throw new IllegalArgumentException("promotion get, buy는 숫자로만 구성해야 합니다");
+ }
+ }
+
+ private void validateDate() {
+ if (endDate.isBefore(startDate)) {
+ throw new IllegalArgumentException("promotion 마감일이 시작일보다 빠를 수 없습니다.");
+ }
+ }
+} | Java | 메시지는 따로 enum으로 처리하면 추후에 관리하기 편할 것 같아요! |
@@ -0,0 +1,71 @@
+package store.model;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+import static camp.nextstep.edu.missionutils.DateTimes.now;
+
+public class Promotion {
+ private final String name;
+ private final Integer buy;
+ private final Integer get;
+ private final LocalDate startDate;
+ private final LocalDate endDate;
+
+ public Promotion(List<String> promotionInfo) {
+ final Integer INDEX_NAME = 0;
+ final Integer INDEX_BUY = 1;
+ final Integer INDEX_GET = 2;
+ final Integer INDEX_START_DATE = 3;
+ final Integer INDEX_END_DATE = 4;
+
+ this.name = promotionInfo.get(INDEX_NAME);
+ this.buy = getNumber(promotionInfo.get(INDEX_BUY));
+ this.get = getNumber(promotionInfo.get(INDEX_GET));
+ this.startDate = LocalDate.parse(promotionInfo.get(INDEX_START_DATE), DateTimeFormatter.ISO_DATE);
+ this.endDate = LocalDate.parse(promotionInfo.get(INDEX_END_DATE), DateTimeFormatter.ISO_DATE);
+ validateDate();
+ }
+
+ public String getName() {
+ return this.name;
+ }
+
+ public Integer getFreeProductCount(Integer count) {
+ return count / (get + buy) * get;
+ }
+
+ public Integer getDiscountedProductCount(Integer count) {
+ return (count / (get + buy)) * (get + buy);
+ }
+
+ public Integer getAdditionalFreeProductCount(Integer count){
+ if(count - getDiscountedProductCount(count) == buy){
+ return get;
+ }
+ return 0;
+ }
+
+ public Boolean inPeriod() {
+ LocalDate now = now().toLocalDate();
+ return ((!now.isBefore(startDate)) && (!now.isAfter(endDate)));
+ }
+
+ private Integer getNumber(String context) {
+ validateOnlyNumber(context);
+ return Integer.parseInt(context);
+ }
+
+ private void validateOnlyNumber(String context) {
+ if (!context.matches("^[0-9]+$")) {
+ throw new IllegalArgumentException("promotion get, buy는 숫자로만 구성해야 합니다");
+ }
+ }
+
+ private void validateDate() {
+ if (endDate.isBefore(startDate)) {
+ throw new IllegalArgumentException("promotion 마감일이 시작일보다 빠를 수 없습니다.");
+ }
+ }
+} | Java | 해당 문자열은 따로 상수 처리하면 좋을 것 같아요! |
@@ -0,0 +1,38 @@
+package store.model;
+
+import java.util.*;
+
+public class PromotionRepository {
+ private final HashMap<String, Promotion> promotions = new HashMap<>();
+
+ public PromotionRepository(Scanner promotionScanner){
+ // 첫 줄 제외
+ promotionScanner.nextLine();
+
+ while(promotionScanner.hasNext()){
+ setPromotions(promotionScanner.nextLine());
+ }
+ }
+
+ public Promotion getPromotion(String name){
+ return promotions.get(name);
+ }
+
+ private void setPromotions(String promotionContext){
+ List<String> promotionInfo = new ArrayList<>(contextToList(promotionContext));
+ String promotionName = promotionInfo.getFirst();
+ this.promotions.put(promotionName, new Promotion(promotionInfo));
+ }
+
+ private List<String> contextToList(String context) {
+ List<String> promotionInfo = Arrays.asList(context.strip().split(","));
+ validateInfoSize(promotionInfo);
+ return promotionInfo;
+ }
+
+ private void validateInfoSize(List<String> promotionInfo) {
+ if (promotionInfo.size() != 5) {
+ throw new IllegalArgumentException("promotion 등록 형식에 문제 있음");
+ }
+ }
+} | Java | 프로모션 입력 사이즈도 체크하셨군요! 배워갑니다 👍 |
@@ -0,0 +1,71 @@
+package hanghaeplus.signupforlecture.application.lecture.facade;
+
+import hanghaeplus.signupforlecture.application.lecture.domain.model.Lecture;
+import hanghaeplus.signupforlecture.application.lecture.domain.model.LectureCapacity;
+import hanghaeplus.signupforlecture.application.lecture.dto.request.LectureApplyRequestDto;
+import hanghaeplus.signupforlecture.application.lecture.dto.request.LectureAvailableRequestDto;
+import hanghaeplus.signupforlecture.application.lecture.dto.response.LectureAvailableResponseDto;
+import hanghaeplus.signupforlecture.application.lecture.dto.response.LectureSignedUpResponseDto;
+import hanghaeplus.signupforlecture.application.lecture.service.LectureApplyHistoryService;
+import hanghaeplus.signupforlecture.application.lecture.service.LectureCapacityService;
+import hanghaeplus.signupforlecture.application.lecture.service.LectureService;
+import hanghaeplus.signupforlecture.application.user.domain.model.User;
+import hanghaeplus.signupforlecture.application.user.service.UserService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+public class LectureFacade {
+
+ private final UserService userService;
+
+ private final LectureService lectureService;
+ private final LectureApplyHistoryService lectureApplyHistoryService;
+ private final LectureCapacityService lectureCapacityService;
+
+ public List<LectureAvailableResponseDto> getAvailableLectures(LectureAvailableRequestDto lectureAvailableRequestDto) {
+ List<Lecture> availableLectureIds = lectureService.getAvailableLectures(lectureAvailableRequestDto.requestDate());
+ List<LectureCapacity> availableLectures = lectureCapacityService.getAvailableSlot(availableLectureIds);
+
+ return LectureAvailableResponseDto.fromDomains(availableLectureIds, availableLectures);
+ }
+
+ @Transactional
+ public void applyLecture(Long lectureId, LectureApplyRequestDto lectureApplyRequestDto) {
+ User user = userService.getUser(lectureApplyRequestDto.userId());
+ Lecture lecture = lectureService.getLecture(lectureId);
+
+ try {
+ // 중복 체크 (history 테이블)
+ lectureApplyHistoryService.checkApplyLectureHistory(lecture.id(), user.id());
+
+ // 신청 가능한 Slot (lectureCapacity 테이블) 조회 <락 획득>
+ LectureCapacity lectureCapacity = lectureCapacityService.getAvailableSlotLock(lecture.id());
+
+ // 내역 저장 (history 테이블)
+ lectureApplyHistoryService.insertAppliedHistory(lecture, user.id());
+
+ // 신청 가능 Slot - 1 로직 >> 저장 (lectureCapacity 테이블)
+ lectureCapacityService.applyAvailableSlot(lectureCapacity);
+ } catch (RuntimeException e) {
+ lectureApplyHistoryService.insertFailedHistory(lecture, user.id());
+ }
+ }
+
+ public List<LectureSignedUpResponseDto> getSignedUpLectures(Long userId) {
+ User user = userService.getUser(userId);
+
+ List<Long> signedUpLectureIds = lectureApplyHistoryService.findSignedUpLectureHistories(user.id());
+ List<Lecture> signedUpLectures = lectureService.findSignedUpLectures(signedUpLectureIds);
+
+ return signedUpLectures.stream()
+ .map(LectureSignedUpResponseDto::fromDomain)
+ .toList();
+ }
+} | Java | 정확한 이유는 모르겠지만 해당 락 획득 코드가 메서드 최상단으로 올라가면 `fail_applyLecture2` 테스트가 정상 진행이 됩니다! |
@@ -0,0 +1,44 @@
+## Default
+- [x] 아키텍처 준수를 위한 애플리케이션 패키지 설계
+- [x] 특강 도메인 테이블 설계 및 목록/신청 등 기본 기능 구현
+- [x] 각 기능에 대한 **단위 테스트** 작성
+
+---
+### 세부 API
+- [x] 특강 선택 API (=신청 가능 강의 목록 조회 API)
+ * 날짜별로 현재 신청 가능한 특강 목록을 조회하는 API 를 작성합니다.
+ * 특강의 정원은 30명으로 고정이며, 사용자는 각 특강에 신청하기전 목록을 조회해볼 수 있어야 합니다.
+
+ **단위 테스트**
+ - [x] 파라미터 validator
+ - [x] 요청된 날짜에 해당되는 강의가 없으면 예외발생
+ - [x] 요청된 날짜에 해당되는 강의 목록 조회
+
+ > (요청한 날짜에 있는 강의 + "신청가능 인원수 = 0초과") 강의 목록 조회
+
+<br>
+
+- [x] 특강 신청 완료 목록 조회 API
+ * 특정 userId 로 신청 완료된 특강 목록을 조회하는 API 를 작성합니다.
+ * 각 항목은 특강 ID 및 이름, 강연자 정보를 담고 있어야 합니다.
+
+ **단위 테스트**
+ - [x] 파라미터 validator
+ - [x] 유저 유무
+
+<br>
+
+- [x] 특강 신청 API
+ * 특정 userId 로 선착순으로 제공되는 특강을 신청하는 API 를 작성합니다.
+ * 동일한 신청자는 동일한 강의에 대해서 한 번의 수강 신청만 성공할 수 있습니다.
+ * 특강은 선착순 30명만 신청 가능합니다.
+ * 이미 신청자가 30명이 초과되면 이후 신청자는 요청을 실패합니다.
+
+ **단위 테스트**
+ - [x] 파라미터 validator
+ - [x] 유저가 없으면 예외 발생
+ - [x] 강의가 없으면 예외 발생
+ - [x] 중복 신청 예외발생 (동일한 신청자는 동일한 강의에 대해서 한 번의 수강 신청만 가능)
+ - [x] 남은 자리가 없으면 예외발생 (30명이 초과된 상태)
+ - [x] (신청 가능한 자리수 - 1)이 정상 동작하는지 확인
+ - [x] (신청 가능한 자리수 - 1) 도중 자리수가 0 일때 예외 발생
\ No newline at end of file | Unknown | 체크 리스트를 만들어 주신 점 멋지십니다! |
@@ -0,0 +1,38 @@
+# 패키지 설계
+
+```text
+├── HanghaeplusSignupForLectureApplication.java
+├── api
+│ ├── controller
+│ └── dto
+│ ├── request
+│ └── response
+├── application
+│ ├── lecture
+│ │ ├── domain
+│ │ │ ├── model
+│ │ │ └── repository
+│ │ ├── dto
+│ │ │ ├── request
+│ │ │ └── response
+│ │ ├── facade
+│ │ ├── service
+│ │ └── validator
+│ └── user
+│ ├── domain
+│ │ ├── model
+│ │ └── repository
+│ ├── service
+│ └── validator
+└── infrastructure
+ ├── lecture
+ │ ├── entity
+ │ └── repository
+ │ ├── impl
+ │ └── jpa
+ └── user
+ ├── entity
+ └── repository
+ ├── impl
+ └── jpa
+``` | Unknown | application 과 domain 과 분리되어야 할 것 같아요. |
@@ -0,0 +1,71 @@
+package hanghaeplus.signupforlecture.application.lecture.facade;
+
+import hanghaeplus.signupforlecture.application.lecture.domain.model.Lecture;
+import hanghaeplus.signupforlecture.application.lecture.domain.model.LectureCapacity;
+import hanghaeplus.signupforlecture.application.lecture.dto.request.LectureApplyRequestDto;
+import hanghaeplus.signupforlecture.application.lecture.dto.request.LectureAvailableRequestDto;
+import hanghaeplus.signupforlecture.application.lecture.dto.response.LectureAvailableResponseDto;
+import hanghaeplus.signupforlecture.application.lecture.dto.response.LectureSignedUpResponseDto;
+import hanghaeplus.signupforlecture.application.lecture.service.LectureApplyHistoryService;
+import hanghaeplus.signupforlecture.application.lecture.service.LectureCapacityService;
+import hanghaeplus.signupforlecture.application.lecture.service.LectureService;
+import hanghaeplus.signupforlecture.application.user.domain.model.User;
+import hanghaeplus.signupforlecture.application.user.service.UserService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+public class LectureFacade {
+
+ private final UserService userService;
+
+ private final LectureService lectureService;
+ private final LectureApplyHistoryService lectureApplyHistoryService;
+ private final LectureCapacityService lectureCapacityService;
+
+ public List<LectureAvailableResponseDto> getAvailableLectures(LectureAvailableRequestDto lectureAvailableRequestDto) {
+ List<Lecture> availableLectureIds = lectureService.getAvailableLectures(lectureAvailableRequestDto.requestDate());
+ List<LectureCapacity> availableLectures = lectureCapacityService.getAvailableSlot(availableLectureIds);
+
+ return LectureAvailableResponseDto.fromDomains(availableLectureIds, availableLectures);
+ }
+
+ @Transactional
+ public void applyLecture(Long lectureId, LectureApplyRequestDto lectureApplyRequestDto) {
+ User user = userService.getUser(lectureApplyRequestDto.userId());
+ Lecture lecture = lectureService.getLecture(lectureId);
+
+ try {
+ // 중복 체크 (history 테이블)
+ lectureApplyHistoryService.checkApplyLectureHistory(lecture.id(), user.id());
+
+ // 신청 가능한 Slot (lectureCapacity 테이블) 조회 <락 획득>
+ LectureCapacity lectureCapacity = lectureCapacityService.getAvailableSlotLock(lecture.id());
+
+ // 내역 저장 (history 테이블)
+ lectureApplyHistoryService.insertAppliedHistory(lecture, user.id());
+
+ // 신청 가능 Slot - 1 로직 >> 저장 (lectureCapacity 테이블)
+ lectureCapacityService.applyAvailableSlot(lectureCapacity);
+ } catch (RuntimeException e) {
+ lectureApplyHistoryService.insertFailedHistory(lecture, user.id());
+ }
+ }
+
+ public List<LectureSignedUpResponseDto> getSignedUpLectures(Long userId) {
+ User user = userService.getUser(userId);
+
+ List<Long> signedUpLectureIds = lectureApplyHistoryService.findSignedUpLectureHistories(user.id());
+ List<Lecture> signedUpLectures = lectureService.findSignedUpLectures(signedUpLectureIds);
+
+ return signedUpLectures.stream()
+ .map(LectureSignedUpResponseDto::fromDomain)
+ .toList();
+ }
+} | Java | 락을 지우고 비관적락만 적용해서 해보는건 어떠실까요? |
@@ -0,0 +1,65 @@
+package menu.controller;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import menu.model.Coach;
+import menu.model.MenuRepository;
+import menu.view.InputView;
+import menu.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class MenuController {
+ MenuRepository menuRepository = new MenuRepository();
+ Validate validate = new Validate();
+ List<Coach> coaches = new ArrayList<>();
+ int[] category;
+
+ public void run() {
+ OutputView.printStart();
+ setCoaches();
+ OutputView.printResultIntro();
+ setCategory();
+ OutputView.printCategory(category);
+ coaches.forEach(this::menuRecommendations);
+ }
+
+ private void setCoaches() {
+ OutputView.printInsertCoach();
+ String[] inputCoaches = InputView.insertCoach().split(",");
+ if (!validate.validateCoach(inputCoaches)) {
+ setCoaches();
+ return;
+ }
+ for (String inputCoach : inputCoaches) {
+ Coach coach = new Coach(inputCoach);
+ OutputView.printInsertNotFood(coach.getName());
+ String[] NotFood = InputView.insertNotFood().split(",");
+ Arrays.stream(NotFood).forEach(coach::addNotFood);
+ coaches.add(coach);
+ }
+ }
+
+ private void setCategory() {
+ category = new int[5];
+ IntStream.range(0, 5).forEach(i -> category[i] = Randoms.pickNumberInRange(1, 5));
+ }
+
+ private void menuRecommendations(Coach coach) {
+ String[] menus = new String[5];
+ for (int i = 0; i < 5; i++) {
+ menus[i] = selectMenu(i, coach);
+ }
+ OutputView.printMenu(coach.getName(), menus);
+ }
+
+ private String selectMenu(int index, Coach coach) {
+ String menu = menuRepository.getMenu(category[index]);
+ if (!coach.checkMenu(menu)) {
+ return selectMenu(index, coach);
+ }
+ return menu;
+ }
+} | Java | 컬렉션 대신 배열을 사용한 이유가 있을까요!? |
@@ -0,0 +1,65 @@
+package menu.controller;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import menu.model.Coach;
+import menu.model.MenuRepository;
+import menu.view.InputView;
+import menu.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class MenuController {
+ MenuRepository menuRepository = new MenuRepository();
+ Validate validate = new Validate();
+ List<Coach> coaches = new ArrayList<>();
+ int[] category;
+
+ public void run() {
+ OutputView.printStart();
+ setCoaches();
+ OutputView.printResultIntro();
+ setCategory();
+ OutputView.printCategory(category);
+ coaches.forEach(this::menuRecommendations);
+ }
+
+ private void setCoaches() {
+ OutputView.printInsertCoach();
+ String[] inputCoaches = InputView.insertCoach().split(",");
+ if (!validate.validateCoach(inputCoaches)) {
+ setCoaches();
+ return;
+ }
+ for (String inputCoach : inputCoaches) {
+ Coach coach = new Coach(inputCoach);
+ OutputView.printInsertNotFood(coach.getName());
+ String[] NotFood = InputView.insertNotFood().split(",");
+ Arrays.stream(NotFood).forEach(coach::addNotFood);
+ coaches.add(coach);
+ }
+ }
+
+ private void setCategory() {
+ category = new int[5];
+ IntStream.range(0, 5).forEach(i -> category[i] = Randoms.pickNumberInRange(1, 5));
+ }
+
+ private void menuRecommendations(Coach coach) {
+ String[] menus = new String[5];
+ for (int i = 0; i < 5; i++) {
+ menus[i] = selectMenu(i, coach);
+ }
+ OutputView.printMenu(coach.getName(), menus);
+ }
+
+ private String selectMenu(int index, Coach coach) {
+ String menu = menuRepository.getMenu(category[index]);
+ if (!coach.checkMenu(menu)) {
+ return selectMenu(index, coach);
+ }
+ return menu;
+ }
+} | Java | 관심사 분리 입장에서 보면 단일 메서드여도 별도 메서드로 분리하는 방향도 고려해볼만 한 것 같아요! |
@@ -0,0 +1,65 @@
+package menu.controller;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import menu.model.Coach;
+import menu.model.MenuRepository;
+import menu.view.InputView;
+import menu.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class MenuController {
+ MenuRepository menuRepository = new MenuRepository();
+ Validate validate = new Validate();
+ List<Coach> coaches = new ArrayList<>();
+ int[] category;
+
+ public void run() {
+ OutputView.printStart();
+ setCoaches();
+ OutputView.printResultIntro();
+ setCategory();
+ OutputView.printCategory(category);
+ coaches.forEach(this::menuRecommendations);
+ }
+
+ private void setCoaches() {
+ OutputView.printInsertCoach();
+ String[] inputCoaches = InputView.insertCoach().split(",");
+ if (!validate.validateCoach(inputCoaches)) {
+ setCoaches();
+ return;
+ }
+ for (String inputCoach : inputCoaches) {
+ Coach coach = new Coach(inputCoach);
+ OutputView.printInsertNotFood(coach.getName());
+ String[] NotFood = InputView.insertNotFood().split(",");
+ Arrays.stream(NotFood).forEach(coach::addNotFood);
+ coaches.add(coach);
+ }
+ }
+
+ private void setCategory() {
+ category = new int[5];
+ IntStream.range(0, 5).forEach(i -> category[i] = Randoms.pickNumberInRange(1, 5));
+ }
+
+ private void menuRecommendations(Coach coach) {
+ String[] menus = new String[5];
+ for (int i = 0; i < 5; i++) {
+ menus[i] = selectMenu(i, coach);
+ }
+ OutputView.printMenu(coach.getName(), menus);
+ }
+
+ private String selectMenu(int index, Coach coach) {
+ String menu = menuRepository.getMenu(category[index]);
+ if (!coach.checkMenu(menu)) {
+ return selectMenu(index, coach);
+ }
+ return menu;
+ }
+} | Java | 5는 상수화하면 좋을 것 같아요 |
@@ -0,0 +1,65 @@
+package menu.controller;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import menu.model.Coach;
+import menu.model.MenuRepository;
+import menu.view.InputView;
+import menu.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class MenuController {
+ MenuRepository menuRepository = new MenuRepository();
+ Validate validate = new Validate();
+ List<Coach> coaches = new ArrayList<>();
+ int[] category;
+
+ public void run() {
+ OutputView.printStart();
+ setCoaches();
+ OutputView.printResultIntro();
+ setCategory();
+ OutputView.printCategory(category);
+ coaches.forEach(this::menuRecommendations);
+ }
+
+ private void setCoaches() {
+ OutputView.printInsertCoach();
+ String[] inputCoaches = InputView.insertCoach().split(",");
+ if (!validate.validateCoach(inputCoaches)) {
+ setCoaches();
+ return;
+ }
+ for (String inputCoach : inputCoaches) {
+ Coach coach = new Coach(inputCoach);
+ OutputView.printInsertNotFood(coach.getName());
+ String[] NotFood = InputView.insertNotFood().split(",");
+ Arrays.stream(NotFood).forEach(coach::addNotFood);
+ coaches.add(coach);
+ }
+ }
+
+ private void setCategory() {
+ category = new int[5];
+ IntStream.range(0, 5).forEach(i -> category[i] = Randoms.pickNumberInRange(1, 5));
+ }
+
+ private void menuRecommendations(Coach coach) {
+ String[] menus = new String[5];
+ for (int i = 0; i < 5; i++) {
+ menus[i] = selectMenu(i, coach);
+ }
+ OutputView.printMenu(coach.getName(), menus);
+ }
+
+ private String selectMenu(int index, Coach coach) {
+ String menu = menuRepository.getMenu(category[index]);
+ if (!coach.checkMenu(menu)) {
+ return selectMenu(index, coach);
+ }
+ return menu;
+ }
+} | Java | 랜덤 숫자 뽑기가 controller의 관심사일지 고민해보면 좋을 것 같아요 |
@@ -0,0 +1,65 @@
+package menu.controller;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import menu.model.Coach;
+import menu.model.MenuRepository;
+import menu.view.InputView;
+import menu.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class MenuController {
+ MenuRepository menuRepository = new MenuRepository();
+ Validate validate = new Validate();
+ List<Coach> coaches = new ArrayList<>();
+ int[] category;
+
+ public void run() {
+ OutputView.printStart();
+ setCoaches();
+ OutputView.printResultIntro();
+ setCategory();
+ OutputView.printCategory(category);
+ coaches.forEach(this::menuRecommendations);
+ }
+
+ private void setCoaches() {
+ OutputView.printInsertCoach();
+ String[] inputCoaches = InputView.insertCoach().split(",");
+ if (!validate.validateCoach(inputCoaches)) {
+ setCoaches();
+ return;
+ }
+ for (String inputCoach : inputCoaches) {
+ Coach coach = new Coach(inputCoach);
+ OutputView.printInsertNotFood(coach.getName());
+ String[] NotFood = InputView.insertNotFood().split(",");
+ Arrays.stream(NotFood).forEach(coach::addNotFood);
+ coaches.add(coach);
+ }
+ }
+
+ private void setCategory() {
+ category = new int[5];
+ IntStream.range(0, 5).forEach(i -> category[i] = Randoms.pickNumberInRange(1, 5));
+ }
+
+ private void menuRecommendations(Coach coach) {
+ String[] menus = new String[5];
+ for (int i = 0; i < 5; i++) {
+ menus[i] = selectMenu(i, coach);
+ }
+ OutputView.printMenu(coach.getName(), menus);
+ }
+
+ private String selectMenu(int index, Coach coach) {
+ String menu = menuRepository.getMenu(category[index]);
+ if (!coach.checkMenu(menu)) {
+ return selectMenu(index, coach);
+ }
+ return menu;
+ }
+} | Java | `!coach.checkMenu()`가 어떤 의미인지 애매한 것 같아요 |
@@ -0,0 +1,19 @@
+package menu.controller;
+
+import menu.view.OutputView;
+
+public class Validate {
+ public boolean validateCoach(String[] inputCoaches) {
+ if (inputCoaches.length > 5 || inputCoaches.length < 2) {
+ OutputView.printCoachesNumberError();
+ return false;
+ }
+ for (String inputCoach : inputCoaches) {
+ if (inputCoach.length() < 2 || inputCoach.length() > 4) {
+ OutputView.printCoachesNameError();
+ return false;
+ }
+ }
+ return true;
+ }
+} | Java | 2, 4는 상수화하면 좋을 것 같아요 |
@@ -0,0 +1,71 @@
+package menu.view;
+
+public class OutputView {
+ private static final String START = "점심 메뉴 추천을 시작합니다.";
+ private static final String INSERT_COACH_NAME = "코치의 이름을 입력해 주세요. (, 로 구분)";
+ private static final String INSERT_NOT_FOOD = "(이)가 못 먹는 메뉴를 입력해 주세요.";
+ private static final String RESULT_INTRO = "메뉴 추천 결과입니다.\n[ 구분 | 월요일 | 화요일 | 수요일 | 목요일 | 금요일 ]";
+ private static final String JAPAN_FOOD = "일식";
+ private static final String KOREA_FOOD = "한식";
+ private static final String CHINA_FOOD = "중식";
+ private static final String ASIA_FOOD = "아시안";
+ private static final String WEASTEN_FOOD = "양식";
+ private static final String CATEGORY_START = "[ 카테고리 | ";
+ private static final String STEP = " | ";
+ private static final String PRINT_START = "[ ";
+ private static final String PRINT_END = " ]";
+
+ public static void printStart() {
+ System.out.println(START);
+ }
+
+ public static void printInsertCoach() {
+ System.out.println(INSERT_COACH_NAME);
+ }
+
+ public static void printInsertNotFood(String name) {
+ System.out.println(name + INSERT_NOT_FOOD);
+ }
+
+ public static void printResultIntro() {
+ System.out.println(RESULT_INTRO);
+ }
+
+ public static void printCategory(int[] category) {
+ String[] stringCategory = new String[category.length];
+ for (int i = 0; i < 5; i++) {
+ if (category[i] == 1) stringCategory[i] = JAPAN_FOOD;
+ if (category[i] == 2) stringCategory[i] = KOREA_FOOD;
+ if (category[i] == 3) stringCategory[i] = CHINA_FOOD;
+ if (category[i] == 4) stringCategory[i] = ASIA_FOOD;
+ if (category[i] == 5) stringCategory[i] = WEASTEN_FOOD;
+ }
+ System.out.print(CATEGORY_START);
+ for (int i = 0; i < 5; i++) {
+ System.out.print(stringCategory[i]);
+ if (i != category.length - 1) {
+ System.out.print(STEP);
+ }
+ }
+ System.out.println(PRINT_END);
+ }
+
+ public static void printMenu(String coach, String[] menus) {
+ System.out.print(PRINT_START + coach + STEP);
+ for (int i = 0; i < menus.length; i++) {
+ System.out.print(menus[i]);
+ if (i != menus.length - 1) {
+ System.out.print(STEP);
+ }
+ }
+ System.out.println(PRINT_END);
+ }
+
+ public static void printCoachesNumberError() {
+ System.out.println("[ERROR] 코치는 최소 2명, 최대 5명까지입니다.");
+ }
+
+ public static void printCoachesNameError() {
+ System.out.println("[ERROR] 코치의 이름은 최소 2글자, 최대 4글자입니다.");
+ }
+} | Java | OutputView가 특정 예외에 의존적이게 되는 것 같아요 |
@@ -0,0 +1,28 @@
+package menu.model;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MenuRepository {
+ private final List<String> japan =
+ Arrays.asList("규동", "우동", "미소시루", "스시", "가츠동", "오니기리", "하이라이스", "라멘", "오코노미야끼");
+ private final List<String> korea =
+ Arrays.asList("김밥", "김치찌개", "쌈밥", "된장찌개", "비빔밥", "칼국수", "불고기", "떡볶이", "제육볶음");
+ private final List<String> china =
+ Arrays.asList("깐풍기", "볶음면", "동파육", "짜장면", "짬뽕", "마파두부", "탕수육", "토마토 달걀볶음", "고추잡채");
+ private final List<String> asia =
+ Arrays.asList("팟타이", "카오 팟", "나시고렝", "파인애플 볶음밥", "쌀국수", "똠얌꿍", "반미", "월남쌈", "분짜");
+ private final List<String> western =
+ Arrays.asList("라자냐", "그라탱", "뇨끼", "끼슈", "프렌치 토스트", "바게트", "스파게티", "피자", "파니니");
+
+ public String getMenu(int category) {
+ if (category == 1) return Randoms.shuffle(japan).get(0);
+ if (category == 2) return Randoms.shuffle(korea).get(0);
+ if (category == 3) return Randoms.shuffle(china).get(0);
+ if (category == 4) return Randoms.shuffle(asia).get(0);
+ if (category == 5) return Randoms.shuffle(western).get(0);
+ return null;
+ }
+} | Java | switch문과 비슷한 구조인 것 같아요.
다른 방법은 없었을까요..? |
@@ -0,0 +1,71 @@
+package menu.view;
+
+public class OutputView {
+ private static final String START = "점심 메뉴 추천을 시작합니다.";
+ private static final String INSERT_COACH_NAME = "코치의 이름을 입력해 주세요. (, 로 구분)";
+ private static final String INSERT_NOT_FOOD = "(이)가 못 먹는 메뉴를 입력해 주세요.";
+ private static final String RESULT_INTRO = "메뉴 추천 결과입니다.\n[ 구분 | 월요일 | 화요일 | 수요일 | 목요일 | 금요일 ]";
+ private static final String JAPAN_FOOD = "일식";
+ private static final String KOREA_FOOD = "한식";
+ private static final String CHINA_FOOD = "중식";
+ private static final String ASIA_FOOD = "아시안";
+ private static final String WEASTEN_FOOD = "양식";
+ private static final String CATEGORY_START = "[ 카테고리 | ";
+ private static final String STEP = " | ";
+ private static final String PRINT_START = "[ ";
+ private static final String PRINT_END = " ]";
+
+ public static void printStart() {
+ System.out.println(START);
+ }
+
+ public static void printInsertCoach() {
+ System.out.println(INSERT_COACH_NAME);
+ }
+
+ public static void printInsertNotFood(String name) {
+ System.out.println(name + INSERT_NOT_FOOD);
+ }
+
+ public static void printResultIntro() {
+ System.out.println(RESULT_INTRO);
+ }
+
+ public static void printCategory(int[] category) {
+ String[] stringCategory = new String[category.length];
+ for (int i = 0; i < 5; i++) {
+ if (category[i] == 1) stringCategory[i] = JAPAN_FOOD;
+ if (category[i] == 2) stringCategory[i] = KOREA_FOOD;
+ if (category[i] == 3) stringCategory[i] = CHINA_FOOD;
+ if (category[i] == 4) stringCategory[i] = ASIA_FOOD;
+ if (category[i] == 5) stringCategory[i] = WEASTEN_FOOD;
+ }
+ System.out.print(CATEGORY_START);
+ for (int i = 0; i < 5; i++) {
+ System.out.print(stringCategory[i]);
+ if (i != category.length - 1) {
+ System.out.print(STEP);
+ }
+ }
+ System.out.println(PRINT_END);
+ }
+
+ public static void printMenu(String coach, String[] menus) {
+ System.out.print(PRINT_START + coach + STEP);
+ for (int i = 0; i < menus.length; i++) {
+ System.out.print(menus[i]);
+ if (i != menus.length - 1) {
+ System.out.print(STEP);
+ }
+ }
+ System.out.println(PRINT_END);
+ }
+
+ public static void printCoachesNumberError() {
+ System.out.println("[ERROR] 코치는 최소 2명, 최대 5명까지입니다.");
+ }
+
+ public static void printCoachesNameError() {
+ System.out.println("[ERROR] 코치의 이름은 최소 2글자, 최대 4글자입니다.");
+ }
+} | Java | 상수가 너무 많은데 enum으로 분리하는 것도 좋을 것 같아요! |
@@ -0,0 +1,71 @@
+package menu.view;
+
+public class OutputView {
+ private static final String START = "점심 메뉴 추천을 시작합니다.";
+ private static final String INSERT_COACH_NAME = "코치의 이름을 입력해 주세요. (, 로 구분)";
+ private static final String INSERT_NOT_FOOD = "(이)가 못 먹는 메뉴를 입력해 주세요.";
+ private static final String RESULT_INTRO = "메뉴 추천 결과입니다.\n[ 구분 | 월요일 | 화요일 | 수요일 | 목요일 | 금요일 ]";
+ private static final String JAPAN_FOOD = "일식";
+ private static final String KOREA_FOOD = "한식";
+ private static final String CHINA_FOOD = "중식";
+ private static final String ASIA_FOOD = "아시안";
+ private static final String WEASTEN_FOOD = "양식";
+ private static final String CATEGORY_START = "[ 카테고리 | ";
+ private static final String STEP = " | ";
+ private static final String PRINT_START = "[ ";
+ private static final String PRINT_END = " ]";
+
+ public static void printStart() {
+ System.out.println(START);
+ }
+
+ public static void printInsertCoach() {
+ System.out.println(INSERT_COACH_NAME);
+ }
+
+ public static void printInsertNotFood(String name) {
+ System.out.println(name + INSERT_NOT_FOOD);
+ }
+
+ public static void printResultIntro() {
+ System.out.println(RESULT_INTRO);
+ }
+
+ public static void printCategory(int[] category) {
+ String[] stringCategory = new String[category.length];
+ for (int i = 0; i < 5; i++) {
+ if (category[i] == 1) stringCategory[i] = JAPAN_FOOD;
+ if (category[i] == 2) stringCategory[i] = KOREA_FOOD;
+ if (category[i] == 3) stringCategory[i] = CHINA_FOOD;
+ if (category[i] == 4) stringCategory[i] = ASIA_FOOD;
+ if (category[i] == 5) stringCategory[i] = WEASTEN_FOOD;
+ }
+ System.out.print(CATEGORY_START);
+ for (int i = 0; i < 5; i++) {
+ System.out.print(stringCategory[i]);
+ if (i != category.length - 1) {
+ System.out.print(STEP);
+ }
+ }
+ System.out.println(PRINT_END);
+ }
+
+ public static void printMenu(String coach, String[] menus) {
+ System.out.print(PRINT_START + coach + STEP);
+ for (int i = 0; i < menus.length; i++) {
+ System.out.print(menus[i]);
+ if (i != menus.length - 1) {
+ System.out.print(STEP);
+ }
+ }
+ System.out.println(PRINT_END);
+ }
+
+ public static void printCoachesNumberError() {
+ System.out.println("[ERROR] 코치는 최소 2명, 최대 5명까지입니다.");
+ }
+
+ public static void printCoachesNameError() {
+ System.out.println("[ERROR] 코치의 이름은 최소 2글자, 최대 4글자입니다.");
+ }
+} | Java | enum을 활용하면 코드 중복을 최소화할 수 있었을 것 같아요! |
@@ -0,0 +1,65 @@
+package menu.controller;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import menu.model.Coach;
+import menu.model.MenuRepository;
+import menu.view.InputView;
+import menu.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class MenuController {
+ MenuRepository menuRepository = new MenuRepository();
+ Validate validate = new Validate();
+ List<Coach> coaches = new ArrayList<>();
+ int[] category;
+
+ public void run() {
+ OutputView.printStart();
+ setCoaches();
+ OutputView.printResultIntro();
+ setCategory();
+ OutputView.printCategory(category);
+ coaches.forEach(this::menuRecommendations);
+ }
+
+ private void setCoaches() {
+ OutputView.printInsertCoach();
+ String[] inputCoaches = InputView.insertCoach().split(",");
+ if (!validate.validateCoach(inputCoaches)) {
+ setCoaches();
+ return;
+ }
+ for (String inputCoach : inputCoaches) {
+ Coach coach = new Coach(inputCoach);
+ OutputView.printInsertNotFood(coach.getName());
+ String[] NotFood = InputView.insertNotFood().split(",");
+ Arrays.stream(NotFood).forEach(coach::addNotFood);
+ coaches.add(coach);
+ }
+ }
+
+ private void setCategory() {
+ category = new int[5];
+ IntStream.range(0, 5).forEach(i -> category[i] = Randoms.pickNumberInRange(1, 5));
+ }
+
+ private void menuRecommendations(Coach coach) {
+ String[] menus = new String[5];
+ for (int i = 0; i < 5; i++) {
+ menus[i] = selectMenu(i, coach);
+ }
+ OutputView.printMenu(coach.getName(), menus);
+ }
+
+ private String selectMenu(int index, Coach coach) {
+ String menu = menuRepository.getMenu(category[index]);
+ if (!coach.checkMenu(menu)) {
+ return selectMenu(index, coach);
+ }
+ return menu;
+ }
+} | Java | 개수가 정해져 있다고 생각해서 생각 없이 배열을 사용했는데 컬렉션을 사용하는 게 더 좋을 것 같습니다! |
@@ -0,0 +1,65 @@
+package menu.controller;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import menu.model.Coach;
+import menu.model.MenuRepository;
+import menu.view.InputView;
+import menu.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class MenuController {
+ MenuRepository menuRepository = new MenuRepository();
+ Validate validate = new Validate();
+ List<Coach> coaches = new ArrayList<>();
+ int[] category;
+
+ public void run() {
+ OutputView.printStart();
+ setCoaches();
+ OutputView.printResultIntro();
+ setCategory();
+ OutputView.printCategory(category);
+ coaches.forEach(this::menuRecommendations);
+ }
+
+ private void setCoaches() {
+ OutputView.printInsertCoach();
+ String[] inputCoaches = InputView.insertCoach().split(",");
+ if (!validate.validateCoach(inputCoaches)) {
+ setCoaches();
+ return;
+ }
+ for (String inputCoach : inputCoaches) {
+ Coach coach = new Coach(inputCoach);
+ OutputView.printInsertNotFood(coach.getName());
+ String[] NotFood = InputView.insertNotFood().split(",");
+ Arrays.stream(NotFood).forEach(coach::addNotFood);
+ coaches.add(coach);
+ }
+ }
+
+ private void setCategory() {
+ category = new int[5];
+ IntStream.range(0, 5).forEach(i -> category[i] = Randoms.pickNumberInRange(1, 5));
+ }
+
+ private void menuRecommendations(Coach coach) {
+ String[] menus = new String[5];
+ for (int i = 0; i < 5; i++) {
+ menus[i] = selectMenu(i, coach);
+ }
+ OutputView.printMenu(coach.getName(), menus);
+ }
+
+ private String selectMenu(int index, Coach coach) {
+ String menu = menuRepository.getMenu(category[index]);
+ if (!coach.checkMenu(menu)) {
+ return selectMenu(index, coach);
+ }
+ return menu;
+ }
+} | Java | setter는 사용한 의도를 쉽게 파악할 수 없어 지양하는 것으로 알고있습니다!
실질적인 setter는 아니지만 다른 네이밍은 어떨까요? |
@@ -0,0 +1,65 @@
+package menu.controller;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import menu.model.Coach;
+import menu.model.MenuRepository;
+import menu.view.InputView;
+import menu.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class MenuController {
+ MenuRepository menuRepository = new MenuRepository();
+ Validate validate = new Validate();
+ List<Coach> coaches = new ArrayList<>();
+ int[] category;
+
+ public void run() {
+ OutputView.printStart();
+ setCoaches();
+ OutputView.printResultIntro();
+ setCategory();
+ OutputView.printCategory(category);
+ coaches.forEach(this::menuRecommendations);
+ }
+
+ private void setCoaches() {
+ OutputView.printInsertCoach();
+ String[] inputCoaches = InputView.insertCoach().split(",");
+ if (!validate.validateCoach(inputCoaches)) {
+ setCoaches();
+ return;
+ }
+ for (String inputCoach : inputCoaches) {
+ Coach coach = new Coach(inputCoach);
+ OutputView.printInsertNotFood(coach.getName());
+ String[] NotFood = InputView.insertNotFood().split(",");
+ Arrays.stream(NotFood).forEach(coach::addNotFood);
+ coaches.add(coach);
+ }
+ }
+
+ private void setCategory() {
+ category = new int[5];
+ IntStream.range(0, 5).forEach(i -> category[i] = Randoms.pickNumberInRange(1, 5));
+ }
+
+ private void menuRecommendations(Coach coach) {
+ String[] menus = new String[5];
+ for (int i = 0; i < 5; i++) {
+ menus[i] = selectMenu(i, coach);
+ }
+ OutputView.printMenu(coach.getName(), menus);
+ }
+
+ private String selectMenu(int index, Coach coach) {
+ String menu = menuRepository.getMenu(category[index]);
+ if (!coach.checkMenu(menu)) {
+ return selectMenu(index, coach);
+ }
+ return menu;
+ }
+} | Java | for문 메서드 분리하면 가독성이 더 좋아질 것 같아요! |
@@ -0,0 +1,19 @@
+package menu.controller;
+
+import menu.view.OutputView;
+
+public class Validate {
+ public boolean validateCoach(String[] inputCoaches) {
+ if (inputCoaches.length > 5 || inputCoaches.length < 2) {
+ OutputView.printCoachesNumberError();
+ return false;
+ }
+ for (String inputCoach : inputCoaches) {
+ if (inputCoach.length() < 2 || inputCoach.length() > 4) {
+ OutputView.printCoachesNameError();
+ return false;
+ }
+ }
+ return true;
+ }
+} | Java | 클래스명은 명사 또는 명사구로 네이밍해야 하는 것으로 알고있습니다!
Validator는 어떨까요?! |
@@ -0,0 +1,29 @@
+package menu.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Coach {
+ private String name;
+ private List<String> notFood = new ArrayList<>();
+ private List<String> foods = new ArrayList<>();
+
+ public Coach(String name) {
+ this.name = name;
+ }
+
+ public void addNotFood(String food) {
+ notFood.add(food);
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public boolean checkMenu(String menu) {
+ if (foods.contains(menu)) return false;
+ if (notFood.contains(menu)) return false;
+ foods.add(menu);
+ return true;
+ }
+} | Java | 해당 필드는 일급컬렉션을 사용하면 더 좋을 것 같아요!:) |
@@ -0,0 +1,28 @@
+package menu.model;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MenuRepository {
+ private final List<String> japan =
+ Arrays.asList("규동", "우동", "미소시루", "스시", "가츠동", "오니기리", "하이라이스", "라멘", "오코노미야끼");
+ private final List<String> korea =
+ Arrays.asList("김밥", "김치찌개", "쌈밥", "된장찌개", "비빔밥", "칼국수", "불고기", "떡볶이", "제육볶음");
+ private final List<String> china =
+ Arrays.asList("깐풍기", "볶음면", "동파육", "짜장면", "짬뽕", "마파두부", "탕수육", "토마토 달걀볶음", "고추잡채");
+ private final List<String> asia =
+ Arrays.asList("팟타이", "카오 팟", "나시고렝", "파인애플 볶음밥", "쌀국수", "똠얌꿍", "반미", "월남쌈", "분짜");
+ private final List<String> western =
+ Arrays.asList("라자냐", "그라탱", "뇨끼", "끼슈", "프렌치 토스트", "바게트", "스파게티", "피자", "파니니");
+
+ public String getMenu(int category) {
+ if (category == 1) return Randoms.shuffle(japan).get(0);
+ if (category == 2) return Randoms.shuffle(korea).get(0);
+ if (category == 3) return Randoms.shuffle(china).get(0);
+ if (category == 4) return Randoms.shuffle(asia).get(0);
+ if (category == 5) return Randoms.shuffle(western).get(0);
+ return null;
+ }
+} | Java | repository로 메뉴 및 카테고리 정보를 관리하셨군요! 좋은 접근 방법인 것 같아요👍
이렇게 하신 이유가 있을까요?? |
@@ -0,0 +1,71 @@
+package menu.view;
+
+public class OutputView {
+ private static final String START = "점심 메뉴 추천을 시작합니다.";
+ private static final String INSERT_COACH_NAME = "코치의 이름을 입력해 주세요. (, 로 구분)";
+ private static final String INSERT_NOT_FOOD = "(이)가 못 먹는 메뉴를 입력해 주세요.";
+ private static final String RESULT_INTRO = "메뉴 추천 결과입니다.\n[ 구분 | 월요일 | 화요일 | 수요일 | 목요일 | 금요일 ]";
+ private static final String JAPAN_FOOD = "일식";
+ private static final String KOREA_FOOD = "한식";
+ private static final String CHINA_FOOD = "중식";
+ private static final String ASIA_FOOD = "아시안";
+ private static final String WEASTEN_FOOD = "양식";
+ private static final String CATEGORY_START = "[ 카테고리 | ";
+ private static final String STEP = " | ";
+ private static final String PRINT_START = "[ ";
+ private static final String PRINT_END = " ]";
+
+ public static void printStart() {
+ System.out.println(START);
+ }
+
+ public static void printInsertCoach() {
+ System.out.println(INSERT_COACH_NAME);
+ }
+
+ public static void printInsertNotFood(String name) {
+ System.out.println(name + INSERT_NOT_FOOD);
+ }
+
+ public static void printResultIntro() {
+ System.out.println(RESULT_INTRO);
+ }
+
+ public static void printCategory(int[] category) {
+ String[] stringCategory = new String[category.length];
+ for (int i = 0; i < 5; i++) {
+ if (category[i] == 1) stringCategory[i] = JAPAN_FOOD;
+ if (category[i] == 2) stringCategory[i] = KOREA_FOOD;
+ if (category[i] == 3) stringCategory[i] = CHINA_FOOD;
+ if (category[i] == 4) stringCategory[i] = ASIA_FOOD;
+ if (category[i] == 5) stringCategory[i] = WEASTEN_FOOD;
+ }
+ System.out.print(CATEGORY_START);
+ for (int i = 0; i < 5; i++) {
+ System.out.print(stringCategory[i]);
+ if (i != category.length - 1) {
+ System.out.print(STEP);
+ }
+ }
+ System.out.println(PRINT_END);
+ }
+
+ public static void printMenu(String coach, String[] menus) {
+ System.out.print(PRINT_START + coach + STEP);
+ for (int i = 0; i < menus.length; i++) {
+ System.out.print(menus[i]);
+ if (i != menus.length - 1) {
+ System.out.print(STEP);
+ }
+ }
+ System.out.println(PRINT_END);
+ }
+
+ public static void printCoachesNumberError() {
+ System.out.println("[ERROR] 코치는 최소 2명, 최대 5명까지입니다.");
+ }
+
+ public static void printCoachesNameError() {
+ System.out.println("[ERROR] 코치의 이름은 최소 2글자, 최대 4글자입니다.");
+ }
+} | Java | 에러 메시지를 따로 분리하는 것도 좋을 것 같네요!:) |
@@ -0,0 +1,28 @@
+package menu.model;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MenuRepository {
+ private final List<String> japan =
+ Arrays.asList("규동", "우동", "미소시루", "스시", "가츠동", "오니기리", "하이라이스", "라멘", "오코노미야끼");
+ private final List<String> korea =
+ Arrays.asList("김밥", "김치찌개", "쌈밥", "된장찌개", "비빔밥", "칼국수", "불고기", "떡볶이", "제육볶음");
+ private final List<String> china =
+ Arrays.asList("깐풍기", "볶음면", "동파육", "짜장면", "짬뽕", "마파두부", "탕수육", "토마토 달걀볶음", "고추잡채");
+ private final List<String> asia =
+ Arrays.asList("팟타이", "카오 팟", "나시고렝", "파인애플 볶음밥", "쌀국수", "똠얌꿍", "반미", "월남쌈", "분짜");
+ private final List<String> western =
+ Arrays.asList("라자냐", "그라탱", "뇨끼", "끼슈", "프렌치 토스트", "바게트", "스파게티", "피자", "파니니");
+
+ public String getMenu(int category) {
+ if (category == 1) return Randoms.shuffle(japan).get(0);
+ if (category == 2) return Randoms.shuffle(korea).get(0);
+ if (category == 3) return Randoms.shuffle(china).get(0);
+ if (category == 4) return Randoms.shuffle(asia).get(0);
+ if (category == 5) return Randoms.shuffle(western).get(0);
+ return null;
+ }
+} | Java | getMenuByCategory가 조금 더 직관적인 네이밍 같다는 생각이 드는데, 성민님 의견은 어떠신가요? |
@@ -0,0 +1,28 @@
+package menu.model;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MenuRepository {
+ private final List<String> japan =
+ Arrays.asList("규동", "우동", "미소시루", "스시", "가츠동", "오니기리", "하이라이스", "라멘", "오코노미야끼");
+ private final List<String> korea =
+ Arrays.asList("김밥", "김치찌개", "쌈밥", "된장찌개", "비빔밥", "칼국수", "불고기", "떡볶이", "제육볶음");
+ private final List<String> china =
+ Arrays.asList("깐풍기", "볶음면", "동파육", "짜장면", "짬뽕", "마파두부", "탕수육", "토마토 달걀볶음", "고추잡채");
+ private final List<String> asia =
+ Arrays.asList("팟타이", "카오 팟", "나시고렝", "파인애플 볶음밥", "쌀국수", "똠얌꿍", "반미", "월남쌈", "분짜");
+ private final List<String> western =
+ Arrays.asList("라자냐", "그라탱", "뇨끼", "끼슈", "프렌치 토스트", "바게트", "스파게티", "피자", "파니니");
+
+ public String getMenu(int category) {
+ if (category == 1) return Randoms.shuffle(japan).get(0);
+ if (category == 2) return Randoms.shuffle(korea).get(0);
+ if (category == 3) return Randoms.shuffle(china).get(0);
+ if (category == 4) return Randoms.shuffle(asia).get(0);
+ if (category == 5) return Randoms.shuffle(western).get(0);
+ return null;
+ }
+} | Java | 좋은 것 같습니다! |
@@ -0,0 +1,28 @@
+package menu.model;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MenuRepository {
+ private final List<String> japan =
+ Arrays.asList("규동", "우동", "미소시루", "스시", "가츠동", "오니기리", "하이라이스", "라멘", "오코노미야끼");
+ private final List<String> korea =
+ Arrays.asList("김밥", "김치찌개", "쌈밥", "된장찌개", "비빔밥", "칼국수", "불고기", "떡볶이", "제육볶음");
+ private final List<String> china =
+ Arrays.asList("깐풍기", "볶음면", "동파육", "짜장면", "짬뽕", "마파두부", "탕수육", "토마토 달걀볶음", "고추잡채");
+ private final List<String> asia =
+ Arrays.asList("팟타이", "카오 팟", "나시고렝", "파인애플 볶음밥", "쌀국수", "똠얌꿍", "반미", "월남쌈", "분짜");
+ private final List<String> western =
+ Arrays.asList("라자냐", "그라탱", "뇨끼", "끼슈", "프렌치 토스트", "바게트", "스파게티", "피자", "파니니");
+
+ public String getMenu(int category) {
+ if (category == 1) return Randoms.shuffle(japan).get(0);
+ if (category == 2) return Randoms.shuffle(korea).get(0);
+ if (category == 3) return Randoms.shuffle(china).get(0);
+ if (category == 4) return Randoms.shuffle(asia).get(0);
+ if (category == 5) return Randoms.shuffle(western).get(0);
+ return null;
+ }
+} | Java | 카테고리를 int로 표현하는 것과 각 카테고리가 어떤 int값이어야 하는지가 코드 상에 명시되어있지 않아서 유지보수에 위험할 수 있을 것 같아요 |
@@ -0,0 +1,28 @@
+package menu.model;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MenuRepository {
+ private final List<String> japan =
+ Arrays.asList("규동", "우동", "미소시루", "스시", "가츠동", "오니기리", "하이라이스", "라멘", "오코노미야끼");
+ private final List<String> korea =
+ Arrays.asList("김밥", "김치찌개", "쌈밥", "된장찌개", "비빔밥", "칼국수", "불고기", "떡볶이", "제육볶음");
+ private final List<String> china =
+ Arrays.asList("깐풍기", "볶음면", "동파육", "짜장면", "짬뽕", "마파두부", "탕수육", "토마토 달걀볶음", "고추잡채");
+ private final List<String> asia =
+ Arrays.asList("팟타이", "카오 팟", "나시고렝", "파인애플 볶음밥", "쌀국수", "똠얌꿍", "반미", "월남쌈", "분짜");
+ private final List<String> western =
+ Arrays.asList("라자냐", "그라탱", "뇨끼", "끼슈", "프렌치 토스트", "바게트", "스파게티", "피자", "파니니");
+
+ public String getMenu(int category) {
+ if (category == 1) return Randoms.shuffle(japan).get(0);
+ if (category == 2) return Randoms.shuffle(korea).get(0);
+ if (category == 3) return Randoms.shuffle(china).get(0);
+ if (category == 4) return Randoms.shuffle(asia).get(0);
+ if (category == 5) return Randoms.shuffle(western).get(0);
+ return null;
+ }
+} | Java | Category를 enum으로 관리하는 것도 좋은 방향일 것 같네요! |
@@ -0,0 +1,38 @@
+package lotto.controller.validator
+
+class PurchaseCostValidator {
+ operator fun invoke(input: String) {
+ isEmpty(input)
+ isInteger(input)
+ isZero(input)
+ isNegativeNumber(input)
+ isBetween(input)
+ isUnits(input)
+ }
+
+ private fun isEmpty(input: String) {
+ require(input.isNotEmpty()) { PurchaseErrorType.EMPTY_INPUT }
+ }
+
+ private fun isInteger(input: String) {
+ requireNotNull(input.toIntOrNull()) { PurchaseErrorType.NOT_INTEGER }
+ }
+
+ private fun isZero(input: String) {
+ require(input.toInt() != 0) { PurchaseErrorType.ZERO }
+ }
+
+ private fun isNegativeNumber(input: String) {
+ require(input.toInt() > 0) {
+ PurchaseErrorType.NEGATIVE_NUMBER
+ }
+ }
+
+ private fun isBetween(input: String) {
+ require(input.toInt() >= 1000) { PurchaseErrorType.BETWEEN }
+ }
+
+ private fun isUnits(input: String) {
+ require(input.toInt() % 1000 == 0) { PurchaseErrorType.NO_UNITS }
+ }
+}
\ No newline at end of file | Kotlin | 전 빨리 풀려고 하다보니 1000원 이하나 음수에 대한 입력은
1000원 미만 금액 입력시 에러 발생하는 식으로 퉁쳤는데
역시 꼼꼼하십니다 👍 |
@@ -0,0 +1,40 @@
+package lotto.controller.validator
+
+class LottoNumbersValidator {
+ operator fun invoke(input: String) {
+ isEmpty(input)
+ val numbers = input.split(",").map { it.trim() }
+ isEmpty(numbers)
+ isInteger(numbers)
+ isBetween(numbers)
+ isDuplicate(numbers)
+ isSix(numbers)
+ }
+
+ private fun isEmpty(input: String) {
+ require(input.isNotEmpty()) { LottoNumbersErrorType.EMPTY_INPUT }
+ }
+
+ private fun isEmpty(numbers: List<String>) {
+ require(numbers.all { it.isNotEmpty() }) { LottoNumbersErrorType.EMPTY_INPUT }
+ }
+
+ private fun isInteger(numbers: List<String>) {
+ require(numbers.all { it.toIntOrNull() != null }) { LottoNumbersErrorType.NOT_INTEGER }
+ }
+
+ private fun isBetween(numbers: List<String>) {
+ val nums = numbers.map { it.toInt() }
+ require(nums.all { it in 1..45 }) { LottoNumbersErrorType.BETWEEN_1_45 }
+ }
+
+ private fun isDuplicate(numbers: List<String>) {
+ val nums = numbers.map { it.toInt() }
+ require(nums.size == nums.toSet().size) { LottoNumbersErrorType.DUPLICATE }
+ }
+
+ private fun isSix(numbers: List<String>) {
+ val nums = numbers.map { it.toInt() }
+ require(nums.size == 6) { LottoNumbersErrorType.SIX }
+ }
+}
\ No newline at end of file | Kotlin | 혹시 String Type 에서 Int로 변형하신 이유가 있으실까용?
변형하지 않아도 원소 개수 비교하는덴 영향이 없을 것 같다고 생각해요 ! |
@@ -0,0 +1,54 @@
+package lotto.model
+
+import lotto.constant.WinnerType
+import lotto.util.RandomNumbers
+
+data class MyLotto(
+ private val purchaseCost: Int,
+ private val _lottos: MutableList<Lotto> = mutableListOf(),
+ private val _winners: MutableList<WinnerType> = mutableListOf(),
+) {
+ val lottoCount: Int
+ get() = purchaseCost / 1000
+
+ val lottos: List<Lotto>
+ get() = _lottos
+
+ val winners: List<WinnerType>
+ get() = _winners
+
+ val rateOfReturn: String
+ get() {
+ val totalPrizeAmount = _winners.sumOf { it.prizeAmount }
+ val rate = totalPrizeAmount / purchaseCost.toDouble() * 100
+ return String.format("%.1f", rate)
+ }
+
+ init {
+ generateLottos()
+ }
+
+ private fun generateLottos() {
+ val randomNumbers = RandomNumbers()
+ for (count in 1..lottoCount) {
+ val nums = randomNumbers()
+ _lottos.add(Lotto(nums))
+ }
+ }
+
+ fun getWinner(winningNumber: Lotto, bonusNumber: Int) {
+ _lottos.forEach { lotto ->
+ val matchCount = lotto.winningNumbers.intersect(winningNumber.winningNumbers).size
+ val hasBonus = bonusNumber in lotto.winningNumbers
+ val winner = when {
+ matchCount == 6 -> WinnerType.FIRST
+ matchCount == 5 && hasBonus -> WinnerType.SECOND
+ matchCount == 5 -> WinnerType.THIRD
+ matchCount == 4 -> WinnerType.FOURTH
+ matchCount == 3 -> WinnerType.FIFTH
+ else -> WinnerType.NONE
+ }
+ _winners.add(winner)
+ }
+ }
+}
\ No newline at end of file | Kotlin | 대박 이렇게 하면 lottoCount를 외부에서 계산해주지 않아도 되는군요 !
하나 배워갑니다 ㅎㅎ |
@@ -0,0 +1,54 @@
+package lotto.model
+
+import lotto.constant.WinnerType
+import lotto.util.RandomNumbers
+
+data class MyLotto(
+ private val purchaseCost: Int,
+ private val _lottos: MutableList<Lotto> = mutableListOf(),
+ private val _winners: MutableList<WinnerType> = mutableListOf(),
+) {
+ val lottoCount: Int
+ get() = purchaseCost / 1000
+
+ val lottos: List<Lotto>
+ get() = _lottos
+
+ val winners: List<WinnerType>
+ get() = _winners
+
+ val rateOfReturn: String
+ get() {
+ val totalPrizeAmount = _winners.sumOf { it.prizeAmount }
+ val rate = totalPrizeAmount / purchaseCost.toDouble() * 100
+ return String.format("%.1f", rate)
+ }
+
+ init {
+ generateLottos()
+ }
+
+ private fun generateLottos() {
+ val randomNumbers = RandomNumbers()
+ for (count in 1..lottoCount) {
+ val nums = randomNumbers()
+ _lottos.add(Lotto(nums))
+ }
+ }
+
+ fun getWinner(winningNumber: Lotto, bonusNumber: Int) {
+ _lottos.forEach { lotto ->
+ val matchCount = lotto.winningNumbers.intersect(winningNumber.winningNumbers).size
+ val hasBonus = bonusNumber in lotto.winningNumbers
+ val winner = when {
+ matchCount == 6 -> WinnerType.FIRST
+ matchCount == 5 && hasBonus -> WinnerType.SECOND
+ matchCount == 5 -> WinnerType.THIRD
+ matchCount == 4 -> WinnerType.FOURTH
+ matchCount == 3 -> WinnerType.FIFTH
+ else -> WinnerType.NONE
+ }
+ _winners.add(winner)
+ }
+ }
+}
\ No newline at end of file | Kotlin | 요 클래스 감탄하면서 봤습니다 ㅎㅎ
응집도면에서 너무나 잘 설계하신 것 같아요 :) |
@@ -0,0 +1,40 @@
+package lotto.controller.validator
+
+class LottoNumbersValidator {
+ operator fun invoke(input: String) {
+ isEmpty(input)
+ val numbers = input.split(",").map { it.trim() }
+ isEmpty(numbers)
+ isInteger(numbers)
+ isBetween(numbers)
+ isDuplicate(numbers)
+ isSix(numbers)
+ }
+
+ private fun isEmpty(input: String) {
+ require(input.isNotEmpty()) { LottoNumbersErrorType.EMPTY_INPUT }
+ }
+
+ private fun isEmpty(numbers: List<String>) {
+ require(numbers.all { it.isNotEmpty() }) { LottoNumbersErrorType.EMPTY_INPUT }
+ }
+
+ private fun isInteger(numbers: List<String>) {
+ require(numbers.all { it.toIntOrNull() != null }) { LottoNumbersErrorType.NOT_INTEGER }
+ }
+
+ private fun isBetween(numbers: List<String>) {
+ val nums = numbers.map { it.toInt() }
+ require(nums.all { it in 1..45 }) { LottoNumbersErrorType.BETWEEN_1_45 }
+ }
+
+ private fun isDuplicate(numbers: List<String>) {
+ val nums = numbers.map { it.toInt() }
+ require(nums.size == nums.toSet().size) { LottoNumbersErrorType.DUPLICATE }
+ }
+
+ private fun isSix(numbers: List<String>) {
+ val nums = numbers.map { it.toInt() }
+ require(nums.size == 6) { LottoNumbersErrorType.SIX }
+ }
+}
\ No newline at end of file | Kotlin | 맞네요! 이게 오버 코딩을 해버렸네요 ㅎㅎ |
@@ -0,0 +1,26 @@
+package lotto.constant
+
+import java.text.NumberFormat
+import java.util.*
+
+enum class WinnerType(
+ val matchingNumberCount: Int,
+ val prizeAmount: Int,
+) {
+ FIRST(6, 2_000_000_000),
+ SECOND(5, 30_000_000),
+ THIRD(5, 1_500_000),
+ FOURTH(4, 50_000),
+ FIFTH(3, 5_000),
+ NONE(0, 0);
+
+ override fun toString(): String {
+ return when (this) {
+ SECOND -> "${matchingNumberCount}개 일치, 보너스 볼 일치 (${
+ NumberFormat.getNumberInstance(Locale.KOREA).format(prizeAmount)
+ }원)"
+
+ else -> "${matchingNumberCount}개 일치 (${NumberFormat.getNumberInstance(Locale.KOREA).format(prizeAmount)}원)"
+ }
+ }
+}
\ No newline at end of file | Kotlin | 와 2등일때만 print다른 것 때문에 골치아팠는데, 아예 enum에서 다르게 toString하시다니.. 또 하나 배웁니다...! |
@@ -0,0 +1,38 @@
+package lotto.controller.validator
+
+class PurchaseCostValidator {
+ operator fun invoke(input: String) {
+ isEmpty(input)
+ isInteger(input)
+ isZero(input)
+ isNegativeNumber(input)
+ isBetween(input)
+ isUnits(input)
+ }
+
+ private fun isEmpty(input: String) {
+ require(input.isNotEmpty()) { PurchaseErrorType.EMPTY_INPUT }
+ }
+
+ private fun isInteger(input: String) {
+ requireNotNull(input.toIntOrNull()) { PurchaseErrorType.NOT_INTEGER }
+ }
+
+ private fun isZero(input: String) {
+ require(input.toInt() != 0) { PurchaseErrorType.ZERO }
+ }
+
+ private fun isNegativeNumber(input: String) {
+ require(input.toInt() > 0) {
+ PurchaseErrorType.NEGATIVE_NUMBER
+ }
+ }
+
+ private fun isBetween(input: String) {
+ require(input.toInt() >= 1000) { PurchaseErrorType.BETWEEN }
+ }
+
+ private fun isUnits(input: String) {
+ require(input.toInt() % 1000 == 0) { PurchaseErrorType.NO_UNITS }
+ }
+}
\ No newline at end of file | Kotlin | 각 분야별로 Validator랑 ErroType이 하나씩 있는 게 파일이 깔끔해서 좋네요! |
@@ -0,0 +1,36 @@
+package lotto.controller.domain
+
+import lotto.model.MyLotto
+import lotto.view.InputView
+import lotto.view.OutputView
+
+class UserInteractionController(
+ private val inputView: InputView = InputView(),
+ private val outputView: OutputView = OutputView(),
+) {
+ fun handlePurchaseCost(): String {
+ outputView.showStartMessage()
+ val purchaseCost = inputView.getInput()
+ return purchaseCost
+ }
+
+ fun handlePurchaseLotto(myLotto: MyLotto) {
+ outputView.showPurchaseLotto(myLotto)
+ }
+
+ fun handleLottoNumbers(): String {
+ outputView.showLottoNumbers()
+ val lottoNumbers = inputView.getInput()
+ return lottoNumbers
+ }
+
+ fun handleBonusNumber(): String {
+ outputView.showBonusNumber()
+ val bonusNumber = inputView.getInput()
+ return bonusNumber
+ }
+
+ fun handlePrize(myLotto: MyLotto) {
+ outputView.showPrize(myLotto)
+ }
+}
\ No newline at end of file | Kotlin | LottoController외 UserController 만드는게 좋네요!
저도 입력이랑 혼재되어있어서 고민이었는데 참고해야겠습니다 ㅎㅎ |
@@ -0,0 +1,14 @@
+package store.common.dto;
+
+public record PromotionConditionResult(
+ int applicableSetCount,
+ int stockUsed,
+ int remainingQuantity,
+ String message
+) {
+ public static PromotionConditionResult from(
+ int applicableSetCount, int stockUsed, int remainingQuantity, String message
+ ) {
+ return new PromotionConditionResult(applicableSetCount, stockUsed, remainingQuantity, message);
+ }
+} | Java | 정적 팩토리 메서드 사용 시, from은 인자 값이 하나일때 사용하고 of는 인자 값이 여러개일때 주로 사용을 한다고 합니다 🤔 |
@@ -0,0 +1,24 @@
+package store.common.dto;
+
+import java.util.Map;
+import java.util.Set;
+
+public record PurchaseRequest(
+ Map<String, Integer> items
+) {
+ public static PurchaseRequest from(Map<String, Integer> cart) {
+ return new PurchaseRequest(cart);
+ }
+
+ public PurchaseProductNames getProductNames() {
+ return PurchaseProductNames.from(items.keySet());
+ }
+
+ public record PurchaseProductNames(
+ Set<String> productNames
+ ) {
+ public static PurchaseProductNames from(Set<String> productNames) {
+ return new PurchaseProductNames(productNames);
+ }
+ }
+} | Java | 내장 클래스를 사용하신 의도가 궁금합니다!! 🙃 |
@@ -0,0 +1,34 @@
+package store.common.util;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.IntStream;
+
+public class StringUtils {
+
+ public static int parseInt(String message) {
+ try {
+ return Integer.parseInt(message);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ public static List<String> splitWithDelimiter(String message, String delimiter) {
+ return Arrays.stream(message.split(delimiter))
+ .map(String::strip)
+ .toList();
+ }
+
+ public static List<String> extractFromRegex(String message, Pattern regex) {
+ Matcher matcher = regex.matcher(message);
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException();
+ }
+ return IntStream.range(1, matcher.groupCount() + 1)
+ .mapToObj(matcher::group)
+ .toList();
+ }
+} | Java | 예외 처리 메세지는 일부러 보내지 않으신 걸까요? |
@@ -0,0 +1,144 @@
+package store.controller;
+
+import static store.common.constant.ErrorMessage.INPUT_INVALID_FORMAT;
+import static store.common.constant.ErrorMessage.PRODUCT_NOT_FOUND_ERROR;
+import static store.common.constant.ErrorMessage.PRODUCT_OUT_OF_STOCK;
+
+import java.io.IOException;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.Locale;
+import java.util.function.Supplier;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import store.common.dto.PurchaseRequest;
+import store.common.dto.PurchaseRequest.PurchaseProductNames;
+import store.common.util.FileReader;
+import store.common.util.StringUtils;
+import store.model.Product;
+import store.model.ProductCatalog;
+import store.model.Products;
+import store.model.Promotion;
+import store.model.PromotionCatalog;
+import store.model.promotion.BuyNGetMFreePromotion;
+import store.model.promotion.PromotionStrategy;
+import store.view.InputView;
+
+public class InputHandler {
+
+ private static final Pattern PURCHASE_ITEM_REGEX = Pattern.compile("^\\[(.+)\\-(.+)\\]$");
+
+ private final InputView inputView;
+
+ public InputHandler(InputView inputView) {
+ this.inputView = inputView;
+ }
+
+ public PromotionCatalog getPromotions() {
+ try {
+ List<String> fileLines = FileReader.readFile("src/main/resources/promotions.md");
+ return PromotionCatalog.from(fileLines.stream()
+ .skip(1)
+ .map(fileLine -> makePromotion(StringUtils.splitWithDelimiter(fileLine, ",")))
+ .collect(Collectors.toMap(Promotion::name, promotion -> promotion))
+ );
+ } catch (IOException e) {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ public ProductCatalog getProducts(PromotionCatalog promotionCatalog) {
+ try {
+ List<String> fileLines = FileReader.readFile("src/main/resources/products.md");
+ return ProductCatalog.from(fileLines.stream()
+ .skip(1)
+ .map(fileLine -> makeProduct(StringUtils.splitWithDelimiter(fileLine, ","), promotionCatalog))
+ .collect(Collectors.toSet())
+ );
+ } catch (IOException e) {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ public PurchaseRequest getPurchaseItems(ProductCatalog productCatalog) {
+ return validate(() -> {
+ List<String> purchaseItems = StringUtils.splitWithDelimiter(inputView.getPurchaseItems(), ",");
+ PurchaseRequest request = getPurchaseRequest(purchaseItems);
+ validateItemsExist(request.getProductNames(), productCatalog);
+ checkItemsStock(request, productCatalog);
+ return request;
+ });
+ }
+
+ private PurchaseRequest getPurchaseRequest(List<String> purchaseItems) {
+ try {
+ return PurchaseRequest.from(
+ purchaseItems.stream()
+ .map(purchaseItem -> StringUtils.extractFromRegex(purchaseItem, PURCHASE_ITEM_REGEX))
+ .collect(Collectors.toMap(item -> item.get(0).strip(),
+ item -> StringUtils.parseInt(item.get(1))))
+ );
+ } catch (IllegalStateException e) {
+ throw new IllegalArgumentException(INPUT_INVALID_FORMAT.message());
+ }
+ }
+
+ public boolean isAffirmative() {
+ return validate(() -> {
+ String yesOrNo = inputView.getYesOrNo().toUpperCase(Locale.ROOT);
+ if (!yesOrNo.equals("Y") && !yesOrNo.equals("N")) {
+ throw new IllegalArgumentException(INPUT_INVALID_FORMAT.message());
+ }
+ return yesOrNo.equals("Y");
+ });
+ }
+
+ private Promotion makePromotion(List<String> promotionValues) {
+ DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE;
+
+ String name = promotionValues.get(0);
+ int purchaseQuantity = StringUtils.parseInt(promotionValues.get(1));
+ int freeQuantity = StringUtils.parseInt(promotionValues.get(2));
+ PromotionStrategy promotionStrategy = new BuyNGetMFreePromotion(purchaseQuantity, freeQuantity);
+ LocalDate startDate = LocalDate.parse(promotionValues.get(3), formatter);
+ LocalDate endDate = LocalDate.parse(promotionValues.get(4), formatter);
+ return Promotion.of(name, promotionStrategy, startDate, endDate);
+ }
+
+ private Product makeProduct(List<String> productValues, PromotionCatalog promotionCatalog) {
+ String name = productValues.get(0);
+ int price = StringUtils.parseInt(productValues.get(1));
+ int stock = StringUtils.parseInt(productValues.get(2));
+ Promotion promotion = promotionCatalog.getPromotionByName(productValues.get(3));
+ return Product.of(name, price, stock, promotion);
+ }
+
+ private void validateItemsExist(PurchaseProductNames productNames, ProductCatalog productCatalog) {
+ boolean doesNotContainsAllProduct = !productCatalog.doesContainsAllProduct(productNames.productNames());
+ if (doesNotContainsAllProduct) {
+ throw new IllegalArgumentException(PRODUCT_NOT_FOUND_ERROR.message());
+ }
+ }
+
+ private void checkItemsStock(PurchaseRequest purchaseItems, ProductCatalog productCatalog) {
+ purchaseItems.items().forEach((productName, quantity) -> {
+ Products product = productCatalog.getProductByName(productName);
+ int totalStock = product.products().stream().mapToInt(Product::stock).sum();
+ boolean isOutOfStock = quantity > totalStock;
+ if (isOutOfStock) {
+ throw new IllegalArgumentException(PRODUCT_OUT_OF_STOCK.message());
+ }
+ });
+ }
+
+ private <T> T validate(Supplier<T> inputSupplier) {
+ while (true) {
+ try {
+ return inputSupplier.get();
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+} | Java | toUpperCase()랑 toUpperCase(Locale.ROOT) 어떤 부분이 다른가요? |
@@ -0,0 +1,162 @@
+package store.controller;
+
+import static store.common.constant.PromotionNotice.GET_FREE_M_NOTICE;
+import static store.common.constant.PromotionNotice.OUT_OF_STOCK_NOTICE;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import store.common.dto.PromotionConditionResult;
+import store.common.dto.PromotionResult;
+import store.common.dto.PurchaseRequest;
+import store.common.dto.PurchaseRequest.PurchaseProductNames;
+import store.model.Cart;
+import store.model.Product;
+import store.model.ProductCatalog;
+import store.model.Products;
+import store.model.PromotionCatalog;
+import store.model.Receipt;
+import store.view.OutputView;
+
+public class StoreController {
+
+ private final InputHandler inputHandler;
+ private final OutputView outputView;
+
+ private final ProductCatalog productCatalog;
+ private final PromotionCatalog promotionCatalog;
+
+ public StoreController(InputHandler inputHandler, OutputView outputView) {
+ this.inputHandler = inputHandler;
+ this.outputView = outputView;
+ promotionCatalog = inputHandler.getPromotions();
+ productCatalog = inputHandler.getProducts(promotionCatalog);
+ }
+
+ public void run() {
+ PurchaseRequest purchaseItems = getPurchaseRequest();
+ Cart cart = Cart.empty();
+
+ Products promotionalProducts = getPromotionalProducts(purchaseItems.getProductNames());
+ List<PromotionResult> promotionResults = addPromotionalProductToCart(promotionalProducts, purchaseItems, cart);
+ addRegularProductToCart(purchaseItems, cart);
+ int membershipDiscount = applyMembership(cart, promotionalProducts);
+ purchaseProducts(cart);
+ printReceipt(cart, promotionResults, membershipDiscount);
+ repurchaseIfWant();
+ }
+
+ private PurchaseRequest getPurchaseRequest() {
+ outputView.printStoreInventory(productCatalog);
+ return inputHandler.getPurchaseItems(productCatalog);
+ }
+
+ private void addRegularProductToCart(PurchaseRequest purchaseItems, Cart cart) {
+ purchaseItems.items().keySet().forEach(productName -> {
+ Product product = productCatalog.getProductByName(productName).products().stream()
+ .findFirst()
+ .orElseThrow(IllegalArgumentException::new);
+ cart.addProduct(product, purchaseItems.items().get(productName));
+ });
+ }
+
+ private List<PromotionResult> addPromotionalProductToCart(
+ Products promotionalProducts, PurchaseRequest purchaseItems, Cart cart
+ ) {
+ promotionalProducts.products().forEach(product -> {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ PromotionConditionResult conditionResult = product.checkPromotionCondition(purchaseQuantity);
+ handlePromotionCondition(purchaseItems, cart, product, conditionResult);
+ });
+ return applyPromotion(cart);
+ }
+
+ private Products getPromotionalProducts(PurchaseProductNames productNames) {
+ return Products.from(
+ productCatalog.getProductsByNames(productNames.productNames()).products().stream()
+ .filter(Product::isPromotionApplicable)
+ .collect(Collectors.toSet())
+ );
+ }
+
+ private List<PromotionResult> applyPromotion(Cart cart) {
+ return cart.cart().keySet().stream()
+ .filter(Product::isPromotionApplicable)
+ .map(product -> product.applyPromotion(cart.cart().get(product)))
+ .toList();
+ }
+
+ private void handlePromotionCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ if (GET_FREE_M_NOTICE.matches(conditionResult.message())) {
+ handleGetFreeCondition(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ if (OUT_OF_STOCK_NOTICE.matches(conditionResult.message())) {
+ handleOutOfPromotionStock(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ cart.addProduct(product, conditionResult.stockUsed());
+ purchaseItems.items()
+ .replace(product.name(), purchaseItems.items().get(product.name()) - conditionResult.stockUsed());
+ }
+
+ private void handleOutOfPromotionStock(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printPromotionOutOfStockNotice(conditionResult.message());
+ cart.addProduct(product, conditionResult.stockUsed());
+ if (inputHandler.isAffirmative()) {
+ purchaseItems.items().replace(product.name(), purchaseQuantity - conditionResult.stockUsed());
+ return;
+ }
+ purchaseItems.items().remove(product.name());
+ }
+
+ private void handleGetFreeCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printGetFreeNotice(conditionResult.message());
+ if (inputHandler.isAffirmative()) {
+ cart.addProduct(product, purchaseQuantity + 1);
+ purchaseItems.items().remove(product.name());
+ return;
+ }
+ cart.addProduct(product, purchaseQuantity);
+ purchaseItems.items().remove(product.name());
+ }
+
+ private int applyMembership(Cart cart, Products promotionalProducts) {
+ outputView.printMembershipNotice();
+ AtomicInteger discountAmount = new AtomicInteger();
+ if (inputHandler.isAffirmative()) {
+ cart.cart().forEach((product, quantity) -> {
+ if (promotionalProducts.products().contains(product)) {
+ return;
+ }
+ discountAmount.addAndGet(product.price() * quantity);
+ });
+ }
+ discountAmount.updateAndGet(value -> Math.min(value * 30 / 100, 8000));
+ return discountAmount.get();
+ }
+
+ private static void purchaseProducts(Cart cart) {
+ cart.cart().forEach(Product::reduceStock);
+ }
+
+ private void printReceipt(Cart cart, List<PromotionResult> promotionResults, int membershipDiscount) {
+ Receipt receipt = Receipt.of(cart, promotionResults, membershipDiscount);
+ outputView.printReceipt(receipt);
+ }
+
+ private void repurchaseIfWant() {
+ outputView.printRepurchaseNotice();
+ if (inputHandler.isAffirmative()) {
+ run();
+ }
+ }
+} | Java | static은 잘못 들어간걸까요? |
@@ -0,0 +1,162 @@
+package store.controller;
+
+import static store.common.constant.PromotionNotice.GET_FREE_M_NOTICE;
+import static store.common.constant.PromotionNotice.OUT_OF_STOCK_NOTICE;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import store.common.dto.PromotionConditionResult;
+import store.common.dto.PromotionResult;
+import store.common.dto.PurchaseRequest;
+import store.common.dto.PurchaseRequest.PurchaseProductNames;
+import store.model.Cart;
+import store.model.Product;
+import store.model.ProductCatalog;
+import store.model.Products;
+import store.model.PromotionCatalog;
+import store.model.Receipt;
+import store.view.OutputView;
+
+public class StoreController {
+
+ private final InputHandler inputHandler;
+ private final OutputView outputView;
+
+ private final ProductCatalog productCatalog;
+ private final PromotionCatalog promotionCatalog;
+
+ public StoreController(InputHandler inputHandler, OutputView outputView) {
+ this.inputHandler = inputHandler;
+ this.outputView = outputView;
+ promotionCatalog = inputHandler.getPromotions();
+ productCatalog = inputHandler.getProducts(promotionCatalog);
+ }
+
+ public void run() {
+ PurchaseRequest purchaseItems = getPurchaseRequest();
+ Cart cart = Cart.empty();
+
+ Products promotionalProducts = getPromotionalProducts(purchaseItems.getProductNames());
+ List<PromotionResult> promotionResults = addPromotionalProductToCart(promotionalProducts, purchaseItems, cart);
+ addRegularProductToCart(purchaseItems, cart);
+ int membershipDiscount = applyMembership(cart, promotionalProducts);
+ purchaseProducts(cart);
+ printReceipt(cart, promotionResults, membershipDiscount);
+ repurchaseIfWant();
+ }
+
+ private PurchaseRequest getPurchaseRequest() {
+ outputView.printStoreInventory(productCatalog);
+ return inputHandler.getPurchaseItems(productCatalog);
+ }
+
+ private void addRegularProductToCart(PurchaseRequest purchaseItems, Cart cart) {
+ purchaseItems.items().keySet().forEach(productName -> {
+ Product product = productCatalog.getProductByName(productName).products().stream()
+ .findFirst()
+ .orElseThrow(IllegalArgumentException::new);
+ cart.addProduct(product, purchaseItems.items().get(productName));
+ });
+ }
+
+ private List<PromotionResult> addPromotionalProductToCart(
+ Products promotionalProducts, PurchaseRequest purchaseItems, Cart cart
+ ) {
+ promotionalProducts.products().forEach(product -> {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ PromotionConditionResult conditionResult = product.checkPromotionCondition(purchaseQuantity);
+ handlePromotionCondition(purchaseItems, cart, product, conditionResult);
+ });
+ return applyPromotion(cart);
+ }
+
+ private Products getPromotionalProducts(PurchaseProductNames productNames) {
+ return Products.from(
+ productCatalog.getProductsByNames(productNames.productNames()).products().stream()
+ .filter(Product::isPromotionApplicable)
+ .collect(Collectors.toSet())
+ );
+ }
+
+ private List<PromotionResult> applyPromotion(Cart cart) {
+ return cart.cart().keySet().stream()
+ .filter(Product::isPromotionApplicable)
+ .map(product -> product.applyPromotion(cart.cart().get(product)))
+ .toList();
+ }
+
+ private void handlePromotionCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ if (GET_FREE_M_NOTICE.matches(conditionResult.message())) {
+ handleGetFreeCondition(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ if (OUT_OF_STOCK_NOTICE.matches(conditionResult.message())) {
+ handleOutOfPromotionStock(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ cart.addProduct(product, conditionResult.stockUsed());
+ purchaseItems.items()
+ .replace(product.name(), purchaseItems.items().get(product.name()) - conditionResult.stockUsed());
+ }
+
+ private void handleOutOfPromotionStock(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printPromotionOutOfStockNotice(conditionResult.message());
+ cart.addProduct(product, conditionResult.stockUsed());
+ if (inputHandler.isAffirmative()) {
+ purchaseItems.items().replace(product.name(), purchaseQuantity - conditionResult.stockUsed());
+ return;
+ }
+ purchaseItems.items().remove(product.name());
+ }
+
+ private void handleGetFreeCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printGetFreeNotice(conditionResult.message());
+ if (inputHandler.isAffirmative()) {
+ cart.addProduct(product, purchaseQuantity + 1);
+ purchaseItems.items().remove(product.name());
+ return;
+ }
+ cart.addProduct(product, purchaseQuantity);
+ purchaseItems.items().remove(product.name());
+ }
+
+ private int applyMembership(Cart cart, Products promotionalProducts) {
+ outputView.printMembershipNotice();
+ AtomicInteger discountAmount = new AtomicInteger();
+ if (inputHandler.isAffirmative()) {
+ cart.cart().forEach((product, quantity) -> {
+ if (promotionalProducts.products().contains(product)) {
+ return;
+ }
+ discountAmount.addAndGet(product.price() * quantity);
+ });
+ }
+ discountAmount.updateAndGet(value -> Math.min(value * 30 / 100, 8000));
+ return discountAmount.get();
+ }
+
+ private static void purchaseProducts(Cart cart) {
+ cart.cart().forEach(Product::reduceStock);
+ }
+
+ private void printReceipt(Cart cart, List<PromotionResult> promotionResults, int membershipDiscount) {
+ Receipt receipt = Receipt.of(cart, promotionResults, membershipDiscount);
+ outputView.printReceipt(receipt);
+ }
+
+ private void repurchaseIfWant() {
+ outputView.printRepurchaseNotice();
+ if (inputHandler.isAffirmative()) {
+ run();
+ }
+ }
+} | Java | 인덴트 depth를 2개까지 허용하는 것이 요구사항이였는데, 3개가 들어간 것 같아 메서드를 분리하는 것이 좋아보여요!! |
@@ -0,0 +1,56 @@
+package store.model;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class ProductCatalog {
+
+ private final Products products;
+
+ private ProductCatalog(Products products) {
+ this.products = products;
+ }
+
+ public static ProductCatalog from(Set<Product> products) {
+ products = new HashSet<>(products);
+ Set<Product> additionalProducts = products.stream()
+ .collect(Collectors.groupingBy(Product::name))
+ .entrySet().stream()
+ .filter(entry -> entry.getValue().stream().noneMatch(p -> p.promotion() == null))
+ .map(entry -> Product.of(entry.getKey(), entry.getValue().getFirst().price(), 0, null))
+ .collect(Collectors.toSet());
+
+ products.addAll(additionalProducts);
+ return new ProductCatalog(Products.from(products));
+ }
+
+ public boolean doesContainsAllProduct(Set<String> productNames) {
+ return this.products.products().stream()
+ .map(Product::name)
+ .collect(Collectors.toSet())
+ .containsAll(productNames);
+ }
+
+ public Products getProductByName(String productName) {
+ return Products.from(
+ this.products.products().stream()
+ .filter(product -> product.name().equals(productName))
+ .collect(Collectors.toSet())
+ );
+ }
+
+ public Products getProductsByNames(Set<String> productNames) {
+ Set<Product> productsByName = new HashSet<>();
+ productNames.forEach(productName ->
+ productsByName.addAll(products.products().stream()
+ .filter(product -> product.name().equals(productName))
+ .collect(Collectors.toSet()))
+ );
+ return Products.from(productsByName);
+ }
+
+ public Set<Product> products() {
+ return products.products();
+ }
+} | Java | 중복 방지를 위해 Set을 사용하셨네요!! 👍 |
@@ -0,0 +1,65 @@
+package store.model;
+
+import java.util.List;
+import store.common.dto.PromotionResult;
+
+public class Receipt {
+
+ private final Cart cart;
+ private final List<PromotionResult> promotionResults;
+ private final int totalPrice;
+ private final int promotionDiscount;
+ private final int membershipDiscount;
+ private final int paymentPrice;
+
+ private Receipt(
+ Cart cart,
+ List<PromotionResult> promotionResults,
+ int totalPrice,
+ int promotionDiscount,
+ int membershipDiscount,
+ int paymentPrice
+ ) {
+ this.cart = cart;
+ this.promotionResults = promotionResults;
+ this.totalPrice = totalPrice;
+ this.promotionDiscount = promotionDiscount;
+ this.membershipDiscount = membershipDiscount;
+ this.paymentPrice = paymentPrice;
+ }
+
+ public static Receipt of(Cart cart, List<PromotionResult> promotionResults, int membershipDiscount) {
+ int totalPrice = cart.cart().entrySet().stream()
+ .mapToInt(entry -> entry.getKey().price() * entry.getValue())
+ .sum();
+ int promotionDiscount = promotionResults.stream()
+ .mapToInt(PromotionResult::discountAmount)
+ .sum();
+ return new Receipt(cart, promotionResults, totalPrice, promotionDiscount, membershipDiscount,
+ totalPrice - promotionDiscount - membershipDiscount);
+ }
+
+ public Cart cart() {
+ return cart;
+ }
+
+ public List<PromotionResult> promotionResults() {
+ return promotionResults;
+ }
+
+ public int totalPrice() {
+ return totalPrice;
+ }
+
+ public int promotionDiscount() {
+ return promotionDiscount;
+ }
+
+ public int membershipDiscount() {
+ return membershipDiscount;
+ }
+
+ public int paymentPrice() {
+ return paymentPrice;
+ }
+} | Java | 메서드를 분리해서 단일 책임 원리 원칙을 지키면 좋을 것 같아요? |
@@ -0,0 +1,162 @@
+package store.controller;
+
+import static store.common.constant.PromotionNotice.GET_FREE_M_NOTICE;
+import static store.common.constant.PromotionNotice.OUT_OF_STOCK_NOTICE;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import store.common.dto.PromotionConditionResult;
+import store.common.dto.PromotionResult;
+import store.common.dto.PurchaseRequest;
+import store.common.dto.PurchaseRequest.PurchaseProductNames;
+import store.model.Cart;
+import store.model.Product;
+import store.model.ProductCatalog;
+import store.model.Products;
+import store.model.PromotionCatalog;
+import store.model.Receipt;
+import store.view.OutputView;
+
+public class StoreController {
+
+ private final InputHandler inputHandler;
+ private final OutputView outputView;
+
+ private final ProductCatalog productCatalog;
+ private final PromotionCatalog promotionCatalog;
+
+ public StoreController(InputHandler inputHandler, OutputView outputView) {
+ this.inputHandler = inputHandler;
+ this.outputView = outputView;
+ promotionCatalog = inputHandler.getPromotions();
+ productCatalog = inputHandler.getProducts(promotionCatalog);
+ }
+
+ public void run() {
+ PurchaseRequest purchaseItems = getPurchaseRequest();
+ Cart cart = Cart.empty();
+
+ Products promotionalProducts = getPromotionalProducts(purchaseItems.getProductNames());
+ List<PromotionResult> promotionResults = addPromotionalProductToCart(promotionalProducts, purchaseItems, cart);
+ addRegularProductToCart(purchaseItems, cart);
+ int membershipDiscount = applyMembership(cart, promotionalProducts);
+ purchaseProducts(cart);
+ printReceipt(cart, promotionResults, membershipDiscount);
+ repurchaseIfWant();
+ }
+
+ private PurchaseRequest getPurchaseRequest() {
+ outputView.printStoreInventory(productCatalog);
+ return inputHandler.getPurchaseItems(productCatalog);
+ }
+
+ private void addRegularProductToCart(PurchaseRequest purchaseItems, Cart cart) {
+ purchaseItems.items().keySet().forEach(productName -> {
+ Product product = productCatalog.getProductByName(productName).products().stream()
+ .findFirst()
+ .orElseThrow(IllegalArgumentException::new);
+ cart.addProduct(product, purchaseItems.items().get(productName));
+ });
+ }
+
+ private List<PromotionResult> addPromotionalProductToCart(
+ Products promotionalProducts, PurchaseRequest purchaseItems, Cart cart
+ ) {
+ promotionalProducts.products().forEach(product -> {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ PromotionConditionResult conditionResult = product.checkPromotionCondition(purchaseQuantity);
+ handlePromotionCondition(purchaseItems, cart, product, conditionResult);
+ });
+ return applyPromotion(cart);
+ }
+
+ private Products getPromotionalProducts(PurchaseProductNames productNames) {
+ return Products.from(
+ productCatalog.getProductsByNames(productNames.productNames()).products().stream()
+ .filter(Product::isPromotionApplicable)
+ .collect(Collectors.toSet())
+ );
+ }
+
+ private List<PromotionResult> applyPromotion(Cart cart) {
+ return cart.cart().keySet().stream()
+ .filter(Product::isPromotionApplicable)
+ .map(product -> product.applyPromotion(cart.cart().get(product)))
+ .toList();
+ }
+
+ private void handlePromotionCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ if (GET_FREE_M_NOTICE.matches(conditionResult.message())) {
+ handleGetFreeCondition(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ if (OUT_OF_STOCK_NOTICE.matches(conditionResult.message())) {
+ handleOutOfPromotionStock(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ cart.addProduct(product, conditionResult.stockUsed());
+ purchaseItems.items()
+ .replace(product.name(), purchaseItems.items().get(product.name()) - conditionResult.stockUsed());
+ }
+
+ private void handleOutOfPromotionStock(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printPromotionOutOfStockNotice(conditionResult.message());
+ cart.addProduct(product, conditionResult.stockUsed());
+ if (inputHandler.isAffirmative()) {
+ purchaseItems.items().replace(product.name(), purchaseQuantity - conditionResult.stockUsed());
+ return;
+ }
+ purchaseItems.items().remove(product.name());
+ }
+
+ private void handleGetFreeCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printGetFreeNotice(conditionResult.message());
+ if (inputHandler.isAffirmative()) {
+ cart.addProduct(product, purchaseQuantity + 1);
+ purchaseItems.items().remove(product.name());
+ return;
+ }
+ cart.addProduct(product, purchaseQuantity);
+ purchaseItems.items().remove(product.name());
+ }
+
+ private int applyMembership(Cart cart, Products promotionalProducts) {
+ outputView.printMembershipNotice();
+ AtomicInteger discountAmount = new AtomicInteger();
+ if (inputHandler.isAffirmative()) {
+ cart.cart().forEach((product, quantity) -> {
+ if (promotionalProducts.products().contains(product)) {
+ return;
+ }
+ discountAmount.addAndGet(product.price() * quantity);
+ });
+ }
+ discountAmount.updateAndGet(value -> Math.min(value * 30 / 100, 8000));
+ return discountAmount.get();
+ }
+
+ private static void purchaseProducts(Cart cart) {
+ cart.cart().forEach(Product::reduceStock);
+ }
+
+ private void printReceipt(Cart cart, List<PromotionResult> promotionResults, int membershipDiscount) {
+ Receipt receipt = Receipt.of(cart, promotionResults, membershipDiscount);
+ outputView.printReceipt(receipt);
+ }
+
+ private void repurchaseIfWant() {
+ outputView.printRepurchaseNotice();
+ if (inputHandler.isAffirmative()) {
+ run();
+ }
+ }
+} | Java | 이 부분은 개인적으로 궁금한 부분인데 인자값을 이렇게 쓰시는데 이유가 있으신걸까요? 🤔 |
@@ -0,0 +1,60 @@
+package store.model.promotion;
+
+import static store.common.constant.PromotionNotice.DEFAULT_NOTICE;
+import static store.common.constant.PromotionNotice.GET_FREE_M_NOTICE;
+import static store.common.constant.PromotionNotice.OUT_OF_STOCK_NOTICE;
+
+import store.common.dto.PromotionConditionResult;
+import store.common.dto.PromotionResult;
+import store.model.Product;
+
+public class BuyNGetMFreePromotion implements PromotionStrategy {
+
+ private final int purchaseQuantity;
+ private final int freeQuantity;
+
+ public BuyNGetMFreePromotion(int purchaseQuantity, int freeQuantity) {
+ this.purchaseQuantity = purchaseQuantity;
+ this.freeQuantity = freeQuantity;
+ }
+
+ @Override
+ public PromotionResult applyPromotion(Product product, int quantity) {
+ int totalFreeQuantity = getApplicableSetCount(quantity) * freeQuantity;
+ return PromotionResult.of(product.name(), product.price() * totalFreeQuantity, totalFreeQuantity);
+ }
+
+ @Override
+ public PromotionConditionResult checkCondition(Product product, int quantity) {
+ int setCountFromRequest = getApplicableSetCount(quantity);
+ int setCountFromStock = getApplicableSetCount(product.stock());
+ int applicableSetCount = Math.min(setCountFromRequest, setCountFromStock);
+ int stockUsed = applicableSetCount * getPromotionSetSize();
+ int remainingQuantity = quantity - stockUsed;
+
+ String message = getConditionMessage(product, product.stock() - stockUsed, remainingQuantity);
+ return PromotionConditionResult.from(applicableSetCount, stockUsed, remainingQuantity, message);
+ }
+
+ private String getConditionMessage(Product product, int remainingStock, int remainingQuantity) {
+ if (remainingQuantity == purchaseQuantity && remainingStock > purchaseQuantity) {
+ return GET_FREE_M_NOTICE.message(product.name(), freeQuantity);
+ }
+ if (remainingQuantity >= getPromotionSetSize()) {
+ return OUT_OF_STOCK_NOTICE.message(product.name(), remainingQuantity);
+ }
+ return DEFAULT_NOTICE.message();
+ }
+
+ private int getPromotionSetSize() {
+ return purchaseQuantity + freeQuantity;
+ }
+
+ private int getApplicableSetCount(int quantity) {
+ return quantity / getPromotionSetSize();
+ }
+
+ private int getRemainingQuantity(int quantity) {
+ return quantity % getPromotionSetSize();
+ }
+} | Java | PromotionStrategy 구현체는 BuyNGetMFreePromotion 뿐 인가요? |
@@ -0,0 +1,14 @@
+package store.common.dto;
+
+public record PromotionConditionResult(
+ int applicableSetCount,
+ int stockUsed,
+ int remainingQuantity,
+ String message
+) {
+ public static PromotionConditionResult from(
+ int applicableSetCount, int stockUsed, int remainingQuantity, String message
+ ) {
+ return new PromotionConditionResult(applicableSetCount, stockUsed, remainingQuantity, message);
+ }
+} | Java | 앗 알고는 있었는데 놓쳤네요..🥲 감사합니다!! |
@@ -0,0 +1,24 @@
+package store.common.dto;
+
+import java.util.Map;
+import java.util.Set;
+
+public record PurchaseRequest(
+ Map<String, Integer> items
+) {
+ public static PurchaseRequest from(Map<String, Integer> cart) {
+ return new PurchaseRequest(cart);
+ }
+
+ public PurchaseProductNames getProductNames() {
+ return PurchaseProductNames.from(items.keySet());
+ }
+
+ public record PurchaseProductNames(
+ Set<String> productNames
+ ) {
+ public static PurchaseProductNames from(Set<String> productNames) {
+ return new PurchaseProductNames(productNames);
+ }
+ }
+} | Java | 상품 이름 목록을 파라미터와 반환값으로 사용하게 되는 경우가 좀 있어서 dto 에 내부 클래스로 정의해 사용했습니다!
근데 좀 통일성이 없다는 느낌이 드네요,, |
@@ -0,0 +1,34 @@
+package store.common.util;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.IntStream;
+
+public class StringUtils {
+
+ public static int parseInt(String message) {
+ try {
+ return Integer.parseInt(message);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ public static List<String> splitWithDelimiter(String message, String delimiter) {
+ return Arrays.stream(message.split(delimiter))
+ .map(String::strip)
+ .toList();
+ }
+
+ public static List<String> extractFromRegex(String message, Pattern regex) {
+ Matcher matcher = regex.matcher(message);
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException();
+ }
+ return IntStream.range(1, matcher.groupCount() + 1)
+ .mapToObj(matcher::group)
+ .toList();
+ }
+} | Java | 아 넵! 어차피 해당 메서드를 사용하는 곳에서 catch 하고 다시 예외를 생성해서 굳이 사용하지 않을 에러 메시지를 정의 해야할까 고민하다가 그냥 비워뒀는데, 지금 보니까 그럴거면 그냥 이 메서드에서는 예외를 잡지 않았으면 됐겠네요..!
급하게 구현하느라 이상한 부분이 많은데 찾아주셔서 감사합니다 😭🙇 |
@@ -0,0 +1,144 @@
+package store.controller;
+
+import static store.common.constant.ErrorMessage.INPUT_INVALID_FORMAT;
+import static store.common.constant.ErrorMessage.PRODUCT_NOT_FOUND_ERROR;
+import static store.common.constant.ErrorMessage.PRODUCT_OUT_OF_STOCK;
+
+import java.io.IOException;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.Locale;
+import java.util.function.Supplier;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import store.common.dto.PurchaseRequest;
+import store.common.dto.PurchaseRequest.PurchaseProductNames;
+import store.common.util.FileReader;
+import store.common.util.StringUtils;
+import store.model.Product;
+import store.model.ProductCatalog;
+import store.model.Products;
+import store.model.Promotion;
+import store.model.PromotionCatalog;
+import store.model.promotion.BuyNGetMFreePromotion;
+import store.model.promotion.PromotionStrategy;
+import store.view.InputView;
+
+public class InputHandler {
+
+ private static final Pattern PURCHASE_ITEM_REGEX = Pattern.compile("^\\[(.+)\\-(.+)\\]$");
+
+ private final InputView inputView;
+
+ public InputHandler(InputView inputView) {
+ this.inputView = inputView;
+ }
+
+ public PromotionCatalog getPromotions() {
+ try {
+ List<String> fileLines = FileReader.readFile("src/main/resources/promotions.md");
+ return PromotionCatalog.from(fileLines.stream()
+ .skip(1)
+ .map(fileLine -> makePromotion(StringUtils.splitWithDelimiter(fileLine, ",")))
+ .collect(Collectors.toMap(Promotion::name, promotion -> promotion))
+ );
+ } catch (IOException e) {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ public ProductCatalog getProducts(PromotionCatalog promotionCatalog) {
+ try {
+ List<String> fileLines = FileReader.readFile("src/main/resources/products.md");
+ return ProductCatalog.from(fileLines.stream()
+ .skip(1)
+ .map(fileLine -> makeProduct(StringUtils.splitWithDelimiter(fileLine, ","), promotionCatalog))
+ .collect(Collectors.toSet())
+ );
+ } catch (IOException e) {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ public PurchaseRequest getPurchaseItems(ProductCatalog productCatalog) {
+ return validate(() -> {
+ List<String> purchaseItems = StringUtils.splitWithDelimiter(inputView.getPurchaseItems(), ",");
+ PurchaseRequest request = getPurchaseRequest(purchaseItems);
+ validateItemsExist(request.getProductNames(), productCatalog);
+ checkItemsStock(request, productCatalog);
+ return request;
+ });
+ }
+
+ private PurchaseRequest getPurchaseRequest(List<String> purchaseItems) {
+ try {
+ return PurchaseRequest.from(
+ purchaseItems.stream()
+ .map(purchaseItem -> StringUtils.extractFromRegex(purchaseItem, PURCHASE_ITEM_REGEX))
+ .collect(Collectors.toMap(item -> item.get(0).strip(),
+ item -> StringUtils.parseInt(item.get(1))))
+ );
+ } catch (IllegalStateException e) {
+ throw new IllegalArgumentException(INPUT_INVALID_FORMAT.message());
+ }
+ }
+
+ public boolean isAffirmative() {
+ return validate(() -> {
+ String yesOrNo = inputView.getYesOrNo().toUpperCase(Locale.ROOT);
+ if (!yesOrNo.equals("Y") && !yesOrNo.equals("N")) {
+ throw new IllegalArgumentException(INPUT_INVALID_FORMAT.message());
+ }
+ return yesOrNo.equals("Y");
+ });
+ }
+
+ private Promotion makePromotion(List<String> promotionValues) {
+ DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE;
+
+ String name = promotionValues.get(0);
+ int purchaseQuantity = StringUtils.parseInt(promotionValues.get(1));
+ int freeQuantity = StringUtils.parseInt(promotionValues.get(2));
+ PromotionStrategy promotionStrategy = new BuyNGetMFreePromotion(purchaseQuantity, freeQuantity);
+ LocalDate startDate = LocalDate.parse(promotionValues.get(3), formatter);
+ LocalDate endDate = LocalDate.parse(promotionValues.get(4), formatter);
+ return Promotion.of(name, promotionStrategy, startDate, endDate);
+ }
+
+ private Product makeProduct(List<String> productValues, PromotionCatalog promotionCatalog) {
+ String name = productValues.get(0);
+ int price = StringUtils.parseInt(productValues.get(1));
+ int stock = StringUtils.parseInt(productValues.get(2));
+ Promotion promotion = promotionCatalog.getPromotionByName(productValues.get(3));
+ return Product.of(name, price, stock, promotion);
+ }
+
+ private void validateItemsExist(PurchaseProductNames productNames, ProductCatalog productCatalog) {
+ boolean doesNotContainsAllProduct = !productCatalog.doesContainsAllProduct(productNames.productNames());
+ if (doesNotContainsAllProduct) {
+ throw new IllegalArgumentException(PRODUCT_NOT_FOUND_ERROR.message());
+ }
+ }
+
+ private void checkItemsStock(PurchaseRequest purchaseItems, ProductCatalog productCatalog) {
+ purchaseItems.items().forEach((productName, quantity) -> {
+ Products product = productCatalog.getProductByName(productName);
+ int totalStock = product.products().stream().mapToInt(Product::stock).sum();
+ boolean isOutOfStock = quantity > totalStock;
+ if (isOutOfStock) {
+ throw new IllegalArgumentException(PRODUCT_OUT_OF_STOCK.message());
+ }
+ });
+ }
+
+ private <T> T validate(Supplier<T> inputSupplier) {
+ while (true) {
+ try {
+ return inputSupplier.get();
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+ }
+} | Java | Locale.ROOT 는 기본 지역 설정으로, 알파벳이 국가에 따라 표기가 다른 경우가 있다고 합니다. 사실 코드 자동완성 기능을 사용했는데 불필요한 부분인 것 같습니다..! |
@@ -0,0 +1,162 @@
+package store.controller;
+
+import static store.common.constant.PromotionNotice.GET_FREE_M_NOTICE;
+import static store.common.constant.PromotionNotice.OUT_OF_STOCK_NOTICE;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import store.common.dto.PromotionConditionResult;
+import store.common.dto.PromotionResult;
+import store.common.dto.PurchaseRequest;
+import store.common.dto.PurchaseRequest.PurchaseProductNames;
+import store.model.Cart;
+import store.model.Product;
+import store.model.ProductCatalog;
+import store.model.Products;
+import store.model.PromotionCatalog;
+import store.model.Receipt;
+import store.view.OutputView;
+
+public class StoreController {
+
+ private final InputHandler inputHandler;
+ private final OutputView outputView;
+
+ private final ProductCatalog productCatalog;
+ private final PromotionCatalog promotionCatalog;
+
+ public StoreController(InputHandler inputHandler, OutputView outputView) {
+ this.inputHandler = inputHandler;
+ this.outputView = outputView;
+ promotionCatalog = inputHandler.getPromotions();
+ productCatalog = inputHandler.getProducts(promotionCatalog);
+ }
+
+ public void run() {
+ PurchaseRequest purchaseItems = getPurchaseRequest();
+ Cart cart = Cart.empty();
+
+ Products promotionalProducts = getPromotionalProducts(purchaseItems.getProductNames());
+ List<PromotionResult> promotionResults = addPromotionalProductToCart(promotionalProducts, purchaseItems, cart);
+ addRegularProductToCart(purchaseItems, cart);
+ int membershipDiscount = applyMembership(cart, promotionalProducts);
+ purchaseProducts(cart);
+ printReceipt(cart, promotionResults, membershipDiscount);
+ repurchaseIfWant();
+ }
+
+ private PurchaseRequest getPurchaseRequest() {
+ outputView.printStoreInventory(productCatalog);
+ return inputHandler.getPurchaseItems(productCatalog);
+ }
+
+ private void addRegularProductToCart(PurchaseRequest purchaseItems, Cart cart) {
+ purchaseItems.items().keySet().forEach(productName -> {
+ Product product = productCatalog.getProductByName(productName).products().stream()
+ .findFirst()
+ .orElseThrow(IllegalArgumentException::new);
+ cart.addProduct(product, purchaseItems.items().get(productName));
+ });
+ }
+
+ private List<PromotionResult> addPromotionalProductToCart(
+ Products promotionalProducts, PurchaseRequest purchaseItems, Cart cart
+ ) {
+ promotionalProducts.products().forEach(product -> {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ PromotionConditionResult conditionResult = product.checkPromotionCondition(purchaseQuantity);
+ handlePromotionCondition(purchaseItems, cart, product, conditionResult);
+ });
+ return applyPromotion(cart);
+ }
+
+ private Products getPromotionalProducts(PurchaseProductNames productNames) {
+ return Products.from(
+ productCatalog.getProductsByNames(productNames.productNames()).products().stream()
+ .filter(Product::isPromotionApplicable)
+ .collect(Collectors.toSet())
+ );
+ }
+
+ private List<PromotionResult> applyPromotion(Cart cart) {
+ return cart.cart().keySet().stream()
+ .filter(Product::isPromotionApplicable)
+ .map(product -> product.applyPromotion(cart.cart().get(product)))
+ .toList();
+ }
+
+ private void handlePromotionCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ if (GET_FREE_M_NOTICE.matches(conditionResult.message())) {
+ handleGetFreeCondition(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ if (OUT_OF_STOCK_NOTICE.matches(conditionResult.message())) {
+ handleOutOfPromotionStock(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ cart.addProduct(product, conditionResult.stockUsed());
+ purchaseItems.items()
+ .replace(product.name(), purchaseItems.items().get(product.name()) - conditionResult.stockUsed());
+ }
+
+ private void handleOutOfPromotionStock(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printPromotionOutOfStockNotice(conditionResult.message());
+ cart.addProduct(product, conditionResult.stockUsed());
+ if (inputHandler.isAffirmative()) {
+ purchaseItems.items().replace(product.name(), purchaseQuantity - conditionResult.stockUsed());
+ return;
+ }
+ purchaseItems.items().remove(product.name());
+ }
+
+ private void handleGetFreeCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printGetFreeNotice(conditionResult.message());
+ if (inputHandler.isAffirmative()) {
+ cart.addProduct(product, purchaseQuantity + 1);
+ purchaseItems.items().remove(product.name());
+ return;
+ }
+ cart.addProduct(product, purchaseQuantity);
+ purchaseItems.items().remove(product.name());
+ }
+
+ private int applyMembership(Cart cart, Products promotionalProducts) {
+ outputView.printMembershipNotice();
+ AtomicInteger discountAmount = new AtomicInteger();
+ if (inputHandler.isAffirmative()) {
+ cart.cart().forEach((product, quantity) -> {
+ if (promotionalProducts.products().contains(product)) {
+ return;
+ }
+ discountAmount.addAndGet(product.price() * quantity);
+ });
+ }
+ discountAmount.updateAndGet(value -> Math.min(value * 30 / 100, 8000));
+ return discountAmount.get();
+ }
+
+ private static void purchaseProducts(Cart cart) {
+ cart.cart().forEach(Product::reduceStock);
+ }
+
+ private void printReceipt(Cart cart, List<PromotionResult> promotionResults, int membershipDiscount) {
+ Receipt receipt = Receipt.of(cart, promotionResults, membershipDiscount);
+ outputView.printReceipt(receipt);
+ }
+
+ private void repurchaseIfWant() {
+ outputView.printRepurchaseNotice();
+ if (inputHandler.isAffirmative()) {
+ run();
+ }
+ }
+} | Java | 아하.... 넵.... 단축키로 extract 하면서 확인하지 못했습니다 |
@@ -0,0 +1,162 @@
+package store.controller;
+
+import static store.common.constant.PromotionNotice.GET_FREE_M_NOTICE;
+import static store.common.constant.PromotionNotice.OUT_OF_STOCK_NOTICE;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import store.common.dto.PromotionConditionResult;
+import store.common.dto.PromotionResult;
+import store.common.dto.PurchaseRequest;
+import store.common.dto.PurchaseRequest.PurchaseProductNames;
+import store.model.Cart;
+import store.model.Product;
+import store.model.ProductCatalog;
+import store.model.Products;
+import store.model.PromotionCatalog;
+import store.model.Receipt;
+import store.view.OutputView;
+
+public class StoreController {
+
+ private final InputHandler inputHandler;
+ private final OutputView outputView;
+
+ private final ProductCatalog productCatalog;
+ private final PromotionCatalog promotionCatalog;
+
+ public StoreController(InputHandler inputHandler, OutputView outputView) {
+ this.inputHandler = inputHandler;
+ this.outputView = outputView;
+ promotionCatalog = inputHandler.getPromotions();
+ productCatalog = inputHandler.getProducts(promotionCatalog);
+ }
+
+ public void run() {
+ PurchaseRequest purchaseItems = getPurchaseRequest();
+ Cart cart = Cart.empty();
+
+ Products promotionalProducts = getPromotionalProducts(purchaseItems.getProductNames());
+ List<PromotionResult> promotionResults = addPromotionalProductToCart(promotionalProducts, purchaseItems, cart);
+ addRegularProductToCart(purchaseItems, cart);
+ int membershipDiscount = applyMembership(cart, promotionalProducts);
+ purchaseProducts(cart);
+ printReceipt(cart, promotionResults, membershipDiscount);
+ repurchaseIfWant();
+ }
+
+ private PurchaseRequest getPurchaseRequest() {
+ outputView.printStoreInventory(productCatalog);
+ return inputHandler.getPurchaseItems(productCatalog);
+ }
+
+ private void addRegularProductToCart(PurchaseRequest purchaseItems, Cart cart) {
+ purchaseItems.items().keySet().forEach(productName -> {
+ Product product = productCatalog.getProductByName(productName).products().stream()
+ .findFirst()
+ .orElseThrow(IllegalArgumentException::new);
+ cart.addProduct(product, purchaseItems.items().get(productName));
+ });
+ }
+
+ private List<PromotionResult> addPromotionalProductToCart(
+ Products promotionalProducts, PurchaseRequest purchaseItems, Cart cart
+ ) {
+ promotionalProducts.products().forEach(product -> {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ PromotionConditionResult conditionResult = product.checkPromotionCondition(purchaseQuantity);
+ handlePromotionCondition(purchaseItems, cart, product, conditionResult);
+ });
+ return applyPromotion(cart);
+ }
+
+ private Products getPromotionalProducts(PurchaseProductNames productNames) {
+ return Products.from(
+ productCatalog.getProductsByNames(productNames.productNames()).products().stream()
+ .filter(Product::isPromotionApplicable)
+ .collect(Collectors.toSet())
+ );
+ }
+
+ private List<PromotionResult> applyPromotion(Cart cart) {
+ return cart.cart().keySet().stream()
+ .filter(Product::isPromotionApplicable)
+ .map(product -> product.applyPromotion(cart.cart().get(product)))
+ .toList();
+ }
+
+ private void handlePromotionCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ if (GET_FREE_M_NOTICE.matches(conditionResult.message())) {
+ handleGetFreeCondition(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ if (OUT_OF_STOCK_NOTICE.matches(conditionResult.message())) {
+ handleOutOfPromotionStock(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ cart.addProduct(product, conditionResult.stockUsed());
+ purchaseItems.items()
+ .replace(product.name(), purchaseItems.items().get(product.name()) - conditionResult.stockUsed());
+ }
+
+ private void handleOutOfPromotionStock(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printPromotionOutOfStockNotice(conditionResult.message());
+ cart.addProduct(product, conditionResult.stockUsed());
+ if (inputHandler.isAffirmative()) {
+ purchaseItems.items().replace(product.name(), purchaseQuantity - conditionResult.stockUsed());
+ return;
+ }
+ purchaseItems.items().remove(product.name());
+ }
+
+ private void handleGetFreeCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printGetFreeNotice(conditionResult.message());
+ if (inputHandler.isAffirmative()) {
+ cart.addProduct(product, purchaseQuantity + 1);
+ purchaseItems.items().remove(product.name());
+ return;
+ }
+ cart.addProduct(product, purchaseQuantity);
+ purchaseItems.items().remove(product.name());
+ }
+
+ private int applyMembership(Cart cart, Products promotionalProducts) {
+ outputView.printMembershipNotice();
+ AtomicInteger discountAmount = new AtomicInteger();
+ if (inputHandler.isAffirmative()) {
+ cart.cart().forEach((product, quantity) -> {
+ if (promotionalProducts.products().contains(product)) {
+ return;
+ }
+ discountAmount.addAndGet(product.price() * quantity);
+ });
+ }
+ discountAmount.updateAndGet(value -> Math.min(value * 30 / 100, 8000));
+ return discountAmount.get();
+ }
+
+ private static void purchaseProducts(Cart cart) {
+ cart.cart().forEach(Product::reduceStock);
+ }
+
+ private void printReceipt(Cart cart, List<PromotionResult> promotionResults, int membershipDiscount) {
+ Receipt receipt = Receipt.of(cart, promotionResults, membershipDiscount);
+ outputView.printReceipt(receipt);
+ }
+
+ private void repurchaseIfWant() {
+ outputView.printRepurchaseNotice();
+ if (inputHandler.isAffirmative()) {
+ run();
+ }
+ }
+} | Java | 맞습니다 이것도 과제 마감 후에 발견했어요.. |
@@ -0,0 +1,65 @@
+package store.model;
+
+import java.util.List;
+import store.common.dto.PromotionResult;
+
+public class Receipt {
+
+ private final Cart cart;
+ private final List<PromotionResult> promotionResults;
+ private final int totalPrice;
+ private final int promotionDiscount;
+ private final int membershipDiscount;
+ private final int paymentPrice;
+
+ private Receipt(
+ Cart cart,
+ List<PromotionResult> promotionResults,
+ int totalPrice,
+ int promotionDiscount,
+ int membershipDiscount,
+ int paymentPrice
+ ) {
+ this.cart = cart;
+ this.promotionResults = promotionResults;
+ this.totalPrice = totalPrice;
+ this.promotionDiscount = promotionDiscount;
+ this.membershipDiscount = membershipDiscount;
+ this.paymentPrice = paymentPrice;
+ }
+
+ public static Receipt of(Cart cart, List<PromotionResult> promotionResults, int membershipDiscount) {
+ int totalPrice = cart.cart().entrySet().stream()
+ .mapToInt(entry -> entry.getKey().price() * entry.getValue())
+ .sum();
+ int promotionDiscount = promotionResults.stream()
+ .mapToInt(PromotionResult::discountAmount)
+ .sum();
+ return new Receipt(cart, promotionResults, totalPrice, promotionDiscount, membershipDiscount,
+ totalPrice - promotionDiscount - membershipDiscount);
+ }
+
+ public Cart cart() {
+ return cart;
+ }
+
+ public List<PromotionResult> promotionResults() {
+ return promotionResults;
+ }
+
+ public int totalPrice() {
+ return totalPrice;
+ }
+
+ public int promotionDiscount() {
+ return promotionDiscount;
+ }
+
+ public int membershipDiscount() {
+ return membershipDiscount;
+ }
+
+ public int paymentPrice() {
+ return paymentPrice;
+ }
+} | Java | 오호 totalPrice 와 promotionDiscount 를 계산하는 부분을 분리할 수 있겠네요! 감사합니다!! |
@@ -0,0 +1,162 @@
+package store.controller;
+
+import static store.common.constant.PromotionNotice.GET_FREE_M_NOTICE;
+import static store.common.constant.PromotionNotice.OUT_OF_STOCK_NOTICE;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import store.common.dto.PromotionConditionResult;
+import store.common.dto.PromotionResult;
+import store.common.dto.PurchaseRequest;
+import store.common.dto.PurchaseRequest.PurchaseProductNames;
+import store.model.Cart;
+import store.model.Product;
+import store.model.ProductCatalog;
+import store.model.Products;
+import store.model.PromotionCatalog;
+import store.model.Receipt;
+import store.view.OutputView;
+
+public class StoreController {
+
+ private final InputHandler inputHandler;
+ private final OutputView outputView;
+
+ private final ProductCatalog productCatalog;
+ private final PromotionCatalog promotionCatalog;
+
+ public StoreController(InputHandler inputHandler, OutputView outputView) {
+ this.inputHandler = inputHandler;
+ this.outputView = outputView;
+ promotionCatalog = inputHandler.getPromotions();
+ productCatalog = inputHandler.getProducts(promotionCatalog);
+ }
+
+ public void run() {
+ PurchaseRequest purchaseItems = getPurchaseRequest();
+ Cart cart = Cart.empty();
+
+ Products promotionalProducts = getPromotionalProducts(purchaseItems.getProductNames());
+ List<PromotionResult> promotionResults = addPromotionalProductToCart(promotionalProducts, purchaseItems, cart);
+ addRegularProductToCart(purchaseItems, cart);
+ int membershipDiscount = applyMembership(cart, promotionalProducts);
+ purchaseProducts(cart);
+ printReceipt(cart, promotionResults, membershipDiscount);
+ repurchaseIfWant();
+ }
+
+ private PurchaseRequest getPurchaseRequest() {
+ outputView.printStoreInventory(productCatalog);
+ return inputHandler.getPurchaseItems(productCatalog);
+ }
+
+ private void addRegularProductToCart(PurchaseRequest purchaseItems, Cart cart) {
+ purchaseItems.items().keySet().forEach(productName -> {
+ Product product = productCatalog.getProductByName(productName).products().stream()
+ .findFirst()
+ .orElseThrow(IllegalArgumentException::new);
+ cart.addProduct(product, purchaseItems.items().get(productName));
+ });
+ }
+
+ private List<PromotionResult> addPromotionalProductToCart(
+ Products promotionalProducts, PurchaseRequest purchaseItems, Cart cart
+ ) {
+ promotionalProducts.products().forEach(product -> {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ PromotionConditionResult conditionResult = product.checkPromotionCondition(purchaseQuantity);
+ handlePromotionCondition(purchaseItems, cart, product, conditionResult);
+ });
+ return applyPromotion(cart);
+ }
+
+ private Products getPromotionalProducts(PurchaseProductNames productNames) {
+ return Products.from(
+ productCatalog.getProductsByNames(productNames.productNames()).products().stream()
+ .filter(Product::isPromotionApplicable)
+ .collect(Collectors.toSet())
+ );
+ }
+
+ private List<PromotionResult> applyPromotion(Cart cart) {
+ return cart.cart().keySet().stream()
+ .filter(Product::isPromotionApplicable)
+ .map(product -> product.applyPromotion(cart.cart().get(product)))
+ .toList();
+ }
+
+ private void handlePromotionCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ if (GET_FREE_M_NOTICE.matches(conditionResult.message())) {
+ handleGetFreeCondition(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ if (OUT_OF_STOCK_NOTICE.matches(conditionResult.message())) {
+ handleOutOfPromotionStock(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ cart.addProduct(product, conditionResult.stockUsed());
+ purchaseItems.items()
+ .replace(product.name(), purchaseItems.items().get(product.name()) - conditionResult.stockUsed());
+ }
+
+ private void handleOutOfPromotionStock(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printPromotionOutOfStockNotice(conditionResult.message());
+ cart.addProduct(product, conditionResult.stockUsed());
+ if (inputHandler.isAffirmative()) {
+ purchaseItems.items().replace(product.name(), purchaseQuantity - conditionResult.stockUsed());
+ return;
+ }
+ purchaseItems.items().remove(product.name());
+ }
+
+ private void handleGetFreeCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printGetFreeNotice(conditionResult.message());
+ if (inputHandler.isAffirmative()) {
+ cart.addProduct(product, purchaseQuantity + 1);
+ purchaseItems.items().remove(product.name());
+ return;
+ }
+ cart.addProduct(product, purchaseQuantity);
+ purchaseItems.items().remove(product.name());
+ }
+
+ private int applyMembership(Cart cart, Products promotionalProducts) {
+ outputView.printMembershipNotice();
+ AtomicInteger discountAmount = new AtomicInteger();
+ if (inputHandler.isAffirmative()) {
+ cart.cart().forEach((product, quantity) -> {
+ if (promotionalProducts.products().contains(product)) {
+ return;
+ }
+ discountAmount.addAndGet(product.price() * quantity);
+ });
+ }
+ discountAmount.updateAndGet(value -> Math.min(value * 30 / 100, 8000));
+ return discountAmount.get();
+ }
+
+ private static void purchaseProducts(Cart cart) {
+ cart.cart().forEach(Product::reduceStock);
+ }
+
+ private void printReceipt(Cart cart, List<PromotionResult> promotionResults, int membershipDiscount) {
+ Receipt receipt = Receipt.of(cart, promotionResults, membershipDiscount);
+ outputView.printReceipt(receipt);
+ }
+
+ private void repurchaseIfWant() {
+ outputView.printRepurchaseNotice();
+ if (inputHandler.isAffirmative()) {
+ run();
+ }
+ }
+} | Java | 아 코드 스타일에 우테코 스키마를 적용하니까 라인이 길어지면 마지막 인자값만 개행돼더라구요.. 통일성이 없어보이는데 또 하나하나 개행하자니 너무 길어보여서 그냥 이렇게 해봤습니다! @discphy 님은 파라미터 개수가 많아질 때 어떻게 포맷팅하시나요? |
@@ -0,0 +1,60 @@
+package store.model.promotion;
+
+import static store.common.constant.PromotionNotice.DEFAULT_NOTICE;
+import static store.common.constant.PromotionNotice.GET_FREE_M_NOTICE;
+import static store.common.constant.PromotionNotice.OUT_OF_STOCK_NOTICE;
+
+import store.common.dto.PromotionConditionResult;
+import store.common.dto.PromotionResult;
+import store.model.Product;
+
+public class BuyNGetMFreePromotion implements PromotionStrategy {
+
+ private final int purchaseQuantity;
+ private final int freeQuantity;
+
+ public BuyNGetMFreePromotion(int purchaseQuantity, int freeQuantity) {
+ this.purchaseQuantity = purchaseQuantity;
+ this.freeQuantity = freeQuantity;
+ }
+
+ @Override
+ public PromotionResult applyPromotion(Product product, int quantity) {
+ int totalFreeQuantity = getApplicableSetCount(quantity) * freeQuantity;
+ return PromotionResult.of(product.name(), product.price() * totalFreeQuantity, totalFreeQuantity);
+ }
+
+ @Override
+ public PromotionConditionResult checkCondition(Product product, int quantity) {
+ int setCountFromRequest = getApplicableSetCount(quantity);
+ int setCountFromStock = getApplicableSetCount(product.stock());
+ int applicableSetCount = Math.min(setCountFromRequest, setCountFromStock);
+ int stockUsed = applicableSetCount * getPromotionSetSize();
+ int remainingQuantity = quantity - stockUsed;
+
+ String message = getConditionMessage(product, product.stock() - stockUsed, remainingQuantity);
+ return PromotionConditionResult.from(applicableSetCount, stockUsed, remainingQuantity, message);
+ }
+
+ private String getConditionMessage(Product product, int remainingStock, int remainingQuantity) {
+ if (remainingQuantity == purchaseQuantity && remainingStock > purchaseQuantity) {
+ return GET_FREE_M_NOTICE.message(product.name(), freeQuantity);
+ }
+ if (remainingQuantity >= getPromotionSetSize()) {
+ return OUT_OF_STOCK_NOTICE.message(product.name(), remainingQuantity);
+ }
+ return DEFAULT_NOTICE.message();
+ }
+
+ private int getPromotionSetSize() {
+ return purchaseQuantity + freeQuantity;
+ }
+
+ private int getApplicableSetCount(int quantity) {
+ return quantity / getPromotionSetSize();
+ }
+
+ private int getRemainingQuantity(int quantity) {
+ return quantity % getPromotionSetSize();
+ }
+} | Java | 아 넵! 이 부분은 인터페이스로 확장성 있게 만들어 보고 싶었는데, 구현은 모두 요구사항 범위 내에서만 했습니다 |
@@ -0,0 +1,162 @@
+package store.controller;
+
+import static store.common.constant.PromotionNotice.GET_FREE_M_NOTICE;
+import static store.common.constant.PromotionNotice.OUT_OF_STOCK_NOTICE;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import store.common.dto.PromotionConditionResult;
+import store.common.dto.PromotionResult;
+import store.common.dto.PurchaseRequest;
+import store.common.dto.PurchaseRequest.PurchaseProductNames;
+import store.model.Cart;
+import store.model.Product;
+import store.model.ProductCatalog;
+import store.model.Products;
+import store.model.PromotionCatalog;
+import store.model.Receipt;
+import store.view.OutputView;
+
+public class StoreController {
+
+ private final InputHandler inputHandler;
+ private final OutputView outputView;
+
+ private final ProductCatalog productCatalog;
+ private final PromotionCatalog promotionCatalog;
+
+ public StoreController(InputHandler inputHandler, OutputView outputView) {
+ this.inputHandler = inputHandler;
+ this.outputView = outputView;
+ promotionCatalog = inputHandler.getPromotions();
+ productCatalog = inputHandler.getProducts(promotionCatalog);
+ }
+
+ public void run() {
+ PurchaseRequest purchaseItems = getPurchaseRequest();
+ Cart cart = Cart.empty();
+
+ Products promotionalProducts = getPromotionalProducts(purchaseItems.getProductNames());
+ List<PromotionResult> promotionResults = addPromotionalProductToCart(promotionalProducts, purchaseItems, cart);
+ addRegularProductToCart(purchaseItems, cart);
+ int membershipDiscount = applyMembership(cart, promotionalProducts);
+ purchaseProducts(cart);
+ printReceipt(cart, promotionResults, membershipDiscount);
+ repurchaseIfWant();
+ }
+
+ private PurchaseRequest getPurchaseRequest() {
+ outputView.printStoreInventory(productCatalog);
+ return inputHandler.getPurchaseItems(productCatalog);
+ }
+
+ private void addRegularProductToCart(PurchaseRequest purchaseItems, Cart cart) {
+ purchaseItems.items().keySet().forEach(productName -> {
+ Product product = productCatalog.getProductByName(productName).products().stream()
+ .findFirst()
+ .orElseThrow(IllegalArgumentException::new);
+ cart.addProduct(product, purchaseItems.items().get(productName));
+ });
+ }
+
+ private List<PromotionResult> addPromotionalProductToCart(
+ Products promotionalProducts, PurchaseRequest purchaseItems, Cart cart
+ ) {
+ promotionalProducts.products().forEach(product -> {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ PromotionConditionResult conditionResult = product.checkPromotionCondition(purchaseQuantity);
+ handlePromotionCondition(purchaseItems, cart, product, conditionResult);
+ });
+ return applyPromotion(cart);
+ }
+
+ private Products getPromotionalProducts(PurchaseProductNames productNames) {
+ return Products.from(
+ productCatalog.getProductsByNames(productNames.productNames()).products().stream()
+ .filter(Product::isPromotionApplicable)
+ .collect(Collectors.toSet())
+ );
+ }
+
+ private List<PromotionResult> applyPromotion(Cart cart) {
+ return cart.cart().keySet().stream()
+ .filter(Product::isPromotionApplicable)
+ .map(product -> product.applyPromotion(cart.cart().get(product)))
+ .toList();
+ }
+
+ private void handlePromotionCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ if (GET_FREE_M_NOTICE.matches(conditionResult.message())) {
+ handleGetFreeCondition(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ if (OUT_OF_STOCK_NOTICE.matches(conditionResult.message())) {
+ handleOutOfPromotionStock(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ cart.addProduct(product, conditionResult.stockUsed());
+ purchaseItems.items()
+ .replace(product.name(), purchaseItems.items().get(product.name()) - conditionResult.stockUsed());
+ }
+
+ private void handleOutOfPromotionStock(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printPromotionOutOfStockNotice(conditionResult.message());
+ cart.addProduct(product, conditionResult.stockUsed());
+ if (inputHandler.isAffirmative()) {
+ purchaseItems.items().replace(product.name(), purchaseQuantity - conditionResult.stockUsed());
+ return;
+ }
+ purchaseItems.items().remove(product.name());
+ }
+
+ private void handleGetFreeCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printGetFreeNotice(conditionResult.message());
+ if (inputHandler.isAffirmative()) {
+ cart.addProduct(product, purchaseQuantity + 1);
+ purchaseItems.items().remove(product.name());
+ return;
+ }
+ cart.addProduct(product, purchaseQuantity);
+ purchaseItems.items().remove(product.name());
+ }
+
+ private int applyMembership(Cart cart, Products promotionalProducts) {
+ outputView.printMembershipNotice();
+ AtomicInteger discountAmount = new AtomicInteger();
+ if (inputHandler.isAffirmative()) {
+ cart.cart().forEach((product, quantity) -> {
+ if (promotionalProducts.products().contains(product)) {
+ return;
+ }
+ discountAmount.addAndGet(product.price() * quantity);
+ });
+ }
+ discountAmount.updateAndGet(value -> Math.min(value * 30 / 100, 8000));
+ return discountAmount.get();
+ }
+
+ private static void purchaseProducts(Cart cart) {
+ cart.cart().forEach(Product::reduceStock);
+ }
+
+ private void printReceipt(Cart cart, List<PromotionResult> promotionResults, int membershipDiscount) {
+ Receipt receipt = Receipt.of(cart, promotionResults, membershipDiscount);
+ outputView.printReceipt(receipt);
+ }
+
+ private void repurchaseIfWant() {
+ outputView.printRepurchaseNotice();
+ if (inputHandler.isAffirmative()) {
+ run();
+ }
+ }
+} | Java | 저는 나름대로의 컨벤션을 유지하려고 하는데 되도록이면(?) 인자값이 3개가 넘어가면 Dto 객체로 분리하곤 합니다! 🙃 |
@@ -0,0 +1,162 @@
+package store.controller;
+
+import static store.common.constant.PromotionNotice.GET_FREE_M_NOTICE;
+import static store.common.constant.PromotionNotice.OUT_OF_STOCK_NOTICE;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+import store.common.dto.PromotionConditionResult;
+import store.common.dto.PromotionResult;
+import store.common.dto.PurchaseRequest;
+import store.common.dto.PurchaseRequest.PurchaseProductNames;
+import store.model.Cart;
+import store.model.Product;
+import store.model.ProductCatalog;
+import store.model.Products;
+import store.model.PromotionCatalog;
+import store.model.Receipt;
+import store.view.OutputView;
+
+public class StoreController {
+
+ private final InputHandler inputHandler;
+ private final OutputView outputView;
+
+ private final ProductCatalog productCatalog;
+ private final PromotionCatalog promotionCatalog;
+
+ public StoreController(InputHandler inputHandler, OutputView outputView) {
+ this.inputHandler = inputHandler;
+ this.outputView = outputView;
+ promotionCatalog = inputHandler.getPromotions();
+ productCatalog = inputHandler.getProducts(promotionCatalog);
+ }
+
+ public void run() {
+ PurchaseRequest purchaseItems = getPurchaseRequest();
+ Cart cart = Cart.empty();
+
+ Products promotionalProducts = getPromotionalProducts(purchaseItems.getProductNames());
+ List<PromotionResult> promotionResults = addPromotionalProductToCart(promotionalProducts, purchaseItems, cart);
+ addRegularProductToCart(purchaseItems, cart);
+ int membershipDiscount = applyMembership(cart, promotionalProducts);
+ purchaseProducts(cart);
+ printReceipt(cart, promotionResults, membershipDiscount);
+ repurchaseIfWant();
+ }
+
+ private PurchaseRequest getPurchaseRequest() {
+ outputView.printStoreInventory(productCatalog);
+ return inputHandler.getPurchaseItems(productCatalog);
+ }
+
+ private void addRegularProductToCart(PurchaseRequest purchaseItems, Cart cart) {
+ purchaseItems.items().keySet().forEach(productName -> {
+ Product product = productCatalog.getProductByName(productName).products().stream()
+ .findFirst()
+ .orElseThrow(IllegalArgumentException::new);
+ cart.addProduct(product, purchaseItems.items().get(productName));
+ });
+ }
+
+ private List<PromotionResult> addPromotionalProductToCart(
+ Products promotionalProducts, PurchaseRequest purchaseItems, Cart cart
+ ) {
+ promotionalProducts.products().forEach(product -> {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ PromotionConditionResult conditionResult = product.checkPromotionCondition(purchaseQuantity);
+ handlePromotionCondition(purchaseItems, cart, product, conditionResult);
+ });
+ return applyPromotion(cart);
+ }
+
+ private Products getPromotionalProducts(PurchaseProductNames productNames) {
+ return Products.from(
+ productCatalog.getProductsByNames(productNames.productNames()).products().stream()
+ .filter(Product::isPromotionApplicable)
+ .collect(Collectors.toSet())
+ );
+ }
+
+ private List<PromotionResult> applyPromotion(Cart cart) {
+ return cart.cart().keySet().stream()
+ .filter(Product::isPromotionApplicable)
+ .map(product -> product.applyPromotion(cart.cart().get(product)))
+ .toList();
+ }
+
+ private void handlePromotionCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ if (GET_FREE_M_NOTICE.matches(conditionResult.message())) {
+ handleGetFreeCondition(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ if (OUT_OF_STOCK_NOTICE.matches(conditionResult.message())) {
+ handleOutOfPromotionStock(purchaseItems, cart, product, conditionResult);
+ return;
+ }
+ cart.addProduct(product, conditionResult.stockUsed());
+ purchaseItems.items()
+ .replace(product.name(), purchaseItems.items().get(product.name()) - conditionResult.stockUsed());
+ }
+
+ private void handleOutOfPromotionStock(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printPromotionOutOfStockNotice(conditionResult.message());
+ cart.addProduct(product, conditionResult.stockUsed());
+ if (inputHandler.isAffirmative()) {
+ purchaseItems.items().replace(product.name(), purchaseQuantity - conditionResult.stockUsed());
+ return;
+ }
+ purchaseItems.items().remove(product.name());
+ }
+
+ private void handleGetFreeCondition(
+ PurchaseRequest purchaseItems, Cart cart, Product product, PromotionConditionResult conditionResult
+ ) {
+ int purchaseQuantity = purchaseItems.items().get(product.name());
+ outputView.printGetFreeNotice(conditionResult.message());
+ if (inputHandler.isAffirmative()) {
+ cart.addProduct(product, purchaseQuantity + 1);
+ purchaseItems.items().remove(product.name());
+ return;
+ }
+ cart.addProduct(product, purchaseQuantity);
+ purchaseItems.items().remove(product.name());
+ }
+
+ private int applyMembership(Cart cart, Products promotionalProducts) {
+ outputView.printMembershipNotice();
+ AtomicInteger discountAmount = new AtomicInteger();
+ if (inputHandler.isAffirmative()) {
+ cart.cart().forEach((product, quantity) -> {
+ if (promotionalProducts.products().contains(product)) {
+ return;
+ }
+ discountAmount.addAndGet(product.price() * quantity);
+ });
+ }
+ discountAmount.updateAndGet(value -> Math.min(value * 30 / 100, 8000));
+ return discountAmount.get();
+ }
+
+ private static void purchaseProducts(Cart cart) {
+ cart.cart().forEach(Product::reduceStock);
+ }
+
+ private void printReceipt(Cart cart, List<PromotionResult> promotionResults, int membershipDiscount) {
+ Receipt receipt = Receipt.of(cart, promotionResults, membershipDiscount);
+ outputView.printReceipt(receipt);
+ }
+
+ private void repurchaseIfWant() {
+ outputView.printRepurchaseNotice();
+ if (inputHandler.isAffirmative()) {
+ run();
+ }
+ }
+} | Java | 아하 dto 로 분리하시는군요! 말씀 감사합니다 😊 |
@@ -0,0 +1,121 @@
+package store.model;
+
+import java.text.NumberFormat;
+import java.time.LocalDateTime;
+import java.util.Locale;
+
+public class Product {
+ private static final String PRICE_UNIT = "원";
+ private static final String STOCK_UNIT = "%d개";
+ private static final String OUT_OF_STOCK = "재고 없음";
+
+ private String name;
+ private int price;
+ private int quantity;
+ private Promotion promotion;
+
+ public Product(String name, int price, int quantity, Promotion promotion) {
+ this.name = name;
+ this.price = price;
+ this.quantity = quantity;
+ this.promotion = promotion;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public int getPrice() {
+ return price;
+ }
+
+ public int getQuantity() {
+ return quantity;
+ }
+
+ public Promotion getPromotion() {
+ return promotion;
+ }
+
+ public int getPromotionGet() {
+ if (promotion == null) {
+ return 0;
+ }
+ return this.promotion.getGet();
+ }
+
+ public boolean isPromotion() {
+ return promotion != null;
+ }
+
+ public boolean matchName(String name) {
+ return this.name.equals(name);
+ }
+
+ public boolean inStock() {
+ return quantity > 0;
+ }
+
+ public boolean canBuy(int quantity) {
+ return this.quantity >= quantity;
+ }
+
+ public void decreaseQuantity(int amount) {
+ quantity -= amount;
+ }
+
+ public boolean isApplyPromotion(LocalDateTime localDateTime) {
+ if (promotion == null) {
+ return false;
+ }
+ return promotion.isApplyPromotion(localDateTime);
+ }
+
+ public boolean canGetForFreeByPromotion(int quantity) {
+ if (promotion == null) {
+ return false;
+ }
+ return this.promotion.canGetForFree(quantity) && this.quantity - quantity >= this.promotion.getGet();
+ }
+
+ public int getMaxCanGetForFreeByPromotion(int quantity) {
+ if (promotion == null) {
+ return 0;
+ }
+ if (quantity > this.quantity) {
+ quantity = this.quantity;
+ }
+ return this.promotion.getMaxCanGetForFree(quantity);
+ }
+
+ public int getMaxCanApplyPromotion(int quantity) {
+ if (promotion == null) {
+ return 0;
+ }
+ if (quantity > this.quantity) {
+ quantity = this.quantity;
+ }
+ return this.promotion.getMaxCanApply(quantity);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append(name).append(" ");
+ sb.append(formatCurrency(price)).append(" ");
+ String stock = String.format(STOCK_UNIT, quantity);
+ if (quantity == 0) {
+ stock = OUT_OF_STOCK;
+ }
+ sb.append(stock).append(" ");
+ if (promotion != null) {
+ sb.append(promotion.getName());
+ }
+ return sb.toString();
+ }
+
+ private String formatCurrency(int price) {
+ NumberFormat numberFormat = NumberFormat.getNumberInstance(Locale.KOREA);
+ return numberFormat.format(price) + PRICE_UNIT;
+ }
+} | Java | quantity를 제외한 다른 필드들은 변경될 여지가 없다고 생각되는데, final 설정을 하지 않으신 이유가 궁금합니다! |
@@ -0,0 +1,125 @@
+package store.service;
+
+import camp.nextstep.edu.missionutils.DateTimes;
+import java.util.ArrayList;
+import java.util.List;
+import store.model.Item;
+import store.model.Product;
+import store.model.Products;
+import store.model.PromotionApplyStatus;
+import store.util.constants.ServiceConstants;
+
+public class StoreService {
+
+ public StoreService() {
+ }
+
+ public PromotionApplyStatus checkPromotionState(Products products, Item item) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ if (product == null || !product.inStock() || !product.isApplyPromotion(DateTimes.now())) {
+ return PromotionApplyStatus.NO_PROMOTION;
+ }
+ if (product.canGetForFreeByPromotion(item.getQuantity())) {
+ return PromotionApplyStatus.NEED_GET;
+ }
+ if (!product.canBuy(item.getQuantity()) || !product.canBuy(item.getQuantity() + product.getPromotionGet())) {
+ return PromotionApplyStatus.NOT_ENOUGH_STOCK;
+ }
+ return PromotionApplyStatus.NO_PROMOTION;
+ }
+
+ public String getPromotionMessage(Products products, Item item, PromotionApplyStatus promotionApplyStatus) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ if (promotionApplyStatus == PromotionApplyStatus.NOT_ENOUGH_STOCK) {
+ int applyPromotion = product.getMaxCanApplyPromotion(item.getQuantity());
+ int notApplyPromotionCount = item.getQuantity() - applyPromotion;
+ return String.format(promotionApplyStatus.getMessage(), item.getName(), notApplyPromotionCount);
+ }
+ if (promotionApplyStatus == PromotionApplyStatus.NEED_GET) {
+ return String.format(promotionApplyStatus.getMessage(), item.getName());
+ }
+ return promotionApplyStatus.getMessage();
+ }
+
+ public void processQuantityByPromotion(Item item, PromotionApplyStatus promotionApplyStatus, String input,
+ Products products) {
+ if (promotionApplyStatus == PromotionApplyStatus.NEED_GET && input.equals(ServiceConstants.YES)) {
+ addGetToItem(item, products);
+ return;
+ }
+ if (promotionApplyStatus == PromotionApplyStatus.NOT_ENOUGH_STOCK && input.equals(ServiceConstants.NO)) {
+ takeOffFormItem(item, products);
+ }
+ }
+
+ private void addGetToItem(Item item, Products products) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ int get = product.getPromotionGet();
+ item.addQuantity(get);
+ }
+
+ private void takeOffFormItem(Item item, Products products) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ int applyPromotion = product.getMaxCanApplyPromotion(item.getQuantity());
+ int notApplyPromotionCount = item.getQuantity() - applyPromotion;
+ item.takeOffQuantity(notApplyPromotionCount);
+ }
+
+ public List<Item> getItemsForFreeByPromotion(Products products, List<Item> items) {
+ List<Item> freeItems = new ArrayList<>();
+ for (Item item : items) {
+ int getForFree = getGetCountByPromotion(products, item);
+ if (getForFree == 0) {
+ continue;
+ }
+ freeItems.add(new Item(item.getName(), getForFree));
+ }
+ return freeItems;
+ }
+
+ private int getGetCountByPromotion(Products products, Item item) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ if (product == null || !product.isApplyPromotion(DateTimes.now())) {
+ return 0;
+ }
+ return product.getMaxCanGetForFreeByPromotion(item.getQuantity());
+ }
+
+ public void processStock(Products products, List<Item> items) {
+ for (Item item : items) {
+ int quantity = processPromotionProduct(products, item);
+ processNotPromotionProduct(products, item, quantity);
+ }
+ }
+
+ private int processPromotionProduct(Products products, Item item) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ int quantity = item.getQuantity();
+ if (product != null) {
+ quantity = decreaseProductQuantity(product, quantity);
+ }
+ return quantity;
+ }
+
+ private void processNotPromotionProduct(Products products, Item item, int quantity) {
+ Product product = products.findProductByNameAndPromotionIsNull(item.getName());
+ if (quantity == 0 || product == null) {
+ return;
+ }
+ product.decreaseQuantity(quantity);
+ }
+
+ private int decreaseProductQuantity(Product product, int quantity) {
+ if (product.canBuy(quantity)) {
+ product.decreaseQuantity(quantity);
+ return 0;
+ }
+ int remainingQuantity = quantity - product.getQuantity();
+ product.decreaseQuantity(product.getQuantity());
+ return remainingQuantity;
+ }
+
+ public boolean isContinue(String input) {
+ return input.equals(ServiceConstants.YES);
+ }
+} | Java | StoreService가 여러 종류의 로직을 가지고 있는 것으로 보이는데(promotion, product, item), 병규님께서 정의하신 StoreService 클래스의 책임이 궁금합니다! |
@@ -0,0 +1,26 @@
+package store.util.constants;
+
+public class ViewConstants {
+ // inputView
+ public static final String INPUT_ITEM_MESSAGE = "구매하실 상품명과 수량을 입력해 주세요. (예: [사이다-2],[감자칩-1])";
+ public static final String ITEM_INPUT_FORMAT = "^\\[(\\w|[가-힣]|.)+-\\d+\\](,\\[(\\w|[가-힣]|.)+-\\d+\\])*$";
+ public static final String ERROR_INPUT_FORMAT = "[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.";
+ public static final String INPUT_MEMBERSHIP_YN_MESSAGE = "멤버십 할인을 받으시겠습니까? (Y/N)";
+ public static final String INPUT_CONTINUE_YN_MESSAGE = "감사합니다. 구매하고 싶은 다른 상품이 있나요? (Y/N)";
+ // outputView
+ public static final String WELCOME_MESSAGE = "안녕하세요. W편의점입니다.";
+ public static final String PRODUCT_INTRODUCE_MESSAGE = "현재 보유하고 있는 상품입니다.";
+ public static final String RECEIPT_HEADER = "\n==============W 편의점================";
+ public static final String RECEIPT_MIDDLE = "=============증\t정===============";
+ public static final String RECEIPT_BOTTOM = "====================================\n";
+ public static final String RECEIPT_HEADER_FORMAT = "%-10s %5s %15s";
+ public static final String RECEIPT_FORMAT = "%-10s %5d %15s";
+ public static final String RECEIPT_BOTTOM_FORMAT = "%-10s %20s\n";
+ public static final String RECEIPT_PRODUCT_NAME = "상품명";
+ public static final String RECEIPT_QUANTITY = "수량";
+ public static final String RECEIPT_AMOUNT = "금액";
+ public static final String RECEIPT_TOTAL_PRICE = "총구매액";
+ public static final String RECEIPT_PROMOTION_DISCOUNT = "행사할인";
+ public static final String RECEIPT_MEMBERSHIP_DISCOUNT = "멤버십할인";
+ public static final String RECEIPT_PAYMENT = "내실돈";
+} | Java | ViewConstants 클래스와 ServiceConstants 클래스를 별도로 정의하신 이유가 궁금합니다! |
@@ -0,0 +1,109 @@
+package store.service;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import store.model.Item;
+import store.model.Product;
+import store.model.Products;
+import store.model.Promotion;
+import store.model.PromotionApplyStatus;
+import store.util.Converter;
+
+class StoreServiceTest {
+ ItemService itemService;
+ StoreService storeService;
+ Converter converter;
+ Products products;
+ List<Item> items;
+
+ @BeforeEach
+ void setUp() {
+ converter = new Converter();
+ itemService = new ItemService(converter);
+ storeService = new StoreService();
+ products = createProducts();
+ items = createItems();
+ }
+
+ private Products createProducts() {
+ List<Product> products = new ArrayList<>();
+ LocalDateTime start = converter.toLocalDateTime("2024-01-01");
+ LocalDateTime end = converter.toLocalDateTime("2024-12-31");
+ Promotion promotion = new Promotion("탄산2+1", 2, 1, start, end);
+
+ products.add(new Product("콜라", 1000, 10, promotion));
+ products.add(new Product("콜라", 1000, 10, null));
+ products.add(new Product("사이다", 1200, 8, promotion));
+ products.add(new Product("사이다", 1200, 7, null));
+ products.add(new Product("탄산수", 1200, 6, promotion));
+ products.add(new Product("탄산수", 1200, 6, null));
+ return new Products(products);
+ }
+
+ private List<Item> createItems() {
+ String input = "[콜라-2],[탄산수-4],[사이다-10]";
+ return itemService.getItems(products, input);
+ }
+
+ @DisplayName("item의 프로모션 적용 상태를 반환한다")
+ @Test
+ void checkPromotionState() {
+ assertThat(this.storeService.checkPromotionState(products, items.get(0))).isEqualTo(
+ PromotionApplyStatus.NEED_GET);
+ assertThat(this.storeService.checkPromotionState(products, items.get(1))).isEqualTo(
+ PromotionApplyStatus.NO_PROMOTION);
+ assertThat(this.storeService.checkPromotionState(products, items.get(2))).isEqualTo(
+ PromotionApplyStatus.NOT_ENOUGH_STOCK);
+ }
+
+ @DisplayName("프로모션 상태에 따라 안내 메시지를 반환한다")
+ @Test
+ void getPromotionMessage() {
+ assertThat(this.storeService.getPromotionMessage(products, items.get(0), PromotionApplyStatus.NEED_GET))
+ .contains("현재 콜라은(는) 1개를 무료로 더 받을 수 있습니다. 추가하시겠습니까? (Y/N)");
+ assertThat(this.storeService.getPromotionMessage(products, items.get(2), PromotionApplyStatus.NOT_ENOUGH_STOCK))
+ .contains("현재 사이다 4개는 프로모션 할인이 적용되지 않습니다. 그래도 구매하시겠습니까? (Y/N)");
+ }
+
+ @DisplayName("프로모션 상태와 사용자 입력에 따라 item의 수량을 수정한다")
+ @Test
+ void processQuantityByPromotion() {
+ this.storeService.processQuantityByPromotion(items.get(0), PromotionApplyStatus.NEED_GET, "Y", products);
+ this.storeService.processQuantityByPromotion(items.get(2), PromotionApplyStatus.NOT_ENOUGH_STOCK, "N",
+ products);
+
+ assertThat(items.get(0).getQuantity()).isEqualTo(3);
+ assertThat(items.get(1).getQuantity()).isEqualTo(4);
+ assertThat(items.get(2).getQuantity()).isEqualTo(6);
+ }
+
+ @DisplayName("증정품 목록을 반환한다")
+ @Test
+ void getItemsForFreeByPromotion() {
+ List<Item> freeItems = this.storeService.getItemsForFreeByPromotion(products, items);
+
+ assertThat(freeItems.size()).isEqualTo(2);
+ assertThat(freeItems.get(0).getName() + freeItems.get(0).getQuantity()).isEqualTo("탄산수1");
+ assertThat(freeItems.get(1).getName() + freeItems.get(1).getQuantity()).isEqualTo("사이다2");
+ }
+
+ @DisplayName("구매한 상품의 수량만큼 재고를 차감한다")
+ @Test
+ void processStock() {
+ this.storeService.processStock(products, items);
+ List<Product> processProduct = products.getProducts();
+
+ assertThat(processProduct.get(0).getQuantity()).isEqualTo(8);
+ assertThat(processProduct.get(1).getQuantity()).isEqualTo(10);
+ assertThat(processProduct.get(2).getQuantity()).isEqualTo(0);
+ assertThat(processProduct.get(3).getQuantity()).isEqualTo(5);
+ assertThat(processProduct.get(4).getQuantity()).isEqualTo(2);
+ assertThat(processProduct.get(5).getQuantity()).isEqualTo(6);
+ }
+}
\ No newline at end of file | Java | 프로모션 상태나 사용자 입력을 구체적으로 정의해서 시나리오를 나누면
버그가 발생했을 때 그게 어떤 로직 때문인지 디버깅하기 훨씬 쉬워질 것 같습니다! |
@@ -0,0 +1,81 @@
+package store.service;
+
+import camp.nextstep.edu.missionutils.DateTimes;
+import java.util.List;
+import store.model.Item;
+import store.model.Product;
+import store.model.Products;
+import store.model.Receipt;
+import store.util.constants.ServiceConstants;
+
+public class ReceiptService {
+ public ReceiptService() {
+ }
+
+ public Receipt createReceipt(Products products, List<Item> items, boolean applyMembership) {
+ int totalPrice = getTotalPrice(products, items);
+ int discountByPromotion = getPromotionDiscount(products, items);
+ int discountByMembership = 0;
+ if (applyMembership) {
+ discountByMembership = getMembershipDiscount(products, items);
+ }
+ int payment = totalPrice - discountByPromotion - discountByMembership;
+ return new Receipt(items, totalPrice, discountByPromotion, discountByMembership, payment);
+ }
+
+ private int getTotalPrice(Products products, List<Item> items) {
+ int totalPrice = 0;
+ for (Item item : items) {
+ totalPrice += getPrice(products, item);
+ }
+ return totalPrice;
+ }
+
+ private int getPrice(Products products, Item item) {
+ Product product = products.findProductByName(item.getName());
+ return item.getQuantity() * product.getPrice();
+ }
+
+
+ public int getPromotionDiscount(Products products, List<Item> items) {
+ int discount = 0;
+ for (Item item : items) {
+ discount += getPriceForFreeByPromotion(products, item);
+ }
+ return discount;
+ }
+
+ private int getPriceForFreeByPromotion(Products products, Item item) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ if (product == null || !product.isApplyPromotion(DateTimes.now())) {
+ return 0;
+ }
+ int price = product.getPrice();
+ int getFreeCount = product.getMaxCanGetForFreeByPromotion(item.getQuantity());
+ return getFreeCount * price;
+ }
+
+ public int getMembershipDiscount(Products products, List<Item> items) {
+ int totalPriceNotApplyPromotion = 0;
+ for (Item item : items) {
+ totalPriceNotApplyPromotion += getPriceNotApplyPromotion(products, item);
+ }
+ int discount = (int) (totalPriceNotApplyPromotion * ServiceConstants.MEMBERSHIP_DISCOUNT_RATE);
+ if (discount > ServiceConstants.MEMBERSHIP_DISCOUNT_LIMIT) {
+ discount = ServiceConstants.MEMBERSHIP_DISCOUNT_LIMIT;
+ }
+ return discount;
+ }
+
+ private int getPriceNotApplyPromotion(Products products, Item item) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ if (product == null || !product.isApplyPromotion(DateTimes.now())) {
+ product = products.findProductByNameAndPromotionIsNull(item.getName());
+ return item.getQuantity() * product.getPrice();
+ }
+ int price = product.getPrice();
+ int applyPromotion = product.getMaxCanApplyPromotion(item.getQuantity());
+ int notApplyPromotionCount = item.getQuantity() - applyPromotion;
+ return notApplyPromotionCount * price;
+ }
+} | Java | ByPromotion란 네이밍을 포함한 메서드가 많이 보여요!
만약 프로모션에 의한 동작이라면,
프로모션을 포함한 Product에 해당 메서드를 포함시키거나,
프로모션을 독립된 주체로 생각하고 별도의 클래스를 만들었 수도 있을 것 같은데
과제와 같은 구조를 택하신 이유가 궁금합니다! 🤔 |
@@ -0,0 +1,121 @@
+package store.model;
+
+import java.text.NumberFormat;
+import java.time.LocalDateTime;
+import java.util.Locale;
+
+public class Product {
+ private static final String PRICE_UNIT = "원";
+ private static final String STOCK_UNIT = "%d개";
+ private static final String OUT_OF_STOCK = "재고 없음";
+
+ private String name;
+ private int price;
+ private int quantity;
+ private Promotion promotion;
+
+ public Product(String name, int price, int quantity, Promotion promotion) {
+ this.name = name;
+ this.price = price;
+ this.quantity = quantity;
+ this.promotion = promotion;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public int getPrice() {
+ return price;
+ }
+
+ public int getQuantity() {
+ return quantity;
+ }
+
+ public Promotion getPromotion() {
+ return promotion;
+ }
+
+ public int getPromotionGet() {
+ if (promotion == null) {
+ return 0;
+ }
+ return this.promotion.getGet();
+ }
+
+ public boolean isPromotion() {
+ return promotion != null;
+ }
+
+ public boolean matchName(String name) {
+ return this.name.equals(name);
+ }
+
+ public boolean inStock() {
+ return quantity > 0;
+ }
+
+ public boolean canBuy(int quantity) {
+ return this.quantity >= quantity;
+ }
+
+ public void decreaseQuantity(int amount) {
+ quantity -= amount;
+ }
+
+ public boolean isApplyPromotion(LocalDateTime localDateTime) {
+ if (promotion == null) {
+ return false;
+ }
+ return promotion.isApplyPromotion(localDateTime);
+ }
+
+ public boolean canGetForFreeByPromotion(int quantity) {
+ if (promotion == null) {
+ return false;
+ }
+ return this.promotion.canGetForFree(quantity) && this.quantity - quantity >= this.promotion.getGet();
+ }
+
+ public int getMaxCanGetForFreeByPromotion(int quantity) {
+ if (promotion == null) {
+ return 0;
+ }
+ if (quantity > this.quantity) {
+ quantity = this.quantity;
+ }
+ return this.promotion.getMaxCanGetForFree(quantity);
+ }
+
+ public int getMaxCanApplyPromotion(int quantity) {
+ if (promotion == null) {
+ return 0;
+ }
+ if (quantity > this.quantity) {
+ quantity = this.quantity;
+ }
+ return this.promotion.getMaxCanApply(quantity);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append(name).append(" ");
+ sb.append(formatCurrency(price)).append(" ");
+ String stock = String.format(STOCK_UNIT, quantity);
+ if (quantity == 0) {
+ stock = OUT_OF_STOCK;
+ }
+ sb.append(stock).append(" ");
+ if (promotion != null) {
+ sb.append(promotion.getName());
+ }
+ return sb.toString();
+ }
+
+ private String formatCurrency(int price) {
+ NumberFormat numberFormat = NumberFormat.getNumberInstance(Locale.KOREA);
+ return numberFormat.format(price) + PRICE_UNIT;
+ }
+} | Java | 요구 사항을 보면 `quantity` 외에는 변할 게 없지만, `Product`를 설계할 때 '상품의 이름과 가격은 변할 수 있지 않을까?' 라는 생각에 좀 `final`로 설정하지 않았습니다. 지금 보니 앞서나간 부분이라 생각되네요. `final`로 하는 것이 좋아보입니다! |
@@ -0,0 +1,125 @@
+package store.service;
+
+import camp.nextstep.edu.missionutils.DateTimes;
+import java.util.ArrayList;
+import java.util.List;
+import store.model.Item;
+import store.model.Product;
+import store.model.Products;
+import store.model.PromotionApplyStatus;
+import store.util.constants.ServiceConstants;
+
+public class StoreService {
+
+ public StoreService() {
+ }
+
+ public PromotionApplyStatus checkPromotionState(Products products, Item item) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ if (product == null || !product.inStock() || !product.isApplyPromotion(DateTimes.now())) {
+ return PromotionApplyStatus.NO_PROMOTION;
+ }
+ if (product.canGetForFreeByPromotion(item.getQuantity())) {
+ return PromotionApplyStatus.NEED_GET;
+ }
+ if (!product.canBuy(item.getQuantity()) || !product.canBuy(item.getQuantity() + product.getPromotionGet())) {
+ return PromotionApplyStatus.NOT_ENOUGH_STOCK;
+ }
+ return PromotionApplyStatus.NO_PROMOTION;
+ }
+
+ public String getPromotionMessage(Products products, Item item, PromotionApplyStatus promotionApplyStatus) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ if (promotionApplyStatus == PromotionApplyStatus.NOT_ENOUGH_STOCK) {
+ int applyPromotion = product.getMaxCanApplyPromotion(item.getQuantity());
+ int notApplyPromotionCount = item.getQuantity() - applyPromotion;
+ return String.format(promotionApplyStatus.getMessage(), item.getName(), notApplyPromotionCount);
+ }
+ if (promotionApplyStatus == PromotionApplyStatus.NEED_GET) {
+ return String.format(promotionApplyStatus.getMessage(), item.getName());
+ }
+ return promotionApplyStatus.getMessage();
+ }
+
+ public void processQuantityByPromotion(Item item, PromotionApplyStatus promotionApplyStatus, String input,
+ Products products) {
+ if (promotionApplyStatus == PromotionApplyStatus.NEED_GET && input.equals(ServiceConstants.YES)) {
+ addGetToItem(item, products);
+ return;
+ }
+ if (promotionApplyStatus == PromotionApplyStatus.NOT_ENOUGH_STOCK && input.equals(ServiceConstants.NO)) {
+ takeOffFormItem(item, products);
+ }
+ }
+
+ private void addGetToItem(Item item, Products products) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ int get = product.getPromotionGet();
+ item.addQuantity(get);
+ }
+
+ private void takeOffFormItem(Item item, Products products) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ int applyPromotion = product.getMaxCanApplyPromotion(item.getQuantity());
+ int notApplyPromotionCount = item.getQuantity() - applyPromotion;
+ item.takeOffQuantity(notApplyPromotionCount);
+ }
+
+ public List<Item> getItemsForFreeByPromotion(Products products, List<Item> items) {
+ List<Item> freeItems = new ArrayList<>();
+ for (Item item : items) {
+ int getForFree = getGetCountByPromotion(products, item);
+ if (getForFree == 0) {
+ continue;
+ }
+ freeItems.add(new Item(item.getName(), getForFree));
+ }
+ return freeItems;
+ }
+
+ private int getGetCountByPromotion(Products products, Item item) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ if (product == null || !product.isApplyPromotion(DateTimes.now())) {
+ return 0;
+ }
+ return product.getMaxCanGetForFreeByPromotion(item.getQuantity());
+ }
+
+ public void processStock(Products products, List<Item> items) {
+ for (Item item : items) {
+ int quantity = processPromotionProduct(products, item);
+ processNotPromotionProduct(products, item, quantity);
+ }
+ }
+
+ private int processPromotionProduct(Products products, Item item) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ int quantity = item.getQuantity();
+ if (product != null) {
+ quantity = decreaseProductQuantity(product, quantity);
+ }
+ return quantity;
+ }
+
+ private void processNotPromotionProduct(Products products, Item item, int quantity) {
+ Product product = products.findProductByNameAndPromotionIsNull(item.getName());
+ if (quantity == 0 || product == null) {
+ return;
+ }
+ product.decreaseQuantity(quantity);
+ }
+
+ private int decreaseProductQuantity(Product product, int quantity) {
+ if (product.canBuy(quantity)) {
+ product.decreaseQuantity(quantity);
+ return 0;
+ }
+ int remainingQuantity = quantity - product.getQuantity();
+ product.decreaseQuantity(product.getQuantity());
+ return remainingQuantity;
+ }
+
+ public boolean isContinue(String input) {
+ return input.equals(ServiceConstants.YES);
+ }
+} | Java | 원래는 StoreController에서 담당하는 비즈니스 로직을 전부 StoreService로 분리하려 하였습니다. 가장 중심이 되는 product와 관련된 로직을 전부 가져가도록 하였는데 이 과정에서 product가 promotion과 item을 모두 사용하는 로직이 많이 포함된 것 같습니다. item 생성과 관련된 로직과 receipt 생성과 관련된 로직은 확실히 구분 지을 수 있다 생각하여 각각의 Service로 분리하였지만, 타임어택 이슈로 StoreService에 대한 고민은 깊게 해보지 못하였습니다. 시간이 부족하여 큰 틀만 가지고 그 안의 세세한 부분까지는 고민하지 못했던 영향이 큰 것 같습니다 |
@@ -0,0 +1,26 @@
+package store.util.constants;
+
+public class ViewConstants {
+ // inputView
+ public static final String INPUT_ITEM_MESSAGE = "구매하실 상품명과 수량을 입력해 주세요. (예: [사이다-2],[감자칩-1])";
+ public static final String ITEM_INPUT_FORMAT = "^\\[(\\w|[가-힣]|.)+-\\d+\\](,\\[(\\w|[가-힣]|.)+-\\d+\\])*$";
+ public static final String ERROR_INPUT_FORMAT = "[ERROR] 올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요.";
+ public static final String INPUT_MEMBERSHIP_YN_MESSAGE = "멤버십 할인을 받으시겠습니까? (Y/N)";
+ public static final String INPUT_CONTINUE_YN_MESSAGE = "감사합니다. 구매하고 싶은 다른 상품이 있나요? (Y/N)";
+ // outputView
+ public static final String WELCOME_MESSAGE = "안녕하세요. W편의점입니다.";
+ public static final String PRODUCT_INTRODUCE_MESSAGE = "현재 보유하고 있는 상품입니다.";
+ public static final String RECEIPT_HEADER = "\n==============W 편의점================";
+ public static final String RECEIPT_MIDDLE = "=============증\t정===============";
+ public static final String RECEIPT_BOTTOM = "====================================\n";
+ public static final String RECEIPT_HEADER_FORMAT = "%-10s %5s %15s";
+ public static final String RECEIPT_FORMAT = "%-10s %5d %15s";
+ public static final String RECEIPT_BOTTOM_FORMAT = "%-10s %20s\n";
+ public static final String RECEIPT_PRODUCT_NAME = "상품명";
+ public static final String RECEIPT_QUANTITY = "수량";
+ public static final String RECEIPT_AMOUNT = "금액";
+ public static final String RECEIPT_TOTAL_PRICE = "총구매액";
+ public static final String RECEIPT_PROMOTION_DISCOUNT = "행사할인";
+ public static final String RECEIPT_MEMBERSHIP_DISCOUNT = "멤버십할인";
+ public static final String RECEIPT_PAYMENT = "내실돈";
+} | Java | 이번 요구사항에 InputView, OutputView 사용에 대한 내용을 보고 MVC 패턴을 적용해보고자 하였습니다. Constants가 여러 곳에서 사용되는 상수를 모아놓는 클래스이지만 너무 많은 곳에서 이를 의존하는 것은 개인적으로 좋지 않다고 생각하였습니다. 그리고 MVC가 역할에 따라 각각 Model, View, Controller로 나누어 놓은 것인데 하나의 Constants에서 모두 관리하는 게 맞을까라는 생각에 View와 Controller 단에서 사용하는 Constants를 나누게 되었습니다.
개인적인 생각으로 나눠 놓은 것이라 이게 맞는 설계인지는 잘 모르겠네요.. |
@@ -0,0 +1,109 @@
+package store.service;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import store.model.Item;
+import store.model.Product;
+import store.model.Products;
+import store.model.Promotion;
+import store.model.PromotionApplyStatus;
+import store.util.Converter;
+
+class StoreServiceTest {
+ ItemService itemService;
+ StoreService storeService;
+ Converter converter;
+ Products products;
+ List<Item> items;
+
+ @BeforeEach
+ void setUp() {
+ converter = new Converter();
+ itemService = new ItemService(converter);
+ storeService = new StoreService();
+ products = createProducts();
+ items = createItems();
+ }
+
+ private Products createProducts() {
+ List<Product> products = new ArrayList<>();
+ LocalDateTime start = converter.toLocalDateTime("2024-01-01");
+ LocalDateTime end = converter.toLocalDateTime("2024-12-31");
+ Promotion promotion = new Promotion("탄산2+1", 2, 1, start, end);
+
+ products.add(new Product("콜라", 1000, 10, promotion));
+ products.add(new Product("콜라", 1000, 10, null));
+ products.add(new Product("사이다", 1200, 8, promotion));
+ products.add(new Product("사이다", 1200, 7, null));
+ products.add(new Product("탄산수", 1200, 6, promotion));
+ products.add(new Product("탄산수", 1200, 6, null));
+ return new Products(products);
+ }
+
+ private List<Item> createItems() {
+ String input = "[콜라-2],[탄산수-4],[사이다-10]";
+ return itemService.getItems(products, input);
+ }
+
+ @DisplayName("item의 프로모션 적용 상태를 반환한다")
+ @Test
+ void checkPromotionState() {
+ assertThat(this.storeService.checkPromotionState(products, items.get(0))).isEqualTo(
+ PromotionApplyStatus.NEED_GET);
+ assertThat(this.storeService.checkPromotionState(products, items.get(1))).isEqualTo(
+ PromotionApplyStatus.NO_PROMOTION);
+ assertThat(this.storeService.checkPromotionState(products, items.get(2))).isEqualTo(
+ PromotionApplyStatus.NOT_ENOUGH_STOCK);
+ }
+
+ @DisplayName("프로모션 상태에 따라 안내 메시지를 반환한다")
+ @Test
+ void getPromotionMessage() {
+ assertThat(this.storeService.getPromotionMessage(products, items.get(0), PromotionApplyStatus.NEED_GET))
+ .contains("현재 콜라은(는) 1개를 무료로 더 받을 수 있습니다. 추가하시겠습니까? (Y/N)");
+ assertThat(this.storeService.getPromotionMessage(products, items.get(2), PromotionApplyStatus.NOT_ENOUGH_STOCK))
+ .contains("현재 사이다 4개는 프로모션 할인이 적용되지 않습니다. 그래도 구매하시겠습니까? (Y/N)");
+ }
+
+ @DisplayName("프로모션 상태와 사용자 입력에 따라 item의 수량을 수정한다")
+ @Test
+ void processQuantityByPromotion() {
+ this.storeService.processQuantityByPromotion(items.get(0), PromotionApplyStatus.NEED_GET, "Y", products);
+ this.storeService.processQuantityByPromotion(items.get(2), PromotionApplyStatus.NOT_ENOUGH_STOCK, "N",
+ products);
+
+ assertThat(items.get(0).getQuantity()).isEqualTo(3);
+ assertThat(items.get(1).getQuantity()).isEqualTo(4);
+ assertThat(items.get(2).getQuantity()).isEqualTo(6);
+ }
+
+ @DisplayName("증정품 목록을 반환한다")
+ @Test
+ void getItemsForFreeByPromotion() {
+ List<Item> freeItems = this.storeService.getItemsForFreeByPromotion(products, items);
+
+ assertThat(freeItems.size()).isEqualTo(2);
+ assertThat(freeItems.get(0).getName() + freeItems.get(0).getQuantity()).isEqualTo("탄산수1");
+ assertThat(freeItems.get(1).getName() + freeItems.get(1).getQuantity()).isEqualTo("사이다2");
+ }
+
+ @DisplayName("구매한 상품의 수량만큼 재고를 차감한다")
+ @Test
+ void processStock() {
+ this.storeService.processStock(products, items);
+ List<Product> processProduct = products.getProducts();
+
+ assertThat(processProduct.get(0).getQuantity()).isEqualTo(8);
+ assertThat(processProduct.get(1).getQuantity()).isEqualTo(10);
+ assertThat(processProduct.get(2).getQuantity()).isEqualTo(0);
+ assertThat(processProduct.get(3).getQuantity()).isEqualTo(5);
+ assertThat(processProduct.get(4).getQuantity()).isEqualTo(2);
+ assertThat(processProduct.get(5).getQuantity()).isEqualTo(6);
+ }
+}
\ No newline at end of file | Java | 지금은 하나의 테스트로 묶어놓았는데, 말씀하신 대로 프로모션 상태와 사용자 입력을 구체적으로 정의하고 경우를 나눠서 테스트 하는 것이 필요할 것 같습니다! 좋은 피드백 감사합니다! |
@@ -0,0 +1,81 @@
+package store.service;
+
+import camp.nextstep.edu.missionutils.DateTimes;
+import java.util.List;
+import store.model.Item;
+import store.model.Product;
+import store.model.Products;
+import store.model.Receipt;
+import store.util.constants.ServiceConstants;
+
+public class ReceiptService {
+ public ReceiptService() {
+ }
+
+ public Receipt createReceipt(Products products, List<Item> items, boolean applyMembership) {
+ int totalPrice = getTotalPrice(products, items);
+ int discountByPromotion = getPromotionDiscount(products, items);
+ int discountByMembership = 0;
+ if (applyMembership) {
+ discountByMembership = getMembershipDiscount(products, items);
+ }
+ int payment = totalPrice - discountByPromotion - discountByMembership;
+ return new Receipt(items, totalPrice, discountByPromotion, discountByMembership, payment);
+ }
+
+ private int getTotalPrice(Products products, List<Item> items) {
+ int totalPrice = 0;
+ for (Item item : items) {
+ totalPrice += getPrice(products, item);
+ }
+ return totalPrice;
+ }
+
+ private int getPrice(Products products, Item item) {
+ Product product = products.findProductByName(item.getName());
+ return item.getQuantity() * product.getPrice();
+ }
+
+
+ public int getPromotionDiscount(Products products, List<Item> items) {
+ int discount = 0;
+ for (Item item : items) {
+ discount += getPriceForFreeByPromotion(products, item);
+ }
+ return discount;
+ }
+
+ private int getPriceForFreeByPromotion(Products products, Item item) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ if (product == null || !product.isApplyPromotion(DateTimes.now())) {
+ return 0;
+ }
+ int price = product.getPrice();
+ int getFreeCount = product.getMaxCanGetForFreeByPromotion(item.getQuantity());
+ return getFreeCount * price;
+ }
+
+ public int getMembershipDiscount(Products products, List<Item> items) {
+ int totalPriceNotApplyPromotion = 0;
+ for (Item item : items) {
+ totalPriceNotApplyPromotion += getPriceNotApplyPromotion(products, item);
+ }
+ int discount = (int) (totalPriceNotApplyPromotion * ServiceConstants.MEMBERSHIP_DISCOUNT_RATE);
+ if (discount > ServiceConstants.MEMBERSHIP_DISCOUNT_LIMIT) {
+ discount = ServiceConstants.MEMBERSHIP_DISCOUNT_LIMIT;
+ }
+ return discount;
+ }
+
+ private int getPriceNotApplyPromotion(Products products, Item item) {
+ Product product = products.findProductByNameAndPromotionIsNotNull(item.getName());
+ if (product == null || !product.isApplyPromotion(DateTimes.now())) {
+ product = products.findProductByNameAndPromotionIsNull(item.getName());
+ return item.getQuantity() * product.getPrice();
+ }
+ int price = product.getPrice();
+ int applyPromotion = product.getMaxCanApplyPromotion(item.getQuantity());
+ int notApplyPromotionCount = item.getQuantity() - applyPromotion;
+ return notApplyPromotionCount * price;
+ }
+} | Java | 먼저 ByPromotion 메서드가 많은 이유는 타임어택 이슈로 설계를 좀 더 고민하지 못한 문제도 있지만, 제 네이밍의 문제도 있는 것 같습니다!
ByPromotion이 붙은 메서드의 경우 프로모션과 관련된 로직이지만, 해당 로직의 주체가 Promotion 자체가 아니라고 생각하여 Promotion에서 처리하지 않았습니다. 그럼에도 ByPromotion을 붙인 이유는 의미를 쉽게 파악할 수 있도록 한 것이었는데, 결과적으로 혼란이 생겼다면 좋지 못한 네이밍인 것 같습니다.
(네이밍 고민을 많이 해도 너무 어렵네요 🥲🥲)
위 메서드의 경우는 영수증에 관한 내용이라 생각해 ReceiptService에서 처리하였지만, 다시 보니 Product에 포함해도 괜찮을 것이라 생각됩니다! 좋은 피드백 감사합니다! |
@@ -0,0 +1,144 @@
+package store.controller;
+
+import static store.constant.Answer.NO;
+import static store.constant.Answer.YES;
+import static store.constant.OutputInfo.MAY_I_TAKE_YOUR_ORDER;
+import static store.constant.OutputInfo.MEMBERSHIP_DISCOUNT;
+import static store.constant.OutputInfo.PRODUCT_START_MESSAGE;
+import static store.constant.OutputInfo.WANNA_BUY_MORE;
+import static store.constant.OutputInfo.WELCOME_MESSAGE;
+import static store.constant.StoreInfo.PRODUCTS_FILE;
+import static store.constant.StoreInfo.PROMOTIONS_FILE;
+
+import store.constant.Answer;
+import store.model.Store;
+import store.model.order.Order;
+import store.model.order.Orders;
+import store.model.product.Products;
+import store.model.product.ProductsLoader;
+import store.model.product.PromotionProducts;
+import store.model.promotion.Promotions;
+import store.model.promotion.PromotionsLoader;
+import store.model.receipt.PurchaseInfos;
+import store.model.receipt.Receipt;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+public class StoreController {
+ public void run() {
+ Store store = loadFilesAndMakeStore();
+
+ while (true) {
+ printWelcomeAndAllProducts(store);
+ takeOrdersAndPrintReceipt(store);
+ if (answerToMoreOrders() == NO) {
+ break;
+ }
+ }
+ }
+
+ private Store loadFilesAndMakeStore() {
+ PromotionsLoader promotionsLoader = new PromotionsLoader(PROMOTIONS_FILE);
+ ProductsLoader productsLoader = new ProductsLoader(PRODUCTS_FILE,
+ new Promotions(promotionsLoader.getPromotions()));
+
+ return new Store(
+ new Products(productsLoader.getProducts()),
+ new PromotionProducts(productsLoader.getPromotionProducts())
+ );
+ }
+
+ private void takeOrdersAndPrintReceipt(Store store) {
+ Orders orders = readAvailableOrders(store);
+
+ readAnswerToFreeGettableCount(store, orders);
+ readAnswerToBuyProductsWithoutPromotion(store, orders);
+
+ OutputView.printReceipt(new Receipt(
+ answerToMembershipDiscount() == YES,
+ sellAllProducts(store, orders)
+ ));
+ }
+
+ private void printWelcomeAndAllProducts(Store store) {
+ OutputView.println(WELCOME_MESSAGE);
+ OutputView.println(PRODUCT_START_MESSAGE);
+ OutputView.printProducts(store.getProducts());
+ OutputView.printPromotionProducts(store.getPromotionProducts());
+ }
+
+ private Orders readAvailableOrders(Store store) {
+ return Task.retryTillNoException(() -> {
+ OutputView.println(MAY_I_TAKE_YOUR_ORDER);
+ Orders orders = new Orders(InputView.readOrders());
+
+ for (Order order : orders.toList()) {
+ store.checkAvailability(order);
+ }
+ return orders;
+ });
+ }
+
+ private void readAnswerToFreeGettableCount(Store store, Orders orders) {
+ for (Order order : orders.toList()) {
+ final int freeGettableCount = store.getFreeGettableCount(order);
+ if (freeGettableCount == 0) {
+ continue;
+ }
+
+ if (answerToGetFreeProducts(order, freeGettableCount) == YES) {
+ order.add(freeGettableCount);
+ }
+ }
+ }
+
+ private Answer answerToGetFreeProducts(Order order, final int freeGettableCount) {
+ return Task.retryTillNoException(() -> {
+ OutputView.printQuestionToFreeGettableCount(order, freeGettableCount);
+ return InputView.readAnswer();
+ });
+ }
+
+ private void readAnswerToBuyProductsWithoutPromotion(Store store, Orders orders) {
+ for (Order order : orders.toList()) {
+ final int buyCountWithoutPromotion = store.getBuyCountWithoutPromotion(order);
+ if (buyCountWithoutPromotion == 0) {
+ continue;
+ }
+
+ if (answerToBuyWithoutPromotion(order, buyCountWithoutPromotion) == NO) {
+ order.cancel(buyCountWithoutPromotion);
+ }
+ }
+ }
+
+ private Answer answerToBuyWithoutPromotion(Order order, final int buyCountWithoutPromotion) {
+ return Task.retryTillNoException(() -> {
+ OutputView.printQuestionToBuyCountWithoutPromotion(order, buyCountWithoutPromotion);
+ return InputView.readAnswer();
+ });
+ }
+
+ private Answer answerToMembershipDiscount() {
+ return Task.retryTillNoException(() -> {
+ OutputView.println(MEMBERSHIP_DISCOUNT);
+ return InputView.readAnswer();
+ });
+ }
+
+ private Answer answerToMoreOrders() {
+ return Task.retryTillNoException(() -> {
+ OutputView.println(WANNA_BUY_MORE);
+ return InputView.readAnswer();
+ });
+ }
+
+ private PurchaseInfos sellAllProducts(Store store, Orders orders) {
+ return new PurchaseInfos(
+ orders.toList().stream()
+ .map(store::sell)
+ .toList()
+ );
+ }
+} | Java | 가벼운 추천 사항이지만..!
더 간단하게 가져가고싶으시다면 이런 형태 코드도 추천드립니다 ㅎㅎ
```java
do {
printWelcomeAndAllProducts(store);
takeOrdersAndPrintReceipt(store);
} while (answerToMoreOrders() != NO);
``` |
@@ -0,0 +1,44 @@
+package store.util;
+
+import static store.constant.ErrorMessage.INVALID_ORDER_FORMAT;
+import static store.constant.ErrorMessage.WRONG_INPUT;
+import static store.constant.OrderInfo.ORDER_PATTERN;
+import static store.constant.OrderInfo.PRODUCT_COUNT_GROUP;
+import static store.constant.OrderInfo.PRODUCT_NAME_GROUP;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.regex.Matcher;
+import store.model.order.Order;
+
+public class Converter {
+ public static int toInteger(String number) {
+ try {
+ return Integer.parseInt(number);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(WRONG_INPUT.getMessage());
+ }
+ }
+
+ public static LocalDateTime toLocalDateTime(String localDate, String dateFormat) {
+ return LocalDate.parse(
+ localDate,
+ DateTimeFormatter.ofPattern(dateFormat)
+ )
+ .atStartOfDay();
+ }
+
+ public static Order toOrder(String order) {
+ Matcher matcher = ORDER_PATTERN.matcher(order);
+
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException(INVALID_ORDER_FORMAT.getMessage());
+ }
+
+ return new Order(
+ matcher.group(PRODUCT_NAME_GROUP),
+ Converter.toInteger(matcher.group(PRODUCT_COUNT_GROUP))
+ );
+ }
+} | Java | util 클래스로 빼서 꼼꼼하게 예외처리 하신 것 너무 좋아요!
저는 3주차때 했다가 이번주차에 까먹어서 못했네요 ㅜ |
@@ -0,0 +1,29 @@
+package store.model.product;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class Products {
+ private final Map<String, Product> productByName;
+
+ public Products(Map<String, Product> productByName) {
+ this.productByName = productByName;
+ }
+
+ public Products(List<Product> products) {
+ this(
+ products.stream()
+ .collect(Collectors.toMap(Product::getName, Function.identity()))
+ );
+ }
+
+ public Product getNameWith(String toFind) {
+ return productByName.get(toFind);
+ }
+
+ public List<Product> toList() {
+ return productByName.values().stream().toList();
+ }
+} | Java | `Function.identity()`는 처음보네요..!
어떤 역할인지 알려주실 수 있나요?! |
@@ -0,0 +1,151 @@
+package store.view;
+
+import static store.constant.OutputInfo.BUY_COUNT_WITHOUT_PROMOTION_QUESTION;
+import static store.constant.OutputInfo.FREE_GETTABLE_COUNT_QUESTION;
+import static store.constant.OutputInfo.NEW_LINE;
+import static store.constant.OutputInfo.NO_QUANTITY;
+import static store.constant.OutputInfo.PRODUCT_FORMAT;
+import static store.constant.OutputInfo.PROMOTION_PRODUCT_FORMAT;
+import static store.constant.OutputInfo.QUANTITY_FORMAT;
+import static store.constant.OutputInfo.RECEIPT_AMOUNT_OF_PAY_FORMAT;
+import static store.constant.OutputInfo.RECEIPT_FREE_PRODUCT_FORMAT;
+import static store.constant.OutputInfo.RECEIPT_FREE_START_MESSAGE;
+import static store.constant.OutputInfo.RECEIPT_MEMBERSHIP_DISCOUNT_FORMAT;
+import static store.constant.OutputInfo.RECEIPT_PAY_START_MESSAGE;
+import static store.constant.OutputInfo.RECEIPT_PROMOTION_DISCOUNT_FORMAT;
+import static store.constant.OutputInfo.RECEIPT_PURCHASE_INFO_FORMAT;
+import static store.constant.OutputInfo.RECEIPT_PURCHASE_INFO_START_MESSAGE;
+import static store.constant.OutputInfo.RECEIPT_START_MESSAGE;
+import static store.constant.OutputInfo.RECEIPT_TOTAL_PRICE_FORMAT;
+
+import java.text.NumberFormat;
+import store.model.order.Order;
+import store.model.product.Product;
+import store.model.product.Products;
+import store.model.product.PromotionProduct;
+import store.model.product.PromotionProducts;
+import store.model.receipt.PurchaseInfo;
+import store.model.receipt.PurchaseInfos;
+import store.model.receipt.Receipt;
+
+public class OutputView {
+ public static final NumberFormat NUMBER_FORMATTER = NumberFormat.getInstance();
+
+ public static void println(String message) {
+ System.out.printf(message);
+ System.out.printf(NEW_LINE);
+ }
+
+ public static void printProducts(Products products) {
+ for (Product product : products.toList()) {
+ System.out.printf(
+ PRODUCT_FORMAT,
+ product.getName(),
+ NUMBER_FORMATTER.format(product.getPrice()),
+ getQuantityMessage(product.getQuantity())
+ );
+ }
+ }
+
+ public static void printPromotionProducts(PromotionProducts promotionProducts) {
+ for (PromotionProduct promotionProduct : promotionProducts.toList()) {
+ System.out.printf(
+ PROMOTION_PRODUCT_FORMAT,
+ promotionProduct.getName(),
+ NUMBER_FORMATTER.format(promotionProduct.getPrice()),
+ getQuantityMessage(promotionProduct.getQuantity()),
+ promotionProduct.getPromotionName()
+ );
+ }
+ }
+
+ private static String getQuantityMessage(final int quantity) {
+ if (quantity == 0) {
+ return NO_QUANTITY;
+ }
+ return String.format(QUANTITY_FORMAT, quantity);
+ }
+
+ public static void printQuestionToFreeGettableCount(Order order, final int freeGettableCount) {
+ System.out.printf(
+ FREE_GETTABLE_COUNT_QUESTION,
+ order.getProductName(),
+ freeGettableCount
+ );
+ }
+
+ public static void printQuestionToBuyCountWithoutPromotion(Order order, final int buyCountWithoutPromotion) {
+ System.out.printf(
+ BUY_COUNT_WITHOUT_PROMOTION_QUESTION,
+ order.getProductName(),
+ buyCountWithoutPromotion
+ );
+ }
+
+ public static void printReceipt(Receipt receipt) {
+ System.out.printf(RECEIPT_START_MESSAGE);
+ printPurchaseInfos(receipt.getPurchaseInfos());
+ printFreePurchaseInfos(receipt.getPurchaseInfos());
+ printPays(receipt);
+ }
+
+ private static void printPurchaseInfos(PurchaseInfos purchaseInfos) {
+ System.out.printf(RECEIPT_PURCHASE_INFO_START_MESSAGE);
+ for (PurchaseInfo purchaseInfo : purchaseInfos.toList()) {
+ System.out.printf(
+ RECEIPT_PURCHASE_INFO_FORMAT,
+ purchaseInfo.getProductName(),
+ purchaseInfo.getBuyCount(),
+ NUMBER_FORMATTER.format(purchaseInfo.getTotalAmount())
+ );
+ }
+ }
+
+ private static void printFreePurchaseInfos(PurchaseInfos purchaseInfos) {
+ System.out.printf(RECEIPT_FREE_START_MESSAGE);
+ for (PurchaseInfo purchaseInfo : purchaseInfos.toPromotionDiscountedList()) {
+ System.out.printf(
+ RECEIPT_FREE_PRODUCT_FORMAT,
+ purchaseInfo.getProductName(),
+ purchaseInfo.getFreeCount()
+ );
+ }
+ }
+
+ private static void printPays(Receipt receipt) {
+ System.out.printf(RECEIPT_PAY_START_MESSAGE);
+ printTotalPrice(receipt);
+ printPromotionDiscount(receipt);
+ printMemberShipDiscount(receipt);
+ printAmountOfPay(receipt);
+ }
+
+ private static void printTotalPrice(Receipt receipt) {
+ System.out.printf(
+ RECEIPT_TOTAL_PRICE_FORMAT,
+ receipt.getTotalBuyCount(),
+ NUMBER_FORMATTER.format(receipt.getTotalAmount())
+ );
+ }
+
+ private static void printPromotionDiscount(Receipt receipt) {
+ System.out.printf(
+ RECEIPT_PROMOTION_DISCOUNT_FORMAT,
+ NUMBER_FORMATTER.format(receipt.getPromotionDiscountAmount())
+ );
+ }
+
+ private static void printMemberShipDiscount(Receipt receipt) {
+ System.out.printf(
+ RECEIPT_MEMBERSHIP_DISCOUNT_FORMAT,
+ NUMBER_FORMATTER.format(receipt.getMembershipDiscountAmount())
+ );
+ }
+
+ private static void printAmountOfPay(Receipt receipt) {
+ System.out.printf(
+ RECEIPT_AMOUNT_OF_PAY_FORMAT,
+ NUMBER_FORMATTER.format(receipt.getAmountOfPay())
+ );
+ }
+} | Java | 저였다면 아마 메소드를 안파고 아래처럼 다른 곳에서 사용했을 것 같은데요!
```java
System.out.println(message);
```
이렇게 `printf()`로 호출하는 메소드를 따로 파신 이유가 궁금합니다! |
@@ -0,0 +1,144 @@
+package store.controller;
+
+import static store.constant.Answer.NO;
+import static store.constant.Answer.YES;
+import static store.constant.OutputInfo.MAY_I_TAKE_YOUR_ORDER;
+import static store.constant.OutputInfo.MEMBERSHIP_DISCOUNT;
+import static store.constant.OutputInfo.PRODUCT_START_MESSAGE;
+import static store.constant.OutputInfo.WANNA_BUY_MORE;
+import static store.constant.OutputInfo.WELCOME_MESSAGE;
+import static store.constant.StoreInfo.PRODUCTS_FILE;
+import static store.constant.StoreInfo.PROMOTIONS_FILE;
+
+import store.constant.Answer;
+import store.model.Store;
+import store.model.order.Order;
+import store.model.order.Orders;
+import store.model.product.Products;
+import store.model.product.ProductsLoader;
+import store.model.product.PromotionProducts;
+import store.model.promotion.Promotions;
+import store.model.promotion.PromotionsLoader;
+import store.model.receipt.PurchaseInfos;
+import store.model.receipt.Receipt;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+public class StoreController {
+ public void run() {
+ Store store = loadFilesAndMakeStore();
+
+ while (true) {
+ printWelcomeAndAllProducts(store);
+ takeOrdersAndPrintReceipt(store);
+ if (answerToMoreOrders() == NO) {
+ break;
+ }
+ }
+ }
+
+ private Store loadFilesAndMakeStore() {
+ PromotionsLoader promotionsLoader = new PromotionsLoader(PROMOTIONS_FILE);
+ ProductsLoader productsLoader = new ProductsLoader(PRODUCTS_FILE,
+ new Promotions(promotionsLoader.getPromotions()));
+
+ return new Store(
+ new Products(productsLoader.getProducts()),
+ new PromotionProducts(productsLoader.getPromotionProducts())
+ );
+ }
+
+ private void takeOrdersAndPrintReceipt(Store store) {
+ Orders orders = readAvailableOrders(store);
+
+ readAnswerToFreeGettableCount(store, orders);
+ readAnswerToBuyProductsWithoutPromotion(store, orders);
+
+ OutputView.printReceipt(new Receipt(
+ answerToMembershipDiscount() == YES,
+ sellAllProducts(store, orders)
+ ));
+ }
+
+ private void printWelcomeAndAllProducts(Store store) {
+ OutputView.println(WELCOME_MESSAGE);
+ OutputView.println(PRODUCT_START_MESSAGE);
+ OutputView.printProducts(store.getProducts());
+ OutputView.printPromotionProducts(store.getPromotionProducts());
+ }
+
+ private Orders readAvailableOrders(Store store) {
+ return Task.retryTillNoException(() -> {
+ OutputView.println(MAY_I_TAKE_YOUR_ORDER);
+ Orders orders = new Orders(InputView.readOrders());
+
+ for (Order order : orders.toList()) {
+ store.checkAvailability(order);
+ }
+ return orders;
+ });
+ }
+
+ private void readAnswerToFreeGettableCount(Store store, Orders orders) {
+ for (Order order : orders.toList()) {
+ final int freeGettableCount = store.getFreeGettableCount(order);
+ if (freeGettableCount == 0) {
+ continue;
+ }
+
+ if (answerToGetFreeProducts(order, freeGettableCount) == YES) {
+ order.add(freeGettableCount);
+ }
+ }
+ }
+
+ private Answer answerToGetFreeProducts(Order order, final int freeGettableCount) {
+ return Task.retryTillNoException(() -> {
+ OutputView.printQuestionToFreeGettableCount(order, freeGettableCount);
+ return InputView.readAnswer();
+ });
+ }
+
+ private void readAnswerToBuyProductsWithoutPromotion(Store store, Orders orders) {
+ for (Order order : orders.toList()) {
+ final int buyCountWithoutPromotion = store.getBuyCountWithoutPromotion(order);
+ if (buyCountWithoutPromotion == 0) {
+ continue;
+ }
+
+ if (answerToBuyWithoutPromotion(order, buyCountWithoutPromotion) == NO) {
+ order.cancel(buyCountWithoutPromotion);
+ }
+ }
+ }
+
+ private Answer answerToBuyWithoutPromotion(Order order, final int buyCountWithoutPromotion) {
+ return Task.retryTillNoException(() -> {
+ OutputView.printQuestionToBuyCountWithoutPromotion(order, buyCountWithoutPromotion);
+ return InputView.readAnswer();
+ });
+ }
+
+ private Answer answerToMembershipDiscount() {
+ return Task.retryTillNoException(() -> {
+ OutputView.println(MEMBERSHIP_DISCOUNT);
+ return InputView.readAnswer();
+ });
+ }
+
+ private Answer answerToMoreOrders() {
+ return Task.retryTillNoException(() -> {
+ OutputView.println(WANNA_BUY_MORE);
+ return InputView.readAnswer();
+ });
+ }
+
+ private PurchaseInfos sellAllProducts(Store store, Orders orders) {
+ return new PurchaseInfos(
+ orders.toList().stream()
+ .map(store::sell)
+ .toList()
+ );
+ }
+} | Java | 이런식으로 출력하면 일반 상품들 먼저 출력하고, 프로모션 상품을 그다음에 몰아서 출력하게 되는 형태일까요??
제가 코드를 맞게 이해한건지 모르겠네요..! |
@@ -0,0 +1,129 @@
+package store.model;
+
+import static store.constant.ErrorMessage.CANNOT_FIND_PRODUCT;
+import static store.constant.ErrorMessage.EXCEEDED_QUANTITY;
+
+import store.model.order.Order;
+import store.model.product.Product;
+import store.model.product.Products;
+import store.model.product.PromotionProduct;
+import store.model.product.PromotionProducts;
+import store.model.receipt.PurchaseInfo;
+
+public class Store {
+ private final Products products;
+ private final PromotionProducts promotionProducts;
+
+ public Store(Products products, PromotionProducts promotionProducts) {
+ this.products = products;
+ this.promotionProducts = promotionProducts;
+ }
+
+ public Products getProducts() {
+ return products;
+ }
+
+ public PromotionProducts getPromotionProducts() {
+ return promotionProducts;
+ }
+
+ private static boolean isAvailable(PromotionProduct promotionProduct) {
+ return promotionProduct != null && promotionProduct.isAvailable();
+ }
+
+ public void checkAvailability(Order order) {
+ checkProductName(order);
+ checkQuantity(order);
+ }
+
+ private void checkProductName(Order order) {
+ Product product = products.getNameWith(order.getProductName());
+ if (product == null) {
+ throw new IllegalArgumentException(CANNOT_FIND_PRODUCT.getMessage());
+ }
+ }
+
+ private void checkQuantity(Order order) {
+ Product product = products.getNameWith(order.getProductName());
+ PromotionProduct promotionProduct = promotionProducts.getNameWith(order.getProductName());
+ int totalQuantity = product.getQuantity();
+ if (isAvailable(promotionProduct)) {
+ totalQuantity += promotionProduct.getQuantity();
+ }
+
+ if (totalQuantity < order.getBuyCount()) {
+ throw new IllegalArgumentException(EXCEEDED_QUANTITY.getMessage());
+ }
+ }
+
+ public int getFreeGettableCount(Order order) {
+ PromotionProduct promotionProduct = promotionProducts.getNameWith(order.getProductName());
+
+ if (!isAvailable(promotionProduct)) {
+ return 0;
+ }
+ return promotionProduct.getFreeGettableCount(order.getBuyCount());
+ }
+
+ public int getBuyCountWithoutPromotion(Order order) {
+ PromotionProduct promotionProduct = promotionProducts.getNameWith(order.getProductName());
+
+ if (!isAvailable(promotionProduct) || order.getBuyCount() <= promotionProduct.getQuantity()) {
+ return 0;
+ }
+ return order.getBuyCount() - promotionProduct.getPromotionEffectCount();
+ }
+
+ public PurchaseInfo sell(Order order) {
+ Seller seller = new Seller(
+ order.getBuyCount(),
+ products.getNameWith(order.getProductName()),
+ promotionProducts.getNameWith(order.getProductName())
+ );
+
+ seller.sell();
+ return new PurchaseInfo(order, seller.getPrice(), seller.getFreeCount());
+ }
+
+ private static class Seller {
+ private int freeCount;
+ private int remainSellCount;
+ private final Product product;
+ private final PromotionProduct promotionProduct;
+
+ public Seller(final int remainSellCount, Product product, PromotionProduct promotionProduct) {
+ this.remainSellCount = remainSellCount;
+ this.product = product;
+ this.promotionProduct = promotionProduct;
+ }
+
+ public void sell() {
+ sellPromotionProduct();
+ sellProduct();
+ }
+
+ private void sellPromotionProduct() {
+ if (!isAvailable(promotionProduct)) {
+ return;
+ }
+
+ final int promotionSellCount = Math.min(remainSellCount, promotionProduct.getQuantity());
+
+ freeCount = promotionProduct.getFreeCountIn(promotionSellCount);
+ remainSellCount -= promotionSellCount;
+ promotionProduct.sell(promotionSellCount);
+ }
+
+ private void sellProduct() {
+ product.sell(remainSellCount);
+ }
+
+ public int getFreeCount() {
+ return freeCount;
+ }
+
+ public int getPrice() {
+ return product.getPrice();
+ }
+ }
+} | Java | 저는 이번 프리코스를 진행하면서 validate 할 부분은 `Validator` 클래스를 따로 파서 input 검증을 진행했었는데요!
개인적으로 검증 로직을 도메인에 담기에는 책임이 더 많아진다고 생각을 했어서 클래스를 따로 만들었었습니다.
태양님은 전체적으로 도메인 자체에 검증 로직을 담아두신 것 같더라구요..!
저의 생각과는 다른 방식으로 구현하신 것 같아서 검증의 책임에 대해 어떤 의견이신지 궁금합니다! |
@@ -0,0 +1,17 @@
+package store.util;
+
+import store.view.OutputView;
+
+public interface Task<T> {
+ static <T> T retryTillNoException(Task<T> task) {
+ while (true) {
+ try {
+ return task.run();
+ } catch (IllegalArgumentException e) {
+ OutputView.println(e.getMessage());
+ }
+ }
+ }
+
+ T run();
+} | Java | 이렇게 반복 처리를 할 수도 있겠군요..!
저는 예외 재입력 로직이 너무 반복적이라 어떻게 처리할지 결론 못내고 끝냈는데 배워갑니다!! |
@@ -0,0 +1,35 @@
+package store.view;
+
+import static store.constant.ErrorMessage.WRONG_INPUT;
+import static store.constant.OrderInfo.ORDER_DELIMITER;
+
+import camp.nextstep.edu.missionutils.Console;
+import java.util.ArrayList;
+import java.util.List;
+import store.constant.Answer;
+import store.model.order.Order;
+import store.util.Converter;
+import store.util.Spliter;
+
+public class InputView {
+ public static List<Order> readOrders() {
+ Spliter spliter = new Spliter(Console.readLine(), ORDER_DELIMITER);
+ List<Order> orders = new ArrayList<>();
+
+ while (spliter.hasMoreTokens()) {
+ String nextToken = spliter.nextToken();
+
+ orders.add(Converter.toOrder(nextToken));
+ }
+ return orders;
+ }
+
+ public static Answer readAnswer() {
+ Answer answer = Answer.getMatchingAnswer(Console.readLine());
+
+ if (answer == null) {
+ throw new IllegalArgumentException(WRONG_INPUT.getMessage());
+ }
+ return answer;
+ }
+} | Java | 저는 입력받을 때 필요한 프롬프트 출력도 `InputView`의 책임이라고 생각했습니다.
태양님은 `InputView`는 딱 입력의 역할만 갖는다는 생각이셨던 것 같네요!
또다른 관점이라 흥미롭습니다..! |
@@ -0,0 +1,12 @@
+package store.constant;
+
+public class StoreInfo {
+ public static final String PRODUCTS_FILE = "src/main/resources/products.md";
+ public static final String PRODUCTS_DELIMITER = ",";
+ public static final String PROMOTIONS_FILE = "src/main/resources/promotions.md";
+ public static final String PROMOTIONS_DATE_FORMAT = "yyyy-MM-dd";
+ public static final String PROMOTIONS_DELIMITER = ",";
+ public static final String NO_PROMOTION = "null";
+ public static final double MEMBERSHIP_DISCOUNT_PERCENTAGE = 0.3;
+ public static final int MAX_MEMBERSHIP_DISCOUNT_AMOUNT = 8_000;
+} | Java | 저는 constants를 enum 없이 class로 생성하는 경우, 생성자를 private으로 돌리고 클래스도 final로 선언해 인스턴스화를 완전히 막아버리곤 합니다!
이번 과제에서는 오버 엔지니어링일 수 있지만..! 참고 차원에서 코멘트 드립니다 :) |
@@ -0,0 +1,28 @@
+package store.constant;
+
+public class OutputInfo {
+ public static final String NEW_LINE = "%n";
+ public static final String WELCOME_MESSAGE = "안녕하세요. W편의점입니다.";
+ public static final String PRODUCT_START_MESSAGE = "현재 보유하고 있는 상품입니다." + NEW_LINE;
+ public static final String PRODUCT_FORMAT = "- %s %s원 %s" + NEW_LINE;
+ public static final String PROMOTION_PRODUCT_FORMAT = "- %s %s원 %s %s" + NEW_LINE;
+ public static final String NO_QUANTITY = "재고 없음";
+ public static final String QUANTITY_FORMAT = "%d개";
+ public static final String MAY_I_TAKE_YOUR_ORDER = "구매하실 상품명과 수량을 입력해 주세요. (예: [사이다-2],[감자칩-1])";
+ public static final String FREE_GETTABLE_COUNT_QUESTION =
+ "현재 %s은(는) %d개를 무료로 더 받을 수 있습니다. 추가하시겠습니까? (Y/N)" + NEW_LINE;
+ public static final String BUY_COUNT_WITHOUT_PROMOTION_QUESTION =
+ "현재 %s %d개는 프로모션 할인이 적용되지 않습니다. 그래도 구매하시겠습니까? (Y/N)" + NEW_LINE;
+ public static final String MEMBERSHIP_DISCOUNT = "멤버십 할인을 받으시겠습니까? (Y/N)";
+ public static final String RECEIPT_START_MESSAGE = "==============W 편의점================" + NEW_LINE;
+ public static final String RECEIPT_PURCHASE_INFO_START_MESSAGE = "상품명\t\t수량\t금액" + NEW_LINE;
+ public static final String RECEIPT_PURCHASE_INFO_FORMAT = "%s\t\t%d \t%s" + NEW_LINE;
+ public static final String RECEIPT_FREE_START_MESSAGE = "=============증\t정===============" + NEW_LINE;
+ public static final String RECEIPT_FREE_PRODUCT_FORMAT = "%s\t\t%d" + NEW_LINE;
+ public static final String RECEIPT_PAY_START_MESSAGE = "====================================" + NEW_LINE;
+ public static final String RECEIPT_TOTAL_PRICE_FORMAT = "총구매액\t\t%d\t%s" + NEW_LINE;
+ public static final String RECEIPT_PROMOTION_DISCOUNT_FORMAT = "행사할인\t\t\t-%s" + NEW_LINE;
+ public static final String RECEIPT_MEMBERSHIP_DISCOUNT_FORMAT = "멤버십할인\t\t\t-%s" + NEW_LINE;
+ public static final String RECEIPT_AMOUNT_OF_PAY_FORMAT = "내실돈\t\t\t %s" + NEW_LINE;
+ public static final String WANNA_BUY_MORE = "감사합니다. 구매하고 싶은 다른 상품이 있나요? (Y/N)";
+} | Java | 우테코에서는 상수 관리를 enum 타입으로 권장하고 있습니다!
저는 개인적으론 enum에 다른 메소드 추가가 없다면 태양님처럼 static final을 사용해 상수화 하는 걸 선호하는데..
태양님은 어떻게 생각하시는지 궁금합니다! |
@@ -0,0 +1,34 @@
+package store.model.promotion;
+
+import static store.constant.ErrorMessage.INVALID_PERIOD;
+
+import java.time.LocalDateTime;
+
+public class Period {
+ private final LocalDateTime start;
+ private final LocalDateTime end;
+
+ public Period(LocalDateTime start, LocalDateTime end) {
+ validate(start, end);
+ this.start = start;
+ this.end = end;
+ }
+
+ private void validate(LocalDateTime start, LocalDateTime end) {
+ validateStartIsBeforeEnd(start, end);
+ }
+
+ private void validateStartIsBeforeEnd(LocalDateTime start, LocalDateTime end) {
+ if (!start.isBefore(end)) {
+ throw new IllegalArgumentException(INVALID_PERIOD.getMessage());
+ }
+ }
+
+ public boolean includes(LocalDateTime time) {
+ if (start.isEqual(time) || end.isEqual(time)) { // 시작과 끝 시간까지 포함
+ return true;
+ }
+
+ return time.isAfter(start) && time.isBefore(end);
+ }
+} | Java | 아마 프로모션 진행 기간인지 판단하는 코드를 작성하신 것 같아요!
아래처럼 단순화 해봐도 괜찮을 것 같다는 생각이 듭니다 :)
```java
return !(time.isBefore(start) || time.isAfter(end));
``` |
@@ -0,0 +1,129 @@
+package store.model;
+
+import static store.constant.ErrorMessage.CANNOT_FIND_PRODUCT;
+import static store.constant.ErrorMessage.EXCEEDED_QUANTITY;
+
+import store.model.order.Order;
+import store.model.product.Product;
+import store.model.product.Products;
+import store.model.product.PromotionProduct;
+import store.model.product.PromotionProducts;
+import store.model.receipt.PurchaseInfo;
+
+public class Store {
+ private final Products products;
+ private final PromotionProducts promotionProducts;
+
+ public Store(Products products, PromotionProducts promotionProducts) {
+ this.products = products;
+ this.promotionProducts = promotionProducts;
+ }
+
+ public Products getProducts() {
+ return products;
+ }
+
+ public PromotionProducts getPromotionProducts() {
+ return promotionProducts;
+ }
+
+ private static boolean isAvailable(PromotionProduct promotionProduct) {
+ return promotionProduct != null && promotionProduct.isAvailable();
+ }
+
+ public void checkAvailability(Order order) {
+ checkProductName(order);
+ checkQuantity(order);
+ }
+
+ private void checkProductName(Order order) {
+ Product product = products.getNameWith(order.getProductName());
+ if (product == null) {
+ throw new IllegalArgumentException(CANNOT_FIND_PRODUCT.getMessage());
+ }
+ }
+
+ private void checkQuantity(Order order) {
+ Product product = products.getNameWith(order.getProductName());
+ PromotionProduct promotionProduct = promotionProducts.getNameWith(order.getProductName());
+ int totalQuantity = product.getQuantity();
+ if (isAvailable(promotionProduct)) {
+ totalQuantity += promotionProduct.getQuantity();
+ }
+
+ if (totalQuantity < order.getBuyCount()) {
+ throw new IllegalArgumentException(EXCEEDED_QUANTITY.getMessage());
+ }
+ }
+
+ public int getFreeGettableCount(Order order) {
+ PromotionProduct promotionProduct = promotionProducts.getNameWith(order.getProductName());
+
+ if (!isAvailable(promotionProduct)) {
+ return 0;
+ }
+ return promotionProduct.getFreeGettableCount(order.getBuyCount());
+ }
+
+ public int getBuyCountWithoutPromotion(Order order) {
+ PromotionProduct promotionProduct = promotionProducts.getNameWith(order.getProductName());
+
+ if (!isAvailable(promotionProduct) || order.getBuyCount() <= promotionProduct.getQuantity()) {
+ return 0;
+ }
+ return order.getBuyCount() - promotionProduct.getPromotionEffectCount();
+ }
+
+ public PurchaseInfo sell(Order order) {
+ Seller seller = new Seller(
+ order.getBuyCount(),
+ products.getNameWith(order.getProductName()),
+ promotionProducts.getNameWith(order.getProductName())
+ );
+
+ seller.sell();
+ return new PurchaseInfo(order, seller.getPrice(), seller.getFreeCount());
+ }
+
+ private static class Seller {
+ private int freeCount;
+ private int remainSellCount;
+ private final Product product;
+ private final PromotionProduct promotionProduct;
+
+ public Seller(final int remainSellCount, Product product, PromotionProduct promotionProduct) {
+ this.remainSellCount = remainSellCount;
+ this.product = product;
+ this.promotionProduct = promotionProduct;
+ }
+
+ public void sell() {
+ sellPromotionProduct();
+ sellProduct();
+ }
+
+ private void sellPromotionProduct() {
+ if (!isAvailable(promotionProduct)) {
+ return;
+ }
+
+ final int promotionSellCount = Math.min(remainSellCount, promotionProduct.getQuantity());
+
+ freeCount = promotionProduct.getFreeCountIn(promotionSellCount);
+ remainSellCount -= promotionSellCount;
+ promotionProduct.sell(promotionSellCount);
+ }
+
+ private void sellProduct() {
+ product.sell(remainSellCount);
+ }
+
+ public int getFreeCount() {
+ return freeCount;
+ }
+
+ public int getPrice() {
+ return product.getPrice();
+ }
+ }
+} | Java | 이 클래스를 따로 빼지 않고 내부에서 사용하신 이유가 있을까요? |
@@ -0,0 +1,36 @@
+package store.model.order;
+
+import static store.constant.ErrorMessage.WRONG_INPUT;
+
+public class Order {
+ protected final String productName;
+ protected int buyCount;
+
+ public Order(String productName, final int buyCount) {
+ validateNotNegative(buyCount);
+ this.productName = productName;
+ this.buyCount = buyCount;
+ }
+
+ private void validateNotNegative(final int buyCount) {
+ if (buyCount < 0) {
+ throw new IllegalArgumentException(WRONG_INPUT.getMessage());
+ }
+ }
+
+ public String getProductName() {
+ return productName;
+ }
+
+ public int getBuyCount() {
+ return buyCount;
+ }
+
+ public void add(final int toAdd) {
+ buyCount += toAdd;
+ }
+
+ public void cancel(final int toCancel) {
+ buyCount -= toCancel;
+ }
+} | Java | 이런것도 상수처리하면 더 좋을것 같아요 |
@@ -0,0 +1,34 @@
+package store.util;
+
+import static store.constant.ErrorMessage.FILE_NOT_FOUND;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.util.ArrayList;
+import java.util.List;
+
+public class FileLines {
+ private final List<String> lines;
+
+ public FileLines(String file) {
+ try {
+ BufferedReader reader = new BufferedReader(new FileReader(file));
+
+ lines = new ArrayList<>(reader.lines().toList());
+ } catch (FileNotFoundException e) {
+ throw new IllegalArgumentException(FILE_NOT_FOUND.getMessage());
+ }
+ }
+
+ public boolean hasMoreLines() {
+ return !lines.isEmpty();
+ }
+
+ public String nextLine() {
+ String line = lines.getFirst();
+
+ lines.removeFirst();
+ return line;
+ }
+} | Java | 파일이 없는 경우는예외 처리할 생각을 못했는데 예외를 꼼꼼하게 처리하셨네요 |
@@ -0,0 +1,27 @@
+package store.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Spliter {
+ private static final int INCLUDE_TRAILING = -1;
+
+ private final List<String> tokens;
+
+ public Spliter(String toBeSplited, String regex) {
+ tokens = new ArrayList<>(List.of(
+ toBeSplited.split(regex, INCLUDE_TRAILING)
+ ));
+ }
+
+ public boolean hasMoreTokens() {
+ return !tokens.isEmpty();
+ }
+
+ public String nextToken() {
+ String token = tokens.getFirst();
+
+ tokens.removeFirst();
+ return token;
+ }
+} | Java | 혹시 이게 주문 상품 관련된 것 일까요? 제가 코드가 잘 이해가 안되서 질문드립니다... |
@@ -0,0 +1,44 @@
+package store.util;
+
+import static store.constant.ErrorMessage.INVALID_ORDER_FORMAT;
+import static store.constant.ErrorMessage.WRONG_INPUT;
+import static store.constant.OrderInfo.ORDER_PATTERN;
+import static store.constant.OrderInfo.PRODUCT_COUNT_GROUP;
+import static store.constant.OrderInfo.PRODUCT_NAME_GROUP;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.regex.Matcher;
+import store.model.order.Order;
+
+public class Converter {
+ public static int toInteger(String number) {
+ try {
+ return Integer.parseInt(number);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(WRONG_INPUT.getMessage());
+ }
+ }
+
+ public static LocalDateTime toLocalDateTime(String localDate, String dateFormat) {
+ return LocalDate.parse(
+ localDate,
+ DateTimeFormatter.ofPattern(dateFormat)
+ )
+ .atStartOfDay();
+ }
+
+ public static Order toOrder(String order) {
+ Matcher matcher = ORDER_PATTERN.matcher(order);
+
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException(INVALID_ORDER_FORMAT.getMessage());
+ }
+
+ return new Order(
+ matcher.group(PRODUCT_NAME_GROUP),
+ Converter.toInteger(matcher.group(PRODUCT_COUNT_GROUP))
+ );
+ }
+} | Java | 저는 프로모션 내부에서 처리했는데 따로 빼는 것도 좋은 방법이네요 |
@@ -0,0 +1,59 @@
+package store.model.product;
+
+import static store.constant.StoreInfo.NO_PROMOTION;
+import static store.constant.StoreInfo.PRODUCTS_DELIMITER;
+
+import java.util.ArrayList;
+import java.util.List;
+import store.model.promotion.Promotions;
+import store.util.Converter;
+import store.util.FileLines;
+import store.util.Spliter;
+
+public class ProductsLoader {
+ private final List<Product> products;
+ private final List<PromotionProduct> promotionProducts;
+
+ public ProductsLoader(String file, Promotions promotions) {
+ FileLines fileLines = new FileLines(file);
+ fileLines.nextLine();
+
+ products = new ArrayList<>();
+ promotionProducts = new ArrayList<>();
+ while (fileLines.hasMoreLines()) {
+ addProduct(new Spliter(fileLines.nextLine(), PRODUCTS_DELIMITER), promotions);
+ }
+ addProductsOnlyInPromotionProducts();
+ }
+
+ private void addProduct(Spliter spliter, Promotions promotions) {
+ String name = spliter.nextToken();
+ final int price = Converter.toInteger(spliter.nextToken());
+ final int quantity = Converter.toInteger(spliter.nextToken());
+ String promotionName = spliter.nextToken();
+
+ if (promotionName.equals(NO_PROMOTION)) {
+ products.add(new Product(name, price, quantity));
+ return;
+ }
+ promotionProducts.add(new PromotionProduct(name, price, quantity, promotions.getNameWith(promotionName)));
+ }
+
+ private void addProductsOnlyInPromotionProducts() {
+ List<String> productNames = products.stream().map(Product::getName).toList();
+
+ promotionProducts.stream()
+ .filter(promotionProduct -> !productNames.contains(promotionProduct.getName()))
+ .forEach(promotionProduct ->
+ products.add(new Product(promotionProduct.getName(), promotionProduct.getPrice(), 0))
+ );
+ }
+
+ public List<Product> getProducts() {
+ return products;
+ }
+
+ public List<PromotionProduct> getPromotionProducts() {
+ return promotionProducts;
+ }
+} | Java | 프로모션과 상품을 파일에서 읽어오신걸 저장하는 클래스가 있던데 따로 만드신 이유가 있을까요? |
@@ -0,0 +1,27 @@
+package store.constant;
+
+public enum ErrorMessage {
+ FILE_NOT_FOUND("파일을 찾을 수 없습니다."),
+ INVALID_PERIOD("기간이 올바르지 않습니다."),
+ PRICE_NEGATIVE("가격이 음수입니다."),
+ QUANTITY_NEGATIVE("수량이 음수입니다."),
+ BUY_COUNT_NOT_POSITIVE("증정 조건이 올바르지 않습니다."),
+ GET_COUNT_NOT_POSITIVE("증정 개수가 올바르지 않습니다."),
+ CANNOT_FIND_PRODUCT("존재하지 않는 상품입니다. 다시 입력해 주세요."),
+ INVALID_ORDER_FORMAT("올바르지 않은 형식으로 입력했습니다. 다시 입력해 주세요."),
+ EXCEEDED_QUANTITY("재고 수량을 초과하여 구매할 수 없습니다. 다시 입력해 주세요."),
+ WRONG_INPUT("잘못된 입력입니다. 다시 입력해 주세요."),
+ ;
+
+ private static final String ERROR_PREFIX = "[ERROR] ";
+
+ private final String message;
+
+ ErrorMessage(String message) {
+ this.message = ERROR_PREFIX + message;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+} | Java | 본인만의 상수를 ENUM 타입으로 관리하는 기준이 있을까요? |
@@ -0,0 +1,30 @@
+package store.constant;
+
+public enum Answer {
+ YES("Y"),
+ NO("N"),
+ ;
+
+ private final String message;
+
+ Answer(String message) {
+ this.message = message;
+ }
+
+ public static Answer getMatchingAnswer(String toFind) {
+ for (Answer answer : Answer.values()) {
+ if (answer.matches(toFind)) {
+ return answer;
+ }
+ }
+ return null;
+ }
+
+ private boolean matches(String answer) {
+ return message.equals(answer);
+ }
+
+ public String getMessage() {
+ return message;
+ }
+} | Java | null로 반환해서 외부에서 잘못된 입력인지 확인하는거 보다 여기서 예외를 던지는 것도 좋을거같습니다 ㅎㅎ!😊 |
@@ -0,0 +1,144 @@
+package store.controller;
+
+import static store.constant.Answer.NO;
+import static store.constant.Answer.YES;
+import static store.constant.OutputInfo.MAY_I_TAKE_YOUR_ORDER;
+import static store.constant.OutputInfo.MEMBERSHIP_DISCOUNT;
+import static store.constant.OutputInfo.PRODUCT_START_MESSAGE;
+import static store.constant.OutputInfo.WANNA_BUY_MORE;
+import static store.constant.OutputInfo.WELCOME_MESSAGE;
+import static store.constant.StoreInfo.PRODUCTS_FILE;
+import static store.constant.StoreInfo.PROMOTIONS_FILE;
+
+import store.constant.Answer;
+import store.model.Store;
+import store.model.order.Order;
+import store.model.order.Orders;
+import store.model.product.Products;
+import store.model.product.ProductsLoader;
+import store.model.product.PromotionProducts;
+import store.model.promotion.Promotions;
+import store.model.promotion.PromotionsLoader;
+import store.model.receipt.PurchaseInfos;
+import store.model.receipt.Receipt;
+import store.util.Task;
+import store.view.InputView;
+import store.view.OutputView;
+
+public class StoreController {
+ public void run() {
+ Store store = loadFilesAndMakeStore();
+
+ while (true) {
+ printWelcomeAndAllProducts(store);
+ takeOrdersAndPrintReceipt(store);
+ if (answerToMoreOrders() == NO) {
+ break;
+ }
+ }
+ }
+
+ private Store loadFilesAndMakeStore() {
+ PromotionsLoader promotionsLoader = new PromotionsLoader(PROMOTIONS_FILE);
+ ProductsLoader productsLoader = new ProductsLoader(PRODUCTS_FILE,
+ new Promotions(promotionsLoader.getPromotions()));
+
+ return new Store(
+ new Products(productsLoader.getProducts()),
+ new PromotionProducts(productsLoader.getPromotionProducts())
+ );
+ }
+
+ private void takeOrdersAndPrintReceipt(Store store) {
+ Orders orders = readAvailableOrders(store);
+
+ readAnswerToFreeGettableCount(store, orders);
+ readAnswerToBuyProductsWithoutPromotion(store, orders);
+
+ OutputView.printReceipt(new Receipt(
+ answerToMembershipDiscount() == YES,
+ sellAllProducts(store, orders)
+ ));
+ }
+
+ private void printWelcomeAndAllProducts(Store store) {
+ OutputView.println(WELCOME_MESSAGE);
+ OutputView.println(PRODUCT_START_MESSAGE);
+ OutputView.printProducts(store.getProducts());
+ OutputView.printPromotionProducts(store.getPromotionProducts());
+ }
+
+ private Orders readAvailableOrders(Store store) {
+ return Task.retryTillNoException(() -> {
+ OutputView.println(MAY_I_TAKE_YOUR_ORDER);
+ Orders orders = new Orders(InputView.readOrders());
+
+ for (Order order : orders.toList()) {
+ store.checkAvailability(order);
+ }
+ return orders;
+ });
+ }
+
+ private void readAnswerToFreeGettableCount(Store store, Orders orders) {
+ for (Order order : orders.toList()) {
+ final int freeGettableCount = store.getFreeGettableCount(order);
+ if (freeGettableCount == 0) {
+ continue;
+ }
+
+ if (answerToGetFreeProducts(order, freeGettableCount) == YES) {
+ order.add(freeGettableCount);
+ }
+ }
+ }
+
+ private Answer answerToGetFreeProducts(Order order, final int freeGettableCount) {
+ return Task.retryTillNoException(() -> {
+ OutputView.printQuestionToFreeGettableCount(order, freeGettableCount);
+ return InputView.readAnswer();
+ });
+ }
+
+ private void readAnswerToBuyProductsWithoutPromotion(Store store, Orders orders) {
+ for (Order order : orders.toList()) {
+ final int buyCountWithoutPromotion = store.getBuyCountWithoutPromotion(order);
+ if (buyCountWithoutPromotion == 0) {
+ continue;
+ }
+
+ if (answerToBuyWithoutPromotion(order, buyCountWithoutPromotion) == NO) {
+ order.cancel(buyCountWithoutPromotion);
+ }
+ }
+ }
+
+ private Answer answerToBuyWithoutPromotion(Order order, final int buyCountWithoutPromotion) {
+ return Task.retryTillNoException(() -> {
+ OutputView.printQuestionToBuyCountWithoutPromotion(order, buyCountWithoutPromotion);
+ return InputView.readAnswer();
+ });
+ }
+
+ private Answer answerToMembershipDiscount() {
+ return Task.retryTillNoException(() -> {
+ OutputView.println(MEMBERSHIP_DISCOUNT);
+ return InputView.readAnswer();
+ });
+ }
+
+ private Answer answerToMoreOrders() {
+ return Task.retryTillNoException(() -> {
+ OutputView.println(WANNA_BUY_MORE);
+ return InputView.readAnswer();
+ });
+ }
+
+ private PurchaseInfos sellAllProducts(Store store, Orders orders) {
+ return new PurchaseInfos(
+ orders.toList().stream()
+ .map(store::sell)
+ .toList()
+ );
+ }
+} | Java | break를 사용하면 코드 흐름을 잡기가 어려워 rladmstn님 말씀처럼 do while로 하는게 좋아보입니다! |
@@ -0,0 +1,44 @@
+package store.util;
+
+import static store.constant.ErrorMessage.INVALID_ORDER_FORMAT;
+import static store.constant.ErrorMessage.WRONG_INPUT;
+import static store.constant.OrderInfo.ORDER_PATTERN;
+import static store.constant.OrderInfo.PRODUCT_COUNT_GROUP;
+import static store.constant.OrderInfo.PRODUCT_NAME_GROUP;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.regex.Matcher;
+import store.model.order.Order;
+
+public class Converter {
+ public static int toInteger(String number) {
+ try {
+ return Integer.parseInt(number);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(WRONG_INPUT.getMessage());
+ }
+ }
+
+ public static LocalDateTime toLocalDateTime(String localDate, String dateFormat) {
+ return LocalDate.parse(
+ localDate,
+ DateTimeFormatter.ofPattern(dateFormat)
+ )
+ .atStartOfDay();
+ }
+
+ public static Order toOrder(String order) {
+ Matcher matcher = ORDER_PATTERN.matcher(order);
+
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException(INVALID_ORDER_FORMAT.getMessage());
+ }
+
+ return new Order(
+ matcher.group(PRODUCT_NAME_GROUP),
+ Converter.toInteger(matcher.group(PRODUCT_COUNT_GROUP))
+ );
+ }
+} | Java | 유틸 클래스로 나누는 본인만의 기준이 있나요? 궁금합니다! |
@@ -0,0 +1,35 @@
+package store.view;
+
+import static store.constant.ErrorMessage.WRONG_INPUT;
+import static store.constant.OrderInfo.ORDER_DELIMITER;
+
+import camp.nextstep.edu.missionutils.Console;
+import java.util.ArrayList;
+import java.util.List;
+import store.constant.Answer;
+import store.model.order.Order;
+import store.util.Converter;
+import store.util.Spliter;
+
+public class InputView {
+ public static List<Order> readOrders() {
+ Spliter spliter = new Spliter(Console.readLine(), ORDER_DELIMITER);
+ List<Order> orders = new ArrayList<>();
+
+ while (spliter.hasMoreTokens()) {
+ String nextToken = spliter.nextToken();
+
+ orders.add(Converter.toOrder(nextToken));
+ }
+ return orders;
+ }
+
+ public static Answer readAnswer() {
+ Answer answer = Answer.getMatchingAnswer(Console.readLine());
+
+ if (answer == null) {
+ throw new IllegalArgumentException(WRONG_INPUT.getMessage());
+ }
+ return answer;
+ }
+} | Java | 주입을 안받고 유틸 클래스로 사용하신 이유가 있나요?? |
@@ -0,0 +1,46 @@
+package store.model.receipt;
+
+import java.util.List;
+
+public class PurchaseInfos {
+ private final List<PurchaseInfo> purchaseInfos;
+
+ public PurchaseInfos(List<PurchaseInfo> purchaseInfos) {
+ this.purchaseInfos = purchaseInfos;
+ }
+
+ public List<PurchaseInfo> toList() {
+ return List.copyOf(purchaseInfos);
+ }
+
+ public List<PurchaseInfo> toPromotionDiscountedList() {
+ return purchaseInfos.stream()
+ .filter(PurchaseInfo::isPromotionDiscounted)
+ .toList();
+ }
+
+ public int getTotalBuyCount() {
+ return purchaseInfos.stream()
+ .mapToInt(PurchaseInfo::getBuyCount)
+ .sum();
+ }
+
+ public int getTotalAmount() {
+ return purchaseInfos.stream()
+ .mapToInt(PurchaseInfo::getTotalAmount)
+ .sum();
+ }
+
+ public int getPromotionDiscountAmount() {
+ return toPromotionDiscountedList().stream()
+ .mapToInt(PurchaseInfo::getPromotionDiscountAmount)
+ .sum();
+ }
+
+ public int getNotPromotionDiscountAppliedProductsAmount() {
+ return purchaseInfos.stream()
+ .filter(PurchaseInfo::isNotPromotionDiscounted)
+ .mapToInt(PurchaseInfo::getTotalAmount)
+ .sum();
+ }
+} | Java | copyof을 통해 읽기용 리스트로 반환하는거 좋은거 같습니다!
Collections.unmodifiableList(purchaseInfos); 이 방법도 있습니다! |
@@ -0,0 +1,30 @@
+package store.constant;
+
+public enum Answer {
+ YES("Y"),
+ NO("N"),
+ ;
+
+ private final String message;
+
+ Answer(String message) {
+ this.message = message;
+ }
+
+ public static Answer getMatchingAnswer(String toFind) {
+ for (Answer answer : Answer.values()) {
+ if (answer.matches(toFind)) {
+ return answer;
+ }
+ }
+ return null;
+ }
+
+ private boolean matches(String answer) {
+ return message.equals(answer);
+ }
+
+ public String getMessage() {
+ return message;
+ }
+} | Java | enum형 활용해서 Y,N만 받을 수 있도록 구현할 수 있는 방법이 있었군요.
저는 생각해보지 못했던 방식이라 새롭네요.. 배워갑니다!! |
@@ -0,0 +1,28 @@
+package store.constant;
+
+public class OutputInfo {
+ public static final String NEW_LINE = "%n";
+ public static final String WELCOME_MESSAGE = "안녕하세요. W편의점입니다.";
+ public static final String PRODUCT_START_MESSAGE = "현재 보유하고 있는 상품입니다." + NEW_LINE;
+ public static final String PRODUCT_FORMAT = "- %s %s원 %s" + NEW_LINE;
+ public static final String PROMOTION_PRODUCT_FORMAT = "- %s %s원 %s %s" + NEW_LINE;
+ public static final String NO_QUANTITY = "재고 없음";
+ public static final String QUANTITY_FORMAT = "%d개";
+ public static final String MAY_I_TAKE_YOUR_ORDER = "구매하실 상품명과 수량을 입력해 주세요. (예: [사이다-2],[감자칩-1])";
+ public static final String FREE_GETTABLE_COUNT_QUESTION =
+ "현재 %s은(는) %d개를 무료로 더 받을 수 있습니다. 추가하시겠습니까? (Y/N)" + NEW_LINE;
+ public static final String BUY_COUNT_WITHOUT_PROMOTION_QUESTION =
+ "현재 %s %d개는 프로모션 할인이 적용되지 않습니다. 그래도 구매하시겠습니까? (Y/N)" + NEW_LINE;
+ public static final String MEMBERSHIP_DISCOUNT = "멤버십 할인을 받으시겠습니까? (Y/N)";
+ public static final String RECEIPT_START_MESSAGE = "==============W 편의점================" + NEW_LINE;
+ public static final String RECEIPT_PURCHASE_INFO_START_MESSAGE = "상품명\t\t수량\t금액" + NEW_LINE;
+ public static final String RECEIPT_PURCHASE_INFO_FORMAT = "%s\t\t%d \t%s" + NEW_LINE;
+ public static final String RECEIPT_FREE_START_MESSAGE = "=============증\t정===============" + NEW_LINE;
+ public static final String RECEIPT_FREE_PRODUCT_FORMAT = "%s\t\t%d" + NEW_LINE;
+ public static final String RECEIPT_PAY_START_MESSAGE = "====================================" + NEW_LINE;
+ public static final String RECEIPT_TOTAL_PRICE_FORMAT = "총구매액\t\t%d\t%s" + NEW_LINE;
+ public static final String RECEIPT_PROMOTION_DISCOUNT_FORMAT = "행사할인\t\t\t-%s" + NEW_LINE;
+ public static final String RECEIPT_MEMBERSHIP_DISCOUNT_FORMAT = "멤버십할인\t\t\t-%s" + NEW_LINE;
+ public static final String RECEIPT_AMOUNT_OF_PAY_FORMAT = "내실돈\t\t\t %s" + NEW_LINE;
+ public static final String WANNA_BUY_MORE = "감사합니다. 구매하고 싶은 다른 상품이 있나요? (Y/N)";
+} | Java | 저도 OutputView에서 사용되는 문자열이 상단에 너무 많아 별도의 파일로 관리해야 할지 고민했었습니다.
그러나 해당 문자열들이 OutputView에서만 사용된다고 판단해 별도의 클래스를 작성하지 않았는데요,
정답이 정해져있는 문제는 아니지만 별도의 클래스를 두신 이유가 궁금합니다! |
@@ -0,0 +1,29 @@
+package store.model.order;
+
+import static store.constant.ErrorMessage.WRONG_INPUT;
+
+import java.util.List;
+
+public class Orders {
+ private final List<Order> orders;
+
+ public Orders(List<Order> orders) {
+ validate(orders);
+ this.orders = orders;
+ }
+
+ private void validate(List<Order> orders) {
+ validateOrderNotDuplicated(orders);
+ }
+
+ private void validateOrderNotDuplicated(List<Order> orders) {
+ int distinctCount = (int) orders.stream().map(Order::getProductName).distinct().count();
+ if (distinctCount != orders.size()) {
+ throw new IllegalArgumentException(WRONG_INPUT.getMessage());
+ }
+ }
+
+ public List<Order> toList() {
+ return List.copyOf(orders);
+ }
+} | Java | `validate` 메소드에서 실행하는 것이 `validateOrderNotDuplicated` 하나인데, `validate`라는 메소드를 따로 만드신 이유가 궁금합니다.
`Orders` 생성자에서 바로 `validateOrderNotDuplicated`를 호출해도 되지 않나요? |
@@ -0,0 +1,50 @@
+package store.model.product;
+
+import static store.constant.ErrorMessage.PRICE_NEGATIVE;
+import static store.constant.ErrorMessage.QUANTITY_NEGATIVE;
+
+public class Product {
+ protected final String name;
+ protected final int price;
+ protected int quantity;
+
+ public Product(String name, final int price, final int quantity) {
+ validate(price, quantity);
+ this.name = name;
+ this.price = price;
+ this.quantity = quantity;
+ }
+
+ private void validate(final int price, final int quantity) {
+ validatePriceNotNegative(price);
+ validateQuantityNotNegative(quantity);
+ }
+
+ private void validatePriceNotNegative(final int price) {
+ if (price < 0) {
+ throw new IllegalArgumentException(PRICE_NEGATIVE.getMessage());
+ }
+ }
+
+ private void validateQuantityNotNegative(final int quantity) {
+ if (quantity < 0) {
+ throw new IllegalArgumentException(QUANTITY_NEGATIVE.getMessage());
+ }
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public int getQuantity() {
+ return quantity;
+ }
+
+ public int getPrice() {
+ return price;
+ }
+
+ public void sell(final int amount) {
+ quantity -= amount;
+ }
+} | Java | `validate`라는 메서드 명이 반복되어서 사용되고 있는데, 저는 개인적으로 다른 클래스에 있더라도 동일한 메서드명을 사용하는 것을 꺼리게 되더라구요.
두 메소드 다 static이 없어서 객체명으로 구분이 되겠지만, 그래도 `validateOrders`나 `validateProduct`와 같이 작성했을 것 같은데, 이에 대한 의견이 궁금합니다! |
@@ -0,0 +1,44 @@
+package store.util;
+
+import static store.constant.ErrorMessage.INVALID_ORDER_FORMAT;
+import static store.constant.ErrorMessage.WRONG_INPUT;
+import static store.constant.OrderInfo.ORDER_PATTERN;
+import static store.constant.OrderInfo.PRODUCT_COUNT_GROUP;
+import static store.constant.OrderInfo.PRODUCT_NAME_GROUP;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.regex.Matcher;
+import store.model.order.Order;
+
+public class Converter {
+ public static int toInteger(String number) {
+ try {
+ return Integer.parseInt(number);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(WRONG_INPUT.getMessage());
+ }
+ }
+
+ public static LocalDateTime toLocalDateTime(String localDate, String dateFormat) {
+ return LocalDate.parse(
+ localDate,
+ DateTimeFormatter.ofPattern(dateFormat)
+ )
+ .atStartOfDay();
+ }
+
+ public static Order toOrder(String order) {
+ Matcher matcher = ORDER_PATTERN.matcher(order);
+
+ if (!matcher.matches()) {
+ throw new IllegalArgumentException(INVALID_ORDER_FORMAT.getMessage());
+ }
+
+ return new Order(
+ matcher.group(PRODUCT_NAME_GROUP),
+ Converter.toInteger(matcher.group(PRODUCT_COUNT_GROUP))
+ );
+ }
+} | Java | Integer.pasreInt와 같이 자주 사용하는 메소드들에 대해서 매변 try-catch를 작성하는 것이 불편하다고 생각했는데, 이런 방식으로 활용할 수 있다는 것을 깨닫고 갑니다! |
@@ -16,7 +16,7 @@
import reviewme.reviewgroup.service.dto.ReviewGroupCreationRequest;
import reviewme.reviewgroup.service.dto.ReviewGroupCreationResponse;
import reviewme.reviewgroup.service.dto.ReviewGroupPageResponse;
-import reviewme.reviewgroup.service.dto.ReviewGroupResponse;
+import reviewme.reviewgroup.service.dto.ReviewGroupSummaryResponse;
@RestController
@RequiredArgsConstructor
@@ -26,8 +26,8 @@ public class ReviewGroupController {
private final ReviewGroupLookupService reviewGroupLookupService;
@GetMapping("/v2/groups/summary")
- public ResponseEntity<ReviewGroupResponse> getReviewGroupSummary(@RequestParam String reviewRequestCode) {
- ReviewGroupResponse response = reviewGroupLookupService.getReviewGroupSummary(reviewRequestCode);
+ public ResponseEntity<ReviewGroupSummaryResponse> getReviewGroupSummary(@RequestParam String reviewRequestCode) {
+ ReviewGroupSummaryResponse response = reviewGroupLookupService.getReviewGroupSummary(reviewRequestCode);
return ResponseEntity.ok(response);
}
| Java | 회의에서
- 이 api 도 reviewGroupId 로 판별할까?🤔
- 리리코로 리뷰 그룹 정보를 식별해오는게 통일도 안된 것 같고 애매하긴 한데,..
호환성의 문제도 있고 복잡하니 일단 api 는 그대로 두고 response 이름만 변경하자! 😇
라고 했어서 반영했습니다~ |
@@ -4,8 +4,6 @@
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
-import reviewme.reviewgroup.controller.ReviewGroupSession;
-import reviewme.reviewgroup.domain.ReviewGroup;
import reviewme.template.service.TemplateService;
import reviewme.template.service.dto.response.SectionNamesResponse;
@@ -16,10 +14,8 @@ public class SectionController {
private final TemplateService templateService;
@GetMapping("/v2/sections")
- public ResponseEntity<SectionNamesResponse> getSectionNames(
- @ReviewGroupSession ReviewGroup reviewGroup
- ) {
- SectionNamesResponse sectionNames = templateService.getSectionNames(reviewGroup);
+ public ResponseEntity<SectionNamesResponse> getSectionNames() {
+ SectionNamesResponse sectionNames = templateService.getSectionNames();
return ResponseEntity.ok(sectionNames);
}
} | Java | 이 부분은 사실 회의에서 `/templates/{templateId}/sections`로 하자고 했었는데,
왜 테드가 기존 api 그대로 두고 고정 응답을 하자고 했는지 코드를 보면서 깨달았어요 ㅠ
templateId 를 받게 해봤자, templateId 를 지정해서 생성하는 곳도 없고, 응답으로 내려주는 곳도 없고...
지금 변경을 하더라도 맥락에 안맞는 변경 같더라고요😅
그래서 기존 내용대로 그대로 뒀습니다!
대신 defaultTemplate 관련된 내용이 응집도있게 존재할 수 있도록
DefaultTemplateService 를 만들어봤어요. |
@@ -0,0 +1,80 @@
+package store;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import store.io.ProductFile;
+import store.io.PromotionFile;
+import store.product.Product;
+import store.utils.ExceptionFactory;
+import store.utils.ExceptionType;
+import store.utils.Transformer;
+import store.utils.Validator;
+
+public class LoadModel {
+ public final static String PRODUCT_LIST_FORMAT = "name,price,quantity,promotion";
+ public final static String PROMOTION_LIST_FROMAT= "name,buy,get,start_date,end_date";
+ public final static String DELIMITER = "\n";
+ final static String RESOURCE_PATH = "./src/main/resources/";
+ final static String PRODUCT_LIST = "products.md";
+ final static String PROMOTION_LIST = "promotions.md";
+ public LoadModel(){
+ }
+
+ public String loadProductList(){
+ String result = readFileAsString(RESOURCE_PATH + PRODUCT_LIST);
+ validateProductList(result);
+ return result;
+ }
+
+ public String loadPromotionList(){
+ String result = readFileAsString(RESOURCE_PATH + PROMOTION_LIST);
+ validatePromotionList(result);
+ return result;
+ }
+
+ public List<String> readFile(String path){
+ Validator.validateFileSize(path);
+ try {
+ return Files.readAllLines(Paths.get(path));
+ } catch (IOException exception){
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.READ_FILE_FAIL,exception);
+ throw new RuntimeException();
+ }
+ }
+
+ public String readFileAsString(String path){
+
+ List<String> contents = readFile(path);
+ if(contents.isEmpty()) {
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.EMPTY_FILE);
+ }
+ return Transformer.concatenateList(contents,DELIMITER);
+ }
+
+ public static void validateProductList(String products){
+ if(products.isBlank()) {
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.EMPTY_FILE);
+ }
+ List<String> productList = Arrays.stream(products.split(DELIMITER)).toList();
+ if(!productList.getFirst().equals(PRODUCT_LIST_FORMAT)){
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.INVALID_FILE_FORMAT);
+ }
+ Validator.validateEachLine(productList, ProductFile.COLUMN_DELIMITER,ProductFile.values().length);
+ }
+
+ public static void validatePromotionList(String promotions){
+ if(promotions.isBlank()) {
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.EMPTY_FILE);
+ }
+ List<String> promotionList = Arrays.stream(promotions.split(DELIMITER)).toList();
+ if(!promotionList.getFirst().equals(PROMOTION_LIST_FROMAT)){
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.INVALID_FILE_FORMAT);
+ }
+ Validator.validateEachLine(promotionList,PromotionFile.COLUMN_DELIMITER,PromotionFile.values().length);
+ }
+
+
+} | Java | 파일 내용 전체를 읽어와서 `\n`으로 split하신 것이 인상깊네요! 다만 운영체제에 따라 줄바꿈 문자가 다를 수 있어서, 문제가 발생할 수도 있다고 하더라구요.
그래서 파일에 접근해서 한 줄씩 읽어오는 방식도 좋을 것 같다고 생각합니다! |
@@ -0,0 +1,80 @@
+package store;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import store.io.ProductFile;
+import store.io.PromotionFile;
+import store.product.Product;
+import store.utils.ExceptionFactory;
+import store.utils.ExceptionType;
+import store.utils.Transformer;
+import store.utils.Validator;
+
+public class LoadModel {
+ public final static String PRODUCT_LIST_FORMAT = "name,price,quantity,promotion";
+ public final static String PROMOTION_LIST_FROMAT= "name,buy,get,start_date,end_date";
+ public final static String DELIMITER = "\n";
+ final static String RESOURCE_PATH = "./src/main/resources/";
+ final static String PRODUCT_LIST = "products.md";
+ final static String PROMOTION_LIST = "promotions.md";
+ public LoadModel(){
+ }
+
+ public String loadProductList(){
+ String result = readFileAsString(RESOURCE_PATH + PRODUCT_LIST);
+ validateProductList(result);
+ return result;
+ }
+
+ public String loadPromotionList(){
+ String result = readFileAsString(RESOURCE_PATH + PROMOTION_LIST);
+ validatePromotionList(result);
+ return result;
+ }
+
+ public List<String> readFile(String path){
+ Validator.validateFileSize(path);
+ try {
+ return Files.readAllLines(Paths.get(path));
+ } catch (IOException exception){
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.READ_FILE_FAIL,exception);
+ throw new RuntimeException();
+ }
+ }
+
+ public String readFileAsString(String path){
+
+ List<String> contents = readFile(path);
+ if(contents.isEmpty()) {
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.EMPTY_FILE);
+ }
+ return Transformer.concatenateList(contents,DELIMITER);
+ }
+
+ public static void validateProductList(String products){
+ if(products.isBlank()) {
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.EMPTY_FILE);
+ }
+ List<String> productList = Arrays.stream(products.split(DELIMITER)).toList();
+ if(!productList.getFirst().equals(PRODUCT_LIST_FORMAT)){
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.INVALID_FILE_FORMAT);
+ }
+ Validator.validateEachLine(productList, ProductFile.COLUMN_DELIMITER,ProductFile.values().length);
+ }
+
+ public static void validatePromotionList(String promotions){
+ if(promotions.isBlank()) {
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.EMPTY_FILE);
+ }
+ List<String> promotionList = Arrays.stream(promotions.split(DELIMITER)).toList();
+ if(!promotionList.getFirst().equals(PROMOTION_LIST_FROMAT)){
+ ExceptionFactory.throwIllegalArgumentException(ExceptionType.INVALID_FILE_FORMAT);
+ }
+ Validator.validateEachLine(promotionList,PromotionFile.COLUMN_DELIMITER,PromotionFile.values().length);
+ }
+
+
+} | Java | 유지보수의 관점에서 생각했을 때, 저는 그냥 첫 줄을 skip하는 것이 좋겠다고 판단했습니다! product의 형식은 언제든 달라질 수 있고, 달라질 때마다 `PRODUCT_LIST_FORMAT`를 수정하면 번거롭겠다고 생각했기 떄문입니다.
여기에 대해 어떻게 생각하시는지 궁금합니다! |
@@ -0,0 +1,125 @@
+package store;
+
+import java.util.List;
+import store.product.Product;
+import store.product.Receipt;
+import store.utils.Transformer;
+
+public class StoreOutputView {
+
+ public void welcomeConsumer(List<Product> products){
+ StoreViewMessage.WELCOME.printMessage();
+ for(Product product : products){
+ printSellingProduct(product);
+ }
+ }
+
+ public void printAccount(List<Receipt> receipts, int disCountPrice){
+ StoreViewMessage.RECEIPT_HEAD.printMessage();
+ printPurchaseProductList(receipts);
+ printPromotionReturnProductList(receipts);
+ printBill(receipts,disCountPrice);
+ }
+
+ public void printSellingProduct(Product product){
+ String promotionName = "";
+ if(product.isPromotionExist()){
+ promotionName = product.getPromotionName();
+ }
+
+ if(product.isInsufficient()){
+ StoreViewMessage.printInsufficientProduct(product.getName(),product.getPrice(),promotionName);
+ return;
+ }
+ StoreViewMessage.printProduct(product.getName(),product.getPrice(),product.getCount(),promotionName);
+ }
+
+
+ public void printPurchaseProductList(List<Receipt> receipts){
+
+ StoreViewMessage.printReceiptProductListHead();
+ for(Receipt receipt : receipts){
+ StoreViewMessage.printReceiptFormat(receipt.getProductName(), Integer.toString(receipt.getActualCount()),Integer.toString(receipt.getActualPrice()));
+ }
+
+ }
+
+ public void printPromotionReturnProductList(List<Receipt> receipts){
+ StoreViewMessage.RECEIPT_HEAD_PROMOTION.printMessage();
+ String emtpy = "";
+ List<Receipt> promotionReceipts = receipts.stream().filter((Receipt::isPromotionApplied)).toList();
+ for(Receipt receipt : promotionReceipts){
+ StoreViewMessage.printReceiptFormat(receipt.getProductName(),Integer.toString(receipt.getActualCount()),emtpy);
+ }
+ }
+
+ public void printBill(List<Receipt> receipts, int disCountPrice){
+ StoreViewMessage.RECEIPT_HEAD_ACCOUNT.printMessage();
+ List<Integer> accounts = calculateTotalReceipt(receipts);
+ int totalCountColumn = 0;
+ int promotedPriceColumn = 1;
+ int totalActualPrice = 2;
+
+ printBillMessage(accounts.get(totalCountColumn),accounts.get(promotedPriceColumn),accounts.get(totalActualPrice),disCountPrice);
+ }
+
+ public void printBillMessage(int totalCount, int promotedPrice, int totalActualPrice, int disCountPrice){
+ printBillMessageTotalActualPrice(totalCount,totalActualPrice);
+ printBillMessagePromotionDiscount(promotedPrice);
+ printBillMessageMembershipDiscount(disCountPrice);
+ printBillMessageTotalPrice(totalActualPrice - promotedPrice - disCountPrice);
+ }
+
+ public void printBillMessageTotalActualPrice(int totalCount,int totalActualPrice){
+ String empty = "";
+ String column = "총구매액";
+ StoreViewMessage.printReceiptFormat(column,Integer.toString(totalCount), Transformer.transformToThousandSeparated(totalActualPrice));
+ }
+
+ public void printBillMessagePromotionDiscount(int promotedPrice){
+ String empty = "";
+ String column = "행사할인";
+ int zero = 0;
+ String discount = "-";
+ if(promotedPrice == zero){
+ discount="";
+ }
+ discount += Transformer.transformToThousandSeparated(promotedPrice);
+
+ StoreViewMessage.printReceiptFormat(column,empty,discount);
+ }
+
+ public void printBillMessageMembershipDiscount(int disCountPrice){
+ String empty = "";
+ String column = "멤버십할인";
+ int zero = 0;
+ String discount = "-";
+ if(disCountPrice == zero){
+ discount="";
+ }
+ discount += Transformer.transformToThousandSeparated(disCountPrice);
+
+ StoreViewMessage.printReceiptFormat(column,empty,discount);
+ }
+
+ public void printBillMessageTotalPrice(int totalPrice){
+ String empty = "";
+ String column = "내실돈";
+
+ StoreViewMessage.printReceiptFormat(column,empty,Transformer.transformToThousandSeparated(totalPrice));
+ }
+
+ public List<Integer> calculateTotalReceipt(List<Receipt> receipts){
+ int totalCount = 0;
+ int promotedPrice = 0;
+ int totalActualPrice = 0;
+ for(Receipt receipt : receipts){
+ totalCount += receipt.getActualCount();
+ promotedPrice += receipt.getDisCountPrice();
+ totalActualPrice += receipt.getActualPrice();
+ }
+
+ return List.of(totalCount,promotedPrice,totalActualPrice) ;
+ }
+
+} | Java | 저는 `model`의 데이터를 출력해주려 할 때에는 `dto`를 사용했는데, @armcortex3445 님께서 사용하신 방법처럼 객체를 복사해서 `view`로 넘겨줘도 되겠다는 생각이 드네요!
혹시 @armcortex3445 님은 출력을 위해 `dto`를 사용하는 것에 대해 어떻게 생각하시나요? 저는 `dto`를 사용하면 출력에 필요한 값만 따로 관리할 수 있고, 출력문을 만드는 로직을 그 안에 만들 수도 있어서 좋다고 생각합니다! |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.