feat: implement portfolio api

api-server/src/main/java/nexters/payout/apiserver/portfolio/application/PortfolioQueryService.java

@@ -0,0 +1,128 @@
+package nexters.payout.apiserver.portfolio.application;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import nexters.payout.apiserver.portfolio.application.dto.response.MonthlyDividendResponse;
+import nexters.payout.apiserver.portfolio.application.dto.response.SingleYearlyDividendResponse;
+import nexters.payout.apiserver.portfolio.application.dto.response.YearlyDividendResponse;
+import nexters.payout.apiserver.portfolio.application.dto.response.SingleMonthlyDividendResponse;
+import nexters.payout.apiserver.portfolio.application.dto.request.PortfolioRequest;
+import nexters.payout.apiserver.portfolio.application.dto.response.PortfolioResponse;
+import nexters.payout.core.time.InstantProvider;
+import nexters.payout.domain.dividend.domain.Dividend;
+import nexters.payout.domain.dividend.domain.repository.DividendRepository;
+import nexters.payout.domain.portfolio.domain.Portfolio;
+import nexters.payout.domain.portfolio.domain.PortfolioStock;
+import nexters.payout.domain.portfolio.domain.exception.PortfolioNotFoundException;
+import nexters.payout.domain.portfolio.domain.repository.PortfolioRepository;
+import nexters.payout.domain.stock.domain.Stock;
+import nexters.payout.domain.stock.domain.exception.StockIdNotFoundException;
+import nexters.payout.domain.stock.domain.exception.TickerNotFoundException;
+import nexters.payout.domain.stock.domain.repository.StockRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Service
+@RequiredArgsConstructor
+@Transactional
+@Slf4j
+public class PortfolioQueryService {
+
+    private final StockRepository stockRepository;
+    private final PortfolioRepository portfolioRepository;
+    private final DividendRepository dividendRepository;
+
+    public PortfolioResponse createPortfolio(final PortfolioRequest request) {
+
+        List<PortfolioStock> portfolioStocks =
+                request.tickerShares()
+                        .stream().map(tickerShare -> new PortfolioStock(
+                                stockRepository.findByTicker(tickerShare.ticker())
+                                        .orElseThrow(() -> new TickerNotFoundException(tickerShare.ticker()))
+                                        .getId(),
+                                tickerShare.share()))
+                        .toList();
+
+        return new PortfolioResponse(portfolioRepository.save(
+                new Portfolio(
+                        InstantProvider.getExpireAt(),
+                        portfolioStocks
+                )).getId()
+        );
+    }
+
+    @Transactional(readOnly = true)
+    public List<MonthlyDividendResponse> getMonthlyDividends(final UUID id) {
+        return InstantProvider.generateNext12Months()
+                .stream()
+                .map(yearMonth -> MonthlyDividendResponse.of(
+                                yearMonth.getYear(),
+                                yearMonth.getMonthValue(),
+                                getDividendsOfLastYearAndMonth(
+                                        portfolioRepository.findById(id)
+                                                .orElseThrow(() -> new PortfolioNotFoundException(id))
+                                                .getPortfolioStocks().getPortfolioStocks(),
+                                        yearMonth.getMonthValue())
+                        )
+                )
+                .collect(Collectors.toList());
+    }
+
+    @Transactional(readOnly = true)
+    public YearlyDividendResponse getYearlyDividends(final UUID id) {
+
+        List<SingleYearlyDividendResponse> dividends = portfolioRepository.findById(id)
+                .orElseThrow(() -> new PortfolioNotFoundException(id))
+                .getPortfolioStocks().getPortfolioStocks()
+                .stream().map(portfolioStock -> {
+                    Stock stock = stockRepository.findById(portfolioStock.getStockId())
+                            .orElseThrow(() -> new StockIdNotFoundException(portfolioStock.getStockId()));
+                    return SingleYearlyDividendResponse.of(
+                            stock, portfolioStock.getShares(), getYearlyDividend(stock.getId())
+                    );
+                })
+                .filter(response -> response.totalDividend() != 0)
+                .toList();
+
+        return YearlyDividendResponse.of(dividends);
+    }
+
+    private double getYearlyDividend(final UUID stockId) {
+        return getLastYearDividendsByStockId(stockId)
+                .stream()
+                .mapToDouble(Dividend::getDividend)
+                .sum();
+    }
+
+    private List<Dividend> getLastYearDividendsByStockId(final UUID id) {
+        return dividendRepository.findAllByIdAndYear(id, InstantProvider.getLastYear());
+    }
+
+    private List<SingleMonthlyDividendResponse> getDividendsOfLastYearAndMonth(
+            final List<PortfolioStock> portfolioStocks, final int month
+    ) {
+        return portfolioStocks
+                .stream()
+                .flatMap(portfolioStock -> stockRepository.findById(portfolioStock.getStockId())
+                        .map(stock -> getMonthlyDividendResponse(month, portfolioStock, stock))
+                        .orElseThrow(() -> new StockIdNotFoundException(portfolioStock.getStockId())))
+                .toList();
+    }
+
+    private Stream<SingleMonthlyDividendResponse> getMonthlyDividendResponse(
+            final int month, final PortfolioStock portfolioStock, final Stock stock
+    ) {
+        return getLastYearDividendsByStockIdAndMonth(portfolioStock.getStockId(), month)
+                .stream()
+                .map(dividend -> SingleMonthlyDividendResponse.of(stock, portfolioStock.getShares(), dividend));
+    }
+
+    private List<Dividend> getLastYearDividendsByStockIdAndMonth(final UUID stockId, final int month) {
+        return dividendRepository.findAllByIdAndYearAndMonth(stockId, InstantProvider.getLastYear(), month);
+    }
+}

