feat: Retrieve Transaction Rendered Resources APIs

api-sql/dicom-web/controller/WADO-RS/rendered/instanceFrames.js

@@ -0,0 +1,74 @@
+const _ = require("lodash");
+const renderedService = require("../service/rendered.service");
+const {
+    RenderedImageMultipartWriter
+} = require("@root/api/dicom-web/controller/WADO-RS/service/rendered.service");
+const { InstanceImagePathFactory } = require("../service/WADO-RS.service");
+const errorResponse = require("@root/utils/errorResponse/errorResponseMessage");
+const { ApiLogger } = require("@root/utils/logs/api-logger");
+const { Controller } = require("@root/api/controller.class");
+
+class RetrieveRenderedInstanceFramesController extends Controller {
+    constructor(req, res) {
+        super(req, res);
+    }
+
+    async mainProcess() {
+        this.apiLogger = new ApiLogger(this.request, "WADO-RS");
+        this.apiLogger.addTokenValue();
+
+        let {
+            studyUID,
+            seriesUID,
+            instanceUID,
+            frameNumber
+        } = this.request.params;
+
+        this.apiLogger.logger.info(`Get study's series' rendered instances' frames, study UID: ${studyUID}, series UID: ${seriesUID}, instance UID: ${instanceUID}, frame: ${frameNumber}`);
+
+        let headerAccept = _.get(this.request.headers, "accept", "");
+        if (!headerAccept.includes("*/*") && !headerAccept.includes("image/jpeg")) {
+            let badRequestMessage = errorResponse.getBadRequestErrorMessage(`header accept only allow */* or image/jpeg , exception : ${headerAccept}`);
+            this.response.writeHead(badRequestMessage.HttpStatus, {
+                "Content-Type": "application/dicom+json"
+            });
+            return this.response.end(JSON.stringify(badRequestMessage));
+        }
+
+        try {
+            let renderedImageMultipartWriter = new RenderedImageMultipartWriter(
+                this.request,
+                this.response,
+                InstanceImagePathFactory,
+                renderedService.InstanceFramesListWriter
+            );
+
+            let buffer = await renderedImageMultipartWriter.write();
+
+            this.apiLogger.logger.info(`Get instance's frame successfully, instance UID: ${instanceUID}, frame number: ${JSON.stringify(frameNumber)}`);
+
+            if (buffer instanceof Buffer) {
+                return this.response.end(buffer, "binary");
+            }
+
+            return this.response.end();
+        } catch(e) {
+            console.error(e);
+            this.response.writeHead(500, {
+                "Content-Type": "application/dicom+json"
+            });
+            this.response.end(JSON.stringify(e, Object.getOwnPropertyNames(e), 4), "utf8");
+        }
+    }
+}
+/**
+ * 
+ * @param {import("http").incomingMessage} req 
+ * @param {import("http").ServerResponse} res 
+ * @returns 
+ */
+module.exports = async function(req, res) {
+    let controller = new RetrieveRenderedInstanceFramesController(req, res);
+
+    await controller.doPipeline();
+};

api-sql/dicom-web/controller/WADO-RS/rendered/instances.js

@@ -0,0 +1,61 @@
+const _ = require("lodash");
+const { RenderedImageMultipartWriter } = require("@root/api/dicom-web/controller/WADO-RS/service/rendered.service");
+const renderedService = require("../service/rendered.service");
+const { InstanceImagePathFactory } = require("../service/WADO-RS.service");
+const errorResponse = require("@root/utils/errorResponse/errorResponseMessage");
+const { ApiLogger } = require("@root/utils/logs/api-logger");
+const { Controller } = require("@root/api/controller.class");
+
+class RetrieveRenderedInstancesController extends Controller {
+    constructor(req, res) {
+        super(req, res);
+    }
+
+    async mainProcess() {
+        let apiLogger = new ApiLogger(this.request, "WADO-RS");
+        apiLogger.addTokenValue();
+
+        let headerAccept = _.get(this.request.headers, "accept", "");
+
+        apiLogger.logger.info(`Get study's series' rendered instances, study UID: ${this.request.params.studyUID}, series UID: ${this.request.params.seriesUID}`);
+
+        if (!headerAccept == `multipart/related; type="image/jpeg"`) {
+            let badRequestMessage = errorResponse.getBadRequestErrorMessage(`header accept only allow \`multipart/related; type="image/jpeg"\`, exception : ${headerAccept}`);
+            this.response.writeHead(badRequestMessage.HttpStatus, {
+                "Content-Type": "application/dicom+json"
+            });
+            return this.response.end(JSON.stringify(badRequestMessage));
+        }
+
+        try {
+            let renderedImageMultipartWriter = new RenderedImageMultipartWriter(
+                this.request,
+                this.response,
+                InstanceImagePathFactory,
+                renderedService.InstanceFramesWriter
+            );
+
+            await renderedImageMultipartWriter.write();
+
+            apiLogger.logger.info(`Write Multipart Successfully, study's series' instances' rendered images, study UID: ${this.request.params.studyUID}, series UID: ${this.request.params.seriesUID}, instance UID: ${this.request.params.instanceUID}`);
+            return this.response.end();
+        } catch(e) {
+            this.response.writeHead(500, {
+                "Content-Type": "application/dicom+json"
+            });
+            this.response.end(JSON.stringify(e));
+        }
+    }
+}
+
+/**
+ * 
+ * @param {import("http").IncomingMessage} req 
+ * @param {import("http").ServerResponse} res 
+ * @returns 
+ */
+module.exports = async function(req, res) {
+    let controller = new RetrieveRenderedInstancesController(req, res);
+
+    await controller.doPipeline();
+};

