How to use

RefundRequestRepository

in

io.fundrequest.core.request.fund.infrastructure

@Override
@Transactional
public void decline(final Long refundRequestId) {
  final RefundRequest refundRequest = refundRequestRepository.findOne(refundRequestId).orElseThrow(() -> new RuntimeException("Refund request not found"));
  refundRequest.setStatus(RefundRequestStatus.DECLINED);
  refundRequestRepository.save(refundRequest);
}

@Override
@Transactional(readOnly = true)
public List<RefundRequestDto> findAllRefundRequestsFor(final long requestId, final String funderAddress, final RefundRequestStatus status) {
  return refundRequestDtoMapper.mapToList(refundRequestRepository.findAllByRequestIdAndFunderAddressAndStatus(requestId, funderAddress, status));
}

@Override
@Transactional(readOnly = true)
public List<RefundRequestDto> findAllRefundRequestsFor(final long requestId, final RefundRequestStatus... statuses) {
  return refundRequestDtoMapper.mapToList(refundRequestRepository.findAllByRequestIdAndStatusIn(requestId, statuses));
}

  @Scheduled(fixedDelay = 300_000L)
  public void cleanRefunds() {
    final List<RefundRequest> refundRequests = refundRequestRepository.findAllByStatus(RefundRequestStatus.APPROVED);

    refundRequests.stream()
           .filter(refundRequest -> refundRequest.getTransactionHash() != null)
           .filter(refundRequest -> azraelClient.getTransactionStatus(refundRequest.getTransactionHash()).equals(TransactionStatus.FAILED))
           .forEach(refundRequest -> {
             refundRequest.setStatus(RefundRequestStatus.TRANSACTION_FAILED);
             refundRequestRepository.save(refundRequest);
           });
  }
}

@Override
@Transactional
public void refundProcessed(final RefundProcessedCommand command) {
  final List<RefundRequest> refundRequests = refundRequestRepository.findAllByRequestIdAndStatusIn(command.getRequestId(), APPROVED);
  refundRequests.forEach(refundRequest -> {
    refundRequest.setStatus(PROCESSED);
    refundRequest.setTransactionHash(command.getTransactionHash());
  });
  refundRequestRepository.save(refundRequests);
  final Refund refund = Refund.builder()
                .requestId(command.getRequestId())
                .funderAddress(command.getFunderAddress())
                .blockchainEventId(command.getBlockchainEventId())
                .requestedBy(resolveRequestedBy(command, refundRequests).orElse(null))
                .tokenValue(TokenValue.builder()
                           .amountInWei(new BigDecimal(command.getAmount()))
                           .tokenAddress(command.getTokenHash())
                           .build())
                .build();
  refundRepository.save(refund);
  cacheManager.getCache ("funds").evict(command.getRequestId());
  applicationEventPublisher.publishEvent(new RefundProcessedEvent(refund));
}

               .build();
when(refundRequestRepository.findAllByRequestIdAndStatusIn(requestId, APPROVED)).thenReturn(new ArrayList<>());
when(refundRequestRepository.findByTransactionHash(transactionHash)).thenReturn(Optional.empty());
when(cacheManager.getCache("funds")).thenReturn(fundsCache);

@Override
@Transactional
public void requestRefund(final RequestRefundCommand requestRefundCommand) {
  refundRequestRepository.save(RefundRequest.builder()
                       .requestId(requestRefundCommand.getRequestId())
                       .funderAddress(requestRefundCommand.getFunderAddress())
                       .requestedBy(requestRefundCommand.getRequestedBy())
                       .build());
}

  private Optional<String> resolveRequestedBy(final RefundProcessedCommand command, final List<RefundRequest> refundRequests) {
    if (refundRequests.isEmpty()) {
      return refundRequestRepository.findByTransactionHash(command.getTransactionHash()).map(RefundRequest::getRequestedBy);
    } else {
      return refundRequests.stream()
                 .map(RefundRequest::getRequestedBy)
                 .filter(Objects::nonNull)
                 .reduce((s, s2) -> s);
    }
  }
}

  private List<RefundRequestDto> getRequestRefunds(final RefundRequestStatus pending) {
    return mappers.mapList(RefundRequest.class, RefundRequestDto.class, refundRequestRepository.findAllByStatusIn(Collections.singletonList(pending), new Sort("creationDate")));
  }
}

