@radicalimaging/static-wado-creator 1.3.2 → 1.6.10

package/lib/operation/getValue.js

@@ -8,7 +8,9 @@ function decodeUtf8(s, options) {
 }
 
 /** Gets a value as a UTF-8 string - todo, make UTF-8 decode optional. */
-const getValueInlineString = (dataSet, attr, options) => [decodeUtf8(dataSet.string(attr.tag), options)];
+const getValueInlineString = (dataSet, attr, options) => [
+  decodeUtf8(dataSet.string(attr.tag), options),
+];
 
 const getStrings = (dataSet, attr, options) => {
   const ret = dataSet.string(attr.tag);
@@ -20,21 +22,27 @@ const getStrings = (dataSet, attr, options) => {
 
 const getValuePatientName = (dataSet, attr) => {
   const strings = getStrings(dataSet, attr);
-  return (strings && strings.map((item) => ({ Alphabetic: item }))) || undefined;
+  return (
+    (strings && strings.map((item) => ({ Alphabetic: item }))) || undefined
+  );
 };
 
 /** Gets either InlineBinary or BulkDataURI, if already defined */
 const getValueInlineBinary = (dataSet, attr) => {
   if (attr.BulkDataURI) return { BulkDataURI: attr.BulkDataURI };
-  const binaryValue = dataSet.byteArray.slice(attr.dataOffset, attr.dataOffset + attr.length);
+  const binaryValue = dataSet.byteArray.slice(
+    attr.dataOffset,
+    attr.dataOffset + attr.length,
+  );
   return { InlineBinary: binaryValue.toString("base64") };
 };
 
 const getValueInlineSignedShort = (dataSet, attr) => {
-  if (attr.length > 2) {
-    return getValueInlineBinary(dataSet, attr);
+  const ret = [];
+  for (let i = 0; i < attr.length / 2; i++) {
+    ret.push(dataSet.int16(attr.tag, i));
   }
-  return [dataSet.int16(attr.tag)];
+  return ret;
 };
 
 const getValueInlineUnsignedShort = (dataSet, attr) => {
@@ -70,9 +78,11 @@ const getValueInlineFloat = (dataSet, attr) => {
   return ret;
 };
 
-const getValueInlineIntString = (dataSet, attr) => getStrings(dataSet, attr).map((val) => parseInt(val));
+const getValueInlineIntString = (dataSet, attr) =>
+  getStrings(dataSet, attr).map((val) => parseInt(val));
 
-const getValueInlineFloatString = (dataSet, attr) => getStrings(dataSet, attr).map((val) => parseFloat(val));
+const getValueInlineFloatString = (dataSet, attr) =>
+  getStrings(dataSet, attr).map((val) => parseFloat(val));
 
 const getValueInlineFloatDouble = (dataSet, attr) => {
   if (attr.length > 8) {
@@ -177,15 +187,30 @@ const isValueInline = (attr, options) => {
  * @param {*} parentAttr attr's parent. If not present means attr is at root level.
  * @returns
  */
-const getValue = async (dataSet, attr, vr, getDataSet, callback, options, parentAttr) => {
+const getValue = async (
+  dataSet,
+  attr,
+  vr,
+  getDataSet,
+  callback,
+  options,
+  parentAttr,
+) => {
   // It will only process pixelData tag if on metadata root. Otherwise it will be skiped.
   if (attr.tag === "x7fe00010" && !parentAttr) {
-    const BulkDataURI = await extractImageFrames(dataSet, attr, vr, callback, options);
+    const BulkDataURI = await extractImageFrames(
+      dataSet,
+      attr,
+      vr,
+      callback,
+      options,
+    );
     return { BulkDataURI };
   }
   if (attr.tag === "xfffee00d") return undefined;
   // Group length
-  if (attr.tag.length == 9 && attr.tag.substring(5, 9) === "0000") return undefined;
+  if (attr.tag.length == 9 && attr.tag.substring(5, 9) === "0000")
+    return undefined;
   if (attr.items) {
     // sequences
     const result = [];
@@ -202,7 +227,10 @@ const getValue = async (dataSet, attr, vr, getDataSet, callback, options, parent
   if (isValueInline(attr, options)) {
     return getValueInline(dataSet, attr, vr, options);
   }
-  const binaryValue = dataSet.byteArray.slice(attr.dataOffset, attr.dataOffset + attr.length);
+  const binaryValue = dataSet.byteArray.slice(
+    attr.dataOffset,
+    attr.dataOffset + attr.length,
+  );
   const mimeType = attr.tag == "x00420011" && dataSet.string("x00420012");
 
   const BulkDataURI = await callback.bulkdata(binaryValue, { mimeType });

package/lib/operation/validateMetadata.js

@@ -0,0 +1,40 @@
+const { Tags } = require("@radicalimaging/static-wado-util");
+
+function validateMetadata(options) {
+  const serviceUrl = "";
+  const { verify, multipart: stowResponse } = options;
+
+  return function (id, result) {
+    const getValue = Tags.getValue.bind(null, result.metadata);
+    if (verify) {
+      console.verbose("Validating metadata", id);
+      if (id.studyInstanceUid.length > 64) {
+        throw new Error(`StudyInstanceUID too long: ${id.studyInstanceUid}`);
+      }
+      if (id.seriesInstanceUid.length > 64) {
+        throw new Error(`SeriesInstanceUID too long: ${id.studyInstanceUid}`);
+      }
+    }
+    if (stowResponse) {
+      const RetrieveURL = `${serviceUrl}${id.studyInstanceUid}/series/${id.seriesInstanceUid}/instances/${id.sopInstanceUid}`;
+
+      // TODO - add check here from plugin to add remote query checks, eg kheops or similar
+      const { filename } = id;
+      const successMessage = {
+        ReferencedSOPSequence: [
+          {
+            StudyInstanceUID: id.studyInstanceUid,
+            SeriesInstanceUID: id.seriesInstanceUid,
+            ReferencedSOPClassUID: getValue(Tags.SOPClassUID),
+            ReferencedSOPInstanceUID: id.sopInstanceUid,
+            RetrieveURL,
+            StorageURL: filename,
+          },
+        ],
+      };
+      this.success("instanceStored", successMessage, filename);
+    }
+  };
+}
+
+module.exports = validateMetadata;

package/lib/program/index.js

@@ -7,9 +7,11 @@ const staticWadoUtil = require("@radicalimaging/static-wado-util");
  * @returns Program object
  */
 async function configureProgram(defaults) {
-  const configurationFile = await staticWadoUtil.loadConfiguration(defaults, process.argv);
-  console.log("Loaded configuration from", configurationFile);
-  staticWadoUtil.configureCommands(defaults);
+  const configurationFile = await staticWadoUtil.loadConfiguration(
+    defaults,
+    process.argv,
+  );
+  return staticWadoUtil.configureCommands(defaults);
 }
 
 exports.configureProgram = configureProgram;

package/lib/serverMain.js

@@ -0,0 +1,27 @@
+const readline = require("node:readline");
+const {
+  argv,
+  argv0,
+  exit,
+  stdin: input,
+  stdout: output,
+} = require("node:process");
+
+const StaticWado = require("./StaticWado");
+const adaptProgramOpts = require("./util/adaptProgramOpts");
+
+module.exports = async function createMain(options, program) {
+  const rl = readline.createInterface({ input, output });
+  for await (const line of rl) {
+    if (!line) continue;
+    if (line.startsWith("exit")) {
+      exit(0);
+    }
+    argv.splice(2, argv.length - 2, ...line.split(" "));
+    console.verbose("exec mkdicomweb", JSON.stringify(argv));
+
+    // Configure program commander
+    await StaticWado.configureProgram(StaticWado.mkdicomwebConfig);
+    output.write("mkdicomweb server -->\n");
+  }
+};

package/lib/util/IdCreator.js

@@ -1,14 +1,40 @@
 const path = require("path");
+const {
+  getStudyUIDPathAndSubPath,
+} = require("@radicalimaging/static-wado-util");
 
-function IdCreator({ directoryName, deduplicatedRoot, deduplicatedInstancesRoot }) {
+function IdCreator({
+  directoryName,
+  deduplicatedRoot,
+  deduplicatedInstancesRoot,
+  hashStudyUidPath,
+}) {
   return (uids, filename) => {
-    const studyPath = path.join(directoryName, "studies", uids.studyInstanceUid);
-    const seriesRootPath = path.join(studyPath, "series", uids.seriesInstanceUid);
-    const sopInstanceRootPath = path.join(studyPath, "series", uids.seriesInstanceUid, "instances", uids.sopInstanceUid);
-    const deduplicatedPath = path.join(deduplicatedRoot, uids.studyInstanceUid);
-    const deduplicatedInstancesPath = path.join(deduplicatedInstancesRoot, uids.studyInstanceUid);
+    const { studyInstanceUid, seriesInstanceUid, sopInstanceUid } = uids;
+
+    const { path: hashPath = "", subpath: hashSubpath = "" } = hashStudyUidPath
+      ? getStudyUIDPathAndSubPath(studyInstanceUid)
+      : {};
+
+    const studySubDir = hashStudyUidPath
+      ? path.join(hashPath, hashSubpath, studyInstanceUid)
+      : studyInstanceUid;
+
+    const studyPath = path.join(directoryName, "studies", studySubDir);
+    const seriesRootPath = path.join(studyPath, "series", seriesInstanceUid);
+    const sopInstanceRootPath = path.join(
+      seriesRootPath,
+      "instances",
+      sopInstanceUid,
+    );
     const imageFrameRootPath = path.join(sopInstanceRootPath, "frames");
 
+    const deduplicatedPath = path.join(deduplicatedRoot, studySubDir);
+    const deduplicatedInstancesPath = path.join(
+      deduplicatedInstancesRoot,
+      studySubDir,
+    );
+
     return {
       ...uids,
       studyPath,

package/lib/util/adaptProgramOpts.js

@@ -34,6 +34,6 @@ module.exports = function adaptProgramOpts(programOpts, defaults) {
       encapsulatedImage: encapsulatedImage ?? singlePartImage !== true,
       singlePartImage: singlePartImage ?? encapsulatedImage === false,
       delete: deleteInstances,
-    }
+    },
   );
 };

package/lib/util/compressionOptionParser.js

@@ -1,13 +1,22 @@
 const { program } = require("@radicalimaging/static-wado-util");
-const { getDestinationTranscoder } = require("../operation/adapter/transcodeImage");
+const {
+  getDestinationTranscoder,
+} = require("../operation/adapter/transcodeImage");
 
 module.exports = function compressionOptionParser(value) {
   const destination = getDestinationTranscoder(value);
   if (destination) {
-    console.log("Found destination transferSyntax ", destination.transferSyntaxUid, "for ", value);
+    console.log(
+      "Found destination transferSyntax ",
+      destination.transferSyntaxUid,
+      "for ",
+      value,
+    );
   } else {
     console.log("No transcoder destination for ", value);
-    throw new program.InvalidArgumentError(`No transcoder destination for ${value}`);
+    throw new program.InvalidArgumentError(
+      `No transcoder destination for ${value}`,
+    );
   }
   return destination.transferSyntaxUid;
 };

package/lib/util/resultsReport.ts

@@ -0,0 +1,88 @@
+import fs from "fs";
+
+const results = [];
+let sopResponse = null;
+
+function ensureSOPResponse(data) {
+    if( !data.ReferencedSOPSequence && !data.FailedSOPSequence ) {
+        return;
+    }
+    if( !sopResponse ) {
+        sopResponse = {
+            ...data,
+            FailedSOPSequence: undefined,
+            ReferencedSOPSequence: undefined,
+        }
+        results.push(sopResponse);
+    }
+    if( data.ReferencedSOPSequence ) {
+        sopResponse.ReferencedSOPSequence ||= [];
+        sopResponse.ReferencedSOPSequence.push(...data.ReferencedSOPSequence);
+    }
+    if( data.FailedSOPSequence ) {
+        sopResponse.FailedSOPSequence ||= [];
+        sopResponse.FailedSOPSequence.push(...data.FailedSOPSequence);
+    }
+
+}
+export function Success(options) {
+    const { deleteInput = false } = options;
+
+    return (_action, data, file) => {
+      if( data.ReferencedSOPSequence ) {
+        ensureSOPResponse(data);
+      } else {
+        results.push(data);
+      }
+      if (file && deleteInput) {
+        console.noQuiet("Deleting", file);
+        fs.unlinkSync(file);
+    } else if( file ) {
+        console.verbose("Not deleting", file);
+      }
+    };
+}
+
+export function Failure(options) {
+    const { deleteFailed } = options;
+
+    return (_action, data, file) => {
+        if (data.FailedSOPSequence) {
+          ensureSOPResponse(data);
+        } else {
+            results.push(data);
+        }
+        if( file && deleteFailed ) {
+            console.noQuiet("Deleting failure", file);
+            fs.unlinkSync(file);
+        } else if( file ) {
+            console.verbose("Not deleting failure file", file);
+        }
+    };
+}
+
+export function clearResults() {
+    results.splice(0,results.length);
+    sopResponse = null;
+}
+
+export function WriteResults(options) {
+    const { multipart } = options;
+
+    return function () {
+      if (multipart) {
+        const str =
+          results.length === 1
+            ? JSON.stringify(results[0])
+            : `[\n${results.map((r) => JSON.stringify(r, null, 2)).join(",\n")}\n]`;
+        console.log(
+          "\r\n--boundary-response\r\n" +
+            "content-type: application/json\r\n\r\n" +
+            str +
+            "\r\n--boundary-response--\r\n"
+        );
+      }
+
+      clearResults();
+    };
+}

package/lib/writer/CompleteStudyWriter.js

@@ -1,4 +1,8 @@
-const { JSONReader, JSONWriter, Stats } = require("@radicalimaging/static-wado-util");
+const {
+  JSONReader,
+  JSONWriter,
+  Stats,
+} = require("@radicalimaging/static-wado-util");
 const { Tags } = require("@radicalimaging/static-wado-util");
 const StudyData = require("../operation/StudyData");
 
@@ -22,48 +26,77 @@ const CompleteStudyWriter = (options) => {
     if (options.isGroup) {
       if (studyData.dirty) {
         await studyData.writeDeduplicatedGroup();
-        console.log("Wrote updated deduplicated data for study", studyData.studyInstanceUid);
+        console.noQuiet(
+          "Wrote updated deduplicated data for study",
+          studyData.studyInstanceUid,
+        );
       } else {
-        console.log("Not writing new deduplicated data because it is clean:", studyData.studyInstanceUid);
+        console.noQuiet(
+          "Not writing new deduplicated data because it is clean:",
+          studyData.studyInstanceUid,
+        );
+        const message = {
+          text: "Metadata clean, not updating",
+          status: 0,
+          studyInstanceUid: studyData.studyInstanceUid,
+        };
+        this.success("metadataClean", message);
       }
       await studyData.deleteInstancesReferenced();
     }
 
     if (!options.isStudyData) {
-      console.verbose("Not configured to write study metadata", studyData.studyInstanceUid);
-      if (options.notifications) this.notificationService.notifyStudy(studyData.studyInstanceUid);
+      if (options.notifications)
+        this.notificationService.notifyStudy(studyData.studyInstanceUid);
       delete this.studyData;
       Stats.StudyStats.summarize();
       return;
     }
 
     const isDirtyMetadata = await studyData.dirtyMetadata();
-    if (!isDirtyMetadata) {
+    if (!isDirtyMetadata && !options.force) {
       console.log("Study metadata", studyData.studyInstanceUid, "is clean.");
       delete this.studyData;
-      Stats.StudyStats.summarize(`Study metadata ${studyData.studyInstanceUid} has clean metadata, not writing`);
+      Stats.StudyStats.summarize(
+        `Study metadata ${studyData.studyInstanceUid} has clean metadata, not writing`,
+      );
       return;
     }
-    console.log("Writing study metadata", studyData.studyInstanceUid);
+    console.noQuiet("Writing study metadata", studyData.studyInstanceUid);
 
     const studyQuery = await studyData.writeMetadata();
 
-    const allStudies = await JSONReader(options.directoryName, "studies/index.json.gz", []);
+    const allStudies = await JSONReader(
+      options.directoryName,
+      "studies/index.json.gz",
+      [],
+    );
     const studyUID = Tags.getValue(studyQuery, Tags.StudyInstanceUID);
     if (!studyUID) {
       console.error("studyQuery=", studyQuery);
       throw new Error("Study query has null studyUID");
     }
-    const studyIndex = allStudies.findIndex((item) => Tags.getValue(item, Tags.StudyInstanceUID) == studyUID);
+    const studyIndex = allStudies.findIndex(
+      (item) => Tags.getValue(item, Tags.StudyInstanceUID) == studyUID,
+    );
     if (studyIndex == -1) {
       allStudies.push(studyQuery);
     } else {
       allStudies[studyIndex] = studyQuery;
     }
     await JSONWriter(options.directoryName, "studies", allStudies);
-    if (options.notifications) this.notificationService.notifyStudy(studyData.studyInstanceUid);
+    if (options.notifications)
+      this.notificationService.notifyStudy(studyData.studyInstanceUid);
+    const message = {
+      action: "metadata",
+      status: 0,
+      studyInstanceUid: studyData.studyInstanceUid,
+    };
+    this.success("completeStudyWriter", message);
     delete this.studyData;
-    Stats.StudyStats.summarize(`Wrote study metadata/query files for ${studyData.studyInstanceUid}`);
+    Stats.StudyStats.summarize(
+      `Wrote study metadata/query files for ${studyData.studyInstanceUid}`,
+    );
   }
 
   /**
@@ -81,7 +114,10 @@ const CompleteStudyWriter = (options) => {
       await callback.completeStudy(studyData);
     }
     callback.setStudyData(new StudyData(id, options));
-    await callback.studyData.init(options);
+    if (!options.isSkipStudyScan) {
+      console.verbose("Initiate StudyData");
+      await callback.studyData.init(options);
+    }
     return callback.studyData;
   };
 

package/lib/writer/DeduplicateWriter.js

@@ -24,7 +24,8 @@ const DeduplicateWriter = (options) =>
     const studyData = await this.completeStudy.getCurrentStudyData(this, id);
 
     if (options.isDeduplicate) {
-      if (options.verbose) console.log("Writing single instance", id.studyInstanceUid);
+      if (options.verbose)
+        console.log("Writing single instance", id.studyInstanceUid);
       await perInstanceWriter(id, data);
     } else if (options.verbose) {
       console.log("Not writing single instance deduplicated");

package/lib/writer/ExpandUriPath.js

@@ -8,7 +8,10 @@ const ExpandUriPath = (id, path, options) => {
     }
     expandedRelative = `studies/${id.studyInstanceUid}/${expandedRelativeSeries}`;
   }
-  if (options.verbose) console.log(`Expanded path returned: ${prependBulkDataUri}${expandedRelative}${path}`);
+  if (options.verbose)
+    console.log(
+      `Expanded path returned: ${prependBulkDataUri}${expandedRelative}${path}`,
+    );
   return `${prependBulkDataUri}${expandedRelative}${path}`;
 };
 

package/lib/writer/HashDataWriter.js

@@ -43,7 +43,11 @@ const HashDataWriter =
       gzip,
     });
     if (isRaw) {
-      await WriteMultipart(writeStream, [new MultipartHeader("Content-Type", "application/octet-stream")], rawData);
+      await WriteMultipart(
+        writeStream,
+        [new MultipartHeader("Content-Type", "application/octet-stream")],
+        rawData,
+      );
     } else {
       await writeStream.write(rawData);
     }

package/lib/writer/ImageFrameWriter.js

@@ -18,29 +18,54 @@ const ImageFrameWriter = (options) => {
     }
 
     if (encapsulatedImage || !extension) {
-      const writeStream = WriteStream(id.imageFrameRootPath, `${1 + index}.mht`, {
-        gzip: type.gzip,
-        mkdir: true,
-      });
+      const writeStream = WriteStream(
+        id.imageFrameRootPath,
+        `${1 + index}.mht`,
+        {
+          gzip: type.gzip,
+          mkdir: true,
+        },
+      );
       await WriteMultipart(
         writeStream,
-        [new MultipartHeader("Content-Type", type.contentType, [new MultipartAttribute("transfer-syntax", transferSyntaxUid)])],
-        content
+        [
+          new MultipartHeader("Content-Type", type.contentType, [
+            new MultipartAttribute("transfer-syntax", transferSyntaxUid),
+          ]),
+        ],
+        content,
       );
       await writeStream.close();
-      console.verbose("Wrote encapsulated image frame", id.sopInstanceUid, index + 1, type.contentType);
+      console.verbose(
+        "Wrote encapsulated image frame",
+        id.sopInstanceUid,
+        index + 1,
+        type.contentType,
+      );
     }
     if (extension && singlePartImage) {
-      const writeStreamSingle = WriteStream(id.imageFrameRootPath, `${1 + index}${extension}`, {
-        gzip: type.gzip,
-        mkdir: true,
-      });
+      const writeStreamSingle = WriteStream(
+        id.imageFrameRootPath,
+        `${1 + index}${extension}`,
+        {
+          gzip: type.gzip,
+          mkdir: true,
+        },
+      );
       await writeStreamSingle.write(content);
       await writeStreamSingle.close();
-      console.verbose("Wrote single part image frame", id.sopInstanceUid, index + 1, extension);
+      console.verbose(
+        "Wrote single part image frame",
+        id.sopInstanceUid,
+        index + 1,
+        extension,
+      );
     }
     const includeSeries = true;
-    return ExpandUriPath(id, `instances/${id.sopInstanceUid}/frames`, { includeSeries, ...options });
+    return ExpandUriPath(id, `instances/${id.sopInstanceUid}/frames`, {
+      includeSeries,
+      ...options,
+    });
   };
 };
 

package/lib/writer/RawDicomWriter.js

@@ -4,10 +4,15 @@ const WriteMultipart = require("./WriteMultipart");
 const { MultipartHeader } = require("./MultipartHeader");
 
 const modalitiesToRawWrite = ["SEG", "SR"];
+const sopClassesToRawWrite = ["1.2.840.10008.5.1.4.1.1.30"];
 
 const defaultSelector = (instance) => {
   const modality = instance.metadata[Tags.Modality]?.Value?.[0];
-  return modalitiesToRawWrite.indexOf(modality) !== -1;
+  const sopClass = instance.metadata[Tags.SOPClassUID]?.Value?.[0];
+  return (
+    modalitiesToRawWrite.indexOf(modality) !== -1 ||
+    sopClassesToRawWrite.indexOf(sopClass) !== -1
+  );
 };
 
 /** Writes out raw DICOM files, encapsulated in multipart and gzipped - currently just DICOM SR and SEG */
@@ -28,7 +33,11 @@ const RawDicomWriter =
     });
     const { length } = content;
     const buffer = content.slice(0, length);
-    await WriteMultipart(writeStream, [new MultipartHeader("Content-Type", contentType, [])], buffer);
+    await WriteMultipart(
+      writeStream,
+      [new MultipartHeader("Content-Type", contentType, [])],
+      buffer,
+    );
     await writeStream.close();
   };
 RawDicomWriter.defaultSelector = defaultSelector;

package/lib/writer/VideoWriter.js

@@ -19,16 +19,23 @@ const VIDEO_TYPES = {
   // TODO - add the new multi-segment MPEG2 and H264 variants
 };
 
-const isVideo = (value) => VIDEO_TYPES[value && value.string ? value.string(Tags.RawTransferSyntaxUID) : value];
+const isVideo = (value) =>
+  VIDEO_TYPES[
+    value && value.string ? value.string(Tags.RawTransferSyntaxUID) : value
+  ];
 
 const VideoWriter = () =>
   async function run(id, dataSet) {
     console.log(`Writing video  ${id.sopInstanceUid}`);
     const extension = VIDEO_TYPES[dataSet.string(Tags.RawTransferSyntaxUID)];
     const filename = `index.${extension}`;
-    const writeStream = WriteStream(`${id.sopInstanceRootPath}/rendered`, filename, {
-      mkdir: true,
-    });
+    const writeStream = WriteStream(
+      `${id.sopInstanceRootPath}/rendered`,
+      filename,
+      {
+        mkdir: true,
+      },
+    );
     let length = 0;
     const { fragments } = dataSet.elements.x7fe00010;
 
@@ -39,13 +46,18 @@ const VideoWriter = () =>
     // The zero position fragment isn't available, even though present in the original data
     for (let i = 0; i < fragments.length; i++) {
       const fragment = fragments[i];
-      const blob = dataSet.byteArray.slice(fragment.position, fragment.position + fragment.length);
+      const blob = dataSet.byteArray.slice(
+        fragment.position,
+        fragment.position + fragment.length,
+      );
       length += blob.length;
       await writeStream.write(blob);
     }
     await writeStream.close();
-    console.log(`Done video ${id.sopInstanceRootPath}\\${filename} of length ${length}`);
-    return `series/${id.seriesInstanceUid}/instances/${id.sopInstanceUid}/pixeldata.${extension}?length=${length}&offset=0`;
+    console.log(
+      `Done video ${id.sopInstanceRootPath}\\${filename} of length ${length}`,
+    );
+    return `series/${id.seriesInstanceUid}/instances/${id.sopInstanceUid}/rendered?length=${length}&offset=0&accept=video/mp4`;
   };
 
 module.exports = VideoWriter;

package/lib/writer/WriteMultipart.js

@@ -9,7 +9,9 @@ const WriteMultipart = async (writeStream, headers, content) => {
     if (header.attributes) {
       for (let j = 0; j < header.attributes.length; j++) {
         const attribute = header.attributes[j];
-        await writeStream.write(`;${attribute.attributeName}=${attribute.attributeValue}`);
+        await writeStream.write(
+          `;${attribute.attributeName}=${attribute.attributeValue}`,
+        );
       }
     }
     await writeStream.write("\r\n");