Fixed sending parameters

revert Commmented redundat endpoints

Backend-libXML/Parser.py

@@ -40,7 +40,7 @@ def formatXML(source: str, prettify: bool) -> str:
     if prolog_start != -1:
         prolog_end = source.find("?>") + 2
         prolog = source[prolog_start:prolog_end]
-        source = source[prolog_end:].strip()
+        source = source[prolog_end: ]
     
     byte_input = BytesIO(source.encode("utf-8"))
     parser = etree.XMLParser(remove_blank_text=True)
@@ -48,12 +48,9 @@ def formatXML(source: str, prettify: bool) -> str:
 
     if prettify:
         prolog += "\n"
-        return prolog + etree.tostring(xml, pretty_print=True, encoding="utf-8").decode("utf-8")
 
-    raw_xml = etree.tostring(xml, encoding="utf-8").decode("utf-8")
-    raw_xml = " ".join(raw_xml.split())
+    return prolog + etree.tostring(xml, pretty_print=prettify).decode()
 
-    return prolog + raw_xml
 
 def xpath(source: str, xpath: str) -> str:
     """
@@ -86,6 +83,7 @@ def xpath(source: str, xpath: str) -> str:
         return result_string, "node"
 
 
+
 def xsd(source: str, xsd: str) -> bool:
     """
     Method used to validate XML string against XSD schema
@@ -106,6 +104,8 @@ def xsd(source: str, xsd: str) -> bool:
     except etree.DocumentInvalid as e:
         return str(e)
 
