Feature/opixxx step4

build.gradle

@@ -32,6 +32,9 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-validation'
     implementation 'org.springframework.security:spring-security-crypto:5.6.3'
 
+    //java mail
+    implementation 'org.springframework.boot:spring-boot-starter-mail'
+
     //apache_commons
     implementation 'org.apache.commons:commons-lang3:3.13.0'
     implementation 'org.apache.commons:commons-collections4:4.4'

src/main/java/org/c4marathon/assignment/account/dto/WithdrawRequest.java

@@ -1,14 +1,20 @@
 package org.c4marathon.assignment.account.dto;
 
+import org.c4marathon.assignment.transaction.domain.TransactionType;
+
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.PositiveOrZero;
 
 public record WithdrawRequest(
 
-        @NotNull
-        Long receiverAccountId,
+    @NotNull
+    Long receiverAccountId,
+
+    @PositiveOrZero
+    long money,
+
+    @NotNull
+    TransactionType type
 
-        @PositiveOrZero
-        long money
 ) {
 }

src/main/java/org/c4marathon/assignment/account/presentation/AccountController.java

@@ -1,11 +1,14 @@
 package org.c4marathon.assignment.account.presentation;
 
 import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Positive;
 import jakarta.validation.constraints.PositiveOrZero;
 import lombok.RequiredArgsConstructor;
 import org.c4marathon.assignment.account.dto.SendToSavingAccountRequest;
 import org.c4marathon.assignment.account.dto.WithdrawRequest;
 import org.c4marathon.assignment.account.service.AccountService;
+import org.c4marathon.assignment.account.service.DepositService;
 import org.c4marathon.assignment.global.annotation.Login;
 import org.c4marathon.assignment.global.session.SessionMemberInfo;
 import org.springframework.http.HttpStatus;
@@ -20,35 +23,54 @@
 public class AccountController {
 
     private final AccountService accountService;
+    private final DepositService depositService;
 
     @PostMapping("/charge")
     public ResponseEntity<Void> charge(
-            @Login SessionMemberInfo loginMember,
-            @RequestParam @PositiveOrZero(message = "음수는 송금할 수 없습니다.") long money
+        @Login SessionMemberInfo loginMember,
+        @RequestParam @PositiveOrZero(message = "음수는 송금할 수 없습니다.") long money
     ) {
         accountService.chargeMoney(loginMember.accountId(), money);
         return ResponseEntity.ok().build();
     }
 
     @PostMapping("/send/saving-account")
     public ResponseEntity<Void> sendToSavingAccount(
-            @Login SessionMemberInfo loginMember,
-            @Valid @RequestBody SendToSavingAccountRequest request
+        @Login SessionMemberInfo loginMember,
+        @Valid @RequestBody SendToSavingAccountRequest request
     ) {
         accountService.sendToSavingAccount(
-                loginMember.accountId(),
-                request.savingAccountId(),
-                request.money()
+            loginMember.accountId(),
+            request.savingAccountId(),
+            request.money()
         );
         return ResponseEntity.ok().build();
     }
 
     @PostMapping("/withdraw")
     public ResponseEntity<Void> withdraw(
-            @Login SessionMemberInfo loginMember,
-            @Valid @RequestBody WithdrawRequest request
+        @Login SessionMemberInfo loginMember,
+        @Valid @RequestBody WithdrawRequest request
     ) {
         accountService.withdraw(loginMember.accountId(), request);
         return ResponseEntity.status(HttpStatus.OK).build();
     }
+
+    @PostMapping("/deposit")
+    public ResponseEntity<Void> deposit(
+        @Login SessionMemberInfo loginMember,
+        @RequestParam @NotNull @Positive Long transactionalId
+    ) {
+        depositService.depositByReceiver(loginMember.accountId(), transactionalId);
+        return ResponseEntity.ok().build();
+    }
+
+    @PostMapping("/cancel/withdraw")
+    public ResponseEntity<Void> cancelWithdraw(
+        @Login SessionMemberInfo loginMember,
+        @RequestParam @NotNull @Positive Long transactionalId
+    ) {
+        accountService.cancelWithdraw(loginMember.accountId(), transactionalId);
+        return ResponseEntity.ok().build();
+    }
 }

