@Transactional(readOnly = true) public List<PendingFund> findAll() { return pendingFundRepository.findAll(); }
@Transactional public void removePendingFund(final String transactionHash) { pendingFundRepository.findByTransactionHash(transactionHash).ifPresent(pendingFundRepository::delete); }
@Transactional(readOnly = true) @Override public List<FundDto> findAll() { return mappers.mapList(Fund.class, FundDto.class, fundRepository.findAll()); }
@Test public void statisticsReturnsTotalAvailableFunding() { TokenAmountDto tokenAmount = new TokenAmountDto(fnd.getAddress(), EthUtil.toWei(BigDecimal.TEN, fnd.getDecimals())); TokenAmountDto tokenAmount2 = new TokenAmountDto(zrx.getAddress(), EthUtil.toWei(BigDecimal.ONE, zrx.getDecimals())); when(fundRepository.getAmountPerTokenWhereRequestHasStatusFunded()).thenReturn(Arrays.asList(tokenAmount, tokenAmount2)); when(fiatService.getUsdPrice(TokenValueDto.builder() .tokenSymbol(fnd.getSymbol()) .tokenAddress(fnd.getAddress()) .totalAmount(EthUtil.fromWei(tokenAmount.getTotalAmount(), fnd.getDecimals())) .build())).thenReturn(10.0); when(fiatService.getUsdPrice(TokenValueDto.builder() .tokenSymbol(zrx.getSymbol()) .tokenAddress(zrx.getAddress()) .totalAmount(EthUtil.fromWei(tokenAmount2.getTotalAmount(), zrx.getDecimals())) .build())).thenReturn(20.0); StatisticsDto result = statisticsService.getStatistics(); assertThat(result.getTotalAvailableFunding()).isEqualTo(30.0); }
@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); }
private List<UserFundsDto> getFundsAndRefundsFor(final Long requestId) { final List<Fund> fundsForRequest = fundRepository.findAllByRequestId(requestId); final List<Refund> refundsForRequest = refundRepository.findAllByRequestId(requestId); return fundsAndRefundsAggregator.aggregate(Stream.concat(fundFundsByFunderAggregator.aggregate(fundsForRequest).stream(), refundFundsByFunderAggregator.aggregate(refundsForRequest).stream()) .collect(Collectors.toList())); }
@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 requestRefund(final RequestRefundCommand requestRefundCommand) { refundRequestRepository.save(RefundRequest.builder() .requestId(requestRefundCommand.getRequestId()) .funderAddress(requestRefundCommand.getFunderAddress()) .requestedBy(requestRefundCommand.getRequestedBy()) .build()); }
private double mapToUsd(TokenAmountDto f) { TokenInfoDto tokenInfo = tokenInfoService.getTokenInfo(f.getTokenAddress()); TokenValueDto dto = TokenValueDto.builder() .totalAmount(fromWei(f.getTotalAmount(), tokenInfo.getDecimals())) .tokenAddress(f.getTokenAddress()) .tokenSymbol(tokenInfo.getSymbol()) .build(); return fiatService.getUsdPrice(dto); } }
@Override @Transactional(readOnly = true) public List<RefundRequestDto> findAllRefundRequestsFor(final long requestId, final RefundRequestStatus... statuses) { return refundRequestDtoMapper.mapToList(refundRequestRepository.findAllByRequestIdAndStatusIn(requestId, statuses)); }
@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)); }
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 String getMostFunded(List<Object[]> objects) { return objects .stream() .collect(Collectors.groupingBy(o -> (String) o[0], Collectors.reducing(0.0, o -> mapToUsd(new TokenAmountDto((String) o[1], (BigDecimal) o[2])), (a, b) -> a + b) ) ) .entrySet().stream().max(Comparator.comparing(Map.Entry::getValue)) .map(Map.Entry::getKey).orElse(""); }
@Transactional public void save(final Principal principal, final PendingFundCommand command) { final IssueInformation issueInformation = githubLinkParser.parseIssue(command.getPlatformId()); final PendingFund pf = PendingFund.builder() .amount(toWei(command)) .description(command.getDescription()) .fromAddress(command.getFromAddress()) .tokenAddress(command.getTokenAddress()) .transactionhash(command.getTransactionId()) .issueInformation(issueInformation) .userId(principal == null ? null : principal.getName()) .build(); pendingFundRepository.save(pf); }
@Transactional(readOnly = true) public List<PendingFundDto> findByUser(final Principal principal) { return mappers.mapList(PendingFund.class, PendingFundDto.class, pendingFundRepository.findByUserId(principal.getName())); } }
@Override @Transactional(readOnly = true) public FundDto findOne(Long id) { return mappers.map(Fund.class, FundDto.class, fundRepository.findOne(id).orElseThrow(ResourceNotFoundException::new)); }
@Transactional public void removePendingFund(final PendingFund pendingFund) { pendingFundRepository.findOne(pendingFund.getId()).ifPresent(pendingFundRepository::delete); }
private List<RefundRequestDto> getRequestRefunds(final RefundRequestStatus pending) { return mappers.mapList(RefundRequest.class, RefundRequestDto.class, refundRequestRepository.findAllByStatusIn(Collections.singletonList(pending), new Sort("creationDate"))); } }
@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())); }
@Transactional(readOnly = true) @Override public List<FundDto> findAll(Iterable<Long> ids) { return mappers.mapList(Fund.class, FundDto.class, fundRepository.findAll(ids)); }