Exemplo n.º 1
0
  public boolean process(PaymentDTOEx payment) throws PluggableTaskException {
    LOG.debug("Payment processing for " + getProcessorName() + " gateway");

    if (payment.getPayoutId() != null) return true;

    SvcType transaction = SvcType.SALE;
    if (BigDecimal.ZERO.compareTo(payment.getAmount()) > 0 || (payment.getIsRefund() != 0)) {
      LOG.debug("Doing a refund using credit card transaction");
      transaction = SvcType.REFUND_CREDIT;
    }

    boolean result;
    try {
      result = doProcess(payment, transaction, null).shouldCallOtherProcessors();
      LOG.debug(
          "Processing result is "
              + payment.getPaymentResult().getId()
              + ", return value of process is "
              + result);

    } catch (Exception e) {
      LOG.error("Exception", e);
      throw new PluggableTaskException(e);
    }
    return result;
  }
Exemplo n.º 2
0
  public boolean confirmPreAuth(PaymentAuthorizationDTO auth, PaymentDTOEx payment)
      throws PluggableTaskException {

    LOG.debug("Confirming pre-authorization for " + getProcessorName() + " gateway");

    if (!getProcessorName().equals(auth.getProcessor())) {
      /*  let the processor be called and fail, so the caller can do something
      about it: probably re-call this payment task as a new "process()" run */
      LOG.warn(
          "The processor of the pre-auth is not "
              + getProcessorName()
              + ", is "
              + auth.getProcessor());
    }

    CreditCardDTO card = payment.getCreditCard();
    if (card == null) {
      throw new PluggableTaskException(
          "Credit card is required capturing" + " payment: " + payment.getId());
    }

    if (!isApplicable(payment)) {
      LOG.error("This payment can not be captured" + payment);
      return true;
    }

    return doProcess(payment, SvcType.SETTLE, auth).shouldCallOtherProcessors();
  }
Exemplo n.º 3
0
  private Result doFakeAuthorization(PaymentDTOEx payment, String transactionId)
      throws PluggableTaskException {
    CreditCardDTO creditCard = payment.getCreditCard();
    if (creditCard == null || !myFilter.accept(creditCard)) {
      // give real processors a chance
      return new Result(null, true);
    }

    Integer resultId = getProcessResultId(creditCard);
    payment.setPaymentResult(new PaymentResultDAS().find(resultId));
    PaymentAuthorizationDTO authInfo = createAuthorizationDTO(resultId, transactionId);
    storeProcessedAuthorization(payment, authInfo);

    boolean wasProcessed =
        (Constants.RESULT_FAIL.equals(resultId) || Constants.RESULT_OK.equals(resultId));
    boolean shouldCallOthers = !wasProcessed && !myShouldBlockOtherProcessors;
    return new Result(authInfo, shouldCallOthers);
  }