when(refundRequestRepository.findAllByRequestIdAndStatusIn(requestId, APPROVED)).thenReturn(refundRequests);
when(cacheManager.getCache("funds")).thenReturn(fundsCache);
verify(refundRequest2).setTransactionHash(transactionHash);
verify(refundRequest2).setStatus(PROCESSED);
verify(refundRequestRepository).save(refundRequests);

               .build();
when(refundRequestRepository.findAllByRequestIdAndStatusIn(requestId, APPROVED)).thenReturn(new ArrayList<>());
when(refundRequestRepository.findByTransactionHash(transactionHash)).thenReturn(Optional.of(RefundRequest.builder()
                                                     .requestedBy(requestedBy)
                                                     .build()));

@Test
void requestRefund() {
  final long requestId = 547L;
  final String funderAddress = "hjfgkh";
  final String requestedBy = "4567gjfh";
  refundService.requestRefund(RequestRefundCommand.builder().requestId(requestId).funderAddress(funderAddress).requestedBy(requestedBy).build());
  verify(refundRequestRepository).save(refEq(RefundRequest.builder()
                              .requestId(requestId)
                              .funderAddress(funderAddress)
                              .requestedBy(requestedBy)
                              .build()));
}

@Override
@Transactional
public void approve(final Long refundRequestId) {
  final RefundRequest refundRequest = refundRequestRepository.findOne(refundRequestId).orElseThrow(() -> new RuntimeException("Refund request not found"));
  refundRequest.setStatus(RefundRequestStatus.APPROVED);
  refundRequest.setTransactionSubmitTime(LocalDateTime.now());
  final IssueInformationDto issueInformation = requestService.findRequest(refundRequest.getRequestId()).getIssueInformation();
  final RefundTransaction refundTransaction = azraelClient.submitRefund(RefundCommand.builder()
                                            .address(refundRequest.getFunderAddress())
                                            .platform(issueInformation.getPlatform().name())
                                            .platformId(issueInformation.getPlatformId())
                                            .build());
  refundRequest.setTransactionHash(refundTransaction.getTransactionHash());
  refundRequestRepository.save(refundRequest);
}

@Test
public void findAllRefundRequestsForRequestIdAndStatus() {
  final long requestId = 3389L;
  final RefundRequestStatus status = PENDING;
  final List<RefundRequest> refundRequests = new ArrayList<>();
  final ArrayList<RefundRequestDto> refundRequestDtos = new ArrayList<>();
  when(refundRequestRepository.findAllByRequestIdAndStatusIn(requestId, status)).thenReturn(refundRequests);
  when(refundRequestDtoMapper.mapToList(same(refundRequests))).thenReturn(refundRequestDtos);
  final List<RefundRequestDto> result = refundService.findAllRefundRequestsFor(requestId, status);
  assertThat(result).isSameAs(refundRequestDtos);
}

@Test
public void findAllRefundRequestsForRequestIdAndFunderAddressAndStatus() {
  final long requestId = 347L;
  final String funderAddress = "0x6457hfd";
  final RefundRequestStatus status = PROCESSED;
  final List<RefundRequest> refundRequests = new ArrayList<>();
  final ArrayList<RefundRequestDto> refundRequestDtos = new ArrayList<>();
  when(refundRequestRepository.findAllByRequestIdAndFunderAddressAndStatus(requestId, funderAddress, status)).thenReturn(refundRequests);
  when(refundRequestDtoMapper.mapToList(same(refundRequests))).thenReturn(refundRequestDtos);
  final List<RefundRequestDto> result = refundService.findAllRefundRequestsFor(requestId, funderAddress, status);
  assertThat(result).isSameAs(refundRequestDtos);
}