/** * Returns the next recurrence of this rule. * * @param startTime The time this recurrence first began. * @param fromTime The time to base the next recurrence on. * @param currentCount The total number of times the recurrence has run. * @return long The next recurrence as a long. */ public long next(long startTime, long fromTime, long currentCount) { // Set up the values if (startTime == 0) startTime = RecurrenceUtil.now(); if (fromTime == 0) fromTime = startTime; // Test the end time of the recurrence. if (getEndTime() != 0 && getEndTime() <= RecurrenceUtil.now()) return 0; Debug.logVerbose("Rule NOT expired by end time.", module); // Test the recurrence limit. if (getCount() != -1 && currentCount >= getCount()) return 0; Debug.logVerbose("Rule NOT expired by max count.", module); boolean isSeeking = true; long nextRuntime = 0; long seekTime = fromTime; int loopProtection = 0; int maxLoop = (10 * 10 * 10 * 10 * 10); while (isSeeking && loopProtection < maxLoop) { Date nextRun = getNextFreq(startTime, seekTime); seekTime = nextRun.getTime(); if (validByRule(nextRun)) { isSeeking = false; nextRuntime = nextRun.getTime(); } loopProtection++; } return nextRuntime; }
@Override public int doStartTag() throws JspTagException { Debug.logVerbose("Starting Iterator Tag...", module); if (!defineIterator()) return SKIP_BODY; Debug.logVerbose("We now have an iterator.", module); if (defineElement()) return EVAL_BODY_AGAIN; else return SKIP_BODY; }
@Override public boolean exec(MethodContext methodContext) { Object fieldVal = null; if (!mapAcsr.isEmpty()) { Map<String, ? extends Object> fromMap = mapAcsr.get(methodContext); if (fromMap == null) { if (Debug.infoOn()) Debug.logInfo( "Map not found with name " + mapAcsr + ", not copying from this map", module); return true; } fieldVal = fieldAcsr.get(fromMap, methodContext); } else { // no map name, try the env fieldVal = fieldAcsr.get(methodContext); } if (fieldVal == null) { if (Debug.verboseOn()) Debug.logVerbose( "Field value not found with name " + fieldAcsr + " in Map with name " + mapAcsr + ", not copying field", module); return true; } // note that going to an env field will only work if it came from an env // field because if not specified the to-map-name will be set to the map-name // to go from a map field to an env field, use the field-to-env operation Map<String, Object> toMap = null; if (!toMapAcsr.isEmpty()) { toMap = toMapAcsr.get(methodContext); if (toMap == null) { if (Debug.verboseOn()) Debug.logVerbose("Map not found with name " + toMapAcsr + ", creating new map", module); toMap = FastMap.newInstance(); toMapAcsr.put(methodContext, toMap); } toFieldAcsr.put(toMap, fieldVal, methodContext); } else { // no to-map, so put in env toFieldAcsr.put(methodContext, fieldVal); } return true; }
/** * Generic service to find party by id. By default return the party find by partyId but you can * pass searchPartyFirst at false if you want search in partyIdentification before or pass * searchAllId at true to find apartyuct with this id (party.partyId and * partyIdentification.idValue) * * @param delegator * @param idToFind * @param partyIdentificationTypeId * @param searchPartyFirst * @param searchAllId * @return * @throws GenericEntityException */ public static List<GenericValue> findPartiesById( Delegator delegator, String idToFind, String partyIdentificationTypeId, boolean searchPartyFirst, boolean searchAllId) throws GenericEntityException { if (Debug.verboseOn()) Debug.logVerbose( "Analyze partyIdentification: entered id = " + idToFind + ", partyIdentificationTypeId = " + partyIdentificationTypeId, module); GenericValue party = null; List<GenericValue> partiesFound = null; // 1) look if the idToFind given is a real partyId if (searchPartyFirst) { party = delegator.findByPrimaryKeyCache("Party", UtilMisc.toMap("partyId", idToFind)); } if (searchAllId || (searchPartyFirst && UtilValidate.isEmpty(party))) { // 2) Retrieve party in PartyIdentification Map<String, String> conditions = UtilMisc.toMap("idValue", idToFind); if (UtilValidate.isNotEmpty(partyIdentificationTypeId)) { conditions.put("partyIdentificationTypeId", partyIdentificationTypeId); } partiesFound = delegator.findByAndCache( "PartyIdentificationAndParty", conditions, UtilMisc.toList("partyId")); } if (!searchPartyFirst) { party = delegator.findByPrimaryKeyCache("Party", UtilMisc.toMap("partyId", idToFind)); } if (UtilValidate.isNotEmpty(party)) { if (UtilValidate.isNotEmpty(partiesFound)) partiesFound.add(party); else partiesFound = UtilMisc.toList(party); } if (Debug.verboseOn()) Debug.logVerbose( "Analyze partyIdentification: found party.partyId = " + party + ", and list : " + partiesFound, module); return partiesFound; }
@Override protected Object get(Map<String, ? extends Object> context, TimeZone timeZone, Locale locale) { try { Object obj = InvokerHelper.createScript(this.parsedScript, GroovyUtil.getBinding(context)).run(); if (obj != null) { return obj; } else { if (Debug.verboseOn()) { Debug.logVerbose( "Groovy scriptlet evaluated to null [" + this + "], got no return so inserting nothing.", module); } } } catch (Exception e) { // handle other things, like the groovy.lang.MissingPropertyException Debug.logWarning( e, "Error evaluating Groovy scriptlet [" + this + "], inserting nothing; error was: " + e, module); } return null; }
@Override protected Object get(Map<String, ? extends Object> context, TimeZone timeZone, Locale locale) { try { Object obj = BshUtil.eval( new String(this.chars, this.parseStart, this.parseLength), UtilMisc.makeMapWritable(context)); if (obj != null) { return obj; } else { if (Debug.verboseOn()) { Debug.logVerbose( "BSH scriptlet evaluated to null [" + this + "], got no return so inserting nothing.", module); } } } catch (EvalError e) { Debug.logWarning( e, "Error evaluating BSH scriptlet [" + this + "], inserting nothing; error was: " + e, module); } return null; }
@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; }
private void executeMacro( Appendable writer, String macroName, Map<String, Object> macroParameters) throws IOException, TemplateException { StringBuilder sb = new StringBuilder("<@"); sb.append(macroName); if (macroParameters != null) { for (Map.Entry<String, Object> parameter : macroParameters.entrySet()) { sb.append(' '); sb.append(parameter.getKey()); sb.append("="); Object value = parameter.getValue(); if (value instanceof String) { sb.append('"'); sb.append(((String) value).replaceAll("\"", "\\\\\"")); sb.append('"'); } else { sb.append(value); } } } sb.append(" />"); if (Debug.verboseOn()) { Debug.logVerbose("Executing macro: " + sb, module); } executeMacro(writer, sb.toString()); }
/** * Runs the service defined in the MapMessage * * @param message * @return Map */ protected Map<String, Object> runService(MapMessage message) { Map<String, ? extends Object> context = null; String serviceName = null; String xmlContext = null; try { serviceName = message.getString("serviceName"); xmlContext = message.getString("serviceContext"); if (serviceName == null || xmlContext == null) { Debug.logError("Message received is not an OFB service message. Ignored!", module); return null; } Object o = XmlSerializer.deserialize(xmlContext, dispatcher.getDelegator()); if (Debug.verboseOn()) Debug.logVerbose("De-Serialized Context --> " + o, module); if (ObjectType.instanceOf(o, "java.util.Map")) context = UtilGenerics.checkMap(o); } catch (JMSException je) { Debug.logError(je, "Problems reading message.", module); } catch (Exception e) { Debug.logError(e, "Problems deserializing the service context.", module); } try { ModelService model = dispatcher.getDispatchContext().getModelService(serviceName); if (!model.export) { Debug.logWarning("Attempt to invoke a non-exported service: " + serviceName, module); return null; } } catch (GenericServiceException e) { Debug.logError(e, "Unable to get ModelService for service : " + serviceName, module); } if (Debug.verboseOn()) Debug.logVerbose("Running service: " + serviceName, module); Map<String, Object> result = null; if (context != null) { try { result = dispatcher.runSync(serviceName, context); } catch (GenericServiceException gse) { Debug.logError(gse, "Problems with service invocation.", module); } } return result; }
/** * Gets the end time of the recurrence rule or 0 if none. * * @return long The timestamp of the end time for this rule or 0 for none. */ public long getEndTime() { if (rule == null) { Debug.logVerbose("Rule is null.", module); return -1; } long time = 0; java.sql.Timestamp stamp = null; stamp = rule.getTimestamp("untilDateTime"); Debug.logVerbose("Stamp value: " + stamp, module); if (stamp != null) { long nanos = stamp.getNanos(); time = stamp.getTime(); time += (nanos / 1000000); } Debug.logVerbose("Returning time: " + time, module); return time; }
// Load the JMS listeners private void loadListeners() { try { Element rootElement = ServiceConfigUtil.getXmlRootElement(); NodeList nodeList = rootElement.getElementsByTagName("jms-service"); if (Debug.verboseOn()) Debug.logVerbose("[ServiceDispatcher] : Loading JMS Listeners.", module); for (int i = 0; i < nodeList.getLength(); i++) { Element element = (Element) nodeList.item(i); for (Element server : UtilXml.childElementList(element, "server")) { try { String listenerEnabled = server.getAttribute("listen"); if (listenerEnabled.equalsIgnoreCase("true")) { // create a server key StringBuilder serverKey = new StringBuilder(); serverKey.append(server.getAttribute("jndi-server-name") + ":"); serverKey.append(server.getAttribute("jndi-name") + ":"); serverKey.append(server.getAttribute("topic-queue")); // store the server element servers.put(serverKey.toString(), server); // load the listener GenericMessageListener listener = loadListener(serverKey.toString(), server); // store the listener w/ the key if (serverKey.length() > 0 && listener != null) listeners.put(serverKey.toString(), listener); } } catch (GenericServiceException gse) { Debug.logVerbose("Cannot load message listener (" + gse.toString() + ").", module); } catch (Exception e) { Debug.logError(e, "Uncaught exception.", module); } } } } catch (org.ofbiz.base.config.GenericConfigException gce) { Debug.logError(gce, "Cannot get serviceengine.xml root element.", module); } catch (Exception e) { Debug.logError(e, "Uncaught exception.", module); } }
/** * Returns an appropriate <code>Converter</code> instance for <code>sourceClass</code> and <code> * targetClass</code>. If no matching <code>Converter</code> is found, the method throws <code> * ClassNotFoundException</code>. * * <p>This method is intended to be used when the source or target <code>Object</code> types are * unknown at compile time. If the source and target <code>Object</code> types are known at * compile time, then one of the "ready made" converters should be used. * * @param sourceClass The object class to convert from * @param targetClass The object class to convert to * @return A matching <code>Converter</code> instance * @throws ClassNotFoundException */ public static <S, T> Converter<S, T> getConverter(Class<S> sourceClass, Class<T> targetClass) throws ClassNotFoundException { String key = sourceClass.getName().concat(DELIMITER).concat(targetClass.getName()); if (Debug.verboseOn()) { Debug.logVerbose("Getting converter: " + key, module); } OUTER: do { Converter<?, ?> result = converterMap.get(key); if (result != null) { return UtilGenerics.cast(result); } if (noConversions.contains(key)) { throw new ClassNotFoundException("No converter found for " + key); } Class<?> foundSourceClass = null; Converter<?, ?> foundConverter = null; for (Converter<?, ?> value : converterMap.values()) { if (value.canConvert(sourceClass, targetClass)) { // this converter can deal with the source/target pair if (foundSourceClass == null || foundSourceClass.isAssignableFrom(value.getSourceClass())) { // remember the current target source class; if we find another converter, check // to see if it's source class is assignable to this one, and if so, it means it's // a child class, so we'll then take that converter. foundSourceClass = value.getSourceClass(); foundConverter = value; } } } if (foundConverter != null) { converterMap.putIfAbsent(key, foundConverter); continue OUTER; } for (ConverterCreator value : creators) { result = createConverter(value, sourceClass, targetClass); if (result != null) { converterMap.putIfAbsent(key, result); continue OUTER; } } if (noConversions.add(key)) { Debug.logWarning( "*** No converter found, converting from " + sourceClass.getName() + " to " + targetClass.getName() + ". Please report this message to the developer community so " + "a suitable converter can be created. ***", module); } throw new ClassNotFoundException("No converter found for " + key); } while (true); }
/** * Receives the MapMessage and processes the service. * * @see javax.jms.MessageListener#onMessage(Message) */ public void onMessage(Message message) { MapMessage mapMessage = null; if (Debug.verboseOn()) Debug.logVerbose("JMS Message Received --> " + message, module); if (message instanceof MapMessage) { mapMessage = (MapMessage) message; } else { Debug.logError("Received message is not a MapMessage!", module); return; } runService(mapMessage); }
private boolean defineElement() { element = null; pageContext.removeAttribute(name, PageContext.PAGE_SCOPE); boolean verboseOn = Debug.verboseOn(); if (this.iterator.hasNext()) { element = this.iterator.next(); if (verboseOn) Debug.logVerbose("iterator has another object: " + element, module); } else { if (verboseOn) Debug.logVerbose("iterator has no more objects", module); } if (element != null) { if (verboseOn) Debug.logVerbose( "set attribute " + name + " to be " + element + " as next value from iterator", module); pageContext.setAttribute(name, element); // expand a map element here if requested if (expandMap) { Map<String, ?> tempMap = UtilGenerics.cast(element); Iterator<Map.Entry<String, ?>> mapEntries = UtilGenerics.cast(tempMap.entrySet().iterator()); while (mapEntries.hasNext()) { Map.Entry<String, ?> entry = mapEntries.next(); Object value = entry.getValue(); if (value == null) value = ""; pageContext.setAttribute(entry.getKey(), value); } } return true; } if (verboseOn) Debug.logVerbose("no more iterations; element = " + element, module); return false; }
public static <S, T> void registerConverter( Converter<S, T> converter, Class<?> sourceClass, Class<?> targetClass) { StringBuilder sb = new StringBuilder(); if (sourceClass != null) { sb.append(sourceClass.getName()); } else { sb.append("<null>"); } sb.append(DELIMITER); sb.append(targetClass.getName()); String key = sb.toString(); if (converterMap.putIfAbsent(key, converter) == null) { Debug.logVerbose("Registered converter " + converter.getClass().getName(), module); } }
public void renderContentBegin( Appendable writer, Map<String, Object> context, ModelScreenWidget.Content content) throws IOException { String editRequest = content.getEditRequest(context); String enableEditName = content.getEnableEditName(context); String enableEditValue = (String) context.get(enableEditName); if (Debug.verboseOn()) Debug.logVerbose("directEditRequest:" + editRequest, module); Map<String, Object> parameters = FastMap.newInstance(); parameters.put("editRequest", editRequest); parameters.put("enableEditValue", enableEditValue == null ? "" : enableEditValue); parameters.put("editContainerStyle", content.getEditContainerStyle(context)); executeMacro(writer, "renderContentBegin", parameters); }
private GenericDispatcher(String name, Delegator delegator) { ClassLoader loader; try { loader = Thread.currentThread().getContextClassLoader(); } catch (SecurityException e) { loader = this.getClass().getClassLoader(); } this.name = name; this.dispatcher = ServiceDispatcher.getInstance(delegator); DispatchContext ctx = new DispatchContext(name, loader, this); this.dispatcher.register(ctx); this.ctx = ctx; if (Debug.verboseOn()) Debug.logVerbose("[GenericDispatcher] : Created Dispatcher for: " + name, module); }
public void run() { Debug.logInfo("Starting JMS Listener Factory Thread", module); while (firstPass || connected < loadable) { if (Debug.verboseOn()) Debug.logVerbose( "First Pass: "******" Connected: " + connected + " Available: " + loadable, module); this.loadListeners(); firstPass = false; try { Thread.sleep(20000); } catch (InterruptedException ie) { } continue; } Debug.logInfo("JMS Listener Factory Thread Finished; All listeners connected.", module); }
/** * Compiles and caches a regexp pattern for the given string pattern. * * @param stringPattern a pattern string * @param caseSensitive case sensitive true/false * @return compiles and caches a regexp pattern for the given string pattern * @throws MalformedPatternException */ private Pattern getTestPattern(String stringPattern, boolean caseSensitive) throws MalformedPatternException { Pattern pattern = compiledPatterns.get(stringPattern); if (pattern == null) { if (caseSensitive) { pattern = compiler.compile(stringPattern); } else { pattern = compiler.compile(stringPattern, Perl5Compiler.CASE_INSENSITIVE_MASK); } compiledPatterns.put(stringPattern, pattern); Debug.logVerbose( "Compiled and cached a pattern: '" + stringPattern + "' - " + Thread.currentThread(), module); } return pattern; }
@Override protected Object get(Map<String, ? extends Object> context, TimeZone timeZone, Locale locale) { try { Object obj = UelUtil.evaluate(context, new String(this.valueStr)); if (obj != null) { String currencyCode = this.codeExpr.expandString(context, timeZone, locale); return UtilFormatOut.formatCurrency(new BigDecimal(obj.toString()), currencyCode, locale); } } catch (PropertyNotFoundException e) { if (Debug.verboseOn()) { Debug.logVerbose("Error evaluating expression: " + e, module); } } catch (Exception e) { Debug.logError("Error evaluating expression: " + e, module); } return null; }
protected void viewHandlerRender( String typeToUse, HttpServletRequest request, HttpServletResponse response) throws ServletException { ServletContext context = (ServletContext) request.getAttribute("servletContext"); RequestHandler requestHandler = (RequestHandler) context.getAttribute("_REQUEST_HANDLER_"); // see if the type is defined in the controller.xml file try { if (Debug.verboseOn()) Debug.logVerbose("Rendering view [" + content + "] of type [" + typeToUse + "]", module); ViewHandler vh = requestHandler.getViewFactory().getViewHandler(typeToUse); // use the default content-type and encoding for the ViewHandler -- may want to change this. vh.render(name, content, info, null, null, request, response); } catch (ViewHandlerException e) { throw new ServletException(e.getNonNestedMessage(), e.getNested()); } }
private void createAndSendSOAPResponse( Map<String, Object> serviceResults, String serviceName, HttpServletResponse response) throws EventHandlerException { try { // setup the response Debug.logVerbose("[EventHandler] : Setting up response message", module); String xmlResults = SoapSerializer.serialize(serviceResults); // Debug.logInfo("xmlResults ==================" + xmlResults, module); XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(xmlResults)); StAXOMBuilder resultsBuilder = new StAXOMBuilder(reader); OMElement resultSer = resultsBuilder.getDocumentElement(); // create the response soap SOAPFactory factory = OMAbstractFactory.getSOAP11Factory(); SOAPEnvelope resEnv = factory.createSOAPEnvelope(); SOAPBody resBody = factory.createSOAPBody(); OMElement resService = factory.createOMElement(new QName(serviceName + "Response")); resService.addChild(resultSer.getFirstElement()); resBody.addChild(resService); resEnv.addChild(resBody); // The declareDefaultNamespace method doesn't work see // (https://issues.apache.org/jira/browse/AXIS2-3156) // so the following doesn't work: // resService.declareDefaultNamespace(ModelService.TNS); // instead, create the xmlns attribute directly: OMAttribute defaultNS = factory.createOMAttribute("xmlns", null, ModelService.TNS); resService.addAttribute(defaultNS); // log the response message if (Debug.verboseOn()) { try { Debug.logInfo("Response Message:\n" + resEnv + "\n", module); } catch (Throwable t) { } } resEnv.serialize(response.getOutputStream()); response.getOutputStream().flush(); } catch (Exception e) { Debug.logError(e, module); throw new EventHandlerException(e.getMessage(), e); } }
@Override protected Object get(Map<String, ? extends Object> context, TimeZone timeZone, Locale locale) { StringBuilder expr = new StringBuilder(this.hint); for (FlexibleStringExpander child : this.childElems) { expr.append(child.expandString(context, timeZone, locale)); } if (expr.length() == 0) { return ""; } try { return UelUtil.evaluate(context, openBracket.concat(expr.toString()).concat(closeBracket)); } catch (PropertyNotFoundException e) { if (Debug.verboseOn()) { Debug.logVerbose("Error evaluating expression: " + e, module); } } catch (Exception e) { Debug.logError("Error evaluating expression: " + e, module); } return ""; }
public static void setTrail( ServletRequest request, String currentCategory, String previousCategory) { if (Debug.verboseOn()) Debug.logVerbose( "[CategoryWorker.setTrail] Start: previousCategory=" + previousCategory + " currentCategory=" + currentCategory, module); // if there is no current category, just return and do nothing to that the last settings will // stay if (UtilValidate.isEmpty(currentCategory)) { return; } // always get the last crumb list List<String> crumb = getTrail(request); crumb = adjustTrail(crumb, currentCategory, previousCategory); setTrail(request, crumb); }
public static List<String> adjustTrail( List<String> origTrail, String currentCategoryId, String previousCategoryId) { List<String> trail = FastList.newInstance(); if (origTrail != null) { trail.addAll(origTrail); } // if no previous category was specified, check to see if currentCategory is in the list if (UtilValidate.isEmpty(previousCategoryId)) { if (trail.contains(currentCategoryId)) { // if cur category is in crumb, remove everything after it and return int cindex = trail.lastIndexOf(currentCategoryId); if (cindex < (trail.size() - 1)) { for (int i = trail.size() - 1; i > cindex; i--) { trail.remove(i); // FIXME can be removed ? // String deadCat = trail.remove(i); // if (Debug.infoOn()) Debug.logInfo("[CategoryWorker.setTrail] Removed after current // category index: " + i + " catname: " + deadCat, module); } } return trail; } else { // current category is not in the list, and no previous category was specified, go back to // the beginning trail.clear(); trail.add("TOP"); if (UtilValidate.isNotEmpty(previousCategoryId)) { trail.add(previousCategoryId); } // if (Debug.infoOn()) Debug.logInfo("[CategoryWorker.setTrail] Starting new list, added TOP // and previousCategory: " + previousCategoryId, module); } } if (!trail.contains(previousCategoryId)) { // previous category was NOT in the list, ERROR, start over // if (Debug.infoOn()) Debug.logInfo("[CategoryWorker.setTrail] previousCategory (" + // previousCategoryId + ") was not in the crumb list, position is lost, starting over with // TOP", module); trail.clear(); trail.add("TOP"); if (UtilValidate.isNotEmpty(previousCategoryId)) { trail.add(previousCategoryId); } } else { // remove all categories after the previous category, preparing for adding the current // category int index = trail.indexOf(previousCategoryId); if (index < (trail.size() - 1)) { for (int i = trail.size() - 1; i > index; i--) { trail.remove(i); // FIXME can be removed ? // String deadCat = trail.remove(i); // if (Debug.infoOn()) Debug.logInfo("[CategoryWorker.setTrail] Removed after current // category index: " + i + " catname: " + deadCat, module); } } } // add the current category to the end of the list trail.add(currentCategoryId); if (Debug.verboseOn()) Debug.logVerbose( "[CategoryWorker.setTrail] Continuing list: Added currentCategory: " + currentCategoryId, module); return trail; }
public static List<GenericValue> getRelatedCategoriesRet( Delegator delegator, String attributeName, String parentId, boolean limitView, boolean excludeEmpty, boolean recursive) { List<GenericValue> categories = FastList.newInstance(); if (Debug.verboseOn()) Debug.logVerbose("[CategoryWorker.getRelatedCategories] ParentID: " + parentId, module); List<GenericValue> rollups = null; try { rollups = delegator.findByAndCache( "ProductCategoryRollup", UtilMisc.toMap("parentProductCategoryId", parentId), UtilMisc.toList("sequenceNum")); if (limitView) { rollups = EntityUtil.filterByDate(rollups, true); } } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); } if (rollups != null) { // Debug.logInfo("Rollup size: " + rollups.size(), module); for (GenericValue parent : rollups) { // Debug.logInfo("Adding child of: " + parent.getString("parentProductCategoryId"), module); GenericValue cv = null; try { cv = parent.getRelatedOneCache("CurrentProductCategory"); } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); } if (cv != null) { if (excludeEmpty) { if (!isCategoryEmpty(cv)) { // Debug.logInfo("Child : " + cv.getString("productCategoryId") + " is not empty.", // module); categories.add(cv); if (recursive) { categories.addAll( getRelatedCategoriesRet( delegator, attributeName, cv.getString("productCategoryId"), limitView, excludeEmpty, recursive)); } } } else { categories.add(cv); if (recursive) { categories.addAll( getRelatedCategoriesRet( delegator, attributeName, cv.getString("productCategoryId"), limitView, excludeEmpty, recursive)); } } } } } return categories; }
/** * JavaMail Service that gets body content from a Screen Widget defined in the product store * record and if available as attachment also. * * @param dctx The DispatchContext that this service is operating in * @param rServiceContext Map containing the input parameters * @return Map with the result of the service, the output parameters */ public static Map<String, Object> sendMailFromScreen( DispatchContext dctx, Map<String, ? extends Object> rServiceContext) { Map<String, Object> serviceContext = UtilMisc.makeMapWritable(rServiceContext); LocalDispatcher dispatcher = dctx.getDispatcher(); String webSiteId = (String) serviceContext.remove("webSiteId"); String bodyText = (String) serviceContext.remove("bodyText"); String bodyScreenUri = (String) serviceContext.remove("bodyScreenUri"); String xslfoAttachScreenLocationParam = (String) serviceContext.remove("xslfoAttachScreenLocation"); String attachmentNameParam = (String) serviceContext.remove("attachmentName"); List<String> xslfoAttachScreenLocationListParam = UtilGenerics.checkList(serviceContext.remove("xslfoAttachScreenLocationList")); List<String> attachmentNameListParam = UtilGenerics.checkList(serviceContext.remove("attachmentNameList")); List<String> xslfoAttachScreenLocationList = FastList.newInstance(); List<String> attachmentNameList = FastList.newInstance(); if (UtilValidate.isNotEmpty(xslfoAttachScreenLocationParam)) xslfoAttachScreenLocationList.add(xslfoAttachScreenLocationParam); if (UtilValidate.isNotEmpty(attachmentNameParam)) attachmentNameList.add(attachmentNameParam); if (UtilValidate.isNotEmpty(xslfoAttachScreenLocationListParam)) xslfoAttachScreenLocationList.addAll(xslfoAttachScreenLocationListParam); if (UtilValidate.isNotEmpty(attachmentNameListParam)) attachmentNameList.addAll(attachmentNameListParam); Locale locale = (Locale) serviceContext.get("locale"); Map<String, Object> bodyParameters = UtilGenerics.checkMap(serviceContext.remove("bodyParameters")); if (bodyParameters == null) { bodyParameters = MapStack.create(); } if (!bodyParameters.containsKey("locale")) { bodyParameters.put("locale", locale); } else { locale = (Locale) bodyParameters.get("locale"); } String partyId = (String) serviceContext.get("partyId"); if (partyId == null) { partyId = (String) bodyParameters.get("partyId"); } String orderId = (String) bodyParameters.get("orderId"); String custRequestId = (String) bodyParameters.get("custRequestId"); bodyParameters.put("communicationEventId", serviceContext.get("communicationEventId")); NotificationServices.setBaseUrl(dctx.getDelegator(), webSiteId, bodyParameters); String contentType = (String) serviceContext.remove("contentType"); StringWriter bodyWriter = new StringWriter(); MapStack<String> screenContext = MapStack.create(); screenContext.put("locale", locale); ScreenRenderer screens = new ScreenRenderer(bodyWriter, screenContext, htmlScreenRenderer); screens.populateContextForService(dctx, bodyParameters); screenContext.putAll(bodyParameters); if (bodyScreenUri != null) { try { screens.render(bodyScreenUri); } catch (GeneralException e) { Debug.logError(e, "Error rendering screen for email: " + e.toString(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendRenderingScreenEmailError", UtilMisc.toMap("errorString", e.toString()), locale)); } catch (IOException e) { Debug.logError(e, "Error rendering screen for email: " + e.toString(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendRenderingScreenEmailError", UtilMisc.toMap("errorString", e.toString()), locale)); } catch (SAXException e) { Debug.logError(e, "Error rendering screen for email: " + e.toString(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendRenderingScreenEmailError", UtilMisc.toMap("errorString", e.toString()), locale)); } catch (ParserConfigurationException e) { Debug.logError(e, "Error rendering screen for email: " + e.toString(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendRenderingScreenEmailError", UtilMisc.toMap("errorString", e.toString()), locale)); } } boolean isMultiPart = false; // check if attachment screen location passed in if (UtilValidate.isNotEmpty(xslfoAttachScreenLocationList)) { List<Map<String, ? extends Object>> bodyParts = FastList.newInstance(); if (bodyText != null) { bodyText = FlexibleStringExpander.expandString(bodyText, screenContext, locale); bodyParts.add(UtilMisc.<String, Object>toMap("content", bodyText, "type", "text/html")); } else { bodyParts.add( UtilMisc.<String, Object>toMap("content", bodyWriter.toString(), "type", "text/html")); } for (int i = 0; i < xslfoAttachScreenLocationList.size(); i++) { String xslfoAttachScreenLocation = xslfoAttachScreenLocationList.get(i); String attachmentName = "Details.pdf"; if (UtilValidate.isNotEmpty(attachmentNameList) && attachmentNameList.size() >= i) { attachmentName = attachmentNameList.get(i); } isMultiPart = true; // start processing fo pdf attachment try { Writer writer = new StringWriter(); MapStack<String> screenContextAtt = MapStack.create(); // substitute the freemarker variables... ScreenRenderer screensAtt = new ScreenRenderer(writer, screenContext, foScreenRenderer); screensAtt.populateContextForService(dctx, bodyParameters); screenContextAtt.putAll(bodyParameters); screensAtt.render(xslfoAttachScreenLocation); /* try { // save generated fo file for debugging String buf = writer.toString(); java.io.FileWriter fw = new java.io.FileWriter(new java.io.File("/tmp/file1.xml")); fw.write(buf.toString()); fw.close(); } catch (IOException e) { Debug.logError(e, "Couldn't save xsl-fo xml debug file: " + e.toString(), module); } */ // create the input stream for the generation StreamSource src = new StreamSource(new StringReader(writer.toString())); // create the output stream for the generation ByteArrayOutputStream baos = new ByteArrayOutputStream(); Fop fop = ApacheFopWorker.createFopInstance(baos, MimeConstants.MIME_PDF); ApacheFopWorker.transform(src, null, fop); // and generate the PDF baos.flush(); baos.close(); // store in the list of maps for sendmail.... bodyParts.add( UtilMisc.<String, Object>toMap( "content", baos.toByteArray(), "type", "application/pdf", "filename", attachmentName)); } catch (GeneralException ge) { Debug.logError(ge, "Error rendering PDF attachment for email: " + ge.toString(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendRenderingScreenPdfError", UtilMisc.toMap("errorString", ge.toString()), locale)); } catch (IOException ie) { Debug.logError(ie, "Error rendering PDF attachment for email: " + ie.toString(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendRenderingScreenPdfError", UtilMisc.toMap("errorString", ie.toString()), locale)); } catch (FOPException fe) { Debug.logError(fe, "Error rendering PDF attachment for email: " + fe.toString(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendRenderingScreenPdfError", UtilMisc.toMap("errorString", fe.toString()), locale)); } catch (SAXException se) { Debug.logError(se, "Error rendering PDF attachment for email: " + se.toString(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendRenderingScreenPdfError", UtilMisc.toMap("errorString", se.toString()), locale)); } catch (ParserConfigurationException pe) { Debug.logError(pe, "Error rendering PDF attachment for email: " + pe.toString(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendRenderingScreenPdfError", UtilMisc.toMap("errorString", pe.toString()), locale)); } serviceContext.put("bodyParts", bodyParts); } } else { isMultiPart = false; // store body and type for single part message in the context. if (bodyText != null) { bodyText = FlexibleStringExpander.expandString(bodyText, screenContext, locale); serviceContext.put("body", bodyText); } else { serviceContext.put("body", bodyWriter.toString()); } // Only override the default contentType in case of plaintext, since other contentTypes may be // multipart // and would require specific handling. if (contentType != null && contentType.equalsIgnoreCase("text/plain")) { serviceContext.put("contentType", "text/plain"); } else { serviceContext.put("contentType", "text/html"); } } // also expand the subject at this point, just in case it has the FlexibleStringExpander syntax // in it... String subject = (String) serviceContext.remove("subject"); subject = FlexibleStringExpander.expandString(subject, screenContext, locale); Debug.logInfo("Expanded email subject to: " + subject, module); serviceContext.put("subject", subject); serviceContext.put("partyId", partyId); if (UtilValidate.isNotEmpty(orderId)) { serviceContext.put("orderId", orderId); } if (UtilValidate.isNotEmpty(custRequestId)) { serviceContext.put("custRequestId", custRequestId); } if (Debug.verboseOn()) Debug.logVerbose("sendMailFromScreen sendMail context: " + serviceContext, module); Map<String, Object> result = ServiceUtil.returnSuccess(); Map<String, Object> sendMailResult; try { if (isMultiPart) { sendMailResult = dispatcher.runSync("sendMailMultiPart", serviceContext); } else { sendMailResult = dispatcher.runSync("sendMail", serviceContext); } } catch (Exception e) { Debug.logError(e, "Error send email:" + e.toString(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendError", UtilMisc.toMap("errorString", e.toString()), locale)); } if (ServiceUtil.isError(sendMailResult)) { return ServiceUtil.returnError(ServiceUtil.getErrorMessage(sendMailResult)); } result.put("messageWrapper", sendMailResult.get("messageWrapper")); result.put("body", bodyWriter.toString()); result.put("subject", subject); result.put("communicationEventId", sendMailResult.get("communicationEventId")); if (UtilValidate.isNotEmpty(orderId)) { result.put("orderId", orderId); } if (UtilValidate.isNotEmpty(custRequestId)) { result.put("custRequestId", custRequestId); } return result; }
@Override public void render(HttpServletRequest request, HttpServletResponse response) throws java.io.IOException, ServletException { ServletContext context = (ServletContext) request.getAttribute("servletContext"); boolean verboseOn = Debug.verboseOn(); if (verboseOn) Debug.logVerbose("Rendering " + this.toString(), module); // long viewStartTime = System.currentTimeMillis(); if (content != null) { if ("direct".equals(type)) { if (UtilJ2eeCompat.useOutputStreamNotWriter(context)) { response.getOutputStream().print(content); } else { response.getWriter().print(content); } } else if ("default".equals(type) || "region".equals(type) || "resource".equals(type) || "jpublish".equals(type)) { // if type is resource then we won't even look up the region // if this is default or region, check to see if the content points to a valid region name Region region = null; if ("default".equals(type) || "region".equals(type)) { region = regionManager.getRegion(content); } if ("region".equals(type) || region != null) { if (region == null) { throw new IllegalArgumentException("No region definition found with name: " + content); } // render the content as a region RegionStack.push(request, region); region.render(request, response); RegionStack.pop(request); } else if ("jpublish".equals(type)) { // rather then using the view handler use the wrapper directly /* NOTE: In order to use the "jpublish" section type the JPublish libraries must be added as described in OPTIONAL_LIBRARIES and then uncomment this section ServletContext sctx = (ServletContext) request.getAttribute("servletContext"); if (sctx != null) { JPublishWrapper jp = this.getJPublishWrapper(sctx); if (jp != null) { String contentStr = "<!-- " + content + " Not Processed -->"; try { contentStr = jp.render(content, request, response); } catch (GeneralException e) { Debug.logError(e, "Problems rendering view from JPublish", module); } if (UtilJ2eeCompat.useOutputStreamNotWriter(context)) { response.getOutputStream().print(contentStr); } else { response.getWriter().print(contentStr); } } else { throw new IllegalStateException("No jpublishWrapper found in ServletContext"); } } else { throw new IllegalStateException("No servletContext found in request"); } */ } else { // default is the string that the ViewFactory expects for webapp resources viewHandlerRender("default", request, response); } } else { viewHandlerRender(type, request, response); } } if (verboseOn) Debug.logVerbose("DONE Rendering " + this.toString(), module); }
/** * Basic JavaMail Service * * @param ctx The DispatchContext that this service is operating in * @param context Map containing the input parameters * @return Map with the result of the service, the output parameters */ public static Map<String, Object> sendMail( DispatchContext ctx, Map<String, ? extends Object> context) { String communicationEventId = (String) context.get("communicationEventId"); String orderId = (String) context.get("orderId"); Locale locale = (Locale) context.get("locale"); if (communicationEventId != null) { Debug.logInfo("SendMail Running, for communicationEventId : " + communicationEventId, module); } Map<String, Object> results = ServiceUtil.returnSuccess(); String subject = (String) context.get("subject"); subject = FlexibleStringExpander.expandString(subject, context); String partyId = (String) context.get("partyId"); String body = (String) context.get("body"); List<Map<String, Object>> bodyParts = UtilGenerics.checkList(context.get("bodyParts")); GenericValue userLogin = (GenericValue) context.get("userLogin"); results.put("communicationEventId", communicationEventId); results.put("partyId", partyId); results.put("subject", subject); if (UtilValidate.isNotEmpty(orderId)) { results.put("orderId", orderId); } if (UtilValidate.isNotEmpty(body)) { body = FlexibleStringExpander.expandString(body, context); results.put("body", body); } if (UtilValidate.isNotEmpty(bodyParts)) { results.put("bodyParts", bodyParts); } results.put("userLogin", userLogin); String sendTo = (String) context.get("sendTo"); String sendCc = (String) context.get("sendCc"); String sendBcc = (String) context.get("sendBcc"); // check to see if we should redirect all mail for testing String redirectAddress = UtilProperties.getPropertyValue("general.properties", "mail.notifications.redirectTo"); if (UtilValidate.isNotEmpty(redirectAddress)) { String originalRecipients = " [To: " + sendTo + ", Cc: " + sendCc + ", Bcc: " + sendBcc + "]"; subject += originalRecipients; sendTo = redirectAddress; sendCc = null; sendBcc = null; } String sendFrom = (String) context.get("sendFrom"); String sendType = (String) context.get("sendType"); String port = (String) context.get("port"); String socketFactoryClass = (String) context.get("socketFactoryClass"); String socketFactoryPort = (String) context.get("socketFactoryPort"); String socketFactoryFallback = (String) context.get("socketFactoryFallback"); String sendVia = (String) context.get("sendVia"); String authUser = (String) context.get("authUser"); String authPass = (String) context.get("authPass"); String messageId = (String) context.get("messageId"); String contentType = (String) context.get("contentType"); Boolean sendPartial = (Boolean) context.get("sendPartial"); Boolean isStartTLSEnabled = (Boolean) context.get("startTLSEnabled"); boolean useSmtpAuth = false; // define some default if (sendType == null || sendType.equals("mail.smtp.host")) { sendType = "mail.smtp.host"; if (UtilValidate.isEmpty(sendVia)) { sendVia = UtilProperties.getPropertyValue( "general.properties", "mail.smtp.relay.host", "localhost"); } if (UtilValidate.isEmpty(authUser)) { authUser = UtilProperties.getPropertyValue("general.properties", "mail.smtp.auth.user"); } if (UtilValidate.isEmpty(authPass)) { authPass = UtilProperties.getPropertyValue("general.properties", "mail.smtp.auth.password"); } if (UtilValidate.isNotEmpty(authUser)) { useSmtpAuth = true; } if (UtilValidate.isEmpty(port)) { port = UtilProperties.getPropertyValue("general.properties", "mail.smtp.port"); } if (UtilValidate.isEmpty(socketFactoryPort)) { socketFactoryPort = UtilProperties.getPropertyValue("general.properties", "mail.smtp.socketFactory.port"); } if (UtilValidate.isEmpty(socketFactoryClass)) { socketFactoryClass = UtilProperties.getPropertyValue("general.properties", "mail.smtp.socketFactory.class"); } if (UtilValidate.isEmpty(socketFactoryFallback)) { socketFactoryFallback = UtilProperties.getPropertyValue( "general.properties", "mail.smtp.socketFactory.fallback", "false"); } if (sendPartial == null) { sendPartial = UtilProperties.propertyValueEqualsIgnoreCase( "general.properties", "mail.smtp.sendpartial", "true") ? true : false; } if (isStartTLSEnabled == null) { isStartTLSEnabled = UtilProperties.propertyValueEqualsIgnoreCase( "general.properties", "mail.smtp.starttls.enable", "true"); } } else if (sendVia == null) { return ServiceUtil.returnError( UtilProperties.getMessage(resource, "CommonEmailSendMissingParameterSendVia", locale)); } if (contentType == null) { contentType = "text/html"; } if (UtilValidate.isNotEmpty(bodyParts)) { contentType = "multipart/mixed"; } results.put("contentType", contentType); Session session; MimeMessage mail; try { Properties props = System.getProperties(); props.put(sendType, sendVia); if (UtilValidate.isNotEmpty(port)) { props.put("mail.smtp.port", port); } if (UtilValidate.isNotEmpty(socketFactoryPort)) { props.put("mail.smtp.socketFactory.port", socketFactoryPort); } if (UtilValidate.isNotEmpty(socketFactoryClass)) { props.put("mail.smtp.socketFactory.class", socketFactoryClass); Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider()); } if (UtilValidate.isNotEmpty(socketFactoryFallback)) { props.put("mail.smtp.socketFactory.fallback", socketFactoryFallback); } if (useSmtpAuth) { props.put("mail.smtp.auth", "true"); } if (sendPartial != null) { props.put("mail.smtp.sendpartial", sendPartial ? "true" : "false"); } if (isStartTLSEnabled) { props.put("mail.smtp.starttls.enable", "true"); } session = Session.getInstance(props); boolean debug = UtilProperties.propertyValueEqualsIgnoreCase("general.properties", "mail.debug.on", "Y"); session.setDebug(debug); mail = new MimeMessage(session); if (messageId != null) { mail.setHeader("In-Reply-To", messageId); mail.setHeader("References", messageId); } mail.setFrom(new InternetAddress(sendFrom)); mail.setSubject(subject, "UTF-8"); mail.setHeader("X-Mailer", "Apache OFBiz, The Apache Open For Business Project"); mail.setSentDate(new Date()); mail.addRecipients(Message.RecipientType.TO, sendTo); if (UtilValidate.isNotEmpty(sendCc)) { mail.addRecipients(Message.RecipientType.CC, sendCc); } if (UtilValidate.isNotEmpty(sendBcc)) { mail.addRecipients(Message.RecipientType.BCC, sendBcc); } if (UtilValidate.isNotEmpty(bodyParts)) { // check for multipart message (with attachments) // BodyParts contain a list of Maps items containing content(String) and type(String) of the // attachement MimeMultipart mp = new MimeMultipart(); Debug.logInfo(bodyParts.size() + " multiparts found", module); for (Map<String, Object> bodyPart : bodyParts) { Object bodyPartContent = bodyPart.get("content"); MimeBodyPart mbp = new MimeBodyPart(); if (bodyPartContent instanceof String) { Debug.logInfo( "part of type: " + bodyPart.get("type") + " and size: " + bodyPart.get("content").toString().length(), module); mbp.setText( (String) bodyPartContent, "UTF-8", ((String) bodyPart.get("type")).substring(5)); } else if (bodyPartContent instanceof byte[]) { ByteArrayDataSource bads = new ByteArrayDataSource((byte[]) bodyPartContent, (String) bodyPart.get("type")); Debug.logInfo( "part of type: " + bodyPart.get("type") + " and size: " + ((byte[]) bodyPartContent).length, module); mbp.setDataHandler(new DataHandler(bads)); } else if (bodyPartContent instanceof DataHandler) { mbp.setDataHandler((DataHandler) bodyPartContent); } else { mbp.setDataHandler(new DataHandler(bodyPartContent, (String) bodyPart.get("type"))); } String fileName = (String) bodyPart.get("filename"); if (fileName != null) { mbp.setFileName(fileName); } mp.addBodyPart(mbp); } mail.setContent(mp); mail.saveChanges(); } else { // create the singelpart message if (contentType.startsWith("text")) { mail.setText(body, "UTF-8", contentType.substring(5)); } else { mail.setContent(body, contentType); } mail.saveChanges(); } } catch (MessagingException e) { Debug.logError( e, "MessagingException when creating message to [" + sendTo + "] from [" + sendFrom + "] cc [" + sendCc + "] bcc [" + sendBcc + "] subject [" + subject + "]", module); Debug.logError( "Email message that could not be created to [" + sendTo + "] had context: " + context, module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendMessagingException", UtilMisc.toMap( "sendTo", sendTo, "sendFrom", sendFrom, "sendCc", sendCc, "sendBcc", sendBcc, "subject", subject), locale)); } catch (IOException e) { Debug.logError( e, "IOExcepton when creating message to [" + sendTo + "] from [" + sendFrom + "] cc [" + sendCc + "] bcc [" + sendBcc + "] subject [" + subject + "]", module); Debug.logError( "Email message that could not be created to [" + sendTo + "] had context: " + context, module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendIOException", UtilMisc.toMap( "sendTo", sendTo, "sendFrom", sendFrom, "sendCc", sendCc, "sendBcc", sendBcc, "subject", subject), locale)); } // check to see if sending mail is enabled String mailEnabled = UtilProperties.getPropertyValue("general.properties", "mail.notifications.enabled", "N"); if (!"Y".equalsIgnoreCase(mailEnabled)) { // no error; just return as if we already processed Debug.logImportant( "Mail notifications disabled in general.properties; mail with subject [" + subject + "] not sent to addressee [" + sendTo + "]", module); Debug.logVerbose( "What would have been sent, the addressee: " + sendTo + " subject: " + subject + " context: " + context, module); results.put("messageWrapper", new MimeMessageWrapper(session, mail)); return results; } Transport trans = null; try { trans = session.getTransport("smtp"); if (!useSmtpAuth) { trans.connect(); } else { trans.connect(sendVia, authUser, authPass); } trans.sendMessage(mail, mail.getAllRecipients()); results.put("messageWrapper", new MimeMessageWrapper(session, mail)); results.put("messageId", mail.getMessageID()); trans.close(); } catch (SendFailedException e) { // message code prefix may be used by calling services to determine the cause of the failure Debug.logError( e, "[ADDRERR] Address error when sending message to [" + sendTo + "] from [" + sendFrom + "] cc [" + sendCc + "] bcc [" + sendBcc + "] subject [" + subject + "]", module); List<SMTPAddressFailedException> failedAddresses = FastList.newInstance(); Exception nestedException = null; while ((nestedException = e.getNextException()) != null && nestedException instanceof MessagingException) { if (nestedException instanceof SMTPAddressFailedException) { SMTPAddressFailedException safe = (SMTPAddressFailedException) nestedException; Debug.logError( "Failed to send message to [" + safe.getAddress() + "], return code [" + safe.getReturnCode() + "], return message [" + safe.getMessage() + "]", module); failedAddresses.add(safe); break; } } Boolean sendFailureNotification = (Boolean) context.get("sendFailureNotification"); if (sendFailureNotification == null || sendFailureNotification) { sendFailureNotification(ctx, context, mail, failedAddresses); results.put("messageWrapper", new MimeMessageWrapper(session, mail)); try { results.put("messageId", mail.getMessageID()); trans.close(); } catch (MessagingException e1) { Debug.logError(e1, module); } } else { return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendAddressError", UtilMisc.toMap( "sendTo", sendTo, "sendFrom", sendFrom, "sendCc", sendCc, "sendBcc", sendBcc, "subject", subject), locale)); } } catch (MessagingException e) { // message code prefix may be used by calling services to determine the cause of the failure Debug.logError( e, "[CON] Connection error when sending message to [" + sendTo + "] from [" + sendFrom + "] cc [" + sendCc + "] bcc [" + sendBcc + "] subject [" + subject + "]", module); Debug.logError( "Email message that could not be sent to [" + sendTo + "] had context: " + context, module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendConnectionError", UtilMisc.toMap( "sendTo", sendTo, "sendFrom", sendFrom, "sendCc", sendCc, "sendBcc", sendBcc, "subject", subject), locale)); } return results; }
@Override public boolean exec(MethodContext methodContext) throws MiniLangException { if (UtilValidate.isEmpty(this.methodName)) { throw new MiniLangRuntimeException("method-name attribute is empty", this); } SimpleMethod simpleMethodToCall = SimpleMethod.getSimpleMethod(this.xmlURL, this.methodName); if (simpleMethodToCall == null) { throw new MiniLangRuntimeException( "Could not find <simple-method name=\"" + this.methodName + "\"> in XML document " + this.xmlResource, this); } MethodContext localContext = methodContext; if ("function".equals(this.scope)) { Map<String, Object> localEnv = new HashMap<String, Object>(); localEnv.putAll(methodContext.getEnvMap()); localEnv.remove(this.simpleMethod.getEventResponseCodeName()); localEnv.remove(this.simpleMethod.getServiceResponseMessageName()); localContext = new MethodContext(localEnv, methodContext.getLoader(), methodContext.getMethodType()); } String returnVal = simpleMethodToCall.exec(localContext); if (Debug.verboseOn()) Debug.logVerbose( "Called simple-method named [" + this.methodName + "] in resource [" + this.xmlResource + "], returnVal is [" + returnVal + "]", module); if (simpleMethodToCall.getDefaultErrorCode().equals(returnVal)) { if (methodContext.getMethodType() == MethodContext.EVENT) { methodContext.putEnv( simpleMethod.getEventResponseCodeName(), simpleMethod.getDefaultErrorCode()); } else if (methodContext.getMethodType() == MethodContext.SERVICE) { methodContext.putEnv( simpleMethod.getServiceResponseMessageName(), simpleMethod.getDefaultErrorCode()); } return false; } if (methodContext.getMethodType() == MethodContext.EVENT) { // FIXME: This doesn't make sense. We are comparing the called method's response code with // this method's // response code. Since response codes are configurable per method, this code will fail. String responseCode = (String) localContext.getEnv(this.simpleMethod.getEventResponseCodeName()); if (this.simpleMethod.getDefaultErrorCode().equals(responseCode)) { Debug.logWarning( "Got error [" + responseCode + "] calling inline simple-method named [" + this.methodName + "] in resource [" + this.xmlResource + "], message is " + methodContext.getEnv(this.simpleMethod.getEventErrorMessageName()), module); return false; } } else if (methodContext.getMethodType() == MethodContext.SERVICE) { // FIXME: This doesn't make sense. We are comparing the called method's response message with // this method's // response message. Since response messages are configurable per method, this code will fail. String responseMessage = (String) localContext.getEnv(this.simpleMethod.getServiceResponseMessageName()); if (this.simpleMethod.getDefaultErrorCode().equals(responseMessage)) { Debug.logWarning( "Got error [" + responseMessage + "] calling inline simple-method named [" + this.methodName + "] in resource [" + this.xmlResource + "], message is " + methodContext.getEnv(this.simpleMethod.getServiceErrorMessageName()) + ", and the error message list is: " + methodContext.getEnv(this.simpleMethod.getServiceErrorMessageListName()), module); return false; } } if ("function".equals(this.scope) && this.resultToFieldList != null) { Map<String, Object> results = localContext.getResults(); if (results != null) { for (ResultToField resultToField : this.resultToFieldList) { resultToField.exec(methodContext.getEnvMap(), results); } } } return true; }