/*******************************************************************************
* 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.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ofbiz.base.location.FlexibleLocation;
import org.apache.ofbiz.base.util.Debug;
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.minilang.MiniLangException;
import org.apache.ofbiz.minilang.MiniLangRuntimeException;
import org.apache.ofbiz.minilang.MiniLangValidate;
import org.apache.ofbiz.minilang.SimpleMethod;
import org.apache.ofbiz.minilang.ValidationException;
import org.apache.ofbiz.minilang.artifact.ArtifactInfoContext;
import org.apache.ofbiz.minilang.method.MethodContext;
import org.apache.ofbiz.minilang.method.MethodOperation;
import org.w3c.dom.Element;
/**
* Implements the <call-simple-method> element.
*
* @see <a href="https://cwiki.apache.org/confluence/display/OFBADMIN/Mini+Language+-+minilang+-+simple-method+-+Reference">Mini-language Reference</a>
*/
public final class CallSimpleMethod extends MethodOperation {
public static final String module = CallSimpleMethod.class.getName();
private final String methodName;
private final String xmlResource;
private final URL xmlURL;
private final String scope;
private final List<ResultToField> resultToFieldList;
public CallSimpleMethod(Element element, SimpleMethod simpleMethod) throws MiniLangException {
super(element, simpleMethod);
if (MiniLangValidate.validationOn()) {
MiniLangValidate.attributeNames(simpleMethod, element, "method-name", "xml-resource", "scope");
MiniLangValidate.requiredAttributes(simpleMethod, element, "method-name");
MiniLangValidate.constantAttributes(simpleMethod, element, "method-name", "xml-resource", "scope");
MiniLangValidate.childElements(simpleMethod, element, "result-to-field");
}
this.methodName = element.getAttribute("method-name");
String xmlResourceAttribute = element.getAttribute("xml-resource");
if (xmlResourceAttribute.isEmpty()) {
xmlResourceAttribute = simpleMethod.getFromLocation();
}
this.xmlResource = xmlResourceAttribute;
URL xmlURL = null;
try {
xmlURL = FlexibleLocation.resolveLocation(this.xmlResource);
} catch (MalformedURLException e) {
MiniLangValidate.handleError("Could not find SimpleMethod XML document in resource: " + this.xmlResource + "; error was: " + e.toString(), simpleMethod, element);
}
this.xmlURL = xmlURL;
this.scope = element.getAttribute("scope");
List<? extends Element> resultToFieldElements = UtilXml.childElementList(element, "result-to-field");
if (UtilValidate.isNotEmpty(resultToFieldElements)) {
if (!"function".equals(this.scope)) {
MiniLangValidate.handleError("Inline scope cannot include <result-to-field> elements.", simpleMethod, element);
}
List<ResultToField> resultToFieldList = new ArrayList<ResultToField>(resultToFieldElements.size());
for (Element resultToFieldElement : resultToFieldElements) {
resultToFieldList.add(new ResultToField(resultToFieldElement, simpleMethod));
}
this.resultToFieldList = resultToFieldList;
} else {
this.resultToFieldList = null;
}
}
@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;
}
@Override
public void gatherArtifactInfo(ArtifactInfoContext aic) {
SimpleMethod simpleMethodToCall;
try {
simpleMethodToCall = SimpleMethod.getSimpleMethod(this.xmlURL, this.methodName);
if (simpleMethodToCall != null) {
if (!aic.hasVisited(simpleMethodToCall)) {
aic.addSimpleMethod(simpleMethodToCall);
simpleMethodToCall.gatherArtifactInfo(aic);
}
}
} catch (MiniLangException e) {
Debug.logWarning("Could not find <simple-method name=\"" + this.methodName + "\"> in XML document " + this.xmlResource + ": " + e.toString(), module);
}
}
public String getMethodName() {
return this.methodName;
}
public String getXmlResource() {
return this.xmlResource;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("<call-simple-method ");
if (this.methodName.length() > 0) {
sb.append("method-name=\"").append(this.methodName).append("\" ");
}
if (this.xmlResource.length() > 0) {
sb.append("xml-resource=\"").append(this.xmlResource).append("\" ");
}
if (this.scope.length() > 0) {
sb.append("scope=\"").append(this.scope).append("\" ");
}
sb.append("/>");
return sb.toString();
}
/**
* A factory for the <call-simple-method> element.
*/
public static final class CallSimpleMethodFactory implements Factory<CallSimpleMethod> {
@Override
public CallSimpleMethod createMethodOperation(Element element, SimpleMethod simpleMethod) throws MiniLangException {
return new CallSimpleMethod(element, simpleMethod);
}
@Override
public String getName() {
return "call-simple-method";
}
}
private final class ResultToField {
private final FlexibleMapAccessor<Object> fieldFma;
private final FlexibleMapAccessor<Object> resultNameFma;
private ResultToField(Element element, SimpleMethod simpleMethod) throws ValidationException {
if (MiniLangValidate.validationOn()) {
MiniLangValidate.attributeNames(simpleMethod, element, "result-name", "field");
MiniLangValidate.requiredAttributes(simpleMethod, element, "result-name");
MiniLangValidate.expressionAttributes(simpleMethod, element, "result-name", "field");
MiniLangValidate.noChildElements(simpleMethod, element);
}
this.resultNameFma = FlexibleMapAccessor.getInstance(element.getAttribute("result-name"));
String fieldAttribute = element.getAttribute("field");
if (fieldAttribute.length() == 0) {
this.fieldFma = this.resultNameFma;
} else {
this.fieldFma = FlexibleMapAccessor.getInstance(fieldAttribute);
}
}
private void exec(Map<String, Object> context, Map<String, Object> results) throws MiniLangException {
Object value = this.resultNameFma.get(results);
if (value != null) {
this.fieldFma.put(context, value);
}
}
}
}