# ScriptMediatorFactory.java

    /*
     *  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 // TreeMap used to keep given scripts order if needed the License for the
     *  specific language governing permissions and limitations
     *  under the License.
     */

    package org.apache.synapse.mediators.bsf;

    import org.apache.axiom.om.OMAttribute;
    import org.apache.axiom.om.OMElement;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.synapse.Mediator;
    import org.apache.synapse.SynapseConstants;
    import org.apache.synapse.SynapseException;
    import org.apache.synapse.config.SynapsePropertiesLoader;
    import org.apache.synapse.config.xml.AbstractMediatorFactory;
    import org.apache.synapse.config.xml.FactoryUtils;
    import org.apache.synapse.config.xml.SynapsePathFactory;
    import org.apache.synapse.config.xml.XMLConfigConstants;
    import org.apache.synapse.mediators.Value;
    import org.apache.synapse.config.xml.ValueFactory;
    import org.apache.synapse.mediators.v2.Utils;
    import org.apache.synapse.mediators.v2.ext.InputArgument;
    import org.jaxen.JaxenException;

    import javax.xml.namespace.QName;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Properties;
    import java.util.*;

    import static org.apache.synapse.mediators.bsf.ScriptMediatorConstants.DEFAULT_SCRIPT_ENGINE;
    import static org.apache.synapse.mediators.bsf.ScriptMediatorConstants.GRAAL_JAVA_SCRIPT;
    import static org.apache.synapse.mediators.bsf.ScriptMediatorConstants.JAVA_SCRIPT;
    import static org.apache.synapse.mediators.bsf.ScriptMediatorConstants.RHINO_JAVA_SCRIPT;

    /**
     * Creates an instance of a Script mediator for inline or external script mediation for BSF
     * scripting languages.
     * <p/>
     * * <pre>
     *    &lt;script [key=&quot;entry-key&quot;]
     *      [function=&quot;script-function-name&quot;] language="javascript|groovy|ruby"&gt
     *      (text | xml)?
     *      &lt;include key=&quot;entry-key&quot; /&gt;
     *    &lt;/script&gt;
     * </pre>
     * <p/>
     * The boolean response from the in-lined mediator is either the response from the evaluation of the
     * script statements or if that result is not a boolean then a response of true is assumed.
     * <p/>
     * The MessageContext passed in to the script mediator has additional methods over the Synapse
     * MessageContext to enable working with the XML in a way natural to the scripting language. For
     * example when using JavaScript get/setPayloadXML use E4X XML objects, when using Ruby they
     * use REXML documents.
     * <p/>
     * For external script mediation, that is when using key, function, language attributes,
     * &lt;include key&quot;entry-key&quot; /&gt; is used to include one or more additional script files.
     */
    public class ScriptMediatorFactory extends AbstractMediatorFactory {

        private static final QName TAG_NAME
                = new QName(XMLConfigConstants.SYNAPSE_NAMESPACE, "script");

        private static final QName INCLUDE_Q
                = new QName(XMLConfigConstants.SYNAPSE_NAMESPACE, "include");

        public Mediator createSpecificMediator(OMElement elem, Properties properties) {

            ScriptMediator mediator;
            ClassLoader  classLoader = null;
            if (properties != null) {
                classLoader = (ClassLoader) properties.get(SynapseConstants.SYNAPSE_LIB_LOADER);
            }

            OMAttribute keyAtt = elem.getAttribute(new QName(XMLConfigConstants.NULL_NAMESPACE,
                    "key"));
            OMAttribute langAtt = elem.getAttribute(new QName(XMLConfigConstants.NULL_NAMESPACE,
                    "language"));
            OMAttribute functionAtt = elem.getAttribute(new QName(XMLConfigConstants.NULL_NAMESPACE,
                    "function"));

            if (langAtt == null) {
                throw new SynapseException("The 'language' attribute is required for" +
                        " a script mediator");
                // TODO: couldn't this be determined from the key in some scenarios?
            }
            if (keyAtt == null && functionAtt != null) {
                throw new SynapseException("Cannot use 'function' attribute without 'key' " +
                        "attribute for a script mediator");
            }

            Map<Value, Object> includeKeysMap = getIncludeKeysMap(elem);
            String language = langAtt.getAttributeValue();
            if (language.equals(JAVA_SCRIPT) &&
                    (RHINO_JAVA_SCRIPT.equals(SynapsePropertiesLoader.getPropertyValue(
                            DEFAULT_SCRIPT_ENGINE, GRAAL_JAVA_SCRIPT)))) {
                language = RHINO_JAVA_SCRIPT;
            }
            if (keyAtt != null) {

                // ValueFactory for creating dynamic or static Key
                ValueFactory keyFac = new ValueFactory();
                // create dynamic or static key based on OMElement
                Value generatedKey = keyFac.createValue(XMLConfigConstants.KEY, elem);

                if (generatedKey.getKeyValue() != null && !generatedKey.hasExprTypeKey()){
                    generatedKey = new Value(FactoryUtils.prependArtifactIdentifierToFileName(
                            generatedKey.getKeyValue(), properties));
                }

                String functionName = (functionAtt == null ? null : functionAtt.getAttributeValue());
                mediator = new ScriptMediator(language, includeKeysMap, generatedKey, functionName, classLoader);
                String targetAtt = elem.getAttributeValue(ATT_TARGET);
                if (StringUtils.isNotBlank(targetAtt)) {
                    // This is V2 script mediator
                    if (StringUtils.isNotBlank(targetAtt)) {
                        if (Utils.isTargetBody(targetAtt)) {
                            mediator.setResultTarget(Utils.TARGET_BODY);
                        } else if (Utils.isTargetVariable(targetAtt)) {
                            String variableNameAttr = elem.getAttributeValue(ATT_TARGET_VARIABLE);
                            if (StringUtils.isBlank(variableNameAttr)) {
                                String msg = "The '" + AbstractMediatorFactory.ATT_TARGET_VARIABLE + "' attribute is required " +
                                        "for the configuration of a Script mediator when the '" +
                                        AbstractMediatorFactory.ATT_TARGET + "' is 'variable'";
                                throw new SynapseException(msg);
                            }
                            mediator.setResultTarget(Utils.TARGET_VARIABLE);
                            mediator.setVariableName(variableNameAttr);
                        } else if (Utils.isTargetNone(targetAtt)) {
                            mediator.setResultTarget(Utils.TARGET_NONE);
                        } else {
                            throw new SynapseException("Invalid '" + AbstractMediatorFactory.ATT_TARGET + "' attribute " +
                                    "value for script mediator : " + targetAtt + ". It should be either 'body', 'variable' or 'none'");
                        }
                        OMElement inputArgsElement = elem.getFirstChildWithName(INPUTS);
                        if (inputArgsElement != null) {
                            Map<String, InputArgument> inputArgsMap = getInputArguments(inputArgsElement);
                            mediator.setInputArgumentMap(inputArgsMap);
                        }
                    }
                }
            } else {
                mediator = new ScriptMediator(language, elem.getText(),classLoader);
            }

            processAuditStatus(mediator, elem);

            addAllCommentChildrenToList(elem, mediator.getCommentsList());

            return mediator;
        }

        private Map<String, InputArgument> getInputArguments(OMElement inputArgsElement) {

            Map<String, InputArgument> inputArgsMap = new LinkedHashMap<>();
            Iterator inputIterator = inputArgsElement.getChildrenWithName(ATT_ARGUMENT);
            while (inputIterator.hasNext()) {
                OMElement inputElement = (OMElement) inputIterator.next();
                String nameAttribute = inputElement.getAttributeValue(ATT_NAME);
                String typeAttribute = inputElement.getAttributeValue(ATT_TYPE);
                String valueAttribute = inputElement.getAttributeValue(ATT_VALUE);
                String expressionAttribute = inputElement.getAttributeValue(ATT_EXPRN);
                InputArgument argument = new InputArgument(nameAttribute);
                if (valueAttribute != null) {
                    argument.setValue(valueAttribute, typeAttribute);
                } else if (expressionAttribute != null) {
                    try {
                        argument.setExpression(SynapsePathFactory.getSynapsePath(inputElement,
                                new QName("expression")), typeAttribute);
                    } catch (JaxenException e) {
                        handleException("Error setting expression : " + expressionAttribute + " as an input argument to " +
                                "script mediator. " + e.getMessage(), e);
                    }
                }
                inputArgsMap.put(nameAttribute, argument);
            }
            return inputArgsMap;
        }

        private Map<Value, Object> getIncludeKeysMap(OMElement elem) {
            // get <include /> scripts
            // map key = registry entry key, value = script source
            // at this time map values are null, later loaded
            // from void ScriptMediator.prepareExternalScript(MessageContext synCtx)

            // TreeMap used to keep given scripts order if needed
            Map<Value, Object> includeKeysMap = new LinkedHashMap<Value, Object>();
            Iterator itr = elem.getChildrenWithName(INCLUDE_Q);
            while (itr.hasNext()) {
                OMElement includeElem = (OMElement) itr.next();
                OMAttribute key = includeElem.getAttribute(new QName(XMLConfigConstants.NULL_NAMESPACE,
                        "key"));
                // ValueFactory for creating dynamic or static Value
                ValueFactory keyFac = new ValueFactory();
                // create dynamic or static key based on OMElement
                Value generatedKey = keyFac.createValue(XMLConfigConstants.KEY, includeElem);

                if (key == null) {
                    throw new SynapseException("Cannot use 'include' element without 'key'" +
                            " attribute for a script mediator");
                }

                includeKeysMap.put(generatedKey, null);
            }

            return includeKeysMap;
        }

        public QName getTagQName() {
            return TAG_NAME;
        }
    }