구매자 페이먼트 충전

src/main/java/camp/woowak/lab/LabApplication.java

@@ -2,8 +2,10 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 
 @SpringBootApplication
+@EnableJpaAuditing
 public class LabApplication {
 
 	public static void main(String[] args) {

src/main/java/camp/woowak/lab/payaccount/domain/AccountTransactionType.java

@@ -0,0 +1,5 @@
+package camp.woowak.lab.payaccount.domain;
+
+public enum AccountTransactionType {
+	DEPOSIT, WITHDRAW, CHARGE;
+}

src/main/java/camp/woowak/lab/payaccount/domain/PayAccount.java

@@ -1,13 +1,100 @@
 package camp.woowak.lab.payaccount.domain;
 
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.hibernate.annotations.ColumnDefault;
+
+import camp.woowak.lab.payaccount.exception.DailyLimitExceededException;
+import camp.woowak.lab.payaccount.exception.InsufficientBalanceException;
+import camp.woowak.lab.payaccount.exception.InvalidTransactionAmountException;
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
+import jakarta.persistence.OneToMany;
 
 @Entity
 public class PayAccount {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+
+	@Column(name = "balance", nullable = false)
+	@ColumnDefault("0")
+	private long balance;
+
+	@OneToMany(mappedBy = "payAccount", fetch = FetchType.LAZY, cascade = CascadeType.PERSIST)
+	private List<PayAccountHistory> history = new ArrayList<>();
+
+	public PayAccount() {
+		this.balance = 0;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public long getBalance() {
+		return this.balance;
+	}
+
+	public PayAccountHistory withdraw(long amount) {
+		validateTransactionAmount(amount);
+		validateInsufficientBalance(amount);
+		this.balance -= amount;
+
+		return issueAndSavePayAccountHistory(amount, AccountTransactionType.WITHDRAW);
+	}
+
+	public PayAccountHistory deposit(long amount) {
+		validateTransactionAmount(amount);
+		this.balance += amount;
+
+		return issueAndSavePayAccountHistory(amount, AccountTransactionType.DEPOSIT);
+	}
+
+	public PayAccountHistory charge(long amount) {
+		validateTransactionAmount(amount);
+		validateDailyChargeLimit(amount);
+		this.balance += amount;
+
+		return issueAndSavePayAccountHistory(amount, AccountTransactionType.CHARGE);
+	}
+
+	private PayAccountHistory issueAndSavePayAccountHistory(long amount, AccountTransactionType type) {
+		PayAccountHistory payAccountHistory = new PayAccountHistory(this, amount, type);
+		this.history.add(payAccountHistory);
+
+		return payAccountHistory;
+	}
+
+	private void validateDailyChargeLimit(long amount) {
+		LocalDateTime startOfDay = LocalDateTime.now().toLocalDate().atStartOfDay();
+		LocalDateTime endOfDay = startOfDay.plusDays(1);
+
+		long todayTotalCharge = history.stream()
+			.filter(h -> h.getType() == AccountTransactionType.CHARGE)
+			.filter(h -> h.getCreatedAt().isAfter(startOfDay) && h.getCreatedAt().isBefore(endOfDay))
+			.mapToLong(PayAccountHistory::getAmount)
+			.sum();
+
+		if (todayTotalCharge + amount > 1_000_000) {
+			throw new DailyLimitExceededException("Daily charge limit of " + 1_000_000 + " exceeded.");
+		}
+	}
+
+	private void validateTransactionAmount(long amount) {
+		if (amount <= 0)
+			throw new InvalidTransactionAmountException("Transaction amount must be greater than zero.");
+	}
+
+	private void validateInsufficientBalance(long amount) {
+		if (this.balance - amount < 0)
+			throw new InsufficientBalanceException("Insufficient balance for this transaction.");
+	}
 }

src/main/java/camp/woowak/lab/payaccount/domain/PayAccountHistory.java

@@ -0,0 +1,64 @@
+package camp.woowak.lab.payaccount.domain;
+
+import java.time.LocalDateTime;
+
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EntityListeners;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+
+@Entity
+@EntityListeners(value = AuditingEntityListener.class)
+public class PayAccountHistory {
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+
+	@ManyToOne
+	@JoinColumn(name = "account_id", nullable = false)
+	private PayAccount payAccount;
+
+	@Column
+	private long amount;
+
+	@Enumerated(value = EnumType.STRING)
+	private AccountTransactionType type;
+
+	@CreatedDate
+	@Column(name = "created_at", updatable = false)
+	private LocalDateTime createdAt = LocalDateTime.now();
+
+	public PayAccountHistory() {
+	}
+
+	public PayAccountHistory(PayAccount payAccount, long amount, AccountTransactionType type) {
+		this.payAccount = payAccount;
+		this.amount = amount;
+		this.type = type;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public long getAmount() {
+		return amount;
+	}
+
+	public AccountTransactionType getType() {
+		return type;
+	}
+
+	public LocalDateTime getCreatedAt() {
+		return createdAt;
+	}
+}

src/main/java/camp/woowak/lab/payaccount/exception/DailyLimitExceededException.java

@@ -0,0 +1,7 @@
+package camp.woowak.lab.payaccount.exception;
+
+public class DailyLimitExceededException extends RuntimeException {
+	public DailyLimitExceededException(String message) {
+		super(message);
+	}
+}

src/main/java/camp/woowak/lab/payaccount/exception/InsufficientBalanceException.java

@@ -0,0 +1,7 @@
+package camp.woowak.lab.payaccount.exception;
+
+public class InsufficientBalanceException extends RuntimeException {
+	public InsufficientBalanceException(String message) {
+		super(message);
+	}
+}

src/main/java/camp/woowak/lab/payaccount/exception/InvalidTransactionAmountException.java

@@ -0,0 +1,7 @@
+package camp.woowak.lab.payaccount.exception;
+
+public class InvalidTransactionAmountException extends RuntimeException {
+	public InvalidTransactionAmountException(String message) {
+		super(message);
+	}
+}

src/main/java/camp/woowak/lab/payaccount/exception/NotFoundAccountException.java

@@ -0,0 +1,7 @@
+package camp.woowak.lab.payaccount.exception;
+
+public class NotFoundAccountException extends RuntimeException {
+	public NotFoundAccountException(String message) {
+		super(message);
+	}
+}

src/main/java/camp/woowak/lab/payaccount/repository/PayAccountHistoryRepository.java

@@ -0,0 +1,8 @@
+package camp.woowak.lab.payaccount.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import camp.woowak.lab.payaccount.domain.PayAccountHistory;
+
+public interface PayAccountHistoryRepository extends JpaRepository<PayAccountHistory, Long> {
+}

src/main/java/camp/woowak/lab/payaccount/repository/PayAccountRepository.java

@@ -0,0 +1,17 @@
+package camp.woowak.lab.payaccount.repository;
+
+import java.util.Optional;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import camp.woowak.lab.payaccount.domain.PayAccount;
+import jakarta.persistence.LockModeType;
+
+public interface PayAccountRepository extends JpaRepository<PayAccount, Long> {
+	@Lock(LockModeType.PESSIMISTIC_WRITE)
+	@Query("SELECT pa FROM PayAccount pa where pa.id = :id")
+	Optional<PayAccount> findByIdForUpdate(@Param("id") Long id);
+}

src/main/java/camp/woowak/lab/payaccount/service/PayAccountChargeService.java

@@ -0,0 +1,32 @@
+package camp.woowak.lab.payaccount.service;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import camp.woowak.lab.payaccount.domain.PayAccount;
+import camp.woowak.lab.payaccount.domain.PayAccountHistory;
+import camp.woowak.lab.payaccount.exception.NotFoundAccountException;
+import camp.woowak.lab.payaccount.repository.PayAccountRepository;
+import camp.woowak.lab.payaccount.service.command.AccountTransactionCommand;
+import lombok.extern.slf4j.Slf4j;
+
+@Service
+@Slf4j
+public class PayAccountChargeService {
+	private final PayAccountRepository payAccountRepository;
+
+	public PayAccountChargeService(PayAccountRepository payAccountRepository) {
+		this.payAccountRepository = payAccountRepository;
+	}
+
+	@Transactional
+	public long chargeAccount(AccountTransactionCommand command) {
+		PayAccount payAccount = payAccountRepository.findByIdForUpdate(command.payAccountId())
+			.orElseThrow(() -> new NotFoundAccountException("Invalid account id with " + command.payAccountId()));
+
+		PayAccountHistory chargeHistory = payAccount.charge(command.amount());
+		log.info("A Charge of {} has been completed from Account ID {}", command.amount(), command.payAccountId());
+
+		return payAccount.getBalance();
+	}
+}

src/main/java/camp/woowak/lab/payaccount/service/PayAccountDepositService.java

@@ -0,0 +1,32 @@
+package camp.woowak.lab.payaccount.service;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import camp.woowak.lab.payaccount.domain.PayAccount;
+import camp.woowak.lab.payaccount.domain.PayAccountHistory;
+import camp.woowak.lab.payaccount.exception.NotFoundAccountException;
+import camp.woowak.lab.payaccount.repository.PayAccountRepository;
+import camp.woowak.lab.payaccount.service.command.AccountTransactionCommand;
+import lombok.extern.slf4j.Slf4j;
+
+@Service
+@Slf4j
+public class PayAccountDepositService {
+	private final PayAccountRepository payAccountRepository;
+
+	public PayAccountDepositService(PayAccountRepository payAccountRepository) {
+		this.payAccountRepository = payAccountRepository;
+	}
+
+	@Transactional
+	public long depositAccount(AccountTransactionCommand command) {
+		PayAccount payAccount = payAccountRepository.findByIdForUpdate(command.payAccountId())
+			.orElseThrow(() -> new NotFoundAccountException("Invalid account id with " + command.payAccountId()));
+
+		PayAccountHistory depositHistory = payAccount.deposit(command.amount());
+		log.info("A deposit of {} has been completed into Account ID {}.", command.amount(), command.payAccountId());
+
+		return payAccount.getBalance();
+	}
+}

src/main/java/camp/woowak/lab/payaccount/service/PayAccountWithdrawService.java

@@ -0,0 +1,32 @@
+package camp.woowak.lab.payaccount.service;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import camp.woowak.lab.payaccount.domain.PayAccount;
+import camp.woowak.lab.payaccount.domain.PayAccountHistory;
+import camp.woowak.lab.payaccount.exception.NotFoundAccountException;
+import camp.woowak.lab.payaccount.repository.PayAccountRepository;
+import camp.woowak.lab.payaccount.service.command.AccountTransactionCommand;
+import lombok.extern.slf4j.Slf4j;
+
+@Service
+@Slf4j
+public class PayAccountWithdrawService {
+	private final PayAccountRepository payAccountRepository;
+
+	public PayAccountWithdrawService(PayAccountRepository payAccountRepository) {
+		this.payAccountRepository = payAccountRepository;
+	}
+
+	@Transactional
+	public long withdrawAccount(AccountTransactionCommand command) {
+		PayAccount payAccount = payAccountRepository.findByIdForUpdate(command.payAccountId())
+			.orElseThrow(() -> new NotFoundAccountException("Invalid account id with " + command.payAccountId()));
+
+		PayAccountHistory withdrawHistory = payAccount.withdraw(command.amount());
+		log.info("A withdrawal of {} has been completed from Account ID {}", command.amount(), command.payAccountId());
+
+		return payAccount.getBalance();
+	}
+}

src/main/java/camp/woowak/lab/payaccount/service/command/AccountTransactionCommand.java

@@ -0,0 +1,6 @@
+package camp.woowak.lab.payaccount.service.command;
+
+public record AccountTransactionCommand(
+	Long payAccountId,
+	long amount) {
+}

src/main/java/camp/woowak/lab/web/api/payaccount/PayAccountApiController.java

@@ -0,0 +1,44 @@
+package camp.woowak.lab.web.api.payaccount;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import camp.woowak.lab.payaccount.service.PayAccountChargeService;
+import camp.woowak.lab.payaccount.service.command.AccountTransactionCommand;
+import camp.woowak.lab.web.dto.request.payaccount.PayAccountChargeRequest;
+import camp.woowak.lab.web.dto.response.payaccount.PayAccountChargeResponse;
+import lombok.extern.slf4j.Slf4j;
+
+@RestController
+@RequestMapping("/account")
+@Slf4j
+public class PayAccountApiController {
+	private final PayAccountChargeService payAccountChargeService;
+
+	public PayAccountApiController(PayAccountChargeService payAccountChargeService) {
+		this.payAccountChargeService = payAccountChargeService;
+	}
+
+	/**
+	 * TODO 1. api end-point 설계 논의
+	 * TODO 2. 인증 방법에 대한 유저 구분값 가져오는 방법 논의
+	 * TODO 3. API Response Format에 대한 논의 후 적용 필요
+	 */
+	@PostMapping("/{payAccountId}/charge")
+	public ResponseEntity<PayAccountChargeResponse> payAccountCharge(@PathVariable("payAccountId") Long payAccountId,
+																	 @Validated @RequestBody PayAccountChargeRequest request) {
+		AccountTransactionCommand command = new AccountTransactionCommand(payAccountId, request.amount());
+		log.info("Pay account charge request received. Account ID: {}, Charge Amount: {}", payAccountId,
+			request.amount());
+
+		long remainBalance = payAccountChargeService.chargeAccount(command);
+		log.info("Charge successful. Account ID: {}, New Balance: {}", payAccountId, remainBalance);
+
+		return ResponseEntity.ok(new PayAccountChargeResponse(remainBalance));
+	}
+}