| /******************************************************************************* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| *******************************************************************************/ |
| package org.apache.ofbiz.minilang.method.callops; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.UtilGenerics; |
| import org.apache.ofbiz.base.util.UtilMisc; |
| import org.apache.ofbiz.base.util.UtilProperties; |
| import org.apache.ofbiz.base.util.UtilValidate; |
| import org.apache.ofbiz.base.util.UtilXml; |
| import org.apache.ofbiz.base.util.collections.FlexibleMapAccessor; |
| import org.apache.ofbiz.base.util.collections.FlexibleServletAccessor; |
| import org.apache.ofbiz.base.util.string.FlexibleStringExpander; |
| import org.apache.ofbiz.entity.GenericValue; |
| import org.apache.ofbiz.minilang.MiniLangException; |
| import org.apache.ofbiz.minilang.MiniLangValidate; |
| import org.apache.ofbiz.minilang.SimpleMethod; |
| import org.apache.ofbiz.minilang.artifact.ArtifactInfoContext; |
| import org.apache.ofbiz.minilang.method.MethodContext; |
| import org.apache.ofbiz.minilang.method.MethodOperation; |
| import org.apache.ofbiz.service.GenericServiceException; |
| import org.apache.ofbiz.service.ModelService; |
| import org.apache.ofbiz.service.ServiceUtil; |
| import org.w3c.dom.Element; |
| |
| /** |
| * Implements the <call-service> element. |
| * |
| * @see <a href="https://cwiki.apache.org/confluence/display/OFBADMIN/Mini+Language+-+minilang+-+simple-method+-+Reference">Mini-language Reference</a> |
| */ |
| public final class CallService extends MethodOperation { |
| |
| public static final String module = CallService.class.getName(); |
| public static final String resource = "MiniLangErrorUiLabels"; |
| |
| private final boolean breakOnError; |
| private final FlexibleMessage defaultMessage; |
| private final String errorCode; |
| private final FlexibleMessage errorPrefix; |
| private final FlexibleMessage errorSuffix; |
| private final boolean includeUserLogin; |
| private final FlexibleMapAccessor<Map<String, Object>> inMapFma; |
| private final FlexibleMessage messagePrefix; |
| private final FlexibleMessage messageSuffix; |
| private final boolean requireNewTransaction; |
| private final List<String> resultsToMapList; |
| private final List<ResultToField> resultToFieldList; |
| private final List<ResultToRequest> resultToRequestList; |
| private final List<ResultToResult> resultToResultList; |
| private final List<ResultToSession> resultToSessionList; |
| private final FlexibleStringExpander serviceNameFse; |
| private final String successCode; |
| private final FlexibleMessage successPrefix; |
| private final FlexibleMessage successSuffix; |
| private final int transactionTimeout; |
| |
| public CallService(Element element, SimpleMethod simpleMethod) throws MiniLangException { |
| super(element, simpleMethod); |
| if (MiniLangValidate.validationOn()) { |
| MiniLangValidate.attributeNames(simpleMethod, element, "service-name", "in-map-name", "include-user-login", "break-on-error", "error-code", "require-new-transaction", "transaction-timeout", "success-code"); |
| MiniLangValidate.constantAttributes(simpleMethod, element, "include-user-login", "break-on-error", "error-code", "require-new-transaction", "transaction-timeout", "success-code"); |
| MiniLangValidate.expressionAttributes(simpleMethod, element, "service-name", "in-map-name"); |
| MiniLangValidate.requiredAttributes(simpleMethod, element, "service-name"); |
| MiniLangValidate.childElements(simpleMethod, element, "error-prefix", "error-suffix", "success-prefix", "success-suffix", "message-prefix", "message-suffix", "default-message", "results-to-map", "result-to-field", "result-to-request", "result-to-session", "result-to-result"); |
| } |
| serviceNameFse = FlexibleStringExpander.getInstance(element.getAttribute("service-name")); |
| inMapFma = FlexibleMapAccessor.getInstance(element.getAttribute("in-map-name")); |
| includeUserLogin = !"false".equals(element.getAttribute("include-user-login")); |
| breakOnError = !"false".equals(element.getAttribute("break-on-error")); |
| errorCode = element.getAttribute("error-code"); |
| requireNewTransaction = "true".equals(element.getAttribute("require-new-transaction")); |
| String timeoutStr = UtilXml.checkEmpty(element.getAttribute("transaction-timeout")); |
| int timeout = -1; |
| if (!timeoutStr.isEmpty()) { |
| try { |
| timeout = Integer.parseInt(timeoutStr); |
| } catch (NumberFormatException e) { |
| MiniLangValidate.handleError("Exception thrown while parsing transaction-timeout attribute: " + e.getMessage(), simpleMethod, element); |
| timeout = 0; |
| } |
| } |
| transactionTimeout = timeout; |
| successCode = element.getAttribute("success-code"); |
| errorPrefix = new FlexibleMessage(UtilXml.firstChildElement(element, "error-prefix"), "service.error.prefix"); |
| errorSuffix = new FlexibleMessage(UtilXml.firstChildElement(element, "error-suffix"), "service.error.suffix"); |
| successPrefix = new FlexibleMessage(UtilXml.firstChildElement(element, "success-prefix"), "service.success.prefix"); |
| successSuffix = new FlexibleMessage(UtilXml.firstChildElement(element, "success-suffix"), "service.success.suffix"); |
| messagePrefix = new FlexibleMessage(UtilXml.firstChildElement(element, "message-prefix"), "service.message.prefix"); |
| messageSuffix = new FlexibleMessage(UtilXml.firstChildElement(element, "message-suffix"), "service.message.suffix"); |
| defaultMessage = new FlexibleMessage(UtilXml.firstChildElement(element, "default-message"), null);// "service.default.message" |
| List<? extends Element> resultsToMapElements = UtilXml.childElementList(element, "results-to-map"); |
| if (UtilValidate.isNotEmpty(resultsToMapElements)) { |
| List<String> resultsToMapList = new ArrayList<String>(resultsToMapElements.size()); |
| for (Element resultsToMapElement : resultsToMapElements) { |
| resultsToMapList.add(resultsToMapElement.getAttribute("map-name")); |
| } |
| this.resultsToMapList = Collections.unmodifiableList(resultsToMapList); |
| } else { |
| this.resultsToMapList = null; |
| } |
| List<? extends Element> resultToFieldElements = UtilXml.childElementList(element, "result-to-field"); |
| if (UtilValidate.isNotEmpty(resultToFieldElements)) { |
| List<ResultToField> resultToFieldList = new ArrayList<ResultToField>(resultToFieldElements.size()); |
| for (Element resultToFieldElement : resultToFieldElements) { |
| resultToFieldList.add(new ResultToField(resultToFieldElement)); |
| } |
| this.resultToFieldList = Collections.unmodifiableList(resultToFieldList); |
| } else { |
| this.resultToFieldList = null; |
| } |
| List<? extends Element> resultToRequestElements = UtilXml.childElementList(element, "result-to-request"); |
| if (UtilValidate.isNotEmpty(resultToRequestElements)) { |
| List<ResultToRequest> resultToRequestList = new ArrayList<ResultToRequest>(resultToRequestElements.size()); |
| for (Element resultToRequestElement : resultToRequestElements) { |
| resultToRequestList.add(new ResultToRequest(resultToRequestElement)); |
| } |
| this.resultToRequestList = Collections.unmodifiableList(resultToRequestList); |
| } else { |
| this.resultToRequestList = null; |
| } |
| List<? extends Element> resultToSessionElements = UtilXml.childElementList(element, "result-to-session"); |
| if (UtilValidate.isNotEmpty(resultToSessionElements)) { |
| List<ResultToSession> resultToSessionList = new ArrayList<ResultToSession>(resultToSessionElements.size()); |
| for (Element resultToSessionElement : resultToSessionElements) { |
| resultToSessionList.add(new ResultToSession(resultToSessionElement)); |
| } |
| this.resultToSessionList = Collections.unmodifiableList(resultToSessionList); |
| } else { |
| this.resultToSessionList = null; |
| } |
| List<? extends Element> resultToResultElements = UtilXml.childElementList(element, "result-to-result"); |
| if (UtilValidate.isNotEmpty(resultToResultElements)) { |
| List<ResultToResult> resultToResultList = new ArrayList<ResultToResult>(resultToResultElements.size()); |
| for (Element resultToResultElement : resultToResultElements) { |
| resultToResultList.add(new ResultToResult(resultToResultElement)); |
| } |
| this.resultToResultList = Collections.unmodifiableList(resultToResultList); |
| } else { |
| this.resultToResultList = null; |
| } |
| } |
| |
| @Override |
| public boolean exec(MethodContext methodContext) throws MiniLangException { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "Begin call-service."); |
| } |
| String serviceName = serviceNameFse.expandString(methodContext.getEnvMap()); |
| String errorCode = this.errorCode; |
| if (errorCode.isEmpty()) { |
| errorCode = simpleMethod.getDefaultErrorCode(); |
| } |
| String successCode = this.successCode; |
| if (successCode.isEmpty()) { |
| successCode = simpleMethod.getDefaultSuccessCode(); |
| } |
| Map<String, Object> inMap = inMapFma.get(methodContext.getEnvMap()); |
| if (inMap == null) { |
| inMap = new HashMap<String, Object>(); |
| } |
| // before invoking the service, clear messages |
| if (methodContext.getMethodType() == MethodContext.EVENT) { |
| methodContext.removeEnv(simpleMethod.getEventErrorMessageName()); |
| methodContext.removeEnv(simpleMethod.getEventEventMessageName()); |
| methodContext.removeEnv(simpleMethod.getEventResponseCodeName()); |
| } else { |
| methodContext.removeEnv(simpleMethod.getServiceErrorMessageName()); |
| methodContext.removeEnv(simpleMethod.getServiceSuccessMessageName()); |
| methodContext.removeEnv(simpleMethod.getServiceResponseMessageName()); |
| } |
| // add UserLogin to context if expected |
| if (includeUserLogin) { |
| GenericValue userLogin = methodContext.getUserLogin(); |
| if (userLogin != null && inMap.get("userLogin") == null) { |
| inMap.put("userLogin", userLogin); |
| } |
| } |
| // always add Locale to context unless null |
| Locale locale = methodContext.getLocale(); |
| if (locale != null) { |
| inMap.put("locale", locale); |
| } |
| // invoke the service |
| Map<String, Object> result = null; |
| try { |
| ModelService modelService = methodContext.getDispatcher().getDispatchContext().getModelService(serviceName); |
| int timeout = modelService.transactionTimeout; |
| if (this.transactionTimeout >= 0) { |
| timeout = this.transactionTimeout; |
| } |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "Invoking service \"" + serviceName + "\", require-new-transaction = " + requireNewTransaction + ", transaction-timeout = " + timeout + ", IN attributes:", inMap.toString()); |
| } |
| result = methodContext.getDispatcher().runSync(serviceName, inMap, timeout, requireNewTransaction); |
| } catch (GenericServiceException e) { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "Service engine threw an exception: " + e.getMessage()); |
| } |
| String errMsg = "ERROR: Could not complete the " + simpleMethod.getShortDescription() + " process [problem invoking the [" + serviceName + "] service with the map named [" + inMapFma + "] containing [" + inMap + "]: " + e.getMessage() + "]"; |
| Debug.logError(e, errMsg, module); |
| if (breakOnError) { |
| if (methodContext.getMethodType() == MethodContext.EVENT) { |
| methodContext.putEnv(simpleMethod.getEventErrorMessageName(), errMsg); |
| methodContext.putEnv(simpleMethod.getEventResponseCodeName(), errorCode); |
| } else { |
| methodContext.putEnv(simpleMethod.getServiceErrorMessageName(), errMsg); |
| methodContext.putEnv(simpleMethod.getServiceResponseMessageName(), errorCode); |
| } |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "break-on-error set to \"true\", halting script execution. End call-service."); |
| } |
| return false; |
| } else { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "End call-service."); |
| } |
| return true; |
| } |
| } |
| if (resultsToMapList != null) { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "Processing " + resultsToMapList.size() + " <results-to-map> elements."); |
| } |
| for (String mapName : resultsToMapList) { |
| methodContext.putEnv(mapName, UtilMisc.makeMapWritable(result)); |
| } |
| } |
| if (resultToFieldList != null) { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "Processing " + resultToFieldList.size() + " <result-to-field> elements."); |
| } |
| for (ResultToField rtfDef : resultToFieldList) { |
| rtfDef.exec(methodContext, result); |
| } |
| } |
| if (resultToResultList != null) { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "Processing " + resultToResultList.size() + " <result-to-result> elements."); |
| } |
| for (ResultToResult rtrDef : resultToResultList) { |
| rtrDef.exec(methodContext, result); |
| } |
| } |
| if (methodContext.getMethodType() == MethodContext.EVENT) { |
| if (resultToRequestList != null) { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "Processing " + resultToRequestList.size() + " <result-to-request> elements."); |
| } |
| for (ResultToRequest rtrDef : resultToRequestList) { |
| rtrDef.exec(methodContext, result); |
| } |
| } |
| if (resultToSessionList != null) { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "Processing " + resultToSessionList.size() + " <result-to-session> elements."); |
| } |
| for (ResultToSession rtsDef : resultToSessionList) { |
| rtsDef.exec(methodContext, result); |
| } |
| } |
| } |
| String errorPrefixStr = errorPrefix.getMessage(methodContext.getLoader(), methodContext); |
| String errorSuffixStr = errorSuffix.getMessage(methodContext.getLoader(), methodContext); |
| String successPrefixStr = successPrefix.getMessage(methodContext.getLoader(), methodContext); |
| String successSuffixStr = successSuffix.getMessage(methodContext.getLoader(), methodContext); |
| String messagePrefixStr = messagePrefix.getMessage(methodContext.getLoader(), methodContext); |
| String messageSuffixStr = messageSuffix.getMessage(methodContext.getLoader(), methodContext); |
| String errorMessage = null; |
| List<String> errorMessageList = null; |
| // See if there is a single message |
| if (result.containsKey(ModelService.ERROR_MESSAGE)) { |
| errorMessage = ServiceUtil.makeErrorMessage(result, messagePrefixStr, messageSuffixStr, errorPrefixStr, errorSuffixStr); |
| } else if (result.containsKey(ModelService.ERROR_MESSAGE_LIST)) { |
| errorMessageList = UtilGenerics.checkList(result.get(ModelService.ERROR_MESSAGE_LIST)); |
| } |
| if ((UtilValidate.isNotEmpty(errorMessage) || UtilValidate.isNotEmpty(errorMessageList)) && breakOnError) { |
| if (methodContext.getMethodType() == MethodContext.EVENT) { |
| if (UtilValidate.isNotEmpty(errorMessage)) { |
| if (Debug.verboseOn()) { |
| errorMessage += UtilProperties.getMessage(resource, "simpleMethod.error_show_service_name", UtilMisc.toMap("serviceName", serviceName, "methodName", simpleMethod.getMethodName()), locale); |
| } |
| methodContext.putEnv(simpleMethod.getEventErrorMessageName(), errorMessage); |
| } else { |
| if (Debug.verboseOn()) { |
| errorMessageList.add(UtilProperties.getMessage(resource, "simpleMethod.error_show_service_name", UtilMisc.toMap("serviceName", serviceName, "methodName", simpleMethod.getMethodName()), locale)); |
| } |
| methodContext.putEnv(simpleMethod.getEventErrorMessageListName(), errorMessageList); |
| } |
| } else { |
| ServiceUtil.addErrors(UtilMisc.<String, String> getListFromMap(methodContext.getEnvMap(), this.simpleMethod.getServiceErrorMessageListName()), UtilMisc.<String, String, Object> getMapFromMap(methodContext.getEnvMap(), this.simpleMethod.getServiceErrorMessageMapName()), result); |
| Debug.logError(new Exception(errorMessage), module); |
| } |
| } |
| String successMessage = ServiceUtil.makeSuccessMessage(result, messagePrefixStr, messageSuffixStr, successPrefixStr, successSuffixStr); |
| if (UtilValidate.isNotEmpty(successMessage)) { |
| if (methodContext.getMethodType() == MethodContext.EVENT) { |
| methodContext.putEnv(simpleMethod.getEventEventMessageName(), successMessage); |
| } else { |
| methodContext.putEnv(simpleMethod.getServiceSuccessMessageName(), successMessage); |
| } |
| } |
| String defaultMessageStr = defaultMessage.getMessage(methodContext.getLoader(), methodContext); |
| if (UtilValidate.isEmpty(errorMessage) && UtilValidate.isEmpty(errorMessageList) && UtilValidate.isEmpty(successMessage) && UtilValidate.isNotEmpty(defaultMessageStr)) { |
| if (methodContext.getMethodType() == MethodContext.EVENT) { |
| methodContext.putEnv(simpleMethod.getEventEventMessageName(), defaultMessageStr); |
| } else { |
| methodContext.putEnv(simpleMethod.getServiceSuccessMessageName(), defaultMessageStr); |
| } |
| } |
| String responseCode = result.containsKey(ModelService.RESPONSE_MESSAGE) ? (String) result.get(ModelService.RESPONSE_MESSAGE) : successCode; |
| if (errorCode.equals(responseCode)) { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "Service returned an error."); |
| } |
| if (breakOnError) { |
| if (methodContext.getMethodType() == MethodContext.EVENT) { |
| methodContext.putEnv(simpleMethod.getEventResponseCodeName(), responseCode); |
| } else { |
| methodContext.putEnv(simpleMethod.getServiceResponseMessageName(), responseCode); |
| } |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "break-on-error set to \"true\", halting script execution. End call-service."); |
| } |
| return false; |
| } else { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "End call-service."); |
| } |
| return true; |
| } |
| } else { |
| if (methodContext.isTraceOn()) { |
| outputTraceMessage(methodContext, "Service ran successfully. End call-service."); |
| } |
| if (methodContext.getMethodType() == MethodContext.EVENT) { |
| methodContext.putEnv(simpleMethod.getEventResponseCodeName(), responseCode); |
| } else { |
| methodContext.putEnv(simpleMethod.getServiceResponseMessageName(), responseCode); |
| } |
| return true; |
| } |
| } |
| |
| @Override |
| public void gatherArtifactInfo(ArtifactInfoContext aic) { |
| aic.addServiceName(this.serviceNameFse.toString()); |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder("<call-service "); |
| sb.append("service-name=\"").append(this.serviceNameFse).append("\" "); |
| if (!this.inMapFma.isEmpty()) { |
| sb.append("in-map-name=\"").append(this.inMapFma).append("\" "); |
| } |
| sb.append("/>"); |
| return sb.toString(); |
| } |
| |
| /** |
| * A factory for the <call-service> element. |
| */ |
| public static final class CallServiceFactory implements Factory<CallService> { |
| @Override |
| public CallService createMethodOperation(Element element, SimpleMethod simpleMethod) throws MiniLangException { |
| return new CallService(element, simpleMethod); |
| } |
| |
| @Override |
| public String getName() { |
| return "call-service"; |
| } |
| } |
| |
| private final class ResultToField { |
| private final FlexibleMapAccessor<Object> fieldFma; |
| private final FlexibleMapAccessor<Object> resultFma; |
| |
| private ResultToField(Element element) { |
| resultFma = FlexibleMapAccessor.getInstance(element.getAttribute("result-name")); |
| String fieldAttribute = element.getAttribute("field"); |
| if (fieldAttribute.isEmpty()) { |
| fieldFma = resultFma; |
| } else { |
| fieldFma = FlexibleMapAccessor.getInstance(fieldAttribute); |
| } |
| } |
| |
| private void exec(MethodContext methodContext, Map<String, Object> resultMap) { |
| fieldFma.put(methodContext.getEnvMap(), resultFma.get(resultMap)); |
| } |
| } |
| |
| private final class ResultToRequest { |
| private final FlexibleMapAccessor<Object> resultFma; |
| private final FlexibleServletAccessor<Object> requestFsa; |
| |
| private ResultToRequest(Element element) { |
| requestFsa = new FlexibleServletAccessor<Object>(element.getAttribute("request-name"), element.getAttribute("result-name")); |
| resultFma =FlexibleMapAccessor.getInstance(element.getAttribute("result-name")); |
| } |
| |
| private void exec(MethodContext methodContext, Map<String, Object> resultMap) { |
| requestFsa.put(methodContext.getRequest(), resultFma.get(resultMap), methodContext.getEnvMap()); |
| } |
| } |
| |
| private final class ResultToResult { |
| private final FlexibleMapAccessor<Object> resultFma; |
| private final FlexibleMapAccessor<Object> serviceResultFma; |
| |
| private ResultToResult(Element element) { |
| resultFma = FlexibleMapAccessor.getInstance(element.getAttribute("result-name")); |
| String serviceResultAttribute = element.getAttribute("service-result-name"); |
| if (serviceResultAttribute.isEmpty()) { |
| serviceResultFma = resultFma; |
| } else { |
| serviceResultFma = FlexibleMapAccessor.getInstance(serviceResultAttribute); |
| } |
| } |
| |
| private void exec(MethodContext methodContext, Map<String, Object> resultMap) { |
| serviceResultFma.put(methodContext.getResults(), resultFma.get(resultMap)); |
| } |
| } |
| |
| private final class ResultToSession { |
| private final FlexibleMapAccessor<Object> resultFma; |
| private final FlexibleServletAccessor<Object> requestFsa; |
| |
| private ResultToSession(Element element) { |
| requestFsa = new FlexibleServletAccessor<Object>(element.getAttribute("session-name"), element.getAttribute("result-name")); |
| resultFma =FlexibleMapAccessor.getInstance(element.getAttribute("result-name")); |
| } |
| |
| private void exec(MethodContext methodContext, Map<String, Object> resultMap) { |
| requestFsa.put(methodContext.getRequest().getSession(), resultFma.get(resultMap), methodContext.getEnvMap()); |
| } |
| } |
| } |
