From c8faaed2e54f52da9d1374e6161632dd620511bf Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 08:59:24 +0200 Subject: [PATCH 01/15] Added new controller --- .../r11/tools/controller/XmlController.java | 94 +++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java new file mode 100644 index 0000000..b5ba958 --- /dev/null +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -0,0 +1,94 @@ +package com.r11.tools.controller; + +import com.google.gson.Gson; +import com.r11.tools.controller.internal.HandlerType; +import com.r11.tools.controller.internal.ScopedControllerManifest; +import com.r11.tools.model.XMLRequestBody; +import com.r11.tools.model.XMLResponseBody; +import com.r11.tools.model.XPathQueryResult; +import com.r11.tools.xml.XmlEngine; +import org.apache.logging.log4j.Logger; +import spark.Request; +import spark.Response; + +public class XmlController { + + private final Gson gson; + private final Logger logger; + + private final XmlEngine saxon; + private final XmlEngine xalan; + + public XmlController(Gson gson, Logger logger, XmlEngine saxon, XmlEngine xalan) { + this.gson = gson; + this.logger = logger; + this.saxon = saxon; + this.xalan = xalan; + } + + private XMLResponseBody errorResponse(String message, String processor) { + return new XMLResponseBody(message, "ERR", processor, -1); + } + + private void nonValidEngineSelectedResponse(Response response) { + XMLResponseBody responseBody = + errorResponse("Valid engines are: saxon, xalan", "N/A"); + response.body(this.gson.toJson(responseBody)); + response.status(400); + } + + @ScopedControllerManifest(method = HandlerType.POST, path = "/xpath") + public void acceptRequest(Request request, Response response) { + XMLRequestBody requestBody; + try { + requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); + } catch (Exception e) { + XMLResponseBody responseBody = errorResponse(e.getMessage(), "N/A"); + response.status(400); + response.body(this.gson.toJson(responseBody)); + return; + } + + if (requestBody.getProcessor() == null) { + nonValidEngineSelectedResponse(response); + return; + } + + switch (requestBody.getProcessor()) { + case "saxon": + process(response, requestBody, saxon); + break; + case "xalan": + process(response, requestBody, xalan); + break; + default: + nonValidEngineSelectedResponse(response); + } + } + + private void process(Response response, XMLRequestBody requestBody, XmlEngine engine) { + long timeStart = System.currentTimeMillis(); + XMLResponseBody responseBody = null; + try { + XPathQueryResult xPathQueryResult = + engine.processXPath(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); + + response.status(200); + long duration = System.currentTimeMillis() - timeStart; + responseBody = new XMLResponseBody(xPathQueryResult.getData().trim(), + "OK", engine.getVersion(),duration); + + responseBody.setType(xPathQueryResult.getType()); + this.logger.info("Request (XPath, " + engine.getVersion() + ") processed in " + duration + " ms."); + } catch (Exception ex) { + responseBody = errorResponse(ex.getMessage(), engine.getVersion()); + response.status(400); + + this.logger.error("Error on processing XPath using " + engine.getVersion() + ". " + ex); + } finally { + response.body(this.gson.toJson(responseBody)); + } + + } + +} -- 2.51.0 From 75d8c69628e5b1db9daee1a71786bfdf5e354f8d Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 09:01:47 +0200 Subject: [PATCH 02/15] Marked old controllers as deprecated --- .../main/java/com/r11/tools/controller/XPathController.java | 1 + .../main/java/com/r11/tools/controller/XQueryController.java | 1 + .../src/main/java/com/r11/tools/controller/XmlController.java | 4 ++++ .../src/main/java/com/r11/tools/controller/XsdController.java | 1 + .../main/java/com/r11/tools/controller/XsltController.java | 1 + 5 files changed, 8 insertions(+) diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XPathController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XPathController.java index dbf3840..aabd6a7 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XPathController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XPathController.java @@ -11,6 +11,7 @@ import spark.Request; import spark.Response; @GlobalControllerManifest +@Deprecated public class XPathController implements RestController { private final Gson gson; diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XQueryController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XQueryController.java index 59bec6a..8254f61 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XQueryController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XQueryController.java @@ -14,6 +14,7 @@ import spark.Response; * @author Adam Bem */ @GlobalControllerManifest +@Deprecated public class XQueryController implements RestController { private final Gson gson; diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index b5ba958..20033fe 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -11,6 +11,10 @@ import org.apache.logging.log4j.Logger; import spark.Request; import spark.Response; +/** + * Controller used to handle XML tools: XPath, XSD validation, XQuery and XSLT + * @author Adam Bem + */ public class XmlController { private final Gson gson; diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XsdController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XsdController.java index 294c6dc..b53db9f 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XsdController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XsdController.java @@ -10,6 +10,7 @@ import spark.Request; import spark.Response; @GlobalControllerManifest +@Deprecated public class XsdController implements RestController { private final Gson gson; diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XsltController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XsltController.java index a2b7e95..ef7316f 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XsltController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XsltController.java @@ -10,6 +10,7 @@ import spark.Request; import spark.Response; @GlobalControllerManifest +@Deprecated public class XsltController implements RestController { private final Gson gson; -- 2.51.0 From 71e17113d1f7199bac4a27231f7e91d460444bf9 Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 09:17:40 +0200 Subject: [PATCH 03/15] Merged XPath and XQuery controllers --- .../java/com/r11/tools/SparkApplication.java | 5 +- .../r11/tools/controller/XmlController.java | 68 ++++++++++++++++--- 2 files changed, 62 insertions(+), 11 deletions(-) diff --git a/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java b/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java index 4908e9b..d17b867 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java @@ -41,11 +41,12 @@ public class SparkApplication { RestControllerRegistry registry = new RestControllerRegistry(); registry.registerController(new ProcessorInfoController(logger, saxon, xalan)); registry.registerController(new XsdController(gson, logger, xalan)); - registry.registerController(new XPathController(gson, logger, saxon, xalan)); + registry.registerController(new XmlController(gson, logger, saxon, xalan)); registry.registerController(new XsltController(gson, logger, saxon, xalan)); registry.registerController(new JsonController(gson, jsongson, logger)); - registry.registerController(new XQueryController(gson, logger, saxon)); + //registry.registerController(new XQueryController(gson, logger, saxon)); + //registry.registerController(new XPathController(gson, logger, saxon, xalan)); registry.register(); logger.info("Server is online at port: " + Spark.port()); diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index 20033fe..3ce2ade 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -1,7 +1,9 @@ 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.model.XMLRequestBody; import com.r11.tools.model.XMLResponseBody; @@ -15,7 +17,8 @@ import spark.Response; * Controller used to handle XML tools: XPath, XSD validation, XQuery and XSLT * @author Adam Bem */ -public class XmlController { +@GlobalControllerManifest +public class XmlController implements RestController { private final Gson gson; private final Logger logger; @@ -30,24 +33,24 @@ public class XmlController { this.xalan = xalan; } - private XMLResponseBody errorResponse(String message, String processor) { + private XMLResponseBody prepareErrorResponse(String message, String processor) { return new XMLResponseBody(message, "ERR", processor, -1); } private void nonValidEngineSelectedResponse(Response response) { XMLResponseBody responseBody = - errorResponse("Valid engines are: saxon, xalan", "N/A"); + prepareErrorResponse("Valid engines are: saxon, xalan", "N/A"); response.body(this.gson.toJson(responseBody)); response.status(400); } @ScopedControllerManifest(method = HandlerType.POST, path = "/xpath") - public void acceptRequest(Request request, Response response) { + public void acceptRequestXPath(Request request, Response response) { XMLRequestBody requestBody; try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); } catch (Exception e) { - XMLResponseBody responseBody = errorResponse(e.getMessage(), "N/A"); + XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); response.status(400); response.body(this.gson.toJson(responseBody)); return; @@ -60,17 +63,17 @@ public class XmlController { switch (requestBody.getProcessor()) { case "saxon": - process(response, requestBody, saxon); + processXPath(response, requestBody, saxon); break; case "xalan": - process(response, requestBody, xalan); + processXPath(response, requestBody, xalan); break; default: nonValidEngineSelectedResponse(response); } } - private void process(Response response, XMLRequestBody requestBody, XmlEngine engine) { + private void processXPath(Response response, XMLRequestBody requestBody, XmlEngine engine) { long timeStart = System.currentTimeMillis(); XMLResponseBody responseBody = null; try { @@ -85,7 +88,7 @@ public class XmlController { responseBody.setType(xPathQueryResult.getType()); this.logger.info("Request (XPath, " + engine.getVersion() + ") processed in " + duration + " ms."); } catch (Exception ex) { - responseBody = errorResponse(ex.getMessage(), engine.getVersion()); + responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); response.status(400); this.logger.error("Error on processing XPath using " + engine.getVersion() + ". " + ex); @@ -95,4 +98,51 @@ public class XmlController { } + @ScopedControllerManifest(method = HandlerType.POST, path = "/xquery") + public void acceptRequestXQuery(Request request, Response response) { + XMLRequestBody requestBody; + try { + requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); + } catch (Exception e) { + XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); + + response.status(400); + response.body(this.gson.toJson(responseBody)); + return; + } + if (requestBody.getProcessor() == null) { + nonValidEngineSelectedResponse(response); + return; + } + + if (requestBody.getProcessor().equalsIgnoreCase("saxon")) + processXQuery(response, requestBody, saxon); + else + nonValidEngineSelectedResponse(response); + } + + private void processXQuery(Response response, XMLRequestBody requestBody, XmlEngine engine) { + XMLResponseBody responseBody = null; + long timeStart = System.currentTimeMillis(); + try { + String result = engine.executeXQuery(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); + + response.status(200); + + long duration = System.currentTimeMillis() - timeStart; + responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); + + this.logger.info("Request (XQuery, " + engine.getVersion() + ") processed in " + duration + " ms."); + } catch (Exception ex) { + response.status(400); + responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); + + this.logger.error("Error on processing XQuery using " + engine.getVersion() + ". " + ex); + } + finally { + response.body(this.gson.toJson(responseBody)); + } + + } + } -- 2.51.0 From 0cfe4436beb8183cf7641ec1d83f6c502797c16f Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 09:24:09 +0200 Subject: [PATCH 04/15] Merged XSD controller --- .../r11/tools/controller/XmlController.java | 68 ++++++++++++++++--- 1 file changed, 59 insertions(+), 9 deletions(-) diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index 3ce2ade..69b5a0f 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -33,16 +33,7 @@ public class XmlController implements RestController { this.xalan = xalan; } - private XMLResponseBody prepareErrorResponse(String message, String processor) { - return new XMLResponseBody(message, "ERR", processor, -1); - } - private void nonValidEngineSelectedResponse(Response response) { - XMLResponseBody responseBody = - prepareErrorResponse("Valid engines are: saxon, xalan", "N/A"); - response.body(this.gson.toJson(responseBody)); - response.status(400); - } @ScopedControllerManifest(method = HandlerType.POST, path = "/xpath") public void acceptRequestXPath(Request request, Response response) { @@ -142,7 +133,66 @@ public class XmlController implements RestController { finally { response.body(this.gson.toJson(responseBody)); } + } + + @ScopedControllerManifest(method = HandlerType.POST, path = "/xsd") + public void acceptRequestXsd(Request request, Response response) { + XMLRequestBody requestBody; + try { + requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); + } catch (Exception e) { + XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); + + response.status(400); + response.body(this.gson.toJson(responseBody)); + return; + } + + if (requestBody.getProcessor() == null) { + nonValidEngineSelectedResponse(response); + return; + } + if (requestBody.getProcessor().equalsIgnoreCase("xalan")) + processXsd(response, requestBody, xalan); + else + nonValidEngineSelectedResponse(response); } + private void processXsd(Response response, XMLRequestBody requestBody, XmlEngine engine) { + XMLResponseBody responseBody = null; + try { + long timeStart = System.currentTimeMillis(); + String result = engine.validate(requestBody.getData(), requestBody.getProcess()).trim(); + + response.status(200); + + long duration = System.currentTimeMillis() - timeStart; + responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); + + this.logger.info("Request (XSD, " + engine.getVersion() + ") processed in " + duration + " ms."); + } catch (Exception ex) { + responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); + response.status(400); + + this.logger.error("Error on validation against XSD using " + engine.getVersion() + ". " + ex); + } + finally { + response.body(this.gson.toJson(responseBody)); + } + + + } + + private XMLResponseBody prepareErrorResponse(String message, String processor) { + return new XMLResponseBody(message, "ERR", processor, -1); + } + + private void nonValidEngineSelectedResponse(Response response) { + XMLResponseBody responseBody = + prepareErrorResponse("Valid engines are: saxon, xalan", "N/A"); + response.body(this.gson.toJson(responseBody)); + response.status(400); + } + } -- 2.51.0 From 5e4d8b51f342bd565aa9c2fb26c7a1d53d55aaf4 Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 09:31:06 +0200 Subject: [PATCH 05/15] Merged XSLT controller --- .../java/com/r11/tools/SparkApplication.java | 5 +- .../r11/tools/controller/XmlController.java | 54 +++++++++++++++++++ 2 files changed, 57 insertions(+), 2 deletions(-) diff --git a/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java b/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java index d17b867..35b38ae 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java @@ -40,11 +40,12 @@ public class SparkApplication { RestControllerRegistry registry = new RestControllerRegistry(); registry.registerController(new ProcessorInfoController(logger, saxon, xalan)); - registry.registerController(new XsdController(gson, logger, xalan)); + registry.registerController(new XmlController(gson, logger, saxon, xalan)); - registry.registerController(new XsltController(gson, logger, saxon, xalan)); registry.registerController(new JsonController(gson, jsongson, logger)); + //registry.registerController(new XsltController(gson, logger, saxon, xalan)); + //registry.registerController(new XsdController(gson, logger, xalan)); //registry.registerController(new XQueryController(gson, logger, saxon)); //registry.registerController(new XPathController(gson, logger, saxon, xalan)); registry.register(); diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index 69b5a0f..28503cb 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -184,6 +184,60 @@ public class XmlController implements RestController { } + @ScopedControllerManifest(method = HandlerType.POST, path = "/xslt") + public void acceptRequestXslt(Request request, Response response) { + XMLRequestBody requestBody; + try { + requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); + } catch (Exception e) { + XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); + + response.status(400); + response.body(this.gson.toJson(responseBody)); + return; + } + + if (requestBody.getProcessor() == null) { + nonValidEngineSelectedResponse(response); + return; + } + + switch (requestBody.getProcessor()) { + case "saxon": + processXslt(response, requestBody, saxon); + return; + + case "xalan": + processXslt(response, requestBody, xalan); + return; + + default: + nonValidEngineSelectedResponse(response); + } + } + + private void processXslt(Response response, XMLRequestBody requestBody, XmlEngine engine) { + XMLResponseBody responseBody = null; + long timeStart = System.currentTimeMillis(); + try { + String result = engine.processXSLT(requestBody.getData(), requestBody.getProcess()); + response.status(200); + + long duration = System.currentTimeMillis() - timeStart; + responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); + + this.logger.info("Request (XSLT, " + engine.getVersion() + ") processed in " + duration + " ms."); + } catch (Exception ex) { + responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); + response.status(400); + this.logger.error("Error on processing XSLT using " + engine.getVersion() + ". " + ex); + + } finally { + response.body(this.gson.toJson(responseBody)); + } + + } + private XMLResponseBody prepareErrorResponse(String message, String processor) { return new XMLResponseBody(message, "ERR", processor, -1); } -- 2.51.0 From 199c9f82b3fb657ee97ad8df203853b1e4d3d009 Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 10:03:13 +0200 Subject: [PATCH 06/15] Merged XPath and XSLT process methods --- .../r11/tools/controller/XmlController.java | 81 ++++++++++--------- .../tools/controller/internal/XmlJobType.java | 8 ++ 2 files changed, 51 insertions(+), 38 deletions(-) create mode 100644 Backend/tools-services/src/main/java/com/r11/tools/controller/internal/XmlJobType.java diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index 28503cb..298f3e1 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -1,10 +1,7 @@ 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.*; import com.r11.tools.model.XMLRequestBody; import com.r11.tools.model.XMLResponseBody; import com.r11.tools.model.XPathQueryResult; @@ -54,40 +51,34 @@ public class XmlController implements RestController { switch (requestBody.getProcessor()) { case "saxon": - processXPath(response, requestBody, saxon); + process(response, requestBody, saxon, XmlJobType.XPath); break; case "xalan": - processXPath(response, requestBody, xalan); + process(response, requestBody, xalan, XmlJobType.XPath); break; default: nonValidEngineSelectedResponse(response); } } - private void processXPath(Response response, XMLRequestBody requestBody, XmlEngine engine) { - long timeStart = System.currentTimeMillis(); - XMLResponseBody responseBody = null; - try { - XPathQueryResult xPathQueryResult = - engine.processXPath(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); - - response.status(200); - long duration = System.currentTimeMillis() - timeStart; - responseBody = new XMLResponseBody(xPathQueryResult.getData().trim(), - "OK", engine.getVersion(),duration); - - responseBody.setType(xPathQueryResult.getType()); - this.logger.info("Request (XPath, " + engine.getVersion() + ") processed in " + duration + " ms."); - } catch (Exception ex) { - responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); - response.status(400); - - this.logger.error("Error on processing XPath using " + engine.getVersion() + ". " + ex); - } finally { - response.body(this.gson.toJson(responseBody)); - } - - } +// private void processXPath(Response response, XMLRequestBody requestBody, XmlEngine engine) { +// long timeStart = System.currentTimeMillis(); +// XMLResponseBody responseBody = null; +// try { +// +// +// +// this.logger.info("Request (XPath, " + engine.getVersion() + ") processed in " + duration + " ms."); +// } catch (Exception ex) { +// responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); +// response.status(400); +// +// this.logger.error("Error on processing XPath using " + engine.getVersion() + ". " + ex); +// } finally { +// response.body(this.gson.toJson(responseBody)); +// } +// +// } @ScopedControllerManifest(method = HandlerType.POST, path = "/xquery") public void acceptRequestXQuery(Request request, Response response) { @@ -204,11 +195,11 @@ public class XmlController implements RestController { switch (requestBody.getProcessor()) { case "saxon": - processXslt(response, requestBody, saxon); + process(response, requestBody, saxon, XmlJobType.XSLT); return; case "xalan": - processXslt(response, requestBody, xalan); + process(response, requestBody, xalan, XmlJobType.XSLT); return; default: @@ -216,21 +207,35 @@ public class XmlController implements RestController { } } - private void processXslt(Response response, XMLRequestBody requestBody, XmlEngine engine) { + private void process(Response response, XMLRequestBody requestBody, XmlEngine engine, XmlJobType xmlJobType) { XMLResponseBody responseBody = null; long timeStart = System.currentTimeMillis(); + long duration; try { - String result = engine.processXSLT(requestBody.getData(), requestBody.getProcess()); + if (xmlJobType == XmlJobType.XPath) { + XPathQueryResult xPathQueryResult = + engine.processXPath(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); + + duration = System.currentTimeMillis() - timeStart; + responseBody = new XMLResponseBody(xPathQueryResult.getData().trim(), + "OK", engine.getVersion(), duration); + responseBody.setType(xPathQueryResult.getType()); + } + else { + String result = engine.processXSLT(requestBody.getData(), requestBody.getProcess()); + + + duration = System.currentTimeMillis() - timeStart; + responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); + } response.status(200); - long duration = System.currentTimeMillis() - timeStart; - responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); - this.logger.info("Request (XSLT, " + engine.getVersion() + ") processed in " + duration + " ms."); + this.logger.info("Request (" + xmlJobType + ", " + engine.getVersion() + ") processed in " + duration + " ms."); } catch (Exception ex) { responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); response.status(400); - this.logger.error("Error on processing XSLT using " + engine.getVersion() + ". " + ex); + this.logger.error("Error on processing " + xmlJobType + " using " + engine.getVersion() + ". " + ex); } finally { response.body(this.gson.toJson(responseBody)); diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/internal/XmlJobType.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/internal/XmlJobType.java new file mode 100644 index 0000000..0967e42 --- /dev/null +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/internal/XmlJobType.java @@ -0,0 +1,8 @@ +package com.r11.tools.controller.internal; + +public enum XmlJobType { + XPath("XPath"), XSD("XSD"), XQuery("XQuery"), XSLT("XSLT"); + + XmlJobType(String type) { + } +} -- 2.51.0 From 8d19f67b1b9c10484a4ede8026d411780d6bbf54 Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 10:47:25 +0200 Subject: [PATCH 07/15] Merged all process methods --- .../r11/tools/controller/XmlController.java | 172 +++++++----------- .../com/r11/tools/model/XMLResponseBody.java | 5 + 2 files changed, 74 insertions(+), 103 deletions(-) diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index 298f3e1..7e9efa8 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -38,14 +38,14 @@ public class XmlController implements RestController { try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); + XMLResponseBody responseBody = prepareErrorResponseBody(e.getMessage(), "N/A"); response.status(400); response.body(this.gson.toJson(responseBody)); return; } if (requestBody.getProcessor() == null) { - nonValidEngineSelectedResponse(response); + invalidEngineSelectedResponse(response); return; } @@ -57,73 +57,31 @@ public class XmlController implements RestController { process(response, requestBody, xalan, XmlJobType.XPath); break; default: - nonValidEngineSelectedResponse(response); + invalidEngineSelectedResponse(response); } } -// private void processXPath(Response response, XMLRequestBody requestBody, XmlEngine engine) { -// long timeStart = System.currentTimeMillis(); -// XMLResponseBody responseBody = null; -// try { -// -// -// -// this.logger.info("Request (XPath, " + engine.getVersion() + ") processed in " + duration + " ms."); -// } catch (Exception ex) { -// responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); -// response.status(400); -// -// this.logger.error("Error on processing XPath using " + engine.getVersion() + ". " + ex); -// } finally { -// response.body(this.gson.toJson(responseBody)); -// } -// -// } - @ScopedControllerManifest(method = HandlerType.POST, path = "/xquery") public void acceptRequestXQuery(Request request, Response response) { XMLRequestBody requestBody; try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); + XMLResponseBody responseBody = prepareErrorResponseBody(e.getMessage(), "N/A"); response.status(400); response.body(this.gson.toJson(responseBody)); return; } if (requestBody.getProcessor() == null) { - nonValidEngineSelectedResponse(response); + invalidEngineSelectedResponse(response); return; } if (requestBody.getProcessor().equalsIgnoreCase("saxon")) - processXQuery(response, requestBody, saxon); + process(response, requestBody, saxon, XmlJobType.XQuery); else - nonValidEngineSelectedResponse(response); - } - - private void processXQuery(Response response, XMLRequestBody requestBody, XmlEngine engine) { - XMLResponseBody responseBody = null; - long timeStart = System.currentTimeMillis(); - try { - String result = engine.executeXQuery(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); - - response.status(200); - - long duration = System.currentTimeMillis() - timeStart; - responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); - - this.logger.info("Request (XQuery, " + engine.getVersion() + ") processed in " + duration + " ms."); - } catch (Exception ex) { - response.status(400); - responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); - - this.logger.error("Error on processing XQuery using " + engine.getVersion() + ". " + ex); - } - finally { - response.body(this.gson.toJson(responseBody)); - } + invalidEngineSelectedResponse(response); } @ScopedControllerManifest(method = HandlerType.POST, path = "/xsd") @@ -132,7 +90,7 @@ public class XmlController implements RestController { try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); + XMLResponseBody responseBody = prepareErrorResponseBody(e.getMessage(), "N/A"); response.status(400); response.body(this.gson.toJson(responseBody)); @@ -140,38 +98,13 @@ public class XmlController implements RestController { } if (requestBody.getProcessor() == null) { - nonValidEngineSelectedResponse(response); + invalidEngineSelectedResponse(response); return; } if (requestBody.getProcessor().equalsIgnoreCase("xalan")) - processXsd(response, requestBody, xalan); + process(response, requestBody, xalan, XmlJobType.XSD); else - nonValidEngineSelectedResponse(response); - - } - - private void processXsd(Response response, XMLRequestBody requestBody, XmlEngine engine) { - XMLResponseBody responseBody = null; - try { - long timeStart = System.currentTimeMillis(); - String result = engine.validate(requestBody.getData(), requestBody.getProcess()).trim(); - - response.status(200); - - long duration = System.currentTimeMillis() - timeStart; - responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); - - this.logger.info("Request (XSD, " + engine.getVersion() + ") processed in " + duration + " ms."); - } catch (Exception ex) { - responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); - response.status(400); - - this.logger.error("Error on validation against XSD using " + engine.getVersion() + ". " + ex); - } - finally { - response.body(this.gson.toJson(responseBody)); - } - + invalidEngineSelectedResponse(response); } @@ -181,7 +114,7 @@ public class XmlController implements RestController { try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); + XMLResponseBody responseBody = prepareErrorResponseBody(e.getMessage(), "N/A"); response.status(400); response.body(this.gson.toJson(responseBody)); @@ -189,7 +122,7 @@ public class XmlController implements RestController { } if (requestBody.getProcessor() == null) { - nonValidEngineSelectedResponse(response); + invalidEngineSelectedResponse(response); return; } @@ -203,7 +136,7 @@ public class XmlController implements RestController { return; default: - nonValidEngineSelectedResponse(response); + invalidEngineSelectedResponse(response); } } @@ -211,31 +144,18 @@ public class XmlController implements RestController { XMLResponseBody responseBody = null; long timeStart = System.currentTimeMillis(); long duration; + try { - if (xmlJobType == XmlJobType.XPath) { - XPathQueryResult xPathQueryResult = - engine.processXPath(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); + responseBody = selectProcessMethod(response, requestBody, engine, xmlJobType); - duration = System.currentTimeMillis() - timeStart; - responseBody = new XMLResponseBody(xPathQueryResult.getData().trim(), - "OK", engine.getVersion(), duration); - responseBody.setType(xPathQueryResult.getType()); - } - else { - String result = engine.processXSLT(requestBody.getData(), requestBody.getProcess()); + duration = System.currentTimeMillis() - timeStart; + responseBody.setDuration(duration); - - duration = System.currentTimeMillis() - timeStart; - responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); - } response.status(200); - this.logger.info("Request (" + xmlJobType + ", " + engine.getVersion() + ") processed in " + duration + " ms."); } catch (Exception ex) { - responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); - response.status(400); - this.logger.error("Error on processing " + xmlJobType + " using " + engine.getVersion() + ". " + ex); + responseBody = processingErrorResponse(response, ex, engine, xmlJobType); } finally { response.body(this.gson.toJson(responseBody)); @@ -243,15 +163,61 @@ public class XmlController implements RestController { } - private XMLResponseBody prepareErrorResponse(String message, String processor) { - return new XMLResponseBody(message, "ERR", processor, -1); + private XMLResponseBody selectProcessMethod(Response response, XMLRequestBody requestBody, XmlEngine engine, XmlJobType xmlJobType) throws Exception { + if (xmlJobType == XmlJobType.XPath) + return processXPath(response, requestBody, engine, xmlJobType); + else + return processOther(response, requestBody, engine, xmlJobType); } - private void nonValidEngineSelectedResponse(Response response) { + private XMLResponseBody processXPath(Response response, XMLRequestBody requestBody, XmlEngine engine, XmlJobType xmlJobType) throws Exception { + XPathQueryResult xPathQueryResult = + engine.processXPath(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); + + XMLResponseBody responseBody = new XMLResponseBody(xPathQueryResult.getData().trim(), + "OK", engine.getVersion()); + responseBody.setType(xPathQueryResult.getType()); + + return responseBody; + } + + private XMLResponseBody processOther(Response response, XMLRequestBody requestBody, XmlEngine engine, XmlJobType xmlJobType) throws Exception { + String result = null; + switch (xmlJobType) { + case XSLT: + result = engine.processXSLT(requestBody.getData(), requestBody.getProcess()); + break; + case XSD: + result = engine.validate(requestBody.getData(), requestBody.getProcess()).trim(); + break; + case XQuery: + result = engine.executeXQuery(requestBody.getData(), + requestBody.getProcess(), + requestBody.getVersion()); + break; + } + return new XMLResponseBody(result, "OK", engine.getVersion()); + } + + private XMLResponseBody processingErrorResponse(Response response, Exception ex, XmlEngine engine, XmlJobType xmlJobType) { + XMLResponseBody responseBody = prepareErrorResponseBody(ex.getMessage(), engine.getVersion()); + response.status(400); + this.logger.error("Error on processing " + xmlJobType + " using " + engine.getVersion() + ". " + ex); + return responseBody; + } + + private void invalidEngineSelectedResponse(Response response) { XMLResponseBody responseBody = - prepareErrorResponse("Valid engines are: saxon, xalan", "N/A"); + prepareErrorResponseBody("Valid engines are: saxon, xalan", "N/A"); response.body(this.gson.toJson(responseBody)); response.status(400); } + private void requestErrorResponse(Response response) { + + } + + private XMLResponseBody prepareErrorResponseBody(String message, String processor) { + return new XMLResponseBody(message, "ERR", processor, -1); + } } diff --git a/Backend/tools-services/src/main/java/com/r11/tools/model/XMLResponseBody.java b/Backend/tools-services/src/main/java/com/r11/tools/model/XMLResponseBody.java index 42e52c1..01fb9c2 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/model/XMLResponseBody.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/model/XMLResponseBody.java @@ -10,6 +10,11 @@ public class XMLResponseBody { // Optional private String type; + public XMLResponseBody(String result, String status, String processor) { + this.result = result; + this.status = status; + this.processor = processor; + } public XMLResponseBody(String result, String status, String processor, long duration) { this.result = result; this.status = status; -- 2.51.0 From a02e0f46babc5ac10401e87a0452d3b634091bfd Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 10:55:17 +0200 Subject: [PATCH 08/15] Minor corretions --- .../r11/tools/controller/XmlController.java | 31 +++++++------------ .../main/java/com/r11/tools/xml/Saxon.java | 6 ++-- 2 files changed, 14 insertions(+), 23 deletions(-) diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index 7e9efa8..39830df 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -37,10 +37,8 @@ public class XmlController implements RestController { XMLRequestBody requestBody; try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); - } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponseBody(e.getMessage(), "N/A"); - response.status(400); - response.body(this.gson.toJson(responseBody)); + } catch (Exception ex) { + requestErrorResponse(response, ex); return; } @@ -66,11 +64,8 @@ public class XmlController implements RestController { XMLRequestBody requestBody; try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); - } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponseBody(e.getMessage(), "N/A"); - - response.status(400); - response.body(this.gson.toJson(responseBody)); + } catch (Exception ex) { + requestErrorResponse(response, ex); return; } if (requestBody.getProcessor() == null) { @@ -89,11 +84,8 @@ public class XmlController implements RestController { XMLRequestBody requestBody; try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); - } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponseBody(e.getMessage(), "N/A"); - - response.status(400); - response.body(this.gson.toJson(responseBody)); + } catch (Exception ex) { + requestErrorResponse(response, ex); return; } @@ -114,10 +106,7 @@ public class XmlController implements RestController { try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponseBody(e.getMessage(), "N/A"); - - response.status(400); - response.body(this.gson.toJson(responseBody)); + requestErrorResponse(response, e); return; } @@ -213,8 +202,10 @@ public class XmlController implements RestController { response.status(400); } - private void requestErrorResponse(Response response) { - + private void requestErrorResponse(Response response, Exception ex) { + XMLResponseBody responseBody = prepareErrorResponseBody(ex.getMessage(), "N/A"); + response.status(400); + response.body(this.gson.toJson(responseBody)); } private XMLResponseBody prepareErrorResponseBody(String message, String processor) { diff --git a/Backend/tools-services/src/main/java/com/r11/tools/xml/Saxon.java b/Backend/tools-services/src/main/java/com/r11/tools/xml/Saxon.java index 897da0b..9237c2e 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/xml/Saxon.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/xml/Saxon.java @@ -40,7 +40,7 @@ public class Saxon implements XmlEngine{ } /** - * This method evaluates XQuery exporession on given xml + * This method evaluates XQuery expression on given xml * @param data xml * @param xquery expression * @return @@ -64,8 +64,8 @@ public class Saxon implements XmlEngine{ /** * Process xpath and return either node or wrapped atomic value - * @param data xml to be querried - * @param query xpath queryy + * @param data xml to be processed + * @param query xpath query * @param version processor version * @return string xml representation of the node * @throws Exception thrown on node building errors or invalid xpath -- 2.51.0 From 08f8e46650d536d8754d33d05933aa93398847e3 Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 11:11:18 +0200 Subject: [PATCH 09/15] Extracted some parameters to XmlJob class --- .../r11/tools/controller/XmlController.java | 56 ++++++++++++------- .../r11/tools/controller/internal/XmlJob.java | 35 ++++++++++++ 2 files changed, 70 insertions(+), 21 deletions(-) create mode 100644 Backend/tools-services/src/main/java/com/r11/tools/controller/internal/XmlJob.java diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index 39830df..34af141 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -49,10 +49,10 @@ public class XmlController implements RestController { switch (requestBody.getProcessor()) { case "saxon": - process(response, requestBody, saxon, XmlJobType.XPath); + process(new XmlJob(response, requestBody, saxon, XmlJobType.XPath)); break; case "xalan": - process(response, requestBody, xalan, XmlJobType.XPath); + process(new XmlJob(response, requestBody, xalan, XmlJobType.XPath)); break; default: invalidEngineSelectedResponse(response); @@ -74,7 +74,7 @@ public class XmlController implements RestController { } if (requestBody.getProcessor().equalsIgnoreCase("saxon")) - process(response, requestBody, saxon, XmlJobType.XQuery); + process(new XmlJob(response, requestBody, saxon, XmlJobType.XQuery)); else invalidEngineSelectedResponse(response); } @@ -94,7 +94,7 @@ public class XmlController implements RestController { return; } if (requestBody.getProcessor().equalsIgnoreCase("xalan")) - process(response, requestBody, xalan, XmlJobType.XSD); + process(new XmlJob(response, requestBody, xalan, XmlJobType.XSD)); else invalidEngineSelectedResponse(response); @@ -117,11 +117,11 @@ public class XmlController implements RestController { switch (requestBody.getProcessor()) { case "saxon": - process(response, requestBody, saxon, XmlJobType.XSLT); + process(new XmlJob(response, requestBody, saxon, XmlJobType.XSLT)); return; case "xalan": - process(response, requestBody, xalan, XmlJobType.XSLT); + process(new XmlJob(response, requestBody, xalan, XmlJobType.XSLT)); return; default: @@ -129,37 +129,43 @@ public class XmlController implements RestController { } } - private void process(Response response, XMLRequestBody requestBody, XmlEngine engine, XmlJobType xmlJobType) { + private void process(XmlJob xmlJob) { XMLResponseBody responseBody = null; long timeStart = System.currentTimeMillis(); long duration; try { - responseBody = selectProcessMethod(response, requestBody, engine, xmlJobType); + responseBody = selectProcessMethod(xmlJob); duration = System.currentTimeMillis() - timeStart; responseBody.setDuration(duration); - response.status(200); + xmlJob.getResponse().status(200); + + this.logger.info("Request (" + xmlJob.getXmlJobType() + ", " + + xmlJob.getEngine().getVersion() + + ") processed in " + duration + " ms."); - this.logger.info("Request (" + xmlJobType + ", " + engine.getVersion() + ") processed in " + duration + " ms."); } catch (Exception ex) { - responseBody = processingErrorResponse(response, ex, engine, xmlJobType); + responseBody = processingErrorResponse(xmlJob.getResponse(), ex, xmlJob); } finally { - response.body(this.gson.toJson(responseBody)); + xmlJob.getResponse().body(this.gson.toJson(responseBody)); } } - private XMLResponseBody selectProcessMethod(Response response, XMLRequestBody requestBody, XmlEngine engine, XmlJobType xmlJobType) throws Exception { - if (xmlJobType == XmlJobType.XPath) - return processXPath(response, requestBody, engine, xmlJobType); + private XMLResponseBody selectProcessMethod(XmlJob xmlJob) throws Exception { + if (xmlJob.getXmlJobType() == XmlJobType.XPath) + return processXPath(xmlJob); else - return processOther(response, requestBody, engine, xmlJobType); + return processOther(xmlJob); } - private XMLResponseBody processXPath(Response response, XMLRequestBody requestBody, XmlEngine engine, XmlJobType xmlJobType) throws Exception { + private XMLResponseBody processXPath(XmlJob xmlJob) throws Exception { + XmlEngine engine = xmlJob.getEngine(); + XMLRequestBody requestBody = xmlJob.getRequestBody(); + XPathQueryResult xPathQueryResult = engine.processXPath(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); @@ -170,9 +176,12 @@ public class XmlController implements RestController { return responseBody; } - private XMLResponseBody processOther(Response response, XMLRequestBody requestBody, XmlEngine engine, XmlJobType xmlJobType) throws Exception { + private XMLResponseBody processOther(XmlJob xmlJob) throws Exception { + XmlEngine engine = xmlJob.getEngine(); + XMLRequestBody requestBody = xmlJob.getRequestBody(); + String result = null; - switch (xmlJobType) { + switch (xmlJob.getXmlJobType()) { case XSLT: result = engine.processXSLT(requestBody.getData(), requestBody.getProcess()); break; @@ -185,13 +194,18 @@ public class XmlController implements RestController { requestBody.getVersion()); break; } - return new XMLResponseBody(result, "OK", engine.getVersion()); + return new XMLResponseBody(result, "OK", requestBody.getVersion()); } - private XMLResponseBody processingErrorResponse(Response response, Exception ex, XmlEngine engine, XmlJobType xmlJobType) { + private XMLResponseBody processingErrorResponse(Response response, Exception ex, XmlJob xmlJob) { + XmlEngine engine = xmlJob.getEngine(); + XmlJobType xmlJobType = xmlJob.getXmlJobType(); + XMLResponseBody responseBody = prepareErrorResponseBody(ex.getMessage(), engine.getVersion()); + response.status(400); this.logger.error("Error on processing " + xmlJobType + " using " + engine.getVersion() + ". " + ex); + return responseBody; } diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/internal/XmlJob.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/internal/XmlJob.java new file mode 100644 index 0000000..3537d2c --- /dev/null +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/internal/XmlJob.java @@ -0,0 +1,35 @@ +package com.r11.tools.controller.internal; + +import com.r11.tools.model.XMLRequestBody; +import com.r11.tools.xml.XmlEngine; +import spark.Response; + +public class XmlJob { + private final Response response; + private final XMLRequestBody requestBody; + private final XmlEngine engine; + private final XmlJobType xmlJobType; + + public XmlJob(Response response, XMLRequestBody requestBody, XmlEngine engine, XmlJobType xmlJobType) { + this.response = response; + this.requestBody = requestBody; + this.engine = engine; + this.xmlJobType = xmlJobType; + } + + public Response getResponse() { + return response; + } + + public XMLRequestBody getRequestBody() { + return requestBody; + } + + public XmlEngine getEngine() { + return engine; + } + + public XmlJobType getXmlJobType() { + return xmlJobType; + } +} -- 2.51.0 From c153e34e22dd890b45aeb8a6428d9180f650f7b3 Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 11:36:05 +0200 Subject: [PATCH 10/15] Merged all 'accept' methods --- .../r11/tools/controller/XmlController.java | 75 ++++--------------- 1 file changed, 13 insertions(+), 62 deletions(-) diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index 34af141..0330421 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -30,78 +30,28 @@ public class XmlController implements RestController { this.xalan = xalan; } - - @ScopedControllerManifest(method = HandlerType.POST, path = "/xpath") public void acceptRequestXPath(Request request, Response response) { - XMLRequestBody requestBody; - try { - requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); - } catch (Exception ex) { - requestErrorResponse(response, ex); - return; - } - - if (requestBody.getProcessor() == null) { - invalidEngineSelectedResponse(response); - return; - } - - switch (requestBody.getProcessor()) { - case "saxon": - process(new XmlJob(response, requestBody, saxon, XmlJobType.XPath)); - break; - case "xalan": - process(new XmlJob(response, requestBody, xalan, XmlJobType.XPath)); - break; - default: - invalidEngineSelectedResponse(response); - } + acceptRequest(request, response, XmlJobType.XPath); } @ScopedControllerManifest(method = HandlerType.POST, path = "/xquery") public void acceptRequestXQuery(Request request, Response response) { - XMLRequestBody requestBody; - try { - requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); - } catch (Exception ex) { - requestErrorResponse(response, ex); - return; - } - if (requestBody.getProcessor() == null) { - invalidEngineSelectedResponse(response); - return; - } - - if (requestBody.getProcessor().equalsIgnoreCase("saxon")) - process(new XmlJob(response, requestBody, saxon, XmlJobType.XQuery)); - else - invalidEngineSelectedResponse(response); + acceptRequest(request, response, XmlJobType.XQuery); } @ScopedControllerManifest(method = HandlerType.POST, path = "/xsd") public void acceptRequestXsd(Request request, Response response) { - XMLRequestBody requestBody; - try { - requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); - } catch (Exception ex) { - requestErrorResponse(response, ex); - return; - } - - if (requestBody.getProcessor() == null) { - invalidEngineSelectedResponse(response); - return; - } - if (requestBody.getProcessor().equalsIgnoreCase("xalan")) - process(new XmlJob(response, requestBody, xalan, XmlJobType.XSD)); - else - invalidEngineSelectedResponse(response); + acceptRequest(request, response, XmlJobType.XSD); } @ScopedControllerManifest(method = HandlerType.POST, path = "/xslt") public void acceptRequestXslt(Request request, Response response) { + acceptRequest(request, response, XmlJobType.XSLT); + } + + public void acceptRequest(Request request, Response response, XmlJobType xmlJobType) { XMLRequestBody requestBody; try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); @@ -115,13 +65,13 @@ public class XmlController implements RestController { return; } - switch (requestBody.getProcessor()) { + switch (requestBody.getProcessor().toLowerCase()) { case "saxon": - process(new XmlJob(response, requestBody, saxon, XmlJobType.XSLT)); + process(new XmlJob(response, requestBody, saxon, xmlJobType)); return; case "xalan": - process(new XmlJob(response, requestBody, xalan, XmlJobType.XSLT)); + process(new XmlJob(response, requestBody, xalan, xmlJobType)); return; default: @@ -147,7 +97,7 @@ public class XmlController implements RestController { ") processed in " + duration + " ms."); } catch (Exception ex) { - responseBody = processingErrorResponse(xmlJob.getResponse(), ex, xmlJob); + responseBody = processingErrorResponse(ex, xmlJob); } finally { xmlJob.getResponse().body(this.gson.toJson(responseBody)); @@ -197,9 +147,10 @@ public class XmlController implements RestController { return new XMLResponseBody(result, "OK", requestBody.getVersion()); } - private XMLResponseBody processingErrorResponse(Response response, Exception ex, XmlJob xmlJob) { + private XMLResponseBody processingErrorResponse(Exception ex, XmlJob xmlJob) { XmlEngine engine = xmlJob.getEngine(); XmlJobType xmlJobType = xmlJob.getXmlJobType(); + Response response = xmlJob.getResponse(); XMLResponseBody responseBody = prepareErrorResponseBody(ex.getMessage(), engine.getVersion()); -- 2.51.0 From 928cd78acd730b3fc227cb7309d19e3fd5186895 Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 11:48:02 +0200 Subject: [PATCH 11/15] Removed unneded method --- .../r11/tools/controller/XmlController.java | 21 ++++++++----------- 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index 0330421..3a81302 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -67,11 +67,11 @@ public class XmlController implements RestController { switch (requestBody.getProcessor().toLowerCase()) { case "saxon": - process(new XmlJob(response, requestBody, saxon, xmlJobType)); + processRequest(new XmlJob(response, requestBody, saxon, xmlJobType)); return; case "xalan": - process(new XmlJob(response, requestBody, xalan, xmlJobType)); + processRequest(new XmlJob(response, requestBody, xalan, xmlJobType)); return; default: @@ -79,13 +79,13 @@ public class XmlController implements RestController { } } - private void process(XmlJob xmlJob) { + private void processRequest(XmlJob xmlJob) { XMLResponseBody responseBody = null; long timeStart = System.currentTimeMillis(); long duration; try { - responseBody = selectProcessMethod(xmlJob); + responseBody = processData(xmlJob); duration = System.currentTimeMillis() - timeStart; responseBody.setDuration(duration); @@ -105,7 +105,7 @@ public class XmlController implements RestController { } - private XMLResponseBody selectProcessMethod(XmlJob xmlJob) throws Exception { + private XMLResponseBody processData(XmlJob xmlJob) throws Exception { if (xmlJob.getXmlJobType() == XmlJobType.XPath) return processXPath(xmlJob); else @@ -152,7 +152,8 @@ public class XmlController implements RestController { XmlJobType xmlJobType = xmlJob.getXmlJobType(); Response response = xmlJob.getResponse(); - XMLResponseBody responseBody = prepareErrorResponseBody(ex.getMessage(), engine.getVersion()); + XMLResponseBody responseBody = + new XMLResponseBody(ex.getMessage(), "ERR", engine.getVersion(), -1); response.status(400); this.logger.error("Error on processing " + xmlJobType + " using " + engine.getVersion() + ". " + ex); @@ -162,18 +163,14 @@ public class XmlController implements RestController { private void invalidEngineSelectedResponse(Response response) { XMLResponseBody responseBody = - prepareErrorResponseBody("Valid engines are: saxon, xalan", "N/A"); + new XMLResponseBody("Valid engines are: saxon, xalan", "ERR", "N/A", -1); response.body(this.gson.toJson(responseBody)); response.status(400); } private void requestErrorResponse(Response response, Exception ex) { - XMLResponseBody responseBody = prepareErrorResponseBody(ex.getMessage(), "N/A"); + XMLResponseBody responseBody = new XMLResponseBody(ex.getMessage(), "ERR", "N/A", -1); response.status(400); response.body(this.gson.toJson(responseBody)); } - - private XMLResponseBody prepareErrorResponseBody(String message, String processor) { - return new XMLResponseBody(message, "ERR", processor, -1); - } } -- 2.51.0 From 80ee87097683ed87540c48eeeffcee12f1c6ab3c Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 13:21:20 +0200 Subject: [PATCH 12/15] Added another constructor to XMLResponseBody --- .../main/java/com/r11/tools/controller/XmlController.java | 7 ++----- .../src/main/java/com/r11/tools/model/XMLResponseBody.java | 7 +++++++ 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index 3a81302..d33c47e 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -119,11 +119,8 @@ public class XmlController implements RestController { XPathQueryResult xPathQueryResult = engine.processXPath(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); - XMLResponseBody responseBody = new XMLResponseBody(xPathQueryResult.getData().trim(), - "OK", engine.getVersion()); - responseBody.setType(xPathQueryResult.getType()); - - return responseBody; + return new XMLResponseBody(xPathQueryResult.getData().trim(), + "OK", engine.getVersion(), xPathQueryResult.getType()); } private XMLResponseBody processOther(XmlJob xmlJob) throws Exception { diff --git a/Backend/tools-services/src/main/java/com/r11/tools/model/XMLResponseBody.java b/Backend/tools-services/src/main/java/com/r11/tools/model/XMLResponseBody.java index 01fb9c2..81f8d73 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/model/XMLResponseBody.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/model/XMLResponseBody.java @@ -22,6 +22,13 @@ public class XMLResponseBody { this.duration = duration; } + public XMLResponseBody(String result, String status, String processor, String type) { + this.result = result; + this.status = status; + this.processor = processor; + this.type = type; + } + public String getResult() { return result; } -- 2.51.0 From 4316de1ef102ea9f3042de368245fc1c1e5e0011 Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 13:21:42 +0200 Subject: [PATCH 13/15] Switched 'Default' to 'Example' --- Frontend/src/components/common/InsertTemplateComponent.vue | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Frontend/src/components/common/InsertTemplateComponent.vue b/Frontend/src/components/common/InsertTemplateComponent.vue index 6548764..0f5a298 100644 --- a/Frontend/src/components/common/InsertTemplateComponent.vue +++ b/Frontend/src/components/common/InsertTemplateComponent.vue @@ -45,5 +45,5 @@ function setDefault() { \ No newline at end of file -- 2.51.0 From 0ab902bc16d0b053a683ac10667ab92c559c41ef Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 13:27:34 +0200 Subject: [PATCH 14/15] Removed old controllers --- .../java/com/r11/tools/SparkApplication.java | 4 - .../r11/tools/controller/XPathController.java | 95 ------------------- .../tools/controller/XQueryController.java | 88 ----------------- .../r11/tools/controller/XsdController.java | 86 ----------------- .../r11/tools/controller/XsltController.java | 94 ------------------ 5 files changed, 367 deletions(-) delete mode 100644 Backend/tools-services/src/main/java/com/r11/tools/controller/XPathController.java delete mode 100644 Backend/tools-services/src/main/java/com/r11/tools/controller/XQueryController.java delete mode 100644 Backend/tools-services/src/main/java/com/r11/tools/controller/XsdController.java delete mode 100644 Backend/tools-services/src/main/java/com/r11/tools/controller/XsltController.java diff --git a/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java b/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java index 35b38ae..93d5828 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/SparkApplication.java @@ -44,10 +44,6 @@ public class SparkApplication { registry.registerController(new XmlController(gson, logger, saxon, xalan)); registry.registerController(new JsonController(gson, jsongson, logger)); - //registry.registerController(new XsltController(gson, logger, saxon, xalan)); - //registry.registerController(new XsdController(gson, logger, xalan)); - //registry.registerController(new XQueryController(gson, logger, saxon)); - //registry.registerController(new XPathController(gson, logger, saxon, xalan)); registry.register(); logger.info("Server is online at port: " + Spark.port()); diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XPathController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XPathController.java deleted file mode 100644 index aabd6a7..0000000 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XPathController.java +++ /dev/null @@ -1,95 +0,0 @@ -package com.r11.tools.controller; - -import com.google.gson.Gson; -import com.r11.tools.controller.internal.*; -import com.r11.tools.model.XMLRequestBody; -import com.r11.tools.model.XMLResponseBody; -import com.r11.tools.model.XPathQueryResult; -import com.r11.tools.xml.XmlEngine; -import org.apache.logging.log4j.Logger; -import spark.Request; -import spark.Response; - -@GlobalControllerManifest -@Deprecated -public class XPathController implements RestController { - - private final Gson gson; - private final Logger logger; - - private final XmlEngine saxon; - private final XmlEngine xalan; - - public XPathController(Gson gson, Logger logger, XmlEngine saxon, XmlEngine xalan) { - this.gson = gson; - this.logger = logger; - this.saxon = saxon; - this.xalan = xalan; - } - - private XMLResponseBody errorResponse(String message, String processor) { - return new XMLResponseBody(message, "ERR", processor, -1); - } - - private void nonValidEngineSelectedResponse(Response response) { - XMLResponseBody responseBody = - errorResponse("Valid engines are: saxon, xalan", "N/A"); - response.body(this.gson.toJson(responseBody)); - response.status(400); - } - - @ScopedControllerManifest(method = HandlerType.POST, path = "/xpath") - public void acceptRequest(Request request, Response response) { - XMLRequestBody requestBody; - try { - requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); - } catch (Exception e) { - XMLResponseBody responseBody = errorResponse(e.getMessage(), "N/A"); - response.status(400); - response.body(this.gson.toJson(responseBody)); - return; - } - - if (requestBody.getProcessor() == null) { - nonValidEngineSelectedResponse(response); - return; - } - - switch (requestBody.getProcessor()) { - case "saxon": - process(response, requestBody, saxon); - break; - case "xalan": - process(response, requestBody, xalan); - break; - default: - nonValidEngineSelectedResponse(response); - } - } - - private void process(Response response, XMLRequestBody requestBody, XmlEngine engine) { - long timeStart = System.currentTimeMillis(); - XMLResponseBody responseBody = null; - try { - XPathQueryResult xPathQueryResult = - engine.processXPath(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); - - response.status(200); - long duration = System.currentTimeMillis() - timeStart; - responseBody = new XMLResponseBody(xPathQueryResult.getData().trim(), - "OK", engine.getVersion(),duration); - - responseBody.setType(xPathQueryResult.getType()); - this.logger.info("Request (XPath, " + engine.getVersion() + ") processed in " + duration + " ms."); - } catch (Exception ex) { - responseBody = errorResponse(ex.getMessage(), engine.getVersion()); - response.status(400); - - this.logger.error("Error on processing XPath using " + engine.getVersion() + ". " + ex); - } finally { - response.body(this.gson.toJson(responseBody)); - } - - } - -} diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XQueryController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XQueryController.java deleted file mode 100644 index 8254f61..0000000 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XQueryController.java +++ /dev/null @@ -1,88 +0,0 @@ -package com.r11.tools.controller; - -import com.google.gson.Gson; -import com.r11.tools.controller.internal.*; -import com.r11.tools.model.XMLRequestBody; -import com.r11.tools.model.XMLResponseBody; -import com.r11.tools.xml.XmlEngine; -import org.apache.logging.log4j.Logger; -import spark.Request; -import spark.Response; - -/** - * Controller used to handle XQuery tool. Currently, it supports Saxon engine - * @author Adam Bem - */ -@GlobalControllerManifest -@Deprecated -public class XQueryController implements RestController { - - private final Gson gson; - private final Logger logger; - private final XmlEngine saxon; - - public XQueryController(Gson gson, Logger logger, XmlEngine saxon) { - this.gson = gson; - this.logger = logger; - this.saxon = saxon; - } - - private XMLResponseBody prepareErrorResponse(String message, String processor) { - return new XMLResponseBody(message, "ERR", processor, -1); - } - - private void nonValidEngineSelectedResponse(Response response) { - XMLResponseBody responseBody = - prepareErrorResponse("Valid engines are: saxon", "N/A"); - response.body(this.gson.toJson(responseBody)); - response.status(400); - } - - @ScopedControllerManifest(method = HandlerType.POST, path = "/xquery") - public void acceptRequest(Request request, Response response) { - XMLRequestBody requestBody; - try { - requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); - } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); - - response.status(400); - response.body(this.gson.toJson(responseBody)); - return; - } - if (requestBody.getProcessor() == null) { - nonValidEngineSelectedResponse(response); - return; - } - - if (requestBody.getProcessor().equalsIgnoreCase("saxon")) - process(response, requestBody, saxon); - else - nonValidEngineSelectedResponse(response); - } - - private void process(Response response, XMLRequestBody requestBody, XmlEngine engine) { - XMLResponseBody responseBody = null; - long timeStart = System.currentTimeMillis(); - try { - String result = engine.executeXQuery(requestBody.getData(), requestBody.getProcess(), requestBody.getVersion()); - - response.status(200); - - long duration = System.currentTimeMillis() - timeStart; - responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); - - this.logger.info("Request (XQuery, " + engine.getVersion() + ") processed in " + duration + " ms."); - } catch (Exception ex) { - response.status(400); - responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); - - this.logger.error("Error on processing XQuery using " + engine.getVersion() + ". " + ex); - } - finally { - response.body(this.gson.toJson(responseBody)); - } - - } - -} diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XsdController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XsdController.java deleted file mode 100644 index b53db9f..0000000 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XsdController.java +++ /dev/null @@ -1,86 +0,0 @@ -package com.r11.tools.controller; - -import com.google.gson.Gson; -import com.r11.tools.controller.internal.*; -import com.r11.tools.model.XMLRequestBody; -import com.r11.tools.model.XMLResponseBody; -import com.r11.tools.xml.XmlEngine; -import org.apache.logging.log4j.Logger; -import spark.Request; -import spark.Response; - -@GlobalControllerManifest -@Deprecated -public class XsdController implements RestController { - - private final Gson gson; - private final Logger logger; - - private final XmlEngine xalan; - - public XsdController(Gson gson, Logger logger, XmlEngine xalan) { - this.gson = gson; - this.logger = logger; - this.xalan = xalan; - } - - private XMLResponseBody prepareErrorResponse(String message, String processor) { - return new XMLResponseBody(message, "ERR", processor, -1); - } - - private void nonValidEngineSelectedResponse(Response response) { - XMLResponseBody responseBody = - prepareErrorResponse("Valid engines is: xalan", "N/A"); - response.body(this.gson.toJson(responseBody)); - response.status(400); - } - @ScopedControllerManifest(method = HandlerType.POST, path = "/xsd") - public void acceptRequest(Request request, Response response) { - XMLRequestBody requestBody; - try { - requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); - } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); - - response.status(400); - response.body(this.gson.toJson(responseBody)); - return; - } - - if (requestBody.getProcessor() == null) { - nonValidEngineSelectedResponse(response); - return; - } - if (requestBody.getProcessor().equalsIgnoreCase("xalan")) - process(response, requestBody, xalan); - else - nonValidEngineSelectedResponse(response); - - } - - private void process(Response response, XMLRequestBody requestBody, XmlEngine engine) { - XMLResponseBody responseBody = null; - try { - long timeStart = System.currentTimeMillis(); - String result = engine.validate(requestBody.getData(), requestBody.getProcess()).trim(); - - response.status(200); - - long duration = System.currentTimeMillis() - timeStart; - responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); - - this.logger.info("Request (XSD, " + engine.getVersion() + ") processed in " + duration + " ms."); - } catch (Exception ex) { - responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); - response.status(400); - - this.logger.error("Error on validation against XSD using " + engine.getVersion() + ". " + ex); - } - finally { - response.body(this.gson.toJson(responseBody)); - } - - - } - -} diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XsltController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XsltController.java deleted file mode 100644 index ef7316f..0000000 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XsltController.java +++ /dev/null @@ -1,94 +0,0 @@ -package com.r11.tools.controller; - -import com.google.gson.Gson; -import com.r11.tools.controller.internal.*; -import com.r11.tools.model.XMLRequestBody; -import com.r11.tools.model.XMLResponseBody; -import com.r11.tools.xml.XmlEngine; -import org.apache.logging.log4j.Logger; -import spark.Request; -import spark.Response; - -@GlobalControllerManifest -@Deprecated -public class XsltController implements RestController { - - private final Gson gson; - private final Logger logger; - - private final XmlEngine saxon; - private final XmlEngine xalan; - - public XsltController(Gson gson, Logger logger, XmlEngine saxon, XmlEngine xalan) { - this.gson = gson; - this.logger = logger; - this.saxon = saxon; - this.xalan = xalan; - } - - private XMLResponseBody prepareErrorResponse(String message, String processor) { - return new XMLResponseBody(message, "ERR", processor, -1); - } - - private void nonValidEngineSelectedResponse(Response response) { - XMLResponseBody responseBody = - prepareErrorResponse("Valid engines are: saxon, xalan", "N/A"); - response.body(this.gson.toJson(responseBody)); - response.status(400); - } - - @ScopedControllerManifest(method = HandlerType.POST, path = "/xslt") - public void acceptRequest(Request request, Response response) { - XMLRequestBody requestBody; - try { - requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); - } catch (Exception e) { - XMLResponseBody responseBody = prepareErrorResponse(e.getMessage(), "N/A"); - - response.status(400); - response.body(this.gson.toJson(responseBody)); - return; - } - - if (requestBody.getProcessor() == null) { - nonValidEngineSelectedResponse(response); - return; - } - - switch (requestBody.getProcessor()) { - case "saxon": - process(response, requestBody, saxon); - return; - - case "xalan": - process(response, requestBody, xalan); - return; - - default: - nonValidEngineSelectedResponse(response); - } - } - - private void process(Response response, XMLRequestBody requestBody, XmlEngine engine) { - XMLResponseBody responseBody = null; - long timeStart = System.currentTimeMillis(); - try { - String result = engine.processXSLT(requestBody.getData(), requestBody.getProcess()); - response.status(200); - - long duration = System.currentTimeMillis() - timeStart; - responseBody = new XMLResponseBody(result, "OK", engine.getVersion(), duration); - - this.logger.info("Request (XSLT, " + engine.getVersion() + ") processed in " + duration + " ms."); - } catch (Exception ex) { - responseBody = prepareErrorResponse(ex.getMessage(), engine.getVersion()); - response.status(400); - this.logger.error("Error on processing XSLT using " + engine.getVersion() + ". " + ex); - - } finally { - response.body(this.gson.toJson(responseBody)); - } - - } - -} -- 2.51.0 From 594e3fb7f40c47f3e76ab72611a10e17e1b0264b Mon Sep 17 00:00:00 2001 From: Adam Bem Date: Thu, 26 Oct 2023 13:34:15 +0200 Subject: [PATCH 15/15] Changed 'acceptRequest' method to private --- .../src/main/java/com/r11/tools/controller/XmlController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java index d33c47e..4c07138 100644 --- a/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java +++ b/Backend/tools-services/src/main/java/com/r11/tools/controller/XmlController.java @@ -51,7 +51,7 @@ public class XmlController implements RestController { acceptRequest(request, response, XmlJobType.XSLT); } - public void acceptRequest(Request request, Response response, XmlJobType xmlJobType) { + private void acceptRequest(Request request, Response response, XmlJobType xmlJobType) { XMLRequestBody requestBody; try { requestBody = this.gson.fromJson(request.body(), XMLRequestBody.class); -- 2.51.0