/** * Performs some static checks and loads the transfers to be chargedback by the bulk reverse * operation. * * @param ids: Could be trace numbers or transfer ids. * @param loader: The object responsible for loading the transfer by trace number or transferId. */ private <V> List<ChargebackResult> doBulkChargeback( final List<V> ids, final TransferLoader<V> loader) { final List<Transfer> transfers = new LinkedList<Transfer>(); final List<AccountDTO> allAccounts = new LinkedList<AccountDTO>(); final Member member = WebServiceContext.getMember(); final List<ChargebackResult> result = new LinkedList<ChargebackResult>(); boolean failed = false; for (final V id : ids) { Transfer transfer = null; try { transfer = loader.load(id); transfers.add(transfer); if (member != null && !transfer.getToOwner().equals(member)) { throw new EntityNotFoundException(); } result.add(new ChargebackResult(ChargebackStatus.NOT_PERFORMED, null, null)); allAccounts.add(new AccountDTO(transfer.getFrom())); allAccounts.add(new AccountDTO(transfer.getTo())); } catch (final EntityNotFoundException e) { failed = true; result.add(new ChargebackResult(ChargebackStatus.TRANSFER_NOT_FOUND, null, null)); webServiceHelper.error( new Exception( "Bulk status [Id=" + id + "]: " + ChargebackStatus.TRANSFER_NOT_FOUND, e)); } } if (failed) { return result; } return bulkReverse(transfers, allAccounts); }
@Override protected void appendVariableValues( final Map<String, Object> variables, final LocalSettings localSettings) { variables.put("grant_date", localSettings.getDateConverter().toString(transfer.getDate())); variables.put( "amount", localSettings .getUnitsConverter(transfer.getTo().getType().getCurrency().getPattern()) .toString(transfer.getAmount())); }
private int getTransferNumber(final Transfer transfer) { final ScheduledPayment scheduledPayment = transfer.getScheduledPayment(); int transferNumber = 0; for (final Transfer currentTransfer : scheduledPayment.getTransfers()) { transferNumber++; if (currentTransfer.equals(transfer)) { break; } } return transferNumber; }
public Status getStatus() { if (transfer.getStatus() == Payment.Status.PENDING) { return Status.PENDING_AUTHORIZATION; } if (transfer.getStatus() == Payment.Status.DENIED) { return Status.AUTHORIZATION_DENIED; } for (final LoanPayment payment : getPayments()) { if (payment.getStatus().isOpen()) { return Status.OPEN; } } return Status.CLOSED; }
public Member getMember() { try { return (Member) transfer.getTo().getOwner(); } catch (final NullPointerException e) { return null; } }
private ChargebackResult doChargeback(final Transfer transfer) { ChargebackStatus status = null; Transfer chargebackTransfer = null; // Check if the transfer can be charged back if (!paymentService.canChargeback(transfer, false)) { if (transfer.getChargedBackBy() != null) { chargebackTransfer = transfer.getChargedBackBy(); status = ChargebackStatus.TRANSFER_ALREADY_CHARGEDBACK; } else { if (transfer.getStatus() == Payment.Status.PENDING) { final TransferAuthorizationDTO transferAuthorizationDto = new TransferAuthorizationDTO(); transferAuthorizationDto.setTransfer(transfer); transferAuthorizationDto.setShowToMember(false); chargebackTransfer = transferAuthorizationService.cancelFromMemberAsReceiver(transferAuthorizationDto); status = ChargebackStatus.SUCCESS; } else { status = ChargebackStatus.TRANSFER_CANNOT_BE_CHARGEDBACK; } } } // Do the chargeback if (status == null) { chargebackTransfer = paymentService.chargeback(transfer, WebServiceContext.getClient().getId()); status = ChargebackStatus.SUCCESS; } if (!status.isSuccessful()) { webServiceHelper.error("Chargeback result: " + status); } final Member member = WebServiceContext.getMember(); // Build the result if (status == ChargebackStatus.SUCCESS || status == ChargebackStatus.TRANSFER_ALREADY_CHARGEDBACK) { final AccountOwner owner = member == null ? transfer.getToOwner() : member; final AccountHistoryTransferVO originalVO = accountHelper.toVO(owner, transfer, null); final AccountHistoryTransferVO chargebackVO = accountHelper.toVO(owner, chargebackTransfer, null); return new ChargebackResult(status, originalVO, chargebackVO); } else { return new ChargebackResult(status, null, null); } }
private <V> ChargebackResult reverse(final V transferId, final TransferLoader<V> loader) { Exception errorException = null; ChargebackStatus status = null; Transfer transfer = null; try { transfer = loader.load(transferId); // Ensure the member is the one who received the payment final Member member = WebServiceContext.getMember(); if (member != null && !transfer.getToOwner().equals(member)) { throw new EntityNotFoundException(); } else { final Collection<TransferType> possibleTypes = fetchService .fetch( WebServiceContext.getClient(), ServiceClient.Relationships.CHARGEBACK_PAYMENT_TYPES) .getChargebackPaymentTypes(); if (!possibleTypes.contains(transfer.getType())) { throw new EntityNotFoundException(); } } } catch (final EntityNotFoundException e) { errorException = e; status = ChargebackStatus.TRANSFER_NOT_FOUND; } if (status == null) { try { return doChargeback(transfer); } catch (final Exception e) { webServiceHelper.error(e); return new ChargebackResult(ChargebackStatus.TRANSFER_CANNOT_BE_CHARGEDBACK, null, null); } } else { if (!status.isSuccessful()) { webServiceHelper.error( errorException != null ? errorException : new Exception("Chargeback status: " + status)); } return new ChargebackResult(status, null, null); } }
@Override protected ActionForward handleSubmit(final ActionContext context) throws Exception { Transfer transfer = resolveTransfer(context); // Validate the transaction password if needed if (shouldValidateTransactionPassword(context, transfer)) { final ScheduledPaymentForm form = context.getForm(); context.checkTransactionPassword(form.getTransactionPassword()); } // Perform the actual payment try { transfer = scheduledPaymentService.processTransfer(transfer); } catch (final CreditsException e) { return context.sendError(actionHelper.resolveErrorKey(e), actionHelper.resolveParameters(e)); } catch (final UnexpectedEntityException e) { return context.sendError("payment.error.invalidTransferType"); } return ActionHelper.redirectWithParam( context.getRequest(), context.getSuccessForward(), "paymentId", transfer.getScheduledPayment().getId()); }
@Override protected void prepareForm(final ActionContext context) throws Exception { final Transfer transfer = resolveTransfer(context); // Check for transaction password final HttpServletRequest request = context.getRequest(); final boolean requestTransactionPassword = shouldValidateTransactionPassword(context, transfer); if (requestTransactionPassword) { context.validateTransactionPassword(); } request.setAttribute("requestTransactionPassword", requestTransactionPassword); request.setAttribute( "wouldRequireAuthorization", paymentService.wouldRequireAuthorization(transfer)); // Transfer number and number of transfers final int transferNumber = getTransferNumber(transfer); final int numberOfTransfers = getNumberOfTransfer(transfer); request.setAttribute("transferNumber", transferNumber); request.setAttribute("numberOfTransfers", numberOfTransfers); // Fetch related data final AccountOwner from = transfer.getFromOwner(); final AccountOwner to = transfer.getToOwner(); final TransferType transferType = transferTypeService.load( transfer.getType().getId(), RelationshipHelper.nested( TransferType.Relationships.FROM, AccountType.Relationships.CURRENCY), TransferType.Relationships.TO); final BigDecimal amount = transfer.getAmount(); if (from instanceof Member) { request.setAttribute("fromMember", from); } if (to instanceof Member) { request.setAttribute("toMember", to); } transfer.setType(transferType); request.setAttribute("unitsPattern", transferType.getFrom().getCurrency().getPattern()); // Store the transaction fees final TransactionFeePreviewDTO preview = transactionFeeService.preview(from, to, transferType, amount); request.setAttribute("finalAmount", preview.getFinalAmount()); request.setAttribute("fees", preview.getFees()); request.setAttribute("transfer", transfer); }
public TransferType getTransferType() { return transfer == null ? null : transfer.getType(); }
public Calendar getGrantDate() { return transfer == null ? null : transfer.getProcessDate(); }
public BigDecimal getAmount() { return transfer == null ? null : transfer.getAmount(); }
public PaymentResult confirmPayment(final ConfirmPaymentParameters params) { Exception errorException = null; AccountStatus fromMemberStatus = null; AccountStatus toMemberStatus = null; Member fromMember = null; Member toMember = null; // It's nonsense to use this if restricted to a member if (WebServiceContext.getMember() != null) { throw new PermissionDeniedException(); } final Channel channel = WebServiceContext.getChannel(); final String channelName = channel == null ? null : channel.getInternalName(); PaymentStatus status = null; AccountHistoryTransferVO transferVO = null; // Get the ticket PaymentRequestTicket ticket = null; try { // Check that the ticket is valid final Ticket t = ticketService.load(params.getTicket()); fromMember = t.getFrom(); toMember = t.getTo(); if (!(t instanceof PaymentRequestTicket) || t.getStatus() != Ticket.Status.PENDING) { throw new Exception( "Invalid ticket and/or status: " + t.getClass().getName() + ", status: " + t.getStatus()); } // Check that the channel is the expected one ticket = (PaymentRequestTicket) t; if (!ticket.getToChannel().getInternalName().equals(channelName)) { throw new Exception( "The ticket's destination channel is not the expected one (expected=" + channelName + "): " + ticket.getToChannel().getInternalName()); } } catch (final Exception e) { errorException = e; status = PaymentStatus.INVALID_PARAMETERS; } // Validate the Channel and credentials Member member = null; if (status == null) { member = ticket.getFrom(); if (!accessService.isChannelEnabledForMember(channelName, member)) { status = PaymentStatus.INVALID_CHANNEL; } if (status == null && WebServiceContext.getClient().isCredentialsRequired()) { try { checkCredentials(member, channel, params.getCredentials()); } catch (final InvalidCredentialsException e) { status = PaymentStatus.INVALID_CREDENTIALS; } catch (final BlockedCredentialsException e) { status = PaymentStatus.BLOCKED_CREDENTIALS; } } } // Confirm the payment if (status == null) { try { final Transfer transfer = (Transfer) paymentService.confirmPayment(ticket.getTicket()); transferVO = accountHelper.toVO(member, transfer, null); status = paymentHelper.toStatus(transfer); if (WebServiceContext.getClient() .getPermissions() .contains(ServiceOperation.ACCOUNT_DETAILS)) { if (WebServiceContext.getMember() == null) { fromMemberStatus = accountService.getStatus( new GetTransactionsDTO(fromMember, transfer.getFrom().getType())); toMemberStatus = accountService.getStatus( new GetTransactionsDTO(toMember, transfer.getTo().getType())); } else if (WebServiceContext.getMember().equals(fromMember)) { fromMemberStatus = accountService.getStatus( new GetTransactionsDTO(fromMember, transfer.getFrom().getType())); } else { toMemberStatus = accountService.getStatus( new GetTransactionsDTO(toMember, transfer.getTo().getType())); } } } catch (final Exception e) { errorException = e; status = paymentHelper.toStatus(e); } } if (!status.isSuccessful()) { webServiceHelper.error( errorException != null ? errorException : new Exception("Confirm payment status: " + status)); } // Build the result return new PaymentResult( status, transferVO, accountHelper.toVO(fromMemberStatus), accountHelper.toVO(toMemberStatus)); }
private boolean shouldValidateTransactionPassword( final ActionContext context, final Transfer transfer) { final TransferType transferType = transferTypeService.load(transfer.getType().getId(), TransferType.Relationships.FROM); return context.isTransactionPasswordEnabled(transferType.getFrom()); }
private int getNumberOfTransfer(final Transfer transfer) { final ScheduledPayment scheduledPayment = transfer.getScheduledPayment(); return scheduledPayment.getTransfers().size(); }