api-server/src/main/java/nexters/payout/apiserver/portfolio/application/dto/request/PortfolioRequest.java

@@ -0,0 +1,15 @@
+package nexters.payout.apiserver.portfolio.application.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Size;
+
+import java.util.List;
+
+public record PortfolioRequest(
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        @Valid
+        @Size(min = 1)
+        List<TickerShare> tickerShares
+) {
+}

api-server/src/main/java/nexters/payout/apiserver/portfolio/application/dto/request/TickerShare.java

@@ -0,0 +1,14 @@
+package nexters.payout.apiserver.portfolio.application.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotEmpty;
+
+public record TickerShare(
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED, example = "ticker name")
+        @NotEmpty
+        String ticker,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED, example = "share")
+        @Min(value = 1)
+        Integer share
+) { }

api-server/src/main/java/nexters/payout/apiserver/portfolio/application/dto/response/MonthlyDividendResponse.java

@@ -0,0 +1,32 @@
+package nexters.payout.apiserver.portfolio.application.dto.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.util.Comparator;
+import java.util.List;
+
+public record MonthlyDividendResponse(
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        Integer year,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        Integer month,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        List<SingleMonthlyDividendResponse> dividends,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        Double totalDividend
+) {
+    public static MonthlyDividendResponse of(
+            final int year, final int month, final List<SingleMonthlyDividendResponse> dividends
+    ) {
+        return new MonthlyDividendResponse(
+                year,
+                month,
+                dividends.stream()
+                        .sorted(Comparator.comparingDouble(SingleMonthlyDividendResponse::totalDividend).reversed())
+                        .toList(),
+                dividends.stream()
+                        .mapToDouble(SingleMonthlyDividendResponse::totalDividend)
+                        .sum()
+        );
+    }
+}

api-server/src/main/java/nexters/payout/apiserver/portfolio/application/dto/response/PortfolioResponse.java

@@ -0,0 +1,11 @@
+package nexters.payout.apiserver.portfolio.application.dto.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.util.UUID;
+
+public record PortfolioResponse(
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        UUID id
+) {
+}

api-server/src/main/java/nexters/payout/apiserver/portfolio/application/dto/response/SingleMonthlyDividendResponse.java

