Example #1
0
  @Override
  protected ActionForward handleDisplay(final ActionContext context) throws Exception {
    final HttpServletRequest request = context.getRequest();
    final SendInvoiceForm form = context.getForm();
    final boolean toSystem = form.isToSystem();
    final boolean selectMember = form.isSelectMember();

    AccountOwner to;
    final Member fromMember =
        (form.getFrom() == null)
            ? null
            : (Member) elementService.load(Long.valueOf(form.getFrom()));
    final Element loggedElement = context.getElement();
    if (toSystem) {
      // System invoice
      to = SystemAccountOwner.instance();
    } else {
      if (!selectMember) {
        // Retrieve the member to send invoice for
        Member member = null;
        final Long memberId = IdConverter.instance().valueOf(form.getTo());
        if (memberId != null && memberId != loggedElement.getId()) {
          final Element element = elementService.load(memberId, Element.Relationships.USER);
          if (element instanceof Member) {
            member = (Member) element;
          }
        }
        if (member == null) {
          throw new ValidationException();
        }
        request.setAttribute("member", member);
        to = member;
      } else {
        // The member will be selected later
        to = null;
      }
    }

    // If we know who will receive the invoice, get the transfer types or dest account types
    if (to != null) {
      if (context.isAdmin() && fromMember == null) {
        // Only admins may select the transfer type
        final TransferTypeQuery query = new TransferTypeQuery();
        query.setChannel(Channel.WEB);
        query.setContext(TransactionContext.PAYMENT);
        query.setFromOwner(to);
        query.setToOwner(context.getAccountOwner());
        query.setUsePriority(true);
        request.setAttribute("transferTypes", transferTypeService.search(query));
      } else {
        // Members may select the destination account type
        final MemberAccountTypeQuery query = new MemberAccountTypeQuery();
        query.setOwner(fromMember == null ? (Member) loggedElement.getAccountOwner() : fromMember);
        query.setCanPay(to);
        final List<? extends AccountType> accountTypes = accountTypeService.search(query);
        if (accountTypes.isEmpty()) {
          return context.sendError("invoice.error.noAccountType");
        }
        request.setAttribute("accountTypes", accountTypes);
      }
    }

    // Resolve the possible currencies
    final MemberGroup group = getMemberGroup(context);
    final List<Currency> currencies;
    if (group != null) {
      currencies = currencyService.listByMemberGroup(group);
      final MemberAccountType defaultAccountType =
          accountTypeService.getDefault(group, AccountType.Relationships.CURRENCY);
      // Preselect the default currency
      if (defaultAccountType != null) {
        form.setCurrency(CoercionHelper.coerce(String.class, defaultAccountType.getCurrency()));
      }
    } else {
      currencies = currencyService.listAll();
    }
    request.setAttribute("currencies", currencies);

    if (currencies.isEmpty()) {
      // No currencies means no possible payment!!!
      throw new ValidationException("payment.error.noTransferType");
    } else if (currencies.size() == 1) {
      // Special case: There is a single currency. The JSP will use this object
      request.setAttribute("singleCurrency", currencies.get(0));
    }

    request.setAttribute("toSystem", toSystem);
    request.setAttribute("toMember", !toSystem);
    request.setAttribute("selectMember", selectMember);
    request.setAttribute("from", fromMember);

    final boolean useTransferType = context.isAdmin() && fromMember == null;
    request.setAttribute("useTransferType", useTransferType);

    // Check whether scheduled payments may be performed
    boolean allowsScheduling = false;
    boolean allowsMultipleScheduling = false;
    if (context.isAdmin() && fromMember == null) {
      allowsScheduling = true;
      allowsMultipleScheduling = true;
    } else {
      MemberGroup memberGroup;
      if (fromMember == null) {
        memberGroup = ((Member) context.getAccountOwner()).getMemberGroup();
      } else {
        memberGroup = fromMember.getMemberGroup();
      }
      final MemberGroupSettings memberSettings = memberGroup.getMemberSettings();
      allowsScheduling = memberSettings.isAllowsScheduledPayments();
      allowsMultipleScheduling = memberSettings.isAllowsMultipleScheduledPayments();
    }
    if (allowsScheduling) {
      request.setAttribute("allowsScheduling", allowsScheduling);
      request.setAttribute("allowsMultipleScheduling", allowsMultipleScheduling);
      final Collection<SchedulingType> schedulingTypes =
          EnumSet.of(SchedulingType.IMMEDIATELY, SchedulingType.SINGLE_FUTURE);
      if (allowsMultipleScheduling) {
        schedulingTypes.add(SchedulingType.MULTIPLE_FUTURE);
      }
      request.setAttribute("schedulingTypes", schedulingTypes);
      request.setAttribute(
          "schedulingFields",
          Arrays.asList(TimePeriod.Field.MONTHS, TimePeriod.Field.WEEKS, TimePeriod.Field.DAYS));
    }

    return context.getInputForward();
  }