+    
+    
 def xslt(source: str, xslt: str) -> str:
     """
     Method used to transform XML string using XSLT

Backend-libXML/main.py

@@ -36,8 +36,8 @@ def process_xml(request: request, type: str) -> str:
             response_json['result'] = Parser.xslt(data, processorData)
         elif (type == "xpath"):
             response_json['result'], response_json['type'] = Parser.xpath(data, processorData)
-        # elif (type == "prettify"):
-        #     response_json['result'] = Parser.formatXML(data, True)
+        elif (type == "prettify"):
+            response_json['result'] = Parser.formatXML(data, True)
         elif (type == "minimize"):
             response_json['result'] = Parser.formatXML(data, False)
         elif (type == "prettifyHtml"):
@@ -77,10 +77,9 @@ def xsd():
 def xslt():
     return process_xml(request, "xslt")
 
-# Removed because lxml can't pretify <xs:complexType mixed="true">
-# @app.route("/prettify", methods=["POST"])
-# def prettify():
-#     return process_xml(request, "prettify")
+@app.route("/prettify", methods=["POST"])
+def prettify():
+    return process_xml(request, "prettify")
 
 @app.route("/minimize", methods=["POST"])
 def minimize():

Backend/tools-services/pom.xml

@@ -84,8 +84,14 @@
     <dependency>
       <groupId>xalan</groupId>
       <artifactId>xalan</artifactId>
-      <version>2.7.2</version>
+      <version>2.7.3</version>
     </dependency>
+    <dependency>
+      <groupId>xerces</groupId>
+      <artifactId>xercesImpl</artifactId>
+      <version>2.12.2</version>
+    </dependency>
+
 
     <!-- Logging -->
     <dependency>

Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java

@@ -44,7 +44,6 @@ public class SparkApplication {
         registry.registerController(new XmlController(gson, logger, saxon, xalan));
         registry.registerController(new MultipleXMLController(gson,logger, saxon));
         registry.registerController(new JsonController(gson, jsongson, logger));
-        registry.registerController(new XmlFormatterController(gson));
 
         registry.register();
 

Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java

@@ -1,17 +1,26 @@
 package com.r11.tools.controller;
 
 import com.google.gson.Gson;
-import com.r11.tools.controller.internal.*;
+import com.r11.tools.controller.internal.GlobalControllerManifest;
+import com.r11.tools.controller.internal.HandlerType;
+import com.r11.tools.controller.internal.RestController;
+import com.r11.tools.controller.internal.ScopedControllerManifest;
+import com.r11.tools.controller.internal.XmlJob;
+import com.r11.tools.controller.internal.XmlJobType;
 import com.r11.tools.model.XMLRequestBody;
 import com.r11.tools.model.XMLResponseBody;
 import com.r11.tools.model.XPathQueryResult;
+import com.r11.tools.model.XmlTools;
 import com.r11.tools.xml.XmlEngine;
 import org.apache.logging.log4j.Logger;
 import spark.Request;
 import spark.Response;
 
+import java.util.Objects;
+
 /**
  * Controller used to handle XML tools: XPath, XSD validation, XQuery and XSLT
+ *
  * @author Adam Bem
  */
 @GlobalControllerManifest
@@ -22,12 +31,15 @@ public class XmlController implements RestController {
 
     private final XmlEngine saxon;
     private final XmlEngine xalan;
+    private final XmlTools tools;
 
     public XmlController(Gson gson, Logger logger, XmlEngine saxon, XmlEngine xalan) {
         this.gson = gson;
         this.logger = logger;
         this.saxon = saxon;
         this.xalan = xalan;
+        this.tools = new XmlTools();
+
     }
 
     @ScopedControllerManifest(method = HandlerType.POST, path = "/xpath")
@@ -48,9 +60,16 @@ public class XmlController implements RestController {
 
     @ScopedControllerManifest(method = HandlerType.POST, path = "/xslt")
     public void acceptRequestXslt(Request request, Response response) {
+        System.out.println("received xslt");
         acceptRequest(request, response, XmlJobType.XSLT);
     }
 
+    @ScopedControllerManifest(method = HandlerType.POST, path = "/xslt/param")
+    public void acceptRequestXsltAddParam(Request request, Response response) {
+        System.out.println("received param");
+        acceptRequest(request, response, XmlJobType.XSLT_PARAM);
+    }
+
     private void acceptRequest(Request request, Response response, XmlJobType xmlJobType) {
         XMLRequestBody requestBody;
         try {
@@ -60,6 +79,22 @@ public class XmlController implements RestController {
             return;
         }
 
+        if (requestBody.getType() != null) {
+            String status;
+            if (Objects.equals(requestBody.getType(), "add")) {
+                status = tools.createNewParam(requestBody.getParamName(), requestBody.getParamValue());
+            } else if (Objects.equals(requestBody.getType(), "remove")) {
+                status = tools.removeParam(requestBody.getParamName(), requestBody.getParamValue());
+            }else {
+                unknownOperationType(response);
+                return;
+            }
+
+            XMLResponseBody responseBody = new XMLResponseBody(status);
+            response.body(this.gson.toJson(responseBody));
+            return;
+        }
+
         if (requestBody.getProcessor() == null) {
             invalidEngineSelectedResponse(response);
             return;
@@ -91,7 +126,6 @@ public class XmlController implements RestController {
             responseBody.setDuration(duration);
 
             xmlJob.getResponse().status(200);
-
             this.logger.info("Request (" + xmlJob.getXmlJobType() + ", " +
                     xmlJob.getEngine().getVersion() +
                     ") processed in " + duration + " ms.");
@@ -141,9 +175,10 @@ public class XmlController implements RestController {
                         requestBody.getVersion());
                 break;
         }
-        return new XMLResponseBody(result, "OK", requestBody.getVersion());
+        return new XMLResponseBody(result, "OK", requestBody.getProcessorData());
     }
 
+
     private XMLResponseBody processingErrorResponse(Exception ex, XmlJob xmlJob) {
         XmlEngine engine = xmlJob.getEngine();
         XmlJobType xmlJobType = xmlJob.getXmlJobType();
@@ -164,6 +199,12 @@ public class XmlController implements RestController {
         response.body(this.gson.toJson(responseBody));
         response.status(400);
     }
+    private void unknownOperationType(Response response) {
+        XMLResponseBody responseBody =
+                new XMLResponseBody("You can only add and remove parameters", "ERR", "N/A", -1);
+        response.body(this.gson.toJson(responseBody));
+        response.status(400);
+    }
 
     private void requestErrorResponse(Response response, Exception ex) {
         XMLResponseBody responseBody = new XMLResponseBody(ex.getMessage(), "ERR", "N/A", -1);

Backend/tools-services/src/main/java/com/r11/tools/controller/XmlFormatterController.java

@@ -1,51 +0,0 @@
-package com.r11.tools.controller;
-
-import com.google.gson.Gson;
-import com.r11.tools.controller.internal.GlobalControllerManifest;
-import com.r11.tools.controller.internal.HandlerType;
-import com.r11.tools.controller.internal.RestController;
-import com.r11.tools.controller.internal.ScopedControllerManifest;
-import com.r11.tools.controller.internal.XmlJobType;
-import com.r11.tools.model.XMLRequestBody;
-import com.r11.tools.model.XMLResponseBody;
-import com.r11.tools.xml.XmlFormatter;
-import spark.Request;
-import spark.Response;
-
-@GlobalControllerManifest
-public class XmlFormatterController implements RestController {
-    private final Gson gson;
-
-    public XmlFormatterController(Gson gson) {
-        this.gson = gson;
-    }
-
-
-    @ScopedControllerManifest(method = HandlerType.POST, path = "/prettify")
-    public void acceptRequestXslt(Request request, Response response) {
-        acceptRequest(request, response);
-    }
-    private void acceptRequest(Request request, Response response){
-        long timeStart = System.currentTimeMillis();
-        long duration;
-
-        XmlFormatter formatter = new XmlFormatter();
-        XMLRequestBody requestBody;
-        try {
-            requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class);
-        } catch (Exception e) {
-            requestErrorResponse(response, e);
-            return;
-        }
-        String responseString = formatter.formatXML(requestBody.getData());
-        duration = System.currentTimeMillis() - timeStart;
-        XMLResponseBody responseBody = new  XMLResponseBody(responseString,"OK",duration);
-        response.body(this.gson.toJson(responseBody));
-
-    }
-    private void requestErrorResponse(Response response, Exception ex) {
-        XMLResponseBody responseBody = new XMLResponseBody(ex.getMessage(), "ERR", "N/A", -1);
-        response.status(400);
-        response.body(this.gson.toJson(responseBody));
-    }
-}

Backend/tools-services/src/main/java/com/r11/tools/controller/internal/XmlJob.java

@@ -7,7 +7,7 @@ import spark.Response;
 public class XmlJob {
     private final Response response;
     private final XMLRequestBody requestBody;
-    private final XmlEngine engine;
+    private XmlEngine engine;
     private final XmlJobType xmlJobType;
 
     public XmlJob(Response response, XMLRequestBody requestBody, XmlEngine engine, XmlJobType xmlJobType) {
@@ -16,7 +16,11 @@ public class XmlJob {
         this.engine = engine;
         this.xmlJobType = xmlJobType;
     }
-
+    public XmlJob(Response response, XMLRequestBody requestBody, XmlJobType xmlJobType) {
+        this.response = response;
+        this.requestBody = requestBody;
+        this.xmlJobType = xmlJobType;
+    }
     public Response getResponse() {
         return response;
     }

Backend/tools-services/src/main/java/com/r11/tools/controller/internal/XmlJobType.java

@@ -1,7 +1,7 @@
 package com.r11.tools.controller.internal;
 
 public enum XmlJobType {
-    XPath("XPath"), XSD("XSD"), XQuery("XQuery"), XSLT("XSLT");
+    XPath("XPath"), XSD("XSD"), XQuery("XQuery"), XSLT("XSLT"), XSLT_PARAM("XSLT_PARAM");
 
     XmlJobType(String type) {
     }

Backend/tools-services/src/main/java/com/r11/tools/model/XMLRequestBody.java

@@ -4,7 +4,6 @@ import com.google.gson.annotations.SerializedName;
 
 /**
  * POJO class used to contain body of XML related requests
- *
  * @author Adam Bem
  */
 public class XMLRequestBody {
@@ -16,26 +15,21 @@ public class XMLRequestBody {
     private String processor;
     @SerializedName("version")
     private String version;
-    @SerializedName("pretify")
-    private String pretif;
+    @SerializedName("paramName")
+    private String paramName;
+    @SerializedName("paramValue")
+    private String paramValue;
 
     public String getData() {
         return data;
     }
-
-    public String getProcessorData() {
-        return processorData;
-    }
-
+    public String getProcessorData() {return processorData;}
+    public String getParamName() {return paramName;}
+    public String getParamValue() {return paramValue;}
     public String getProcessor() {
         return processor;
     }
-
     public String getVersion() {
         return version;
     }
-
-    public String getPretif() {
-        return pretif;
-    }
 }

Backend/tools-services/src/main/java/com/r11/tools/model/XMLResponseBody.java

@@ -2,7 +2,6 @@ package com.r11.tools.model;
 
 public class XMLResponseBody {
 
-
     private String result;
     private String status;
     private String processor;
@@ -11,11 +10,10 @@ public class XMLResponseBody {
     // Optional
     private String type;
 
-    public XMLResponseBody(String result, String status, long duration) {
-        this.result = result;
+    public XMLResponseBody(String status){
         this.status = status;
-        this.duration = duration;
     }
+
     public XMLResponseBody(String result, String status, String processor) {
         this.result = result;
         this.status = status;

Backend/tools-services/src/main/java/com/r11/tools/model/XmlTools.java

@@ -0,0 +1,82 @@
+package com.r11.tools.model;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+
+public class XmlTools {
+    private final Map<String, String> createdParameters = new HashMap<>();
+    private final int paramsLimit = 1000;
+    private final String errorMessage = "ERR";
+    private final String succesMessage = "OK";
+
+    private final String parameter = "xsl:param";
+    private final String nameAttribute = "name";
+    private final String valueAttribute = "select";
+    private  void createNewNode(String paramName, String paramValue, Document doc) {
+
+        Element param = doc.createElement(parameter);
+        param.setAttribute(nameAttribute, paramName);
+        param.setAttribute(valueAttribute, "'" + paramValue + "'");
+        doc.getDocumentElement().appendChild(param);
+    }
+
+    public String addParams(String processorData ) {
+
+        try {
+            Document doc = addNode(processorData);
+            return docToString(doc);
+
+        } catch (ParserConfigurationException | SAXException | IOException | TransformerException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public String createNewParam(String paramName, String paramValue) {
+        if(createdParameters.size()<paramsLimit){
+            createdParameters.put(paramName, paramValue);
+            return succesMessage;
+        }else {
+            return errorMessage;
+        }
+
+    }
+
+    private Document addNode(String processorData) throws ParserConfigurationException, SAXException, IOException {
+        DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+        InputStream stream = new ByteArrayInputStream(processorData.getBytes(StandardCharsets.UTF_8));
+        Document doc = builder.parse(stream);
+        createdParameters.forEach((paramName, paramValue) -> createNewNode(paramName, paramValue, doc));
+        return doc;
+    }
+
+    private String docToString(Document doc) throws TransformerException {
+        TransformerFactory transformerFactory = TransformerFactory.newInstance();
+        Transformer transformer = transformerFactory.newTransformer();
+        DOMSource source = new DOMSource(doc);
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        StreamResult result = new StreamResult(outputStream);
+        transformer.transform(source, result);
+        return outputStream.toString();
+    }
+
+    public String removeParam(String paramName, String paramValue) {
+        return createdParameters.remove(paramName,paramValue) ? succesMessage : errorMessage;
+    }
+}

Backend/tools-services/src/main/java/com/r11/tools/xml/XmlEngine.java

@@ -9,9 +9,6 @@ public interface XmlEngine {
     XPathQueryResult processXPath(String data, String query, String version) throws Exception;
     String processXSLT(String data, String transform) throws Exception;
     String validate(String data, String xsd) throws Exception;
-
     String executeXQuery(String data, String xquery, String version) throws Exception;
-
     public String getVersion();
-
 }

Backend/tools-services/src/main/java/com/r11/tools/xml/XmlFormatter.java

@@ -1,37 +0,0 @@
-package com.r11.tools.xml;
-
-import org.w3c.dom.Document;
-import org.xml.sax.InputSource;
-
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.transform.OutputKeys;
-import javax.xml.transform.Transformer;
-import javax.xml.transform.TransformerFactory;
-import javax.xml.transform.dom.DOMSource;
-import javax.xml.transform.stream.StreamResult;
-import java.io.StringReader;
-import java.io.StringWriter;
-
-public class XmlFormatter {
-    public String formatXML(String inputXML) {
-        try {
-            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
-            factory.setNamespaceAware(true);
-            DocumentBuilder builder = factory.newDocumentBuilder();
-            Document document = builder.parse(new InputSource(new StringReader(inputXML)));
-
-            TransformerFactory transformerFactory = TransformerFactory.newInstance();
-            Transformer transformer = transformerFactory.newTransformer();
-            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
-            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
-
-            StringWriter writer = new StringWriter();
-            transformer.transform(new DOMSource(document), new StreamResult(writer));
-            return writer.toString();
-        } catch (Exception e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-}

Frontend/src/components/XsltParamComponent.vue

@@ -0,0 +1,126 @@
+<script setup lang="ts">
+import {ref} from 'vue'
+
+const emit = defineEmits<{
+  (event: 'update-value', options: { name: string }[]): void;
+}>();
+
+const options = ref<{ name: string }[]>([
+  { name: "Add Param" }
+]);
+
+const sendToParent = () => {
+  options.value.forEach((value) => {console.log("KID" + value + options.value.indexOf(value))})
+  emit('update-value', options.value);
+};
+
+
+const nameInput = ref('')
+const valueInput = ref('')
+
+
+const selectedOption = ref(options.value[0].name)
+
+const selectedFunction = () => {
+  if (selectOption(selectedOption.value) === 'Add Param') {
+    options.value.push({name: nameInput.value + " = " + valueInput.value});
+
+  }
+  if (selectOption(selectedOption.value) === 'Remove Param') {
+    const currentIndex = options.value.indexOf(selectedOption.value)
+    options.value.splice(currentIndex, 1);
+    selectedOption.value= options.value[0].name
+    valueInput.value = ""
+    nameInput.value = ""
+  }
+  sendToParent()
+  /*
+
+    if(selectedOption.value === "Add Param") {
+      sendRequest("add");
+    }
+    else {
+      sendRequest("remove");
+      }
+  */
+}
+
+/*
+const sendRequest = (type:string) => {
+  console.log(type)
+  let request: Request = prepareRequest(type)
+  fetchRequest(request).then((body) => {
+
+    const {status} = body as any;
+    console.log(status)
+    if (status === "OK") {
+      options.value.push({ name: nameInput.value + " = " + valueInput.value });
+    }
+  });
+}
+*/
+function selectOption(option: string): string {
+  return option == "Add Param" ? "Add Param" : "Remove Param"
+}
+
+//
+// function prepareRequest(type :string): Request {
+//   let request = new Request(prepareURL(), {
+//     body: prepareRequestBody(type),
+//     method: "POST"
+//   });
+//   return request
+// }
+//
+// function prepareURL(): string {
+//   //const engineEndpoint = engine.value == "libxml" ? "libxml" : "java";
+//   return document.location.protocol + "//" + document.location.hostname + "/" + "java" + "/xslt/param";
+//   //return "http://localhost:8081/xslt/param";
+// }
+//
+// function prepareRequestBody(type: string): string {
+//   let requestBody = JSON.stringify({
+//     "paramName": nameInput.value,
+//     "paramValue": valueInput.value,
+//     "type": type
+//   });
+//   console.log(requestBody);
+//   return requestBody;
+// }
+//
+// async function fetchRequest(request: Request): Promise<JSON> {
+//   console.log(request)
+//   let responseBody = await fetch(request)
+//   return await responseBody.json()
+//      }
+
+</script>
+
+<template>
+  <select
+      v-model="selectedOption"
+      class="flex h-full px-3 rounded-full border border-slate-400 bg-white dark:text-slate-100 dark:bg-gray-600 w-48"
+  >
+    <option v-for="option in options" :value="option.name" :key="option.name">
+      {{ option.name }}
+    </option>
+  </select>
+  <input
+      v-if="selectedOption==='Add Param'"
+      id="NameTextInput"
+      v-model="nameInput"
+      class="text-input h-full px-3 rounded-full border border-slate-400 bg-white dark:text-slate-100 dark:bg-gray-600 w-1/3"
+      type="text"
+      placeholder="Name"
+  />
+  <input
+      v-if="selectedOption==='Add Param'"
+      id="ValueTextInput"
+      v-model="valueInput"
+      class="text-input h-full px-3 rounded-full border border-slate-400 bg-white dark:text-slate-100 dark:bg-gray-600 w-1/3"
+      type="text"
+      placeholder="Value"
+  />
+  <button class="tool-button" @click="selectedFunction">{{ selectOption(selectedOption) }}</button>
+</template>
+

Frontend/src/components/formatter/XMLButtonFormatterComponent.vue

@@ -18,37 +18,38 @@ function process() {
 }
 
 function prepareRequest():Request {
-  return new Request(prepareURL(), {
+    var request = new Request(prepareURL(), {
         body: prepareRequestBody(),
         method: "POST"
     })
+    return request
 }
 
 function prepareURL(): string {
-  let mode = "/java/prettify";
-  console.log("prepareUrl")
-  console.log(props.isMinimizer)
+    var mode = "prettify"
     if (props.isMinimizer)
-        mode = "/libxml/minimize"
-    return document.location.protocol + "//" + document.location.hostname + mode
+        mode = "minimize"
+    return document.location.protocol + "//" + document.location.hostname + "/libxml/" + mode
 }
 
 function prepareRequestBody():string {
-  return JSON.stringify({
+    var requestBody = JSON.stringify({
         "data": props.xml,
         "processorData": "N/A",
         "processor": "libxml",
         "version": "1.0"
     })
+    return requestBody
 }
 
 async function fetchRequest(request: Request):Promise<JSON> {
-  return await fetch(request)
+    var responseBody = await fetch(request)
     .then(response => response.json())
     .then((body) => {
         emit("update:error", body.status == "ERR")
         return body
     })
+    return responseBody
 }
 
 function sendProcessedData(data: JSON) {

Frontend/src/components/xml/XmlInputFieldComponent.vue

@@ -2,24 +2,31 @@
 import InsertTemplateComponent from '@components/common/InsertTemplateComponent.vue'
 import XMLButtonFormatterComponent from '@components/formatter/XMLButtonFormatterComponent.vue'
 import CodeEditor from '@/components/common/CodeEditorComponent.vue'
+import XsltParamComponent from '@/components/XsltParamComponent.vue'
 
-import { ref } from 'vue'
+import {ref} from 'vue'
 
-const props = defineProps(
-    {
-        stylizedName: {type: String, required: true},
-        data: {type: String},
-    }
-)
-const emit = defineEmits(['update:modelValue'])
+const props = defineProps<{
+  stylizedName: string;
+  data?: string;
+  params?: { name: string }[];
+}>();
+
+const emit = defineEmits(['update:modelValue','update:params'])
 
 const data = ref('')
 const inputFile = ref()
+const params = ref<{ name: string }[]>([]);
 
 function sendValue() {
   emit('update:modelValue', data.value)
 }
 
+function updateParams(newParams: { name: string }[]) {
+  emit('update:params', newParams);
+}
+
+
 function updateData(newData: string, clearFileSelector: boolean = true) {
   data.value = newData
   if (clearFileSelector)
@@ -37,34 +44,53 @@ function canBeFormatted() {
       props.stylizedName.toLowerCase() == 'xslt'
 }
 
-function readFile(file : any) {
+function addParameters() {
+  return props.stylizedName?.toLowerCase() == "xslt"
+}
+
+function readFile(file: any) {
 
   const reader = new FileReader()
   reader.onloadend = () => {
     let result = reader.result?.toString()
     if (typeof result == "string")
-            updateData(result, false);
+      updateData(result, false)
 
   }
   reader.readAsText(file.target.files[0])
 }
 
+const handleUpdateValue = (options: { name: string }[]) => {
+  console.log("from parent" +options.length)
+  params.value = options
+  updateParams(params)
+};
+
 </script>
 
 <template>
   <div class="flex flex-col w-full h-1/2 lg:h-1/2 flex-none xl:pr-2 2xl:pr-4 pb-2">
+    <div class="flex justify-between mb-2"></div>
+
     <div class="flex place-content-between w-full items-center">
+
       <span class="dark:text-white mr-2">{{ stylizedName }}</span>
-            <div class="flex space-x-2 pb-2 overflow-x-auto">
+
       <div class="flex items-stretch w-64">
-                    <input id="fileLoader" ref="inputFile" class="file-selector" type="file" accept=".xml,.xql,.xquery,.xslt,text/xml,text/plain" @change="readFile" />
+        <input id="fileLoader" ref="inputFile" class="file-selector" type="file" accept=".xml,.xql,.xquery,.xslt,text/xml,text/plain" @change="readFile"/>
       </div>
 
+      <div class="flex space-x-2 pb-2 overflow-x-auto">
         <InsertTemplateComponent :stylized-name="props.stylizedName" @update:default-data="updateData"></InsertTemplateComponent>
         <XMLButtonFormatterComponent v-if="canBeFormatted()" :xml="data" @update:result="(data:any) => updateData(data.result)"></XMLButtonFormatterComponent>
         <button class="tool-button" @click="clear">Clear</button>
       </div>
     </div>
+
+    <div class="flex justify-end gap-2 place-content-between w-full items-center">
+        <XsltParamComponent v-if="addParameters()" @update-value="handleUpdateValue" :xslt="data"/>
+    </div>
+
     <CodeEditor @update:updated-code="updateData" v-model="data" :code="data" :config="{disabled:false, language:stylizedName}"></CodeEditor>
   </div>
 </template>

Frontend/src/components/xml/XmlOutputFieldComponent.vue

@@ -1,15 +1,14 @@
 <script setup lang="ts">
-import { onMounted, ref } from 'vue';
-import { type TabData } from '../common/TabData'
+import {onMounted, ref} from 'vue';
+import {type TabData} from '../common/TabData'
 import CodeEditor from '@/components/common/CodeEditorComponent.vue';
 
-const props = defineProps(
-    {
-        tool: {type: String, required: true},
-        xml: {type: [String, Array<TabData>], required: true},
-        query: {type: String, required: true}
-    }
-)
+const props = defineProps<{
+  tool: string;
+  xml: string | TabData[];
+  query: string;
+  params?: { name: string }[];
+}>();
 
 const emit = defineEmits(["update"]);
 
@@ -86,6 +85,8 @@ function selectDefaultVersion() {
 }
 
 function process() {
+  props.params?.forEach((param) => {console.log(param.name)})
+
   let request:Request = prepareRequest();
     fetchRequest(request).then((data) => {
         updateOutputField(data);
@@ -125,14 +126,25 @@ function selectRequestBodyType() : string {
     else
         return prepareRequestBodySingleXml(props.xml!);
 }
+function formatParams() {
+  return props.params.map(param => {
+    const [key, value] = param.name.split(" = ");
+    return {key, value};
+  });
+}
 
 function prepareRequestBodySingleXml(data: string):string {
+
+  const formattedParams = formatParams();
+
   let requestBody = JSON.stringify({
+        "params": formattedParams,
         "data": data,
         "processorData": props.query,
         "processor": engine.value,
         "version": version.value
     });
+    console.log(requestBody);
     return requestBody;
 }