src/main/java/org/c4marathon/assignment/account/service/AccountService.java

@@ -1,8 +1,11 @@
 package org.c4marathon.assignment.account.service;
 
 import static org.c4marathon.assignment.global.util.Const.*;
+import static org.c4marathon.assignment.transaction.domain.TransactionStatus.*;
+import static org.c4marathon.assignment.transaction.domain.TransactionStatus.PENDING_DEPOSIT;
+import static org.c4marathon.assignment.transaction.domain.TransactionType.*;
 
-import java.util.UUID;
+import java.time.LocalDateTime;
 
 import org.c4marathon.assignment.account.domain.Account;
 import org.c4marathon.assignment.account.domain.SavingAccount;
@@ -11,10 +14,15 @@
 import org.c4marathon.assignment.account.dto.WithdrawRequest;
 import org.c4marathon.assignment.account.exception.DailyChargeLimitExceededException;
 import org.c4marathon.assignment.account.exception.NotFoundAccountException;
-import org.c4marathon.assignment.global.event.withdraw.WithdrawCompletedEvent;
+import org.c4marathon.assignment.global.event.transactional.TransactionCreateEvent;
 import org.c4marathon.assignment.member.domain.Member;
 import org.c4marathon.assignment.member.domain.repository.MemberRepository;
 import org.c4marathon.assignment.member.exception.NotFoundMemberException;
