public static ClaimBuilder aClaim() { return new ClaimBuilder(); }
@Override public RequestClaimDto map(RequestClaim arg0) { if ( arg0 == null ) { return null; } RequestClaimDto requestClaimDto = new RequestClaimDto(); requestClaimDto.setId( arg0.getId() ); requestClaimDto.setAddress( arg0.getAddress() ); requestClaimDto.setSolver( arg0.getSolver() ); requestClaimDto.setStatus( arg0.getStatus() ); requestClaimDto.setFlagged( arg0.getFlagged() ); return requestClaimDto; } }
public static ClaimBuilder aClaim() { return ClaimBuilder.aClaim() .withTokenValue(TokenValue.builder() .tokenAddress("0x02f96ef85cad6639500ca1cc8356f0b5ca5bf1d2") .amountInWei(new BigDecimal("50330000000000000000")) .build()) .withSolver("davyvanroy") .withTimestamp(LocalDateTime.now()) .withRequestId(1L); } }
@Test public void onClaimed() { long requestId = 3124L; final RequestDto requestDto = RequestDtoMother.fundRequestArea51(); requestDto.setId(requestId); final RequestClaim requestClaim1 = RequestClaim.builder().status(ClaimRequestStatus.PENDING).build(); final RequestClaim requestClaim2 = RequestClaim.builder().status(ClaimRequestStatus.PENDING).build(); when(requestClaimRepository.findByRequestId(requestId)).thenReturn(Arrays.asList(requestClaim1, requestClaim2)); claimService.onClaimed(RequestClaimedEvent.builder() .blockchainEventId(324L) .requestDto(requestDto) .build()); assertThat(requestClaim1.getStatus()).isEqualTo(PROCESSED); assertThat(requestClaim2.getStatus()).isEqualTo(PROCESSED); verify(requestClaimRepository).save(requestClaim1); verify(requestClaimRepository).save(requestClaim2); } }
@Override public ClaimDto map(Claim arg0) { if ( arg0 == null ) { return null; } ClaimDto claimDto = new ClaimDto(); claimDto.setId( arg0.getId() ); claimDto.setSolver( arg0.getSolver() ); claimDto.setTokenValue( tokenValueDtoMapper.map( arg0.getTokenValue() ) ); claimDto.setRequestId( arg0.getRequestId() ); claimDto.setTimestamp( arg0.getTimestamp() ); claimDto.setBlockchainEventId( arg0.getBlockchainEventId() ); return claimDto; } }
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT) public void onRequestClaimPending(final ClaimRequestedEvent claimRequestedEvent) { telegramService.sendMessageToChannel("Holy Moly, " + claimRequestedEvent.getRequestClaim().getSolver() + " just requested an approval for a claim! (" + claimRequestedEvent.getRequestClaim().getRequestId() + ")"); } }
private SignClaimCommand createSignClaimCommand(RequestClaim requestClaim, Request request) { return SignClaimCommand.builder() .platform(request.getIssueInformation().getPlatform().name()) .platformId(request.getIssueInformation().getPlatformId()) .solver(requestClaim.getSolver()) .address(requestClaim.getAddress()) .build(); } }
@Transactional @Override public void decline(Long requestClaimId) { RequestClaim requestClaim = requestClaimRepository.findOne(requestClaimId).orElseThrow(() -> new RuntimeException("Request claim not found")); Request request = requestRepository.findOne(requestClaim.getRequestId()).orElseThrow(ResourceNotFoundException::new); request.setStatus(RequestStatus.FUNDED); requestClaim.setStatus(ClaimRequestStatus.DECLINED); requestRepository.save(request); requestClaimRepository.save(requestClaim); }
@Test void map_blockchainEventEmpty() { final long blockchainEventId = 465L; final Claim claim = Claim.builder().blockchainEventId(blockchainEventId).build(); when(delegate.map(claim)).thenReturn(new ClaimDto()); when(blockchainEventService.findOne(blockchainEventId)).thenReturn(Optional.empty()); final ClaimDto result = decorator.map(claim); assertThat(result.getTransactionHash()).isEmpty(); } }
@Scheduled(fixedDelay = 300_000L) public void cleanClaims() { final List<RequestClaim> claims = requestClaimRepository.findByStatus(ClaimRequestStatus.APPROVED); claims.stream() .filter(x -> x.getTransactionHash() != null) .filter(x -> azraelClient.getTransactionStatus(x.getTransactionHash()).equals(TransactionStatus.FAILED)) .forEach(x -> { x.setStatus(ClaimRequestStatus.TRANSACTION_FAILED); requestClaimRepository.save(x); }); }
@Override public RequestClaimDto map(RequestClaim r) { RequestClaimDto dto = delegate.map(r); if (dto != null) { RequestDto request = requestService.findRequest(r.getRequestId()); dto.setUrl(createLink(request.getIssueInformation())); dto.setTitle(request.getIssueInformation().getTitle()); dto.setFundRequestUrl(createFundRequestLink(request.getId())); } return dto; }
@EventListener public void onClaimed(final RequestClaimedEvent claimedEvent) { requestClaimRepository.findByRequestId(claimedEvent.getRequestDto().getId()) .forEach(requestClaim -> { requestClaim.setStatus(ClaimRequestStatus.PROCESSED); requestClaimRepository.save(requestClaim); }); } }
@Test public void findClaim() { final long claimId = 697L; final Claim claim = Claim.builder().build(); final ClaimDto expected = ClaimDtoMother.aClaimDto().build(); when(claimRepository.findOne(claimId)).thenReturn(Optional.of(claim)); when(mappers.map(eq(Claim.class), eq(ClaimDto.class), same(claim))).thenReturn(expected); final Optional<ClaimDto> result = claimService.findOne(claimId); assertThat(result).containsSame(expected); }
@Override public ClaimDto map(Claim r) { final ClaimDto dto = delegate.map(r); if (dto != null) { dto.setTransactionHash(blockchainEventService.findOne(r.getBlockchainEventId()) .map(BlockchainEventDto::getTransactionHash) .orElse("")); } return dto; } }
@Test public void map_null() { final RequestClaim requestClaim = RequestClaim.builder() .id(657L) .address("0xE51551D3B11eF7559164D051D9714E59A1c4E486") .status(ClaimRequestStatus.PENDING) .flagged(false) .requestId(9L) .solver("ghjgfhg") .build(); when(delegate.map(requestClaim)).thenReturn(null); final RequestClaimDto result = decorator.map(requestClaim); assertThat(result).isNull(); } }
@Test void map() { final long blockchainEventId = 465L; final Claim claim = Claim.builder().blockchainEventId(blockchainEventId).build(); final String transactionHash = "rqwerwet"; when(delegate.map(claim)).thenReturn(new ClaimDto()); when(blockchainEventService.findOne(blockchainEventId)).thenReturn(Optional.of(BlockchainEventDto.builder().transactionHash(transactionHash).build())); final ClaimDto result = decorator.map(claim); assertThat(result.getTransactionHash()).isEqualTo(transactionHash); }
@Transactional @Override public void claim(Principal user, UserClaimRequest userClaimRequest) { Request request = requestRepository.findByPlatformAndPlatformId(userClaimRequest.getPlatform(), userClaimRequest.getPlatformId()) .orElseThrow(() -> new RuntimeException("Request not found")); RequestDto requestDto = mappers.map(Request.class, RequestDto.class, request); String solver = githubClaimResolver.getUserPlatformUsername(user, request.getIssueInformation().getPlatform()) .orElseThrow(() -> new RuntimeException("You are not linked to github")); final RequestClaim requestClaim = RequestClaim.builder() .address(userClaimRequest.getAddress()) .requestId(request.getId()) .flagged(!githubClaimResolver.canClaim(user, requestDto)) .solver(solver) .status(ClaimRequestStatus.PENDING) .build(); requestClaimRepository.save(requestClaim); request.setStatus(RequestStatus.CLAIM_REQUESTED); eventPublisher.publishEvent(ClaimRequestedEvent.builder() .requestClaim(requestClaim) .build()); requestRepository.save(request); }
@Test public void map() { final RequestClaim requestClaim = RequestClaim.builder() .id(657L) .address("0xE51551D3B11eF7559164D051D9714E59A1c4E486") .status(ClaimRequestStatus.PENDING) .flagged(false) .requestId(9L) .solver("ghjgfhg") .build(); final RequestClaimDto requestClaimDto = new RequestClaimDto(); final RequestDto requestDto = RequestDtoMother.fundRequestArea51(); final IssueInformationDto issueInformation = requestDto.getIssueInformation(); when(delegate.map(requestClaim)).thenReturn(requestClaimDto); when(requestService.findRequest(requestClaim.getRequestId())).thenReturn(requestDto); final RequestClaimDto result = decorator.map(requestClaim); assertThat(result.getTitle()).isEqualTo(requestDto.getIssueInformation().getTitle()); assertThat(result.getUrl()).isEqualTo("https://github.com/" + issueInformation.getOwner() + "/" + issueInformation.getRepo() + "/issues/" + issueInformation.getNumber()); assertThat(result.getFundRequestUrl()).isEqualTo("https://fundrequest.io/requests/" + requestDto.getId()); }