private String getProcessorName(Integer userId) throws PluggableTaskException {
ContactBL contactLoader;
String processorName = null;
contactLoader = new ContactBL();
contactLoader.set(userId);
UserDTO user = new UserDAS().find(userId);
if (user.getCustomer() != null && user.getCustomer().getMetaFields() != null) {
String metaFieldName = parameters.get(PARAM_CUSTOM_FIELD_PAYMENT_PROCESSOR.getName());
MetaFieldValue customField = user.getCustomer().getMetaField(metaFieldName);
if (customField == null) {
// todo: try to search by id, may be temporary (now is applied)
try {
Integer metaFieldNameId = Integer.valueOf(metaFieldName);
customField = user.getCustomer().getMetaField(metaFieldNameId);
} catch (Exception ex) {
// do nothing
}
}
if (customField == null) {
LOG.warn(
"Can't find Custom Field with type "
+ parameters.get(PARAM_CUSTOM_FIELD_PAYMENT_PROCESSOR.getName())
+ " user = "
+ userId);
processorName = null;
} else {
processorName = (String) customField.getValue();
}
}
return processorName;
}
/** 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();
}
/**
* Get the control parameters of the given primitive.
*
* @return a vector of ParameterDescription containing each control parameter. The first
* parameters should always be the virtual points.
*/
public Vector<ParameterDescription> getControls() {
Vector<ParameterDescription> v = new Vector<ParameterDescription>(10);
ParameterDescription pd = new ParameterDescription();
pd.parameter = name;
pd.description = Globals.messages.getString("ctrl_name");
pd.isExtension = true;
v.add(pd);
pd = new ParameterDescription();
pd.parameter = value;
pd.description = Globals.messages.getString("ctrl_value");
pd.isExtension = true;
v.add(pd);
return v;
}
private Map<String, Object> getData(PaymentDTOEx paymentInfo) throws PluggableTaskException {
PaymentInformationBL piBl = new PaymentInformationBL();
Map<String, Object> data = new HashMap<String, Object>();
data.put("merchantAccountCode", ensureGetParameter(PARAMETER_MERCHANT_ACCOUNT_CODE.getName()));
if (paymentInfo.getUserId() != null)
data.put("customerAccountCode", String.valueOf(paymentInfo.getUserId()));
data.put(
"accountNumber",
piBl.getStringMetaFieldByType(
paymentInfo.getInstrument(), MetaFieldType.PAYMENT_CARD_NUMBER));
data.put(
"name", piBl.getStringMetaFieldByType(paymentInfo.getInstrument(), MetaFieldType.TITLE));
data.put("amount", paymentInfo.getAmount().multiply(new BigDecimal("100")).intValue());
data.put("taxAmount", 0);
// This was not being set in previous code too
// String securityCode = paymentInfo.getCreditCard().getSecurityCode();
// if (securityCode != null)
// data.put("cvv2", securityCode);
data.put("expirationDate", piBl.get4digitExpiry(paymentInfo.getInstrument()));
data.put("transactionDate", paymentInfo.getPaymentDate());
data.put("transactionCode", paymentInfo.getId() + "");
return data;
}
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;
}
private void validateParameters() throws PluggableTaskException {
ensureGetParameter(PARAMETER_MERCHANT_ACCOUNT_CODE.getName());
ensureGetParameter(PARAMETER_PASSWORD.getName());
}