+import org.c4marathon.assignment.transaction.domain.Transaction;
+import org.c4marathon.assignment.transaction.domain.repository.TransactionRepository;
+import org.c4marathon.assignment.transaction.exception.InvalidTransactionStatusException;
+import org.c4marathon.assignment.transaction.exception.NotFoundTransactionException;
+import org.c4marathon.assignment.transaction.exception.UnauthorizedTransactionException;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Isolation;
@@ -27,7 +35,9 @@
 public class AccountService {
 	private final AccountRepository accountRepository;
 	private final MemberRepository memberRepository;
+	private final TransactionRepository transactionRepository;
 	private final SavingAccountRepository savingAccountRepository;
+
 	private final ApplicationEventPublisher eventPublisher;
 
 	@Transactional
@@ -82,7 +92,8 @@ public void sendToSavingAccount(Long accountId, Long savingAccountId, long money
 	}
 
 	/**
-	 * 출금 시 Redis List 에 출금 기록을 저장
+	 * 송금 시 송금 내역을 저장하는 이벤트 발행 후 커밋
+	 *
 	 * @param senderAccountId
 	 * @param request
 	 */
@@ -98,18 +109,71 @@ public void withdraw(Long senderAccountId, WithdrawRequest request) {
 		senderAccount.withdraw(request.money());
 		accountRepository.save(senderAccount);
 
-		String transactionId = UUID.randomUUID().toString();
+		if (request.type().equals(IMMEDIATE_TRANSFER)) {
+			eventPublisher.publishEvent(
+				new TransactionCreateEvent(
+					senderAccountId,
+					request.receiverAccountId(),
+					request.money(),
+					request.type(),
+					WITHDRAW,
+					LocalDateTime.now()
+				)
+			);
+		} else if (request.type().equals(PENDING_TRANSFER)) {
+			eventPublisher.publishEvent(
+				new TransactionCreateEvent(
+					senderAccountId,
+					request.receiverAccountId(),
+					request.money(),
+					request.type(),
+					PENDING_DEPOSIT,
+					LocalDateTime.now()
+				)
+			);
+		}
+	}
+
+	/**
+	 * 송금 취소 기능(사용자가 직접 취소 요청)
+	 * 취소하려는 송금 내역을 가져와 검증 후 송금을 취소함
+	 *
+	 * @param senderAccountId
+	 * @param transactionalId
+	 */
+	@Transactional(isolation = Isolation.READ_COMMITTED)
+	public void cancelWithdraw(Long senderAccountId, Long transactionalId) {
+		Transaction transaction = transactionRepository.findTransactionalByTransactionIdWithLock(transactionalId)
+			.orElseThrow(NotFoundTransactionException::new);
+
+		validationTransactional(senderAccountId, transaction);
 
-		eventPublisher.publishEvent(
-			new WithdrawCompletedEvent(
-				transactionId,
-				senderAccountId,
-				request.receiverAccountId(),
-				request.money()
-			)
-		);
+		Account senderAccount = accountRepository.findByIdWithLock(senderAccountId)
+			.orElseThrow(NotFoundAccountException::new);
+
+		senderAccount.deposit(transaction.getAmount());
+		transaction.updateStatus(CANCEL);
 	}
 
+	/**
+	 * 72시간이 지난 송금 내역을 취소하는 비즈니스 로직
+	 *
+	 * @param transaction
+	 */
+	public void cancelWithdrawByExpirationTime(Transaction transaction) {
+		Account senderAccount = accountRepository.findByIdWithLock(transaction.getSenderAccountId())
+			.orElseThrow(NotFoundAccountException::new);
+
+		senderAccount.deposit(transaction.getAmount());
+		transaction.updateStatus(CANCEL);
+	}
+
+	/**
+	 * 입금 재시도가 실패하면 송금 롤백을 하는 로직
+	 *
+	 * @param senderAccountId
+	 * @param money
+	 */
 	@Transactional(isolation = Isolation.READ_COMMITTED)
 	public void rollbackWithdraw(Long senderAccountId, long money) {
 		Account senderAccount = accountRepository.findByIdWithLock(senderAccountId)
@@ -121,6 +185,7 @@ public void rollbackWithdraw(Long senderAccountId, long money) {
 
 	/**
 	 * 송금할 때 메인 계좌에 잔액이 부족할 때 10,000원 단위로 충전하는 로직
+	 *
 	 * @param money
 	 * @param senderAccount
 	 */
@@ -136,4 +201,14 @@ private void autoCharge(long money, Account senderAccount) {
 		senderAccount.deposit(chargeMoney);
 	}
 
+	private static void validationTransactional(Long senderAccountId, Transaction transaction) {
+		if (!transaction.getSenderAccountId().equals(senderAccountId)) {
+			throw new UnauthorizedTransactionException();
+		}
+
+		if (!transaction.getStatus().equals(PENDING_DEPOSIT)) {
+			throw new InvalidTransactionStatusException();
+		}
+	}
+
 }

src/main/java/org/c4marathon/assignment/account/service/DepositService.java

@@ -1,10 +1,17 @@
 package org.c4marathon.assignment.account.service;
 
+import static org.c4marathon.assignment.transaction.domain.TransactionStatus.*;
+
+import java.time.LocalDateTime;
+
 import org.c4marathon.assignment.account.domain.Account;
 import org.c4marathon.assignment.account.domain.repository.AccountRepository;
 import org.c4marathon.assignment.account.exception.NotFoundAccountException;
-import org.c4marathon.assignment.global.event.deposit.DepositCompletedEvent;
-import org.springframework.context.ApplicationEventPublisher;
+import org.c4marathon.assignment.transaction.domain.Transaction;
+import org.c4marathon.assignment.transaction.domain.repository.TransactionRepository;
+import org.c4marathon.assignment.transaction.exception.InvalidTransactionStatusException;
+import org.c4marathon.assignment.transaction.exception.NotFoundTransactionException;
+import org.c4marathon.assignment.transaction.exception.UnauthorizedTransactionException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Isolation;
 import org.springframework.transaction.annotation.Transactional;
@@ -17,46 +24,74 @@
 @RequiredArgsConstructor
 public class DepositService {
 	private final AccountRepository accountRepository;
-	private final ApplicationEventPublisher eventPublisher;
+	private final TransactionRepository transactionRepository;
 
 	/**
-	 * 입금을 시도하는 로직.
-	 * 입금이 정상적으로 커밋 완료 시 -> 이벤트 발행을 하며 Redis에 저장된 송금 기록을 삭제
-	 * 입금 중 예외가 발생 시 -> AOP를 통해 예외를 감지하여 Redis에 실패 송금 기록을 저장
-	 * @param deposit
+	 * 송금 내역 데이터를 조회해서 출금 로직 실행
+	 * status = WITHDRAW인 송금 내역을 조회해서 입금 처리를 함
+	 * 입금 성공 : 송금 내역 status를 SUCCESS_DEPOSIT, 입금 한 시간을 업데이트 한다.
+	 * 입금 실패 : AOP를 통해 송금 내역 status를 FAILED_DEPOSIT로 변경한다.
+	 * @param transactional
 	 */
 	@Transactional(isolation = Isolation.READ_COMMITTED)
-	public void successDeposit(String deposit) {
-		processDeposit(deposit);
+	public void successDeposit(Transaction transactional) {
+		processDeposit(transactional);
 	}
 
 	/**
-	 * 실패한 입금을 재시도하는 로직
-	 * 재입금이 정상적으로 커밋 완료 시 -> 이벤트 발행을 하며 Redis에 저장된 송금 기록을 삭제
-	 * 재입금 중 예외(실패) 시 -> AOP를 통해 예외를 감지하여 송금 롤백 시도
-	 * @param failedDeposit
+	 * 송금 내역 데이터를 조회해서 출금 로직 실행
+	 * status = FAILED_DEPOSIT인 송금 내역을 조회해서 입금 재시도를 함
+	 * 입금 성공 : 송금 내역 status를 SUCCESS_DEPOSIT, 입금 한 시간을 업데이트 한다.
+	 * 입금 재시도 실패 : AOP를 통해 송금 내역 status를 CANCEL로 변경 후 송금 취소한다.
+	 * @param transactional
 	 */
 	@Transactional(isolation = Isolation.READ_COMMITTED)
-	public void failedDeposit(String failedDeposit) {
-		processDeposit(failedDeposit);
+	public void failedDeposit(Transaction transactional) {
+		processDeposit(transactional);
 	}
 
-	private void processDeposit(String deposit) {
-		String[] parts = deposit.split(":");
-		String transactionId = parts[0];
-		Long senderAccountId = Long.valueOf(parts[1]);
-		Long receiverAccountId = Long.valueOf(parts[2]);
-		long money = Long.parseLong(parts[3]);
+	/**
+	 * 금액을 받는 사용자가 직접 확인 후 금액을 받는 비즈니스 로직
+	 * @param receiverAccountId
+	 * @param transactionalId
+	 */
+	@Transactional(isolation = Isolation.READ_COMMITTED)
+	public void depositByReceiver(Long receiverAccountId, Long transactionalId) {
+		Transaction transaction = transactionRepository.findTransactionalByTransactionIdWithLock(transactionalId)
+			.orElseThrow(NotFoundTransactionException::new);
+
+		validationTransaction(receiverAccountId, transaction);
 
 		Account receiverAccount = accountRepository.findByIdWithLock(receiverAccountId)
 			.orElseThrow(NotFoundAccountException::new);
 
-		receiverAccount.deposit(money);
+		receiverAccount.deposit(transaction.getAmount());
+		transaction.updateStatus(SUCCESS_DEPOSIT);
+	}
+
+	private void processDeposit(Transaction transactional) {
+		Long receiverAccountId = transactional.getReceiverAccountId();
+		long amount = transactional.getAmount();
+
+		Account receiverAccount = accountRepository.findByIdWithLock(receiverAccountId)
+			.orElseThrow(NotFoundAccountException::new);
+
+		receiverAccount.deposit(amount);
 		accountRepository.save(receiverAccount);
 
-		eventPublisher.publishEvent(new DepositCompletedEvent(deposit));
+		transactional.setReceiverTime(LocalDateTime.now());
+		transactional.updateStatus(SUCCESS_DEPOSIT);
+		transactionRepository.save(transactional);
+
+	}
+
+	private static void validationTransaction(Long receiverAccountId, Transaction transaction) {
+		if (!transaction.getReceiverAccountId().equals(receiverAccountId)) {
+			throw new UnauthorizedTransactionException();
+		}
 
-		log.debug("입금 성공 : transactionId : {}, senderAccountId : {}, receiverAccountId : {}, money : {}",
-			transactionId, senderAccountId, receiverAccountId, money);
+		if (!transaction.getStatus().equals(PENDING_DEPOSIT)) {
+			throw new InvalidTransactionStatusException();
+		}
 	}
 }