/** Returns a string of the generated rules using data from the passed in object. */
  protected String generateRules(Object objects) throws TaskException {
    // get filename
    if (parameters.get(PARAM_TEMPLATE_FILENAME.getName()) == null) {
      throw new TaskException(
          "No '" + PARAM_TEMPLATE_FILENAME.getName() + "' parameter specified.");
    }
    File templateFilename =
        new File(getAbsolutePath((String) parameters.get(PARAM_TEMPLATE_FILENAME.getName())));

    // create a new engine (we need to set the file path)
    VelocityEngine velocityEngine = new VelocityEngine();
    velocityEngine.setProperty(
        VelocityEngine.FILE_RESOURCE_LOADER_PATH, templateFilename.getParent());
    try {
      velocityEngine.init();
    } catch (Exception e) {
      LOG.error("Error initializing template engine.");
      throw new TaskException(e);
    }

    VelocityContext velocityContext = new VelocityContext();
    // add parameters using reflection
    addParameters(velocityContext, objects);

    // generate rules and return
    StringWriter result = new StringWriter();
    try {
      velocityEngine.mergeTemplate(templateFilename.getName(), velocityContext, result);
    } catch (Exception e) {
      LOG.error("Error generating rules.");
      throw new TaskException(e);
    }
    return result.toString();
  }
 /**
  * Adds parameters to the velocity context using reflection. All 'get' methods that return Objects
  * are added to the context, with the chars after 'get' (first char lowercase) as the key.
  */
 private void addParameters(VelocityContext context, Object objects) throws TaskException {
   Class<?> objectsClass = objects.getClass();
   Method methods[] = objectsClass.getMethods();
   for (Method method : methods) {
     // If method starts with 'get', returns an Object and
     // takes no parameters, execute it and save result for
     // the velocity context.
     String methodName = method.getName();
     if (methodName.length() > 3
         && methodName.startsWith("get")
         && !method.getReturnType().isPrimitive()
         && method.getParameterTypes().length == 0) {
       // use the chars after the 'get' as the key
       String key = methodName.substring(3, 4).toLowerCase();
       if (methodName.length() > 4) {
         key += methodName.substring(4);
       }
       try {
         context.put(key, method.invoke(objects));
       } catch (Exception e) {
         LOG.error("Error invoking " + methodName + " method via reflection.");
         throw new TaskException(e);
       }
     }
     // add the passed in Object itself to the context
     context.put("data", objects);
   }
 }