api-sql/dicom-web/controller/WADO-RS/rendered/series.js

@@ -0,0 +1,56 @@
+const _ = require("lodash");
+const { RenderedImageMultipartWriter } = require("@root/api/dicom-web/controller/WADO-RS/service/rendered.service");
+const renderedService = require("../service/rendered.service");
+const { SeriesImagePathFactory } = require("../service/WADO-RS.service");
+const errorResponse = require("@root/utils/errorResponse/errorResponseMessage");
+const { logger } = require("@root/utils/logs/log");
+const { Controller } = require("@root/api/controller.class");
+
+class RetrieveRenderedSeriesController extends Controller {
+    constructor(req, res) {
+        super(req, res);
+    }
+
+    async mainProcess() {
+        let headerAccept = _.get(this.request.headers, "accept", "");
+        logger.info(`[WADO-RS] [Get study's series' rendered instances, study UID: ${this.request.params.studyUID}, series UID: ${this.request.params.seriesUID}]`);
+        if (!headerAccept == `multipart/related; type="image/jpeg"`) {
+            let badRequestMessage = errorResponse.getBadRequestErrorMessage(`header accept only allow \`multipart/related; type="image/jpeg"\`, exception : ${headerAccept}`);
+            this.response.writeHead(badRequestMessage.HttpStatus, {
+                "Content-Type": "application/dicom+json"
+            });
+            return this.response.end(JSON.stringify(badRequestMessage));
+        }
+
+        try {
+            let renderedImageMultipartWriter = new RenderedImageMultipartWriter(
+                this.request,
+                this.response,
+                SeriesImagePathFactory,
+                renderedService.SeriesFramesWriter
+            );
+
+            await renderedImageMultipartWriter.write();
+
+            logger.info(`[WADO-RS] [path: ${this.request.originalUrl}] [Write Multipart Successfully, study's series' rendered instances, study UID: ${this.request.params.studyUID}, series UID: ${this.request.params.seriesUID}]`);
+
+            return this.response.end();
+        } catch(e) {
+            this.response.writeHead(500, {
+                "Content-Type": "application/dicom+json"
+            });
+            this.response.end(JSON.stringify(e));
+        }
+    }
+}
+/**
+ * 
+ * @param {import("http").IncomingMessage} req 
+ * @param {import("http").ServerResponse} res 
+ * @returns 
+ */
+module.exports = async function(req, res) {
+    let controller = new RetrieveRenderedSeriesController(req, res);
+
+    await controller.doPipeline();
+};

api-sql/dicom-web/controller/WADO-RS/rendered/study.js

@@ -0,0 +1,65 @@
+const _ = require("lodash");
+const { RenderedImageMultipartWriter } = require("@root/api/dicom-web/controller/WADO-RS/service/rendered.service");
+const renderedService = require("../service/rendered.service");
+const {
+    StudyImagePathFactory
+} = require("../service/WADO-RS.service");
+const errorResponse = require("@root/utils/errorResponse/errorResponseMessage");
+const { ApiLogger } = require("@root/utils/logs/api-logger");
+const { Controller } = require("@root/api/controller.class");
+
+class RetrieveRenderedStudyController extends Controller {
+    constructor(req, res) {
+        super(req, res);
+    }
+
+    async mainProcess() {
+        let headerAccept = _.get(this.request.headers, "accept", "");
+        let apiLogger = new ApiLogger(this.request, "WADO-RS");
+        apiLogger.addTokenValue();
+
+        apiLogger.logger.info(`Get study's rendered instances, study UID: ${this.request.params.studyUID}`);
+
+        if (!headerAccept == `multipart/related; type="image/jpeg"`) {
+            let badRequestMessage = errorResponse.getBadRequestErrorMessage(`header accept only allow \`multipart/related; type="image/jpeg"\`, exception : ${headerAccept}`);
+            this.response.writeHead(badRequestMessage.HttpStatus, {
+                "Content-Type": "application/dicom+json"
+            });
+            return this.response.end(JSON.stringify(badRequestMessage));
+        }
+
+        try {
+
+            let renderedImageMultipartWriter = new RenderedImageMultipartWriter(
+                this.request,
+                this.response,
+                StudyImagePathFactory,
+                renderedService.StudyFramesWriter
+            );
+
+            await renderedImageMultipartWriter.write();
+
+            apiLogger.logger.info(`Write Multipart Successfully, study's rendered instances, study UID: ${this.request.params.studyUID}`);
+
+            return this.response.end();
+        } catch(e) {
+            apiLogger.logger.error(e);
+
+            this.response.writeHead(500, {
+                "Content-Type": "application/dicom+json"
+            });
+            this.response.end(JSON.stringify(e));
+        }
+    }
+}
+/**
+ * 
+ * @param {import("http").IncomingMessage} req 
+ * @param {import("http").ServerResponse} res 
+ * @returns 
+ */
+module.exports = async function(req, res) {
+    let controller = new RetrieveRenderedStudyController(req, res);
+
+    await controller.doPipeline();
+};