@@ -0,0 +1,28 @@
+package nexters.payout.apiserver.portfolio.application.dto.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import nexters.payout.domain.dividend.domain.Dividend;
+import nexters.payout.domain.stock.domain.Stock;
+
+public record SingleMonthlyDividendResponse(
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        String ticker,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        String logoUrl,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        Integer share,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        Double dividend,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        Double totalDividend
+) {
+    public static SingleMonthlyDividendResponse of(Stock stock, int share, Dividend dividend) {
+        return new SingleMonthlyDividendResponse(
+                stock.getTicker(),
+                stock.getLogoUrl(),
+                share,
+                dividend.getDividend(),
+                dividend.getDividend() * share
+        );
+    }
+}

api-server/src/main/java/nexters/payout/apiserver/portfolio/application/dto/response/SingleYearlyDividendResponse.java

@@ -0,0 +1,24 @@
+package nexters.payout.apiserver.portfolio.application.dto.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import nexters.payout.domain.stock.domain.Stock;
+
+public record SingleYearlyDividendResponse(
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        String ticker,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        String logoUrl,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        Integer share,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        Double totalDividend
+) {
+    public static SingleYearlyDividendResponse of(Stock stock, int share, double dividend) {
+        return new SingleYearlyDividendResponse(
+                stock.getTicker(),
+                stock.getLogoUrl(),
+                share,
+                dividend * share
+        );
+    }
+}

api-server/src/main/java/nexters/payout/apiserver/portfolio/application/dto/response/YearlyDividendResponse.java

@@ -0,0 +1,28 @@
+package nexters.payout.apiserver.portfolio.application.dto.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.util.Comparator;
+import java.util.List;
+
+public record YearlyDividendResponse(
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        List<SingleYearlyDividendResponse> dividends,
+        @Schema(requiredMode = Schema.RequiredMode.REQUIRED)
+        Double totalDividend
+) {
+    public static YearlyDividendResponse of(List<SingleYearlyDividendResponse> dividends) {
+
+        dividends = dividends
+                .stream()
+                .sorted(Comparator.comparingDouble(SingleYearlyDividendResponse::totalDividend).reversed())
+                .toList();
+        return new YearlyDividendResponse(
+                dividends,
+                dividends
+                        .stream()
+                        .mapToDouble(SingleYearlyDividendResponse::totalDividend)
+                        .sum()
+        );
+    }
+}

api-server/src/main/java/nexters/payout/apiserver/portfolio/presentation/PortfolioController.java

@@ -0,0 +1,39 @@
+package nexters.payout.apiserver.portfolio.presentation;
+
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import nexters.payout.apiserver.portfolio.application.PortfolioQueryService;
+import nexters.payout.apiserver.portfolio.application.dto.request.PortfolioRequest;
+import nexters.payout.apiserver.portfolio.application.dto.response.MonthlyDividendResponse;
+import nexters.payout.apiserver.portfolio.application.dto.response.PortfolioResponse;
+import nexters.payout.apiserver.portfolio.application.dto.response.YearlyDividendResponse;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.UUID;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/portfolios")
+@Slf4j
+public class PortfolioController implements PortfolioControllerDocs {
+
+    private final PortfolioQueryService portfolioQueryService;
+
+    @PostMapping
+    public ResponseEntity<PortfolioResponse> createPortfolio(@RequestBody @Valid final PortfolioRequest portfolioRequest) {
+        return ResponseEntity.ok(portfolioQueryService.createPortfolio(portfolioRequest));
+    }
+
+    @GetMapping("/{id}/monthly")
+    public ResponseEntity<List<MonthlyDividendResponse>> getMonthlyDividends(@PathVariable("id") final UUID portfolioId) {
+        return ResponseEntity.ok(portfolioQueryService.getMonthlyDividends(portfolioId));
+    }
+
+    @GetMapping("/{id}/yearly")
+    public ResponseEntity<YearlyDividendResponse> getYearlyDividends(@PathVariable("id") final UUID portfolioId) {
+        return ResponseEntity.ok(portfolioQueryService.getYearlyDividends(portfolioId));
+    }
+}