Fixed sending parameters

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/controller/XmlController.java

@@ -1,19 +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.io.StringWriter;
+import java.util.Objects;
 
 /**
  * Controller used to handle XML tools: XPath, XSD validation, XQuery and XSLT
+ *
  * @author Adam Bem
  */
 @GlobalControllerManifest
@@ -24,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")
@@ -53,11 +63,13 @@ public class XmlController implements RestController {
         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 {
@@ -67,12 +79,23 @@ public class XmlController implements RestController {
             return;
         }
 
-        if (requestBody.getProcessor() == null ) {
+        if (requestBody.getType() != null) {
-            if(requestBody.getProcessorData() != null){
+            String status;
-                processRequest(new XmlJob(response, requestBody, xmlJobType));
+            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;
             }
-            System.out.println("getProcessor=null");
+
+            XMLResponseBody responseBody = new XMLResponseBody(status);
+            response.body(this.gson.toJson(responseBody));
+            return;
+        }
+
+        if (requestBody.getProcessor() == null) {
             invalidEngineSelectedResponse(response);
             return;
         }
@@ -103,9 +126,9 @@ public class XmlController implements RestController {
             responseBody.setDuration(duration);
 
             xmlJob.getResponse().status(200);
-           /* this.logger.info("Request (" + xmlJob.getXmlJobType() + ", " +
+            this.logger.info("Request (" + xmlJob.getXmlJobType() + ", " +
                     xmlJob.getEngine().getVersion() +
-                    ") processed in " + duration + " ms.");*/
+                    ") processed in " + duration + " ms.");
 
         } catch (Exception ex) {
             responseBody = processingErrorResponse(ex, xmlJob);
@@ -140,13 +163,6 @@ public class XmlController implements RestController {
 
         String result = null;
         switch (xmlJob.getXmlJobType()) {
-            case XSLT_PARAM:
-                System.out.println("xstl_param");
-                System.out.println(requestBody.getProcessorData());
-                System.out.println(requestBody.getParamName());
-                System.out.println(requestBody.getParamValue());
-                result = addParam(requestBody.getProcessorData(), requestBody.getParamName(), requestBody.getParamValue());
-                break;
             case XSLT:
                 result = engine.processXSLT(requestBody.getData(), requestBody.getProcessorData());
                 break;
@@ -159,17 +175,9 @@ public class XmlController implements RestController {
                         requestBody.getVersion());
                 break;
         }
-        System.out.println("can we get here?");
         return new XMLResponseBody(result, "OK", requestBody.getProcessorData());
     }
 
-    private String addParam(String processorData, String paramName, String paramValue) {
-        System.out.println("addParamSaxon");
-        processorData= processorData.replace("<xsl:template match=\"/\">", "<xsl:param name=\""+paramName+"\" select=\"'"+paramValue+"'\"/>\n\t\t<xsl:template match=\"/\">");
-        StringWriter sw = new StringWriter();
-        sw.write(processorData);
-        return sw.toString();
-    }
 
     private XMLResponseBody processingErrorResponse(Exception ex, XmlJob xmlJob) {
         XmlEngine engine = xmlJob.getEngine();
@@ -191,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/model/XMLResponseBody.java

@@ -10,6 +10,10 @@ public class XMLResponseBody {
     // Optional
     private String type;
 
+    public XMLResponseBody(String status){
+        this.status = status;
+    }
+
     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;
+    }
+}

Frontend/src/components/XsltParamComponent.vue

@@ -2,106 +2,125 @@
 import {ref} from 'vue'
 
 const emit = defineEmits<{
-  (event: 'update-value', value: string): void;
+  (event: 'update-value', options: { name: string }[]): void;
 }>();
 
-const props = defineProps({
+const options = ref<{ name: string }[]>([
-  xslt: {type: String, required: true}
+  { name: "Add Param" }
-})
+]);
 
-
+const sendToParent = () => {
-const sendToParent = (xslt: string) => {
+  options.value.forEach((value) => {console.log("KID" + value + options.value.indexOf(value))})
-  emit('update-value', xslt);
+  emit('update-value', options.value);
 };
+
+
 const nameInput = ref('')
 const valueInput = ref('')
 
-const options = ref<{ name: string }[]>([
-  { name: "Add Param" },
-  { name: "Set Param" },
-]);
-
-const selectedOption = ref(options.value[0].name);
 
+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("addParam");
+      sendRequest("add");
     }
     else {
-    sendRequest("setParam")
+      sendRequest("remove");
       }
-};
+  */
+}
+
+/*
 const sendRequest = (type:string) => {
   console.log(type)
   let request: Request = prepareRequest(type)
   fetchRequest(request).then((body) => {
-    const result = (body as any).result;
+
-    sendToParent(result);
+    const {status} = body as any;
+    console.log(status)
+    if (status === "OK") {
+      options.value.push({ name: nameInput.value + " = " + valueInput.value });
+    }
   });
 }
-
+*/
-function prepareRequest(type :string): Request {
+function selectOption(option: string): string {
-  let request = new Request(prepareURL(), {
+  return option == "Add Param" ? "Add Param" : "Remove Param"
-    body: prepareRequestBody(type),
-    method: "POST"
-  });
-  return request
 }
 
-function prepareURL(): string {
+//
-  //const engineEndpoint = engine.value == "libxml" ? "libxml" : "java";
+// function prepareRequest(type :string): Request {
-  return document.location.protocol + "//" + document.location.hostname + "/" + "java" + "/xslt/param";
+//   let request = new Request(prepareURL(), {
-  //return "http://localhost:8081/xslt/param";
+//     body: prepareRequestBody(type),
-}
+//     method: "POST"
-
+//   });
-function prepareRequestBody(type: string): string {
+//   return request
-  let requestBody = JSON.stringify({
+// }
-    "processorData": props.xslt,
+//
-    "paramName": nameInput.value,
+// function prepareURL(): string {
-    "paramValue": valueInput.value,
+//   //const engineEndpoint = engine.value == "libxml" ? "libxml" : "java";
-    "type": type
+//   return document.location.protocol + "//" + document.location.hostname + "/" + "java" + "/xslt/param";
-  });
+//   //return "http://localhost:8081/xslt/param";
-  console.log(requestBody);
+// }
-  return requestBody;
+//
-}
+// function prepareRequestBody(type: string): string {
-
+//   let requestBody = JSON.stringify({
-async function fetchRequest(request: Request): Promise<JSON> {
+//     "paramName": nameInput.value,
-  console.log(request)
+//     "paramValue": valueInput.value,
-  let responseBody = await fetch(request)
+//     "type": type
-  return await responseBody.json()
+//   });
-     // .then(response => response.json())
+//   console.log(requestBody);
-   //   .then((body) => body)
+//   return requestBody;
-  //console.log(responseBody);
+// }
-  //return responseBody
+//
-}
+// 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="px-3 rounded-full border border-slate-400 bg-white dark:text-slate-100 dark:bg-gray-600 w-1/3"
+      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 px-3 rounded-full border border-slate-400 bg-white dark:text-slate-100 dark:bg-gray-600 w-1/3"
+      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 px-3 rounded-full border border-slate-400 bg-white dark:text-slate-100 dark:bg-gray-600 w-1/3"
+      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">{{selectedOption}}</button>
+  <button class="tool-button" @click="selectedFunction">{{ selectOption(selectedOption) }}</button>
 </template>
 

Frontend/src/components/xml/XmlInputFieldComponent.vue

@@ -6,21 +6,26 @@ import XsltParamComponent from '@/components/XsltParamComponent.vue'
 
 import {ref} from 'vue'
 
-const props = defineProps(
+const props = defineProps<{
-    {
+  stylizedName: string;
-      stylizedName: {type: String, required: true},
+  data?: string;
-      data: {type: String},
+  params?: { name: string }[];
-    }
+}>();
-)
+
-const emit = defineEmits(['update:modelValue'])
+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
@@ -54,8 +59,12 @@ function readFile(file: any) {
   }
   reader.readAsText(file.target.files[0])
 }
-const handleUpdateValue = (value: string) => {data.value = value};
 
+const handleUpdateValue = (options: { name: string }[]) => {
+  console.log("from parent" +options.length)
+  params.value = options
+  updateParams(params)
+};
 
 </script>
 
@@ -78,10 +87,8 @@ const handleUpdateValue = (value: string) => {data.value = value};
       </div>
     </div>
 
-    <div class="flex place-content-between w-full items-center">
+    <div class="flex justify-end gap-2 place-content-between w-full items-center">
-      <div v-if="addParameters()" class="flex justify-end space-x-2 pb-2 overflow-x-auto ml-auto">
+        <XsltParamComponent v-if="addParameters()" @update-value="handleUpdateValue" :xslt="data"/>
-        <XsltParamComponent @update-value="handleUpdateValue" :xslt="data"/>
-      </div>
     </div>
 
     <CodeEditor @update:updated-code="updateData" v-model="data" :code="data" :config="{disabled:false, language:stylizedName}"></CodeEditor>

Frontend/src/components/xml/XmlOutputFieldComponent.vue

@@ -1,15 +1,14 @@
 <script setup lang="ts">
-import { onMounted, ref } from 'vue';
+import {onMounted, ref} from 'vue';
-import { type TabData } from '../common/TabData'
+import {type TabData} from '../common/TabData'
 import CodeEditor from '@/components/common/CodeEditorComponent.vue';
 
-const props = defineProps(
+const props = defineProps<{
-    {
+  tool: string;
-        tool: {type: String, required: true},
+  xml: string | TabData[];
-        xml: {type: [String, Array<TabData>], required: true},
+  query: string;
-        query: {type: String, required: true}
+  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;
 }