Beispiel #3
0
    public static boolean validate(BillingProcessConfigurationWS ws) {
    	boolean retValue = true;
 
    	//validate nextRunDate - Unique if there is already a successful run for that date 
    	//(if a process failed, it is fine to run it again)
    	//TODO Should I Util.truncateDate before using the ws.nextRunDate?
    	BillingProcessDTO billingProcessDTO=new BillingProcessDAS().isPresent(ws.getEntityId(), 0, ws.getNextRunDate()); 
    	if ( billingProcessDTO != null) {
    		for (ProcessRunDTO run: billingProcessDTO.getProcessRuns()) {
    			//if status is not failed i.e. for the same date, if the process is either running or finished
    			if (!Constants.PROCESS_RUN_STATUS_FAILED.equals(run.getStatus().getId()) ) {
    			    LOG.error("Trying to set this configuration: " + ws + " but already has this: " + run);
    				SessionInternalError exception = new SessionInternalError(
    				        "There is already a billing process for the give date." + ws.getNextRunDate());
    	            String messages[] = new String[1];
    	            messages[0] = new String("BillingProcessConfigurationWS,nextRunDate,billing.configuration.error.unique.nextrundate,");
    	            exception.setErrorMessages(messages);
    	            throw exception;
    			}
    		}
    	}
    	
    	ProcessRunDTO run = new ProcessRunDAS().getLatestSuccessful(ws.getEntityId());
    	
    	//The nextRunDate must be greater than the latest successful one
    	if (run != null
            && run.getBillingProcess().getBillingDate() != null
            && !run.getBillingProcess().getBillingDate().before(ws.getNextRunDate())) {

    		LOG.error("Trying to set this configuration: " + ws + " but the it should be in the future " + run.getBillingProcess());
			SessionInternalError exception = new SessionInternalError("The new next date needs to be in the future from the last successful run");
			String messages[] = new String[1];
			messages[0] = new String("BillingProcessConfigurationWS,nextRunDate,"
                                     + "billing.configuration.error.past.nextrundate,"
                                     + run.getBillingProcess().getBillingDate());

			exception.setErrorMessages(messages);
			throw exception;
		}

    	return retValue;
    }
  public boolean preAuth(PaymentDTOEx payment) throws PluggableTaskException {
    try {
      validateParameters();
      Map<String, Object> data = getChargeData(payment);
      PaymentAuthorizationDTO response = makeCall(data, false);

      PaymentAuthorizationDTO authDtoEx = new PaymentAuthorizationDTO(response);
      PaymentAuthorizationBL bl = new PaymentAuthorizationBL();
      bl.create(authDtoEx, payment.getId());

      payment.setAuthorization(authDtoEx);
      return false;
    } catch (Exception e) {
      log.error("error trying to pre-authorize", e);
      return true;
    }
  }
 private void addAVSFields(Integer userId, Map<String, Object> data) {
   try {
     ContactBL contact = new ContactBL();
     contact.set(userId);
     ContactDTO entity = contact.getEntity();
     data.put("city", entity.getCity());
     data.put("email", entity.getEmail());
     data.put("customerAccountCode", userId.toString());
     data.put("phone", entity.getPhoneNumber());
     data.put("state", entity.getStateProvince());
     data.put("street", entity.getAddress1() + " " + entity.getAddress2());
     data.put("zipCode", entity.getPostalCode());
     data.put("isOrganization", Boolean.FALSE);
   } catch (Exception e) {
     log.error("Exception when trying to add the AVS fields", e);
   }
 }
  public boolean process(PaymentDTOEx paymentInfo) throws PluggableTaskException {
    boolean retValue = false;

    if (paymentInfo.getPayoutId() != null) {
      return true;
    }
    try {
      if (!new PaymentInformationBL().isCreditCard(paymentInfo.getInstrument())) {
        log.error("Can't process without a credit card");
        throw new TaskException("Credit card not present in payment");
      }

      if (paymentInfo.getIsRefund() == 1
          && (paymentInfo.getPayment() == null
              || paymentInfo.getPayment().getAuthorization() == null)) {
        log.error("Can't process refund without a payment with an authorization record");
        throw new TaskException("Refund without previous authorization");
      }
      validateParameters();

      Map<String, Object> data;
      if (paymentInfo.getIsRefund() == 0) {
        data = getChargeData(paymentInfo);
      } else {
        data = getRefundData(paymentInfo);
      }

      if ("true".equals(getOptionalParameter(PARAMETER_AVS.getName(), "false"))) {
        addAVSFields(paymentInfo.getUserId(), data);

        /* #12686 - We do not want to log credit card numbers */
        Map<String, Object> dataLog =
            (Map<String, Object>) ((HashMap<String, Object>) data).clone();
        // dataLog.remove("accountNumber");
        dataLog.put("accountNumber", "******");
        // TODO: check this log
        log.debug("returning after avs " + dataLog);
      }

      PaymentAuthorizationDTO response = makeCall(data, true);
      paymentInfo.setAuthorization(response);

      if ("1".equals(response.getCode1())) {
        paymentInfo.setPaymentResult(new PaymentResultDAS().find(Constants.RESULT_OK));
        log.debug("result is ok");
      } else {
        paymentInfo.setPaymentResult(new PaymentResultDAS().find(Constants.RESULT_FAIL));
        log.debug("result is fail");
      }

      PaymentAuthorizationBL bl = new PaymentAuthorizationBL();
      bl.create(response, paymentInfo.getId());

    } catch (MalformedURLException e) {
      log.error("MalformedURLException exception when calling Atlas", e);
      paymentInfo.setPaymentResult(new PaymentResultDAS().find(Constants.RESULT_UNAVAILABLE));
      retValue = true;
    } catch (XmlRpcException e) {
      log.error("XmlRpcException exception when calling Atlas", e);
      paymentInfo.setPaymentResult(new PaymentResultDAS().find(Constants.RESULT_UNAVAILABLE));
      retValue = false;
    } catch (PluggableTaskException e) {
      log.error("PluggableTaskException", e);
      throw e;
    } catch (Exception e) {
      log.error("Exception", e);
      throw new PluggableTaskException(e);
    }
    log.debug("returning " + retValue);
    return retValue;
  }
  private PaymentAuthorizationDTO makeCall(Map<String, Object> data, boolean isCharge)
      throws XmlRpcException, MalformedURLException, PluggableTaskException {

    URL callURL = null;
    if ("true".equals(getOptionalParameter(PARAMETER_TEST.getName(), "false"))) {
      callURL = new URL(TEST_URL);
      log.debug("Running Atlas task in test mode!");
    } else {
      callURL = new URL(URL);
    }
    String merchantAccountCode = ensureGetParameter(PARAMETER_MERCHANT_ACCOUNT_CODE.getName());

    int merchantCode = Integer.parseInt(merchantAccountCode);
    merchantCode = merchantCode - (merchantCode % 1000);

    XmlRpcClient paymentProcessor = new XmlRpcClient();
    paymentProcessor.setTransportFactory(new XmlRpcCommonsTransportFactory(paymentProcessor));

    XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
    config.setServerURL(callURL);
    config.setEnabledForExtensions(true);
    config.setConnectionTimeout(CONNECTION_TIME_OUT);
    config.setReplyTimeout(REPLY_TIME_OUT);

    paymentProcessor.setConfig(config);

    List<Map<String, Object>> transactionRequestList = new ArrayList<Map<String, Object>>(1);
    transactionRequestList.add(data);

    Map<String, Object> configParam = new HashMap<String, Object>();
    if (isCharge) {
      configParam.put("waitConfirmation", "ignore");
    } else {
      configParam.put("waitConfirmation", "terminate");
    }

    Object[] params =
        new Object[] {
          String.valueOf(merchantCode),
          ensureGetParameter(PARAMETER_PASSWORD.getName()),
          transactionRequestList,
          configParam
        };

    Object[] resresponse = (Object[]) paymentProcessor.execute("XMLRPCGates.processRetail", params);

    Map<String, Object> transactionResponseMap = (Map<String, Object>) resresponse[0];

    log.debug("Got response:" + transactionResponseMap);

    boolean isCredit = "credit-response".equals(transactionResponseMap.get("type"));

    PaymentAuthorizationDTO dbRow = new PaymentAuthorizationDTO();
    if (!isCredit && "A01".equals(transactionResponseMap.get("responseCode"))) {
      dbRow.setCode1("1"); // code if 1 it is ok
    } else if (isCredit && "A02".equals(transactionResponseMap.get("responseCode"))) {
      dbRow.setCode1("1");
    } else if ('A' != ((String) transactionResponseMap.get("responseCode")).charAt(0)) {
      dbRow.setCode1("2");
    } else {
      dbRow.setCode1("0");
    }
    dbRow.setCode3((String) transactionResponseMap.get("responseCode"));
    dbRow.setResponseMessage((String) transactionResponseMap.get("responseMessage"));
    dbRow.setApprovalCode((String) transactionResponseMap.get("processorCode"));
    dbRow.setAvs((String) transactionResponseMap.get("avsResultCode"));
    dbRow.setTransactionId((String) transactionResponseMap.get("referenceNumber"));
    dbRow.setProcessor("Intrannuity");
    return dbRow;
  }