Exemplo n.º 4
0
  @Override // implements abstract method
  public NVPList buildRequest(PaymentDTOEx payment, SvcType transaction)
      throws PluggableTaskException {
    NVPList request = new NVPList();

    request.add(PARAMETER_MERCHANT_ID, getMerchantId());
    request.add(PARAMETER_STORE_ID, getStoreId());
    request.add(PARAMETER_TERMINAL_ID, getTerminalId());
    request.add(PARAMETER_SELLER_ID, getSellerId());
    request.add(PARAMETER_PASSWORD, getPassword());

    ContactBL contact = new ContactBL();
    contact.set(payment.getUserId());

    request.add(WorldPayParams.General.STREET_ADDRESS, contact.getEntity().getAddress1());
    request.add(WorldPayParams.General.CITY, contact.getEntity().getCity());
    request.add(WorldPayParams.General.STATE, contact.getEntity().getStateProvince());
    request.add(WorldPayParams.General.ZIP, contact.getEntity().getPostalCode());

    request.add(WorldPayParams.General.FIRST_NAME, contact.getEntity().getFirstName());
    request.add(WorldPayParams.General.LAST_NAME, contact.getEntity().getLastName());
    request.add(WorldPayParams.General.COUNTRY, contact.getEntity().getCountryCode());

    request.add(WorldPayParams.General.AMOUNT, formatDollarAmount(payment.getAmount()));
    request.add(WorldPayParams.General.SVC_TYPE, transaction.getCode());

    CreditCardDTO card = payment.getCreditCard();
    request.add(WorldPayParams.CreditCard.CARD_NUMBER, card.getNumber());
    request.add(
        WorldPayParams.CreditCard.EXPIRATION_DATE,
        EXPIRATION_DATE_FORMAT.format(card.getCcExpiry()));

    if (card.getSecurityCode() != null) {
      request.add(
          WorldPayParams.CreditCard.CVV2,
          String.valueOf(payment.getCreditCard().getSecurityCode()));
    }

    return request;
  }
  @Override
  protected PaymentTask selectDelegate(PaymentDTOEx paymentInfo) throws PluggableTaskException {
    String currencyCode = paymentInfo.getCurrency().getCode();
    Integer selectedTaskId = null;

    try {
      // try to get the task id for this currency
      selectedTaskId = intValueOf(parameters.get(currencyCode));
    } catch (NumberFormatException e) {
      throw new PluggableTaskException("Invalid task id for currency " + "code: " + currencyCode);
    }
    if (selectedTaskId == null) {
      LOG.warn("Could not find processor for " + parameters.get(currencyCode));
      return null;
    }

    LOG.debug("Delegating to task id " + selectedTaskId);
    PaymentTask selectedTask = instantiateTask(selectedTaskId);

    return selectedTask;
  }
  public boolean process(PaymentDTOEx paymentInfo) throws PluggableTaskException {
    FormatLogger log = new FormatLogger(Logger.getLogger(PaymentEmailAuthorizeNetTask.class));
    boolean retValue = super.process(paymentInfo);
    String address = (String) parameters.get(PARAMETER_EMAIL_ADDRESS.getName());
    try {
      UserBL user = new UserBL(paymentInfo.getUserId());
      String message;
      if (new Integer(paymentInfo.getPaymentResult().getId()).equals(Constants.RESULT_OK)) {
        message = "payment.success";
      } else {
        message = "payment.fail";
      }
      String params[] = new String[6];
      params[0] = paymentInfo.getUserId().toString();
      params[1] = user.getEntity().getUserName();
      params[2] = paymentInfo.getId() + "";
      params[3] = paymentInfo.getAmount().toString();
      if (paymentInfo.getAuthorization() != null) {
        params[4] = paymentInfo.getAuthorization().getTransactionId();
        params[5] = paymentInfo.getAuthorization().getApprovalCode();
      } else {
        params[4] = "Not available";
        params[5] = "Not available";
      }
      log.debug(
          "Bkp 6 " + params[0] + " " + params[1] + " " + params[2] + " " + params[3] + " "
              + params[4] + " " + params[5] + " ");
      NotificationBL.sendSapienterEmail(
          address, user.getEntity().getEntity().getId(), message, null, params);
    } catch (Exception e) {

      log.warn("Cant send receit email");
    }

    return retValue;
  }
