cotato-mange 과제 구현

src/main/java/cotato/cotatomanage/controller/ManageController.java

@@ -0,0 +1,37 @@
+package cotato.cotatomanage.controller;
+
+import cotato.cotatomanage.domain.dto.JoinMemberRequest;
+import cotato.cotatomanage.service.ManageService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/member")
+public class ManageController {
+
+    private final ManageService memberService;
+    @PostMapping("/join")
+    public ResponseEntity<?> createMember(@RequestBody JoinMemberRequest request){
+        memberService.addMember(request);
+        return ResponseEntity.status(HttpStatus.CREATED).build();
+    }
+
+    @GetMapping("/print/part/{period}")
+    public ResponseEntity<?> printByPart(@PathVariable("period") int period){
+        return ResponseEntity.ok().body(memberService.printByPart(period));
+    }
+
+    @GetMapping("/print/member/{period}")
+    public ResponseEntity<?> printAllMembers(@PathVariable("period") int period) {
+        return ResponseEntity.ok().body(memberService.printAllMembers(period));
+    }
+
+    @GetMapping("/print/{part}/member/{period}")
+    public ResponseEntity<?> printAllMembersByPart(@PathVariable("part") String part, @PathVariable("period") int period) {
+        return ResponseEntity.ok().body(memberService.printAllMembersByPart(period,part));
+    }
+}

src/main/java/cotato/cotatomanage/domain/Part.java

@@ -0,0 +1,17 @@
+package cotato.cotatomanage.domain;
+
+import lombok.Getter;
+
+@Getter
+public enum Part {
+    디자이너(1),
+    기획(2),
+    백엔드(3),
+    프론트엔드(4);
+
+    private final int order;
+
+    Part(int order) {
+        this.order = order;
+    }
+}

src/main/java/cotato/cotatomanage/domain/dto/JoinMemberRequest.java

@@ -0,0 +1,11 @@
+package cotato.cotatomanage.domain.dto;
+
+import lombok.Getter;
+
+@Getter
+public class JoinMemberRequest {
+    private String name;
+    private String period;
+    private int age;
+    private String part;
+}

src/main/java/cotato/cotatomanage/domain/dto/MemberResponse.java

@@ -0,0 +1,32 @@
+package cotato.cotatomanage.domain.dto;
+
+import java.util.Comparator;
+
+public class MemberResponse implements Comparable<MemberResponse> {
+
+    private String name;
+    private String period;
+    private int ability;
+
+    @Override
+    public int compareTo(MemberResponse o) {
+        return Comparator
+                .comparing(MemberResponse::getAbility, Comparator.reverseOrder())
+                .thenComparing(MemberResponse::getPeriod, Comparator.reverseOrder())
+                .thenComparing(MemberResponse::getName)
+                .compare(this, o);
+    }
+
+    public int getAbility() {
+        return ability;
+    }
+
+    public String getPeriod() {
+        return period;
+    }
+
+    public String getName() {
+        return name;
+    }
+}
+

src/main/java/cotato/cotatomanage/domain/dto/PartResponse.java

@@ -0,0 +1,30 @@
+package cotato.cotatomanage.domain.dto;
+
+import cotato.cotatomanage.domain.Part;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+
+@Getter
+@Slf4j
+public class PartResponse implements Comparable<PartResponse> {
+    private Part part;
+    private int ability;
+    private int count;
+
+    @Override
+    public int compareTo(PartResponse other) {
+        log.info(this.part.name() + " " + this.ability + " " + other.part.name() + " " + other.ability);
+
+        int abilityComparision = Integer.compare(other.ability, this.ability);
+        if(abilityComparision != 0){
+            return abilityComparision;
+        }
+
+        int countComparison = Integer.compare(this.count, other.count);
+        if (countComparison != 0) {
+            return countComparison;
+        }
+
+        return Integer.compare(this.part.getOrder(), other.part.getOrder());
+    }
+}

src/main/java/cotato/cotatomanage/domain/entity/Member.java

@@ -0,0 +1,94 @@
+package cotato.cotatomanage.domain.entity;
+
+import cotato.cotatomanage.domain.Part;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+
+import java.time.LocalDate;
+import java.util.Arrays;
+
+@Getter
+@Slf4j
+public class Member implements Comparable<Member> {
+    private static final int MIN_AGE = 22;
+    private static final int MAX_AGE = 30;
+    private static final int CURRENT_PERIOD = 9;
+
+    private String name;
+    private String period;
+    private int age;
+    private Part part;
+    private int ability;
+
+    @Builder
+    public Member(String name, String period, int age, String part) {
+        validate(name, part, age);
+        this.name = name;
+        this.period = period;
+        this.age = age;
+        this.part = Part.valueOf(part);
+        this.ability = setAbility();
+    }
+
+    private int setAbility() {
+        int intPeriod = Integer.parseInt(period.split("기")[0]);
+        int periodAbility = (CURRENT_PERIOD - intPeriod) * 2;
+        int partAbility = age < 27 ? getBuffPart(part.name()) : 0;
+        return age + periodAbility + partAbility;
+    }
+
+    public void updateAbility(int currentPeriod) {
+        int intPeriod = Integer.parseInt(period.split("기")[0]);
+        int periodAbility = (currentPeriod - intPeriod) * 2;
+        int partAbility = age < 27 ? getBuffPart(part.name()) : 0;
+        this.ability = age + periodAbility + partAbility;
+    }
+
+    private int getBuffPart(String part) {
+        int month = LocalDate.now().getMonthValue();
+        String buffPart;
+        switch (month) {
+            case 1, 5, 9 -> buffPart = "기획";
+            case 2, 6, 10 -> buffPart = "디자이너";
+            case 3, 7, 11 -> buffPart = "프론트엔드";
+            default -> buffPart = "백엔드";
+        }
+        return buffPart.equals(part) ? 10 : 0;
+    }
+
+    private void validate(String name, String part, int age) {
+        if (name.isBlank() || name.length() < 3 || name.length() > 10) {
+            throw new IllegalArgumentException("이름은 3자에서 10자 사이여야 합니다.");
+        }
+        if (age > MAX_AGE || age < MIN_AGE) {
+            throw new IllegalArgumentException("나이는 " + MIN_AGE + "에서 " + MAX_AGE + "사이여야 합니다.");
+        }
+        if (Arrays.stream(Part.values()).noneMatch(v -> v.name().equals(part))) {
+            throw new IllegalArgumentException("유효하지 않은 파트입니다.");
+        }
+    }
+
+    @Override
+    public int compareTo(Member o) {
+        int abilityComparison = Integer.compare(o.getAbility(), this.ability);
+
+        if (abilityComparison != 0) {
+            return abilityComparison;
+        }
+
+        int ageComparison = Integer.compare(this.age, o.age);
+
+        if (ageComparison != 0) {
+            return ageComparison;
+        }
+
+        int periodComparison = this.period.compareTo(o.period);
+
+        if (periodComparison != 0) {
+            return periodComparison;
+        }
+
+        return this.name.compareTo(o.name);
+    }
+}

