/** * 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; }