Exemplo n.º 7
0
  public ActionForward execute(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response)
      throws IOException, ServletException {

    Logger log = Logger.getLogger(MaintainAction.class);
    String forward = null;
    ActionForward retValue = null;
    try {
      IPaymentSessionBean myRemoteSession =
          (IPaymentSessionBean) Context.getBean(Context.Name.PAYMENT_SESSION);

      /*
       * Because of the review step, the payment has some actions that
       * so far makes no sense to dump them in the generic action
       */
      String action = request.getParameter("action");
      HttpSession session = request.getSession(false);
      ActionMessages messages = new ActionMessages();

      String key;
      key = session.getAttribute("jsp_is_refund") == null ? "payment." : "refund.";
      // get the payment/refund information
      String sessionKey;
      if (key.equals("payment.")) {
        sessionKey = Constants.SESSION_PAYMENT_DTO;
      } else {
        sessionKey = Constants.SESSION_PAYMENT_DTO_REFUND;
      }

      if (action.equals("send")) {

        PaymentDTOEx paymentDto = (PaymentDTOEx) session.getAttribute(sessionKey);

        if (paymentDto == null) {
          log.error("dto can't be null when sending");
          throw new ServletException("paymentDTO is null");
        }
        // get the invoice, it might not be there
        Integer invoiceId = null;
        InvoiceDTO invoice = (InvoiceDTO) session.getAttribute(Constants.SESSION_INVOICE_DTO);
        if (invoice != null) {
          invoiceId = invoice.getId();
        }

        boolean isPayout = false;
        PartnerPayout payout = null;
        Partner partner = null;
        if (request.getParameter("payout") != null
            && request.getParameter("payout").equals("yes")) {
          isPayout = true;
          payout = (PartnerPayout) session.getAttribute(Constants.SESSION_PAYOUT_DTO);
          partner = (Partner) session.getAttribute(Constants.SESSION_PARTNER_DTO);
        }

        if (((Boolean) session.getAttribute("tmp_process_now")).booleanValue()) {
          Integer result;
          if (!isPayout) {
            result =
                myRemoteSession.processAndUpdateInvoice(
                    paymentDto,
                    invoiceId,
                    (Integer) session.getAttribute(Constants.SESSION_ENTITY_ID_KEY));
          } else {

            result =
                myRemoteSession.processPayout(
                    paymentDto,
                    payout.getStartingDate(),
                    payout.getEndingDate(),
                    partner.getId(),
                    new Boolean(true));
            payout.setPayment(new PaymentDTO(paymentDto));
          }

          if (result == null) {
            key = key + "no_result";
          } else if (result.equals(Constants.RESULT_OK)) {
            key = key + "result.approved";
          } else if (result.equals(Constants.RESULT_FAIL)) {
            key = key + "result.rejected";
          } else if (result.equals(Constants.RESULT_UNAVAILABLE)) {
            key = key + "result.unavailable";
          } else {
            key = "all.internal";
            log.error("Unsupported result from server:" + result);
          }

        } else {
          if (!isPayout) {
            log.debug(
                "sending payment. Id = "
                    + paymentDto.getId()
                    + " refund "
                    + paymentDto.getIsRefund());
            if (paymentDto.getId() != 0 && paymentDto.getIsRefund() == 0) {
              // it is an update
              myRemoteSession.update(
                  (Integer) session.getAttribute(Constants.SESSION_LOGGED_USER_ID), paymentDto);
            } else {
              // it is a new payment
              paymentDto.setId(myRemoteSession.applyPayment(paymentDto, invoiceId));
              // I need to update the DTO, so the left bar can
              // make the right decitions
              if (invoiceId != null) {
                List<Integer> invoices = new ArrayList<Integer>();
                invoices.add(invoiceId);
                paymentDto.setInvoiceIds(invoices);
              }
            }
          } else {
            myRemoteSession.processPayout(
                paymentDto,
                payout.getStartingDate(),
                payout.getEndingDate(),
                partner.getId(),
                new Boolean(false));
          }
          key = key + "enter.success";
        }

        messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(key));
        if (!isPayout) {
          // the dto has to be refreshed, otherwise the
          // map to the invoice won't be there
          session.setAttribute(
              Constants.SESSION_PAYMENT_DTO,
              myRemoteSession.getPayment(
                  paymentDto.getId(), (Integer) session.getAttribute(Constants.SESSION_LANGUAGE)));
          forward = "payment_view";
        } else {
          forward = "payout_view";
        }
      } else if (action.equals("last_invoice")) {
        forward = "no_invoice";
        // make sure the logged user shows up as the user for the payment
        session.setAttribute(
            Constants.SESSION_USER_ID, session.getAttribute(Constants.SESSION_LOGGED_USER_ID));
        // now find out which is the latest invoice and make it available
        UserDTOEx user = (UserDTOEx) session.getAttribute(Constants.SESSION_USER_DTO);
        Integer invoiceId = user.getLastInvoiceId();
        if (invoiceId != null) {
          IInvoiceSessionBean invoiceSession =
              (IInvoiceSessionBean) Context.getBean(Context.Name.INVOICE_SESSION);
          InvoiceDTO invoice = invoiceSession.getInvoice(invoiceId);
          if (invoice.getToProcess().intValue() == 1) {
            session.setAttribute(Constants.SESSION_INVOICE_DTO, invoice);
            // this will chain the action, but it's effective
            forward = "last_invoice";
          }
        }

        if (forward.equals("no_invoice")) {
          messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("payment.error.noInvoice"));
        }
      } else if (action.equals("current_invoice")) {
        session.setAttribute(
            Constants.SESSION_USER_ID, session.getAttribute(Constants.SESSION_LOGGED_USER_ID));
        // the invoice dto is already in the sesssion .. piece of cake
        forward = "last_invoice";
      } else if (action.equals("cancel")) {
        session.removeAttribute(sessionKey);
        messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("payment.enter.cancel"));
        forward = "payment_list";
      } else if (action.equals("view")) {
        // this is called when a payment is selected from the list
        // for a read-only view

        Integer paymentId;
        if (request.getParameter("id") != null) {
          // this is being called from anywhere, to check out a payment
          paymentId = Integer.valueOf(request.getParameter("id"));
        } else {
          // this is called from the list of payments
          paymentId = (Integer) session.getAttribute(Constants.SESSION_LIST_ID_SELECTED);
        }
        Integer languageId = (Integer) session.getAttribute(Constants.SESSION_LANGUAGE);
        PaymentDTOEx dto = myRemoteSession.getPayment(paymentId, languageId);
        log.debug("my dto is " + dto);
        if (dto.getIsRefund() == 1) {
          session.setAttribute(Constants.SESSION_PAYMENT_DTO_REFUND, dto);
          if (dto.getPayment() != null) {
            session.setAttribute(
                Constants.SESSION_PAYMENT_DTO,
                myRemoteSession.getPayment(dto.getPayment().getId(), languageId));
          } else {
            session.removeAttribute(Constants.SESSION_PAYMENT_DTO);
          }

        } else {
          session.setAttribute(Constants.SESSION_PAYMENT_DTO, dto);
        }

        // now include the invoice and customer dto of this payment
        try {
          // now the user
          session.setAttribute(Constants.SESSION_USER_ID, dto.getUserId());

          ICustomerSessionBean userSession =
              (ICustomerSessionBean) Context.getBean(Context.Name.CUSTOMER_SESSION);
          session.setAttribute(
              Constants.SESSION_CUSTOMER_CONTACT_DTO,
              userSession.getPrimaryContactDTO(dto.getUserId()));

        } catch (Exception e) {
          throw new SessionInternalError(e);
        }

        forward = "payment_view";
      } else if (action.equals("notify")) {
        INotificationSessionBean notificationSession =
            (INotificationSessionBean) Context.getBean(Context.Name.NOTIFICATION_SESSION);
        Integer paymentId = Integer.valueOf(request.getParameter("id"));
        Boolean result = notificationSession.emailPayment(paymentId);
        String field;
        if (result.booleanValue()) {
          field = "email.notify.ok";
        } else {
          field = "email.notify.error";
        }
        messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(field));
        forward = "payment_view";
      } else if (action.equals("unlink")) {
        Integer mapId = Integer.valueOf(request.getParameter("mapId"));
        myRemoteSession.removeInvoiceLink(mapId);
        messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("payment.link.removalDone"));
        // make sure the payment now shows up updated
        session.setAttribute(
            Constants.SESSION_LIST_ID_SELECTED,
            ((PaymentDTO) session.getAttribute(Constants.SESSION_PAYMENT_DTO)).getId());
        session.removeAttribute(Constants.SESSION_PAYMENT_DTO);
        forward = "payment_setupView";
      } else if (action.equals("apply")) {
        // call the server to apply tha payment
        myRemoteSession.applyPayment(
            ((PaymentDTO) session.getAttribute(Constants.SESSION_PAYMENT_DTO)).getId(),
            ((InvoiceDTO) session.getAttribute(Constants.SESSION_INVOICE_DTO)).getId());
        // show a 'done' message
        messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("payment.link.applyDone"));
        // redirect to payment view, with the refreshed payment record
        session.setAttribute(
            Constants.SESSION_LIST_ID_SELECTED,
            ((PaymentDTO) session.getAttribute(Constants.SESSION_PAYMENT_DTO)).getId());
        session.removeAttribute(Constants.SESSION_PAYMENT_DTO);
        forward = "payment_setupView";
      } else {
        PaymentCrudAction delegate = new PaymentCrudAction(myRemoteSession);
        delegate.setServlet(getServlet());
        retValue = delegate.execute(mapping, form, request, response);
      }

      saveMessages(request, messages);
    } catch (Exception e) {
      log.error("Exception ", e);
      retValue = mapping.findForward("error");
      forward = null;
    }

    if (forward != null) {
      retValue = mapping.findForward(forward);
    }
    return retValue;
  }
Exemplo n.º 8
0
  protected final void storeProcessedAuthorization(
      PaymentDTOEx paymentInfo, PaymentAuthorizationDTO auth) throws PluggableTaskException {

    new PaymentAuthorizationBL().create(auth, paymentInfo.getId());
    paymentInfo.setAuthorization(auth);
  }