Example #2
0
  /** Prepares the parameters for a payment. The resulting status is null when no problem found */
  private PrepareParametersResult prepareParameters(final PaymentParameters params) {

    final Member restricted = WebServiceContext.getMember();
    final boolean fromSystem = params.isFromSystem();
    final boolean toSystem = params.isToSystem();
    PaymentStatus status = null;
    Member fromMember = null;
    Member toMember = null;
    // Load the from member
    if (!fromSystem) {
      try {
        fromMember = paymentHelper.resolveFromMember(params);
      } catch (final EntityNotFoundException e) {
        webServiceHelper.error(e);
        status = PaymentStatus.FROM_NOT_FOUND;
      }
    }
    // Load the to member
    if (!toSystem) {
      try {
        toMember = paymentHelper.resolveToMember(params);
      } catch (final EntityNotFoundException e) {
        webServiceHelper.error(e);
        status = PaymentStatus.TO_NOT_FOUND;
      }
    }

    if (status == null) {
      if (restricted == null) {
        // Ensure has the do payment permission
        if (!WebServiceContext.hasPermission(ServiceOperation.DO_PAYMENT)) {
          throw new PermissionDeniedException(
              "The service client doesn't have the following permission: "
                  + ServiceOperation.DO_PAYMENT);
        }
        // Check the channel immediately, as needed by SMS controller
        if (fromMember != null
            && !accessService.isChannelEnabledForMember(channelHelper.restricted(), fromMember)) {
          status = PaymentStatus.INVALID_CHANNEL;
        }
      } else {
        // Enforce the restricted to member parameters
        if (fromSystem) {
          // Restricted to member can't perform payment from system
          status = PaymentStatus.FROM_NOT_FOUND;
        } else {
          if (fromMember == null) {
            fromMember = restricted;
          } else if (toMember == null && !toSystem) {
            toMember = restricted;
          }
        }
        if (status == null) {
          // Check make / receive payment permissions
          if (fromMember.equals(restricted)) {
            if (!WebServiceContext.hasPermission(ServiceOperation.DO_PAYMENT)) {
              throw new PermissionDeniedException(
                  "The service client doesn't have the following permission: "
                      + ServiceOperation.DO_PAYMENT);
            }
          } else {
            if (!WebServiceContext.hasPermission(ServiceOperation.RECEIVE_PAYMENT)) {
              throw new PermissionDeniedException(
                  "The service client doesn't have the following permission: "
                      + ServiceOperation.RECEIVE_PAYMENT);
            }
          }
          // Ensure that either from or to member is the restricted one
          if (!fromMember.equals(restricted) && !toMember.equals(restricted)) {
            status = PaymentStatus.INVALID_PARAMETERS;
            webServiceHelper.trace(
                status
                    + ". Reason: Neither the origin nor the destination members are equal to the restricted: "
                    + restricted);
          }
        }
        if (status == null) {
          // Enforce the permissions
          if (restricted.equals(fromMember)
              && !WebServiceContext.hasPermission(ServiceOperation.DO_PAYMENT)) {
            throw new PermissionDeniedException(
                "The service client doesn't have the following permission: "
                    + ServiceOperation.DO_PAYMENT);
          } else if (restricted.equals(toMember)
              && !WebServiceContext.hasPermission(ServiceOperation.RECEIVE_PAYMENT)) {
            throw new PermissionDeniedException(
                "The service client doesn't have the following permission: "
                    + ServiceOperation.RECEIVE_PAYMENT);
          }
        }
      }
    }

    // Ensure both from and to member are present
    if (status == null) {
      if (fromMember == null && !fromSystem) {
        status = PaymentStatus.FROM_NOT_FOUND;
      } else if (toMember == null && !toSystem) {
        status = PaymentStatus.TO_NOT_FOUND;
      }
    }

    if (status == null) {
      // Check the channel
      if (fromMember != null
          && !accessService.isChannelEnabledForMember(channelHelper.restricted(), fromMember)) {
        status = PaymentStatus.INVALID_CHANNEL;
      }
    }
    if (status == null) {
      // Check the credentials
      boolean checkCredentials;
      if (restricted != null) {
        checkCredentials = !fromMember.equals(restricted);
      } else {
        checkCredentials = !fromSystem && WebServiceContext.getClient().isCredentialsRequired();
      }
      if (checkCredentials) {
        try {
          checkCredentials(fromMember, WebServiceContext.getChannel(), params.getCredentials());
        } catch (final InvalidCredentialsException e) {
          status = PaymentStatus.INVALID_CREDENTIALS;
        } catch (final BlockedCredentialsException e) {
          status = PaymentStatus.BLOCKED_CREDENTIALS;
        }
      }
    }

    // No error
    final AccountOwner fromOwner = fromSystem ? SystemAccountOwner.instance() : fromMember;
    final AccountOwner toOwner = toSystem ? SystemAccountOwner.instance() : toMember;
    return new PrepareParametersResult(status, fromOwner, toOwner);
  }
Example #3
0
 public AccountOwner valueOf(final String string) {
   final Member member = REFERENCE_CONVERTER.valueOf(string);
   return member == null
       ? (zeroIsSystem ? SystemAccountOwner.instance() : LoggedUser.accountOwner())
       : member;
 }