/**
* Generate a new MWK
*
* @return Hex String of the new encrypted MWK ready for transmission to ValueLink
*/
public byte[] generateMwk() {
KeyGenerator keyGen = null;
try {
keyGen = KeyGenerator.getInstance("DES");
} catch (NoSuchAlgorithmException e) {
Debug.logError(e, module);
}
// generate the DES key 1
SecretKey des1 = keyGen.generateKey();
SecretKey des2 = keyGen.generateKey();
if (des1 != null && des2 != null) {
byte[] desByte1 = des1.getEncoded();
byte[] desByte2 = des2.getEncoded();
byte[] desByte3 = des1.getEncoded();
// check for weak keys
try {
if (DESKeySpec.isWeak(des1.getEncoded(), 0) || DESKeySpec.isWeak(des2.getEncoded(), 0)) {
return generateMwk();
}
} catch (Exception e) {
Debug.logError(e, module);
}
byte[] des3 = copyBytes(desByte1, copyBytes(desByte2, desByte3, 0), 0);
return generateMwk(des3);
} else {
Debug.logInfo("Null DES keys returned", module);
}
return null;
}
protected SecretKey getDesEdeKey(byte[] rawKey) {
SecretKeyFactory skf = null;
try {
skf = SecretKeyFactory.getInstance("DESede");
} catch (NoSuchAlgorithmException e) {
// should never happen since DESede is a standard algorithm
Debug.logError(e, module);
return null;
}
// load the raw key
if (rawKey.length > 0) {
DESedeKeySpec desedeSpec1 = null;
try {
desedeSpec1 = new DESedeKeySpec(rawKey);
} catch (InvalidKeyException e) {
Debug.logError(e, "Not a valid DESede key", module);
return null;
}
// create the SecretKey Object
SecretKey key = null;
try {
key = skf.generateSecret(desedeSpec1);
} catch (InvalidKeySpecException e) {
Debug.logError(e, module);
}
return key;
} else {
throw new RuntimeException("No valid DESede key available");
}
}
/**
* Generate a new MWK
*
* @param desBytes byte array of the DES key (24 bytes)
* @return Hex String of the new encrypted MWK ready for transmission to ValueLink
*/
public byte[] generateMwk(byte[] desBytes) {
if (debug) {
Debug.logInfo(
"DES Key : " + StringUtil.toHexString(desBytes) + " / " + desBytes.length, module);
}
SecretKeyFactory skf1 = null;
SecretKey mwk = null;
try {
skf1 = SecretKeyFactory.getInstance("DESede");
} catch (NoSuchAlgorithmException e) {
Debug.logError(e, module);
}
DESedeKeySpec desedeSpec2 = null;
try {
desedeSpec2 = new DESedeKeySpec(desBytes);
} catch (InvalidKeyException e) {
Debug.logError(e, module);
}
if (skf1 != null && desedeSpec2 != null) {
try {
mwk = skf1.generateSecret(desedeSpec2);
} catch (InvalidKeySpecException e) {
Debug.logError(e, module);
}
}
if (mwk != null) {
return generateMwk(mwk);
} else {
return null;
}
}
public void setMessage(MimeMessage message) {
if (message != null) {
// serialize the message
this.message = message;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
message.writeTo(baos);
baos.flush();
serializedBytes = baos.toByteArray();
this.contentType = message.getContentType();
// see if this is a multi-part message
Object content = message.getContent();
if (content instanceof Multipart) {
Multipart mp = (Multipart) content;
this.parts = mp.getCount();
} else {
this.parts = 0;
}
} catch (MessagingException e) {
Debug.logError(e, module);
} catch (IOException e) {
Debug.logError(e, module);
} finally {
try {
baos.close();
} catch (IOException e) {
Debug.logError(e, module);
}
}
}
}
public void renderPortalPagePortletBody(
Appendable writer,
Map<String, Object> context,
ModelScreenWidget.PortalPage portalPage,
GenericValue portalPortlet)
throws GeneralException, IOException {
String portalPortletId = portalPortlet.getString("portalPortletId");
String screenName = portalPortlet.getString("screenName");
String screenLocation = portalPortlet.getString("screenLocation");
ModelScreen modelScreen = null;
if (UtilValidate.isNotEmpty(screenName) && UtilValidate.isNotEmpty(screenLocation)) {
try {
modelScreen = ScreenFactory.getScreenFromLocation(screenLocation, screenName);
} catch (IOException e) {
String errMsg = "Error rendering portlet ID [" + portalPortletId + "]: " + e.toString();
Debug.logError(e, errMsg, module);
throw new RuntimeException(errMsg);
} catch (SAXException e) {
String errMsg = "Error rendering portlet ID [" + portalPortletId + "]: " + e.toString();
Debug.logError(e, errMsg, module);
throw new RuntimeException(errMsg);
} catch (ParserConfigurationException e) {
String errMsg = "Error rendering portlet ID [" + portalPortletId + "]: " + e.toString();
Debug.logError(e, errMsg, module);
throw new RuntimeException(errMsg);
}
}
modelScreen.renderScreenString(writer, context, this);
}
private static NVPDecoder sendNVPRequest(GenericValue payPalConfig, NVPEncoder encoder)
throws PayPalException {
NVPCallerServices caller = new NVPCallerServices();
try {
APIProfile profile = ProfileFactory.createSignatureAPIProfile();
profile.setAPIUsername(payPalConfig.getString("apiUserName"));
profile.setAPIPassword(payPalConfig.getString("apiPassword"));
profile.setSignature(payPalConfig.getString("apiSignature"));
profile.setEnvironment(payPalConfig.getString("apiEnvironment"));
caller.setAPIProfile(profile);
} catch (PayPalException e) {
Debug.logError(e.getMessage(), module);
}
String requestMessage = encoder.encode();
String responseMessage = caller.call(requestMessage);
NVPDecoder decoder = new NVPDecoder();
decoder.decode(responseMessage);
if (!"Success".equals(decoder.get("ACK"))) {
Debug.logError(
"A response other than success was received from PayPal: " + responseMessage, module);
}
return decoder;
}
private static String getLastProductStoreId(Delegator delegator, String finAccountId) {
GenericValue trans = null;
try {
trans =
EntityQuery.use(delegator)
.from("FinAccountTrans")
.where(
EntityCondition.makeCondition(
"finAccountTransTypeId", EntityOperator.EQUALS, "DEPOSIT"),
EntityCondition.makeCondition(
"finAccountId", EntityOperator.EQUALS, finAccountId),
EntityCondition.makeCondition("orderId", EntityOperator.NOT_EQUAL, null))
.orderBy("-transactionDate")
.queryFirst();
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (trans != null) {
String orderId = trans.getString("orderId");
OrderReadHelper orh = new OrderReadHelper(delegator, orderId);
return orh.getProductStoreId();
}
// none found; pick one from our set stores
try {
GenericValue store =
EntityQuery.use(delegator).from("ProductStore").orderBy("productStoreId").queryFirst();
if (store != null) return store.getString("productStoreId");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
return null;
}
@Override
public boolean eval(Map<String, Object> context) {
Object fieldVal = this.fieldAcsr.get(context);
String expr = this.exprExdr.expandString(context);
Pattern pattern;
try {
pattern = compiler.compile(expr);
} catch (MalformedPatternException e) {
String errMsg = "Error in evaluation in if-regexp in screen: " + e.toString();
Debug.logError(e, errMsg, module);
throw new IllegalArgumentException(errMsg);
}
String fieldString = null;
try {
fieldString =
(String)
ObjectType.simpleTypeConvert(
fieldVal,
"String",
null,
(TimeZone) context.get("timeZone"),
(Locale) context.get("locale"),
true);
} catch (GeneralException e) {
Debug.logError(e, "Could not convert object to String, using empty String", module);
}
// always use an empty string by default
if (fieldString == null) fieldString = "";
return matcher.matches(fieldString, pattern);
}
public static Map<String, Object> streamTest(DispatchContext dctx, Map<String, ?> context) {
InputStream in = (InputStream) context.get("inputStream");
OutputStream out = (OutputStream) context.get("outputStream");
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
Writer writer = new OutputStreamWriter(out);
String line;
try {
while ((line = reader.readLine()) != null) {
Debug.log("Read line: " + line, module);
writer.write(line);
}
} catch (IOException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
} finally {
try {
writer.close();
} catch (Exception e) {
Debug.logError(e, module);
}
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("contentType", "text/plain");
return result;
}
private static void writeJSONtoResponse(JSON json, HttpServletResponse response) {
String jsonStr = json.toString();
if (jsonStr == null) {
Debug.logError("JSON Object was empty; fatal error!", module);
return;
}
// set the X-JSON content type
response.setContentType("application/x-json");
// jsonStr.length is not reliable for unicode characters
try {
response.setContentLength(jsonStr.getBytes("UTF8").length);
} catch (UnsupportedEncodingException e) {
Debug.logError("Problems with Json encoding: " + e, module);
}
// return the JSON String
Writer out;
try {
out = response.getWriter();
out.write(jsonStr);
out.flush();
} catch (IOException e) {
Debug.logError(e, module);
}
}
public static GenericValue getPaymentAddress(Delegator delegator, String partyId) {
List<GenericValue> paymentAddresses = null;
try {
paymentAddresses =
delegator.findByAnd(
"PartyContactMechPurpose",
UtilMisc.toMap("partyId", partyId, "contactMechPurposeTypeId", "PAYMENT_LOCATION"),
UtilMisc.toList("-fromDate"));
paymentAddresses = EntityUtil.filterByDate(paymentAddresses);
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting PartyContactMechPurpose entity list", module);
}
// get the address for the primary contact mech
GenericValue purpose = EntityUtil.getFirst(paymentAddresses);
GenericValue postalAddress = null;
if (purpose != null) {
try {
postalAddress =
delegator.findByPrimaryKey(
"PostalAddress",
UtilMisc.toMap("contactMechId", purpose.getString("contactMechId")));
} catch (GenericEntityException e) {
Debug.logError(
e,
"Trouble getting PostalAddress record for contactMechId: "
+ purpose.getString("contactMechId"),
module);
}
}
return postalAddress;
}
/**
* Authorizes and captures an EFT transaction. If the authorization or capture fails due to
* problems with the transaction, this service will result in a failure.
*
* <p>If this service results in an error, it means that the service is not propery configured and
* will not work until the issues are resolved.
*/
public static Map authorizeAndCaptureEft(DispatchContext dctx, Map context) {
Delegator delegator = dctx.getDelegator();
String resource = getResource(context);
Double amount = (Double) context.get("processAmount");
GenericValue eftAccount = (GenericValue) context.get("eftAccount");
String currencyUomId = (String) context.get("currency");
try {
Map request = buildRequestHeader(resource);
request.putAll(buildRequest(eftAccount, amount, currencyUomId, "AUTH_CAPTURE"));
request.putAll(buildCustomerRequest(delegator, context));
request.putAll(buildOrderRequest(context));
AuthorizeResponse response = processRequest(request, resource);
// process the response
Map results = ServiceUtil.returnSuccess();
if (response == null) {
results.put("authResult", Boolean.FALSE);
results.put("authRefNum", AuthorizeResponse.ERROR);
results.put("processAmount", new Double(0.0));
} else if (AuthorizeResponse.APPROVED.equals(response.getResponseCode())) {
results.put("authResult", Boolean.TRUE);
results.put("authFlag", response.getReasonCode());
results.put("authMessage", response.getReasonText());
results.put("authCode", response.getResponseField(AuthorizeResponse.AUTHORIZATION_CODE));
results.put("authRefNum", response.getResponseField(AuthorizeResponse.TRANSACTION_ID));
results.put(
"processAmount", new Double(response.getResponseField(AuthorizeResponse.AMOUNT)));
} else {
results.put("authResult", Boolean.FALSE);
results.put("authFlag", response.getReasonCode());
results.put("authMessage", response.getReasonText());
results.put("authCode", response.getResponseField(AuthorizeResponse.AUTHORIZATION_CODE));
results.put("authRefNum", AuthorizeResponse.ERROR);
results.put("processAmount", new Double(0.0));
}
if (isTestMode(resource)) {
Debug.logInfo("eCheck.NET AUTH_CAPTURE results: " + results, module);
}
return results;
} catch (GenericEntityException e) {
String message =
"Entity engine error when attempting to authorize and capture EFT via eCheck.net: "
+ e.getMessage();
Debug.logError(e, message, module);
return ServiceUtil.returnError(message);
} catch (GenericServiceException e) {
String message =
"Service error when attempting to authorize and capture EFT via eCheck.net. This is a configuration problem that must be fixed before this service can work properly: "
+ e.getMessage();
Debug.logError(e, message, module);
return ServiceUtil.returnError(message);
}
}
public static void checkPathAlias(
ServletRequest request, ServletResponse response, Delegator delegator, String pathInfo) {
HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpServletResponse httpResponse = (HttpServletResponse) response;
String webSiteId = WebSiteWorker.getWebSiteId(request);
// check path alias
GenericValue pathAlias = null;
try {
pathAlias =
EntityQuery.use(delegator)
.from("WebSitePathAlias")
.where("webSiteId", webSiteId, "pathAlias", pathInfo)
.cache()
.queryOne();
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (pathAlias != null) {
String alias = pathAlias.getString("aliasTo");
String contentId = pathAlias.getString("contentId");
if (contentId == null && UtilValidate.isNotEmpty(alias)) {
if (!alias.startsWith("/")) {
alias = "/" + alias;
}
RequestDispatcher rd = request.getRequestDispatcher(alias);
try {
rd.forward(request, response);
return;
} catch (ServletException e) {
Debug.logWarning(e, module);
} catch (IOException e) {
Debug.logWarning(e, module);
}
}
} else {
// send 404 error if a URI is alias TO
try {
List<GenericValue> aliasTos =
EntityQuery.use(delegator)
.from("WebSitePathAlias")
.where("webSiteId", webSiteId, "aliasTo", httpRequest.getRequestURI())
.queryList();
if (UtilValidate.isNotEmpty(aliasTos)) {
httpResponse.sendError(HttpServletResponse.SC_NOT_FOUND, "Not Found");
return;
}
} catch (GenericEntityException e) {
Debug.logError(e, module);
} catch (IOException e) {
Debug.logError(e, module);
}
}
}
/*
* Returns the value of a given ShipmentPackageContent record. Calculated by working out the total value (from the OrderItems) of all ItemIssuances
* for the ShipmentItem then dividing that by the total quantity issued for the same to get an average item value then multiplying that by the package
* content quantity.
* Note: No rounding of the calculation is performed so you will need to round it to the accuracy that you require
*/
public static BigDecimal getShipmentPackageContentValue(GenericValue shipmentPackageContent) {
BigDecimal quantity = shipmentPackageContent.getBigDecimal("quantity");
BigDecimal value = new BigDecimal("0");
// lookup the issuance to find the order
List<GenericValue> issuances = null;
try {
GenericValue shipmentItem = shipmentPackageContent.getRelatedOne("ShipmentItem");
issuances = shipmentItem.getRelated("ItemIssuance");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
BigDecimal totalIssued = BigDecimal.ZERO;
BigDecimal totalValue = BigDecimal.ZERO;
if (UtilValidate.isNotEmpty(issuances)) {
for (GenericValue issuance : issuances) {
// we only need one
BigDecimal issuanceQuantity = issuance.getBigDecimal("quantity");
BigDecimal issuanceCancelQuantity = issuance.getBigDecimal("cancelQuantity");
if (issuanceCancelQuantity != null) {
issuanceQuantity = issuanceQuantity.subtract(issuanceCancelQuantity);
}
// get the order item
GenericValue orderItem = null;
try {
orderItem = issuance.getRelatedOne("OrderItem");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (orderItem != null) {
// get the value per unit - (base price * amount)
BigDecimal selectedAmount = orderItem.getBigDecimal("selectedAmount");
if (selectedAmount == null || selectedAmount.compareTo(BigDecimal.ZERO) <= 0) {
selectedAmount = BigDecimal.ONE;
}
BigDecimal unitPrice = orderItem.getBigDecimal("unitPrice");
BigDecimal itemValue = unitPrice.multiply(selectedAmount);
// total value for package (per unit * quantity)
totalIssued = totalIssued.add(issuanceQuantity);
totalValue = totalValue.add(itemValue.multiply(issuanceQuantity));
}
}
}
// take the average value of the issuances and multiply it by the shipment package content
// quantity
value = totalValue.divide(totalIssued, 10, BigDecimal.ROUND_HALF_EVEN).multiply(quantity);
return value;
}
public static Map<String, Object> uploadTest(DispatchContext dctx, Map<String, ?> context) {
LocalDispatcher dispatcher = dctx.getDispatcher();
GenericValue userLogin = (GenericValue) context.get("userLogin");
byte[] array = (byte[]) context.get("uploadFile");
String fileName = (String) context.get("_uploadFile_fileName");
String contentType = (String) context.get("_uploadFile_contentType");
Map<String, Object> createCtx = FastMap.newInstance();
createCtx.put("binData", array);
createCtx.put("dataResourceTypeId", "OFBIZ_FILE");
createCtx.put("dataResourceName", fileName);
createCtx.put("dataCategoryId", "PERSONAL");
createCtx.put("statusId", "CTNT_PUBLISHED");
createCtx.put("mimeTypeId", contentType);
createCtx.put("userLogin", userLogin);
Map<String, Object> createResp = null;
try {
createResp = dispatcher.runSync("createFile", createCtx);
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (ServiceUtil.isError(createResp)) {
return ServiceUtil.returnError(ServiceUtil.getErrorMessage(createResp));
}
GenericValue dataResource = (GenericValue) createResp.get("dataResource");
if (dataResource != null) {
Map<String, Object> contentCtx = FastMap.newInstance();
contentCtx.put("dataResourceId", dataResource.getString("dataResourceId"));
contentCtx.put("localeString", ((Locale) context.get("locale")).toString());
contentCtx.put("contentTypeId", "DOCUMENT");
contentCtx.put("mimeTypeId", contentType);
contentCtx.put("contentName", fileName);
contentCtx.put("statusId", "CTNT_PUBLISHED");
contentCtx.put("userLogin", userLogin);
Map<String, Object> contentResp = null;
try {
contentResp = dispatcher.runSync("createContent", contentCtx);
} catch (GenericServiceException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (ServiceUtil.isError(contentResp)) {
return ServiceUtil.returnError(ServiceUtil.getErrorMessage(contentResp));
}
}
return ServiceUtil.returnSuccess();
}
private static List<Map<Object, Object>> getListMapsFromXmlFile(String XmlFilePath) {
List<Map<Object, Object>> listMaps = FastList.newInstance();
InputStream ins = null;
URL xmlFileUrl = null;
Document xmlDocument = null;
try {
if (UtilValidate.isNotEmpty(XmlFilePath)) {
xmlFileUrl = UtilURL.fromFilename(XmlFilePath);
if (xmlFileUrl != null) ins = xmlFileUrl.openStream();
if (ins != null) {
xmlDocument = UtilXml.readXmlDocument(ins, xmlFileUrl.toString());
List<? extends Node> nodeList =
UtilXml.childNodeList(xmlDocument.getDocumentElement().getFirstChild());
for (Node node : nodeList) {
if (node.getNodeType() == Node.ELEMENT_NODE) {
Map<Object, Object> fields = FastMap.newInstance();
fields.put(node.getNodeName(), UtilXml.elementValue((Element) node));
Map<Object, Object> attrFields = getAttributeNameValueMap(node);
Set<Object> keys = attrFields.keySet();
Iterator<Object> attrFieldsIter = keys.iterator();
while (attrFieldsIter.hasNext()) {
Object key = attrFieldsIter.next();
fields.put(key, attrFields.get(key));
}
List<? extends Node> childNodeList = UtilXml.childNodeList(node.getFirstChild());
for (Node childNode : childNodeList) {
fields.put(childNode.getNodeName(), UtilXml.elementValue((Element) childNode));
attrFields = getAttributeNameValueMap(childNode);
keys = attrFields.keySet();
attrFieldsIter = keys.iterator();
while (attrFieldsIter.hasNext()) {
Object key = attrFieldsIter.next();
fields.put(key, attrFields.get(key));
}
}
listMaps.add(fields);
}
}
}
}
} catch (Exception exc) {
Debug.logError(exc, "Error reading xml file", module);
} finally {
try {
if (ins != null) ins.close();
} catch (Exception exc) {
Debug.logError(exc, "Error reading xml file", module);
}
}
return listMaps;
}
public static <F> List<F> getAllFutures(Collection<Future<F>> futureList) {
List<F> result = FastList.newInstance();
for (Future<F> future : futureList) {
try {
result.add(future.get());
} catch (ExecutionException e) {
Debug.logError(e, module);
} catch (InterruptedException e) {
Debug.logError(e, module);
}
}
return result;
}
public AssignmentEventAudit(EntityAuditMgr mgr, Delegator delegator, String eventAuditId) {
super(mgr, delegator, eventAuditId);
if (this.delegator != null) {
try {
this.assignmentEventAudit =
delegator.findByPrimaryKey(
"WfAssignmentEventAudit", UtilMisc.toMap("eventAuditId", eventAuditId));
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
} else {
Debug.logError("Invalid delegator object passed", module);
}
}
// actual kek encryption/decryption code
protected byte[] cryptoViaKek(byte[] content, int mode) {
// open a cipher using the kek for transport
Cipher cipher = this.getCipher(this.getKekKey(), mode);
byte[] dec = new byte[0];
try {
dec = cipher.doFinal(content);
} catch (IllegalStateException e) {
Debug.logError(e, module);
} catch (IllegalBlockSizeException e) {
Debug.logError(e, module);
} catch (BadPaddingException e) {
Debug.logError(e, module);
}
return dec;
}
public static Delegator getDelegator(String delegatorName) {
if (delegatorName == null) {
delegatorName = "default";
// Debug.logWarning(new Exception("Location where getting delegator with null name"), "Got a
// getGenericDelegator call with a null delegatorName, assuming default for the name.",
// module);
}
do {
Delegator delegator = delegatorCache.get(delegatorName);
if (delegator != null) {
// setup the Entity ECA Handler
delegator.initEntityEcaHandler();
// Debug.logInfo("got delegator(" + delegatorName + ") from cache", module);
// setup the distributed CacheClear
delegator.initDistributedCacheClear();
return delegator;
}
try {
delegator = UtilObject.getObjectFromFactory(DelegatorFactory.class, delegatorName);
} catch (ClassNotFoundException e) {
Debug.logError(e, module);
}
// Debug.logInfo("putting delegator(" + delegatorName + ") into cache", module);
delegatorCache.putIfAbsent(delegatorName, delegator);
} while (true);
}
/**
* Retrieve the last deactivation date if the party is currently deactivated.
*
* @param partyId
* @param delegator
* @return the timestamp of last deactivation, null if the party is not deactivated
* @throws GenericEntityNotFoundException
*/
public static Timestamp getDeactivationDate(String partyId, Delegator delegator)
throws GenericEntityException {
// check party current status:
if (isActive(partyId, delegator)) {
return null;
}
// party is currently deactivated, get the deactivation date
try {
List<GenericValue> deactivationDates =
delegator.findByAnd(
"PartyDeactivation",
UtilMisc.toMap("partyId", partyId),
UtilMisc.toList("-deactivationTimestamp"));
if (UtilValidate.isNotEmpty(deactivationDates)) {
return (Timestamp) deactivationDates.get(0).get("deactivationTimestamp");
} else {
Debug.logWarning(
"The party ["
+ partyId
+ "] status is disabled but there is no registered deactivation date.",
MODULE);
}
} catch (GenericEntityException e) {
Debug.logError(e, MODULE);
}
return null;
}
/**
* Gets a partial list of a given size starting from a cursor index. Note that although the
* arguments are longs, the EntityListIterator must accept ints.
*
* @param viewSize a <code>long</code> value
* @param cursorIndex a <code>long</code> value
* @return a <code>List</code> value
* @exception ListBuilderException if an error occurs
*/
public List getPartialList(long viewSize, long cursorIndex) throws ListBuilderException {
if (!isInitialized()) {
initialize();
}
try {
// XXX Note: EntityListIterator is a 1 based list, so we must add 1 to index
List<GenericValue> results = iterator.getPartialList((int) cursorIndex + 1, (int) viewSize);
close();
// convert to domain entities if needed
if (repository != null && entityClass != null) {
List domainResults = null;
try {
domainResults = Repository.loadFromGeneric(entityClass, results, repository);
} catch (RepositoryException e) {
Debug.logError(e, module);
}
if (domainResults != null) {
return domainResults;
}
}
return results;
} catch (GenericEntityException e) {
throw new ListBuilderException(e);
}
}
public static boolean isBinComplete(Delegator delegator, String picklistBinId)
throws GeneralException {
// lookup the items in the bin
List<GenericValue> items;
try {
items = delegator.findByAnd("PicklistItem", UtilMisc.toMap("picklistBinId", picklistBinId));
} catch (GenericEntityException e) {
Debug.logError(e, module);
throw e;
}
if (!UtilValidate.isEmpty(items)) {
for (GenericValue v : items) {
String itemStatus = v.getString("itemStatusId");
if (itemStatus != null) {
if (!"PICKITEM_COMPLETED".equals(itemStatus)) {
return false;
}
}
}
return true;
}
return false;
}
public static Map<String, Object> makeALotOfVisits(DispatchContext dctx, Map<String, ?> context) {
Delegator delegator = dctx.getDelegator();
int count = ((Integer) context.get("count")).intValue();
for (int i = 0; i < count; i++) {
GenericValue v = delegator.makeValue("Visit");
String seqId = delegator.getNextSeqId("Visit");
v.set("visitId", seqId);
v.set("userCreated", "N");
v.set("sessionId", "NA-" + seqId);
v.set("serverIpAddress", "127.0.0.1");
v.set("serverHostName", "localhost");
v.set("webappName", "webtools");
v.set("initialLocale", "en_US");
v.set("initialRequest", "http://localhost:8080/webtools/control/main");
v.set("initialReferrer", "http://localhost:8080/webtools/control/main");
v.set(
"initialUserAgent",
"Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en-us) AppleWebKit/124 (KHTML, like Gecko) Safari/125.1");
v.set("clientIpAddress", "127.0.0.1");
v.set("clientHostName", "localhost");
v.set("fromDate", UtilDateTime.nowTimestamp());
try {
delegator.create(v);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
}
return ServiceUtil.returnSuccess();
}
/**
* Converts the supplied String into a String suitable for address line matching. Performs the
* following transformations on the supplied String: - Converts to upper case - Retrieves all
* records from the AddressMatchMap table and replaces all occurrences of addressMatchMap.mapKey
* with addressMatchMap.mapValue using upper case matching. - Removes all non-word characters from
* the String i.e. everything except A-Z, 0-9 and _
*
* @param delegator A Delegator instance
* @param address The address String to convert
* @return The converted Address
*/
public static String makeMatchingString(Delegator delegator, String address) {
if (address == null) {
return null;
}
// upper case the address
String str = address.trim().toUpperCase();
// replace mapped words
List<GenericValue> addressMap = null;
try {
addressMap =
delegator.findList(
"AddressMatchMap", null, null, UtilMisc.toList("sequenceNum"), null, false);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (addressMap != null) {
for (GenericValue v : addressMap) {
str =
str.replaceAll(
v.getString("mapKey").toUpperCase(), v.getString("mapValue").toUpperCase());
}
}
// remove all non-word characters
return str.replaceAll("\\W", "");
}
public static Map<String, Object> doAuthorization(
DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
String orderId = (String) context.get("orderId");
BigDecimal processAmount = (BigDecimal) context.get("processAmount");
GenericValue payPalPaymentMethod = (GenericValue) context.get("payPalPaymentMethod");
OrderReadHelper orh = new OrderReadHelper(delegator, orderId);
GenericValue payPalConfig =
getPaymentMethodGatewayPayPal(dctx, context, PaymentGatewayServices.AUTH_SERVICE_TYPE);
Locale locale = (Locale) context.get("locale");
NVPEncoder encoder = new NVPEncoder();
encoder.add("METHOD", "DoAuthorization");
encoder.add("TRANSACTIONID", payPalPaymentMethod.getString("transactionId"));
encoder.add("AMT", processAmount.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString());
encoder.add("TRANSACTIONENTITY", "Order");
String currency = (String) context.get("currency");
if (currency == null) {
currency = orh.getCurrency();
}
encoder.add("CURRENCYCODE", currency);
NVPDecoder decoder = null;
try {
decoder = sendNVPRequest(payPalConfig, encoder);
} catch (PayPalException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
if (decoder == null) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "AccountingPayPalUnknownError", locale));
}
Map<String, Object> result = ServiceUtil.returnSuccess();
Map<String, String> errors = getErrorMessageMap(decoder);
if (UtilValidate.isNotEmpty(errors)) {
result.put("authResult", false);
result.put("authRefNum", "N/A");
result.put("processAmount", BigDecimal.ZERO);
if (errors.size() == 1) {
Map.Entry<String, String> error = errors.entrySet().iterator().next();
result.put("authCode", error.getKey());
result.put("authMessage", error.getValue());
} else {
result.put(
"authMessage",
"Multiple errors occurred, please refer to the gateway response messages");
result.put("internalRespMsgs", errors);
}
} else {
result.put("authResult", true);
result.put("processAmount", new BigDecimal(decoder.get("AMT")));
result.put("authRefNum", decoder.get("TRANSACTIONID"));
}
// TODO: Look into possible PAYMENTSTATUS and PENDINGREASON return codes, it is unclear what
// should be checked for this type of transaction
return result;
}
private static String parseStateProvinceGeoId(
String payPalShipToState, String countryGeoId, Delegator delegator) {
String lookupField = "geoName";
List<EntityCondition> conditionList = FastList.newInstance();
conditionList.add(EntityCondition.makeCondition("geoAssocTypeId", "REGIONS"));
if ("USA".equals(countryGeoId) || "CAN".equals(countryGeoId)) {
// PayPal returns two letter code for US and Canadian States/Provinces
String geoTypeId = "USA".equals(countryGeoId) ? "STATE" : "PROVINCE";
conditionList.add(EntityCondition.makeCondition("geoTypeId", geoTypeId));
lookupField = "geoCode";
}
conditionList.add(EntityCondition.makeCondition("geoIdFrom", countryGeoId));
conditionList.add(EntityCondition.makeCondition(lookupField, payPalShipToState));
EntityCondition cond = EntityCondition.makeCondition(conditionList);
GenericValue geoAssocAndGeoTo = null;
try {
geoAssocAndGeoTo =
EntityQuery.use(delegator).from("GeoAssocAndGeoTo").where(cond).cache().queryFirst();
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (geoAssocAndGeoTo != null) {
return geoAssocAndGeoTo.getString("geoId");
}
return null;
}
public static Map<String, Object> ping(DispatchContext dctx, Map<String, ?> context) {
Delegator delegator = dctx.getDelegator();
String message = (String) context.get("message");
Locale locale = (Locale) context.get("locale");
if (message == null) {
message = "PONG";
}
long count = -1;
try {
count = delegator.findCountByCondition("SequenceValueItem", null, null, null);
} catch (GenericEntityException e) {
Debug.logError(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "CommonPingDatasourceCannotConnect", locale));
}
if (count > 0) {
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("message", message);
return result;
} else {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "CommonPingDatasourceInvalidCount", locale));
}
}
/**
* Transmit a request to ValueLink
*
* @param url override URL from what is defined in the properties
* @param request request Map of request parameters
* @return Map of response parameters
* @throws HttpClientException
*/
public Map<String, Object> send(String url, Map<String, Object> request)
throws HttpClientException {
if (debug) {
Debug.logInfo("Request : " + url + " / " + request, module);
}
// read the timeout value
String timeoutString = (String) props.get("payment.valuelink.timeout");
int timeout = 34;
try {
timeout = Integer.parseInt(timeoutString);
} catch (NumberFormatException e) {
Debug.logError(e, "Unable to set timeout to " + timeoutString + " using default " + timeout);
}
// create the HTTP client
HttpClient client = new HttpClient(url, request);
client.setTimeout(timeout * 1000);
client.setDebug(debug);
client.setClientCertificateAlias((String) props.get("payment.valuelink.certificateAlias"));
String response = client.post();
// parse the response and return a map
return this.parseResponse(response);
}
@Override
protected Object get(Map<String, ? extends Object> context, TimeZone timeZone, Locale locale) {
Object obj = null;
try {
obj = UelUtil.evaluate(context, new String(this.bracketedOriginal));
} catch (PropertyNotFoundException e) {
if (Debug.verboseOn()) {
Debug.logVerbose("Error evaluating expression " + this + ": " + e, module);
}
} catch (Exception e) {
Debug.logError("Error evaluating expression " + this + ": " + e, module);
}
if (obj != null) {
try {
// Check for runtime nesting
String str = (String) obj;
if (str.contains(openBracket)) {
FlexibleStringExpander fse = FlexibleStringExpander.getInstance(str);
return fse.get(context, timeZone, locale);
}
} catch (ClassCastException e) {
}
}
return obj;
}