src/main/java/cotato/cotatomanage/repository/MemberRepository.java

@@ -0,0 +1,86 @@
+package cotato.cotatomanage.repository;
+
+
+import cotato.cotatomanage.domain.entity.Member;
+import cotato.cotatomanage.domain.Part;
+import cotato.cotatomanage.domain.dto.PartResponse;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.PriorityQueue;
+
+@Getter
+@Slf4j
+public class MemberRepository {
+    private List<Member> members = new ArrayList<>();
+    @Getter
+    private static MemberRepository instance = new MemberRepository();
+
+    public void addMember(Member member) {
+        members.add(member);
+    }
+
+    public void calculateAbility(int currentPeriod){
+        members.forEach(member -> member.updateAbility(currentPeriod));
+        log.info("calculateAbility finished");
+    }
+
+    public List<Member> orderAllMembers() {
+        return printMemberWithOrder(members);
+    }
+
+    public List<PartResponse> orderByPart() {
+        PriorityQueue<PartResponse> list = new PriorityQueue<>();
+        for (Part part : Part.values()) {
+            PartResponse data = makeOrderByPartResponse(part);
+            if (data!=null) {
+                list.add(data);
+            }
+        }
+        List<PartResponse> orderedList = new ArrayList<>();
+        while (!list.isEmpty()){
+            PartResponse tmp = list.poll();
+            log.info(tmp.getPart().name());
+            orderedList.add(tmp);
+        }
+        return orderedList;
+    }
+
+    public List<Member> orderAllMembersByPart(String part) {
+        Part enumPart = Part.valueOf(part);
+        List<Member> members = findAllMembersByPart(enumPart);
+        return printMemberWithOrder(members);
+    }
+
+    private List<Member> printMemberWithOrder(List<Member> members) {
+        PriorityQueue<Member> list = new PriorityQueue<>();
+        list.addAll(members);
+        List<Member> orderedList = new ArrayList<>();
+        while (!list.isEmpty()) {
+            Member tmp = list.poll();
+            orderedList.add(tmp);
+        }
+        return orderedList;
+    }
+
+    private PartResponse makeOrderByPartResponse(Part part) {
+        List<Member> findMembersByPart = findAllMembersByPart(part);
+        int count = findMembersByPart.size();
+        if(count==0){
+            return null;
+        }
+        int average = (findMembersByPart.stream().mapToInt(Member::getAbility).sum())/count;
+
+        return PartResponse.builder()
+                .part(part)
+                .ability(average)
+                .count(count)
+                .build();
+    }
+
+    private List<Member> findAllMembersByPart(Part part) {
+        return members.stream().filter(member -> member.getPart().equals(part)).toList();
+    }
+}

src/main/java/cotato/cotatomanage/service/ManageService.java

@@ -0,0 +1,46 @@
+package cotato.cotatomanage.service;
+
+import cotato.cotatomanage.domain.entity.Member;
+import cotato.cotatomanage.repository.MemberRepository;
+import cotato.cotatomanage.domain.dto.JoinMemberRequest;
+import cotato.cotatomanage.domain.dto.PartResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Slf4j
+@Service
+public class ManageService {
+    MemberRepository memberRepository = MemberRepository.getInstance();
+
+    public void addMember(JoinMemberRequest request) {
+        Member member = Member.builder()
+                .age(request.getAge())
+                .part(request.getPart())
+                .name(request.getName())
+                .period(request.getPeriod())
+                .build();
+        memberRepository.addMember(member);
+        memberRepository.getMembers()
+                .forEach(member1 -> log.info(member1.getName() + " " + member1.getPart().name() + " " + member1.getAbility()));
+    }
+
+    public List<PartResponse> printByPart(int period) {
+        log.info("printByPart Start");
+        memberRepository.calculateAbility(period);
+        return memberRepository.orderByPart();
+    }
+
+    public List<Member> printAllMembers(int period) {
+        log.info("printAllMembers Start");
+        memberRepository.calculateAbility(period);
+        return memberRepository.orderAllMembers();
+    }
+
+    public List<Member> printAllMembersByPart(int period, String part) {
+        log.info("printAllMembersByPart Start");
+        memberRepository.calculateAbility(period);
+        return memberRepository.orderAllMembersByPart(part);
+    }
+}