@radicalimaging/static-wado-creator 1.5.0 → 1.6.11

package/lib/operation/getValue.js

@@ -1,7 +1,7 @@
-const extractImageFrames = require("./extractImageFrames");
+const extractImageFrames = require('./extractImageFrames');
 
 function decodeUtf8(s, options) {
-  if (options?.SpecificCharacterSet === "ISO_IR 192") {
+  if (options?.SpecificCharacterSet === 'ISO_IR 192') {
     return decodeURIComponent(escape(s));
   }
   return s;
@@ -22,19 +22,14 @@ 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
-  );
-  return { InlineBinary: binaryValue.toString("base64") };
+  const binaryValue = dataSet.byteArray.slice(attr.dataOffset, attr.dataOffset + attr.length);
+  return { InlineBinary: binaryValue.toString('base64') };
 };
 
 const getValueInlineSignedShort = (dataSet, attr) => {
@@ -79,10 +74,10 @@ const getValueInlineFloat = (dataSet, attr) => {
 };
 
 const getValueInlineIntString = (dataSet, attr) =>
-  getStrings(dataSet, attr).map((val) => parseInt(val));
+  getStrings(dataSet, attr).map(val => parseInt(val));
 
 const getValueInlineFloatString = (dataSet, attr) =>
-  getStrings(dataSet, attr).map((val) => parseFloat(val));
+  getStrings(dataSet, attr).map(val => parseFloat(val));
 
 const getValueInlineFloatDouble = (dataSet, attr) => {
   if (attr.length > 8) {
@@ -105,63 +100,63 @@ const getValueInline = (dataSet, attr, vr, options) => {
   }
 
   switch (vr) {
-    case "AE":
-    case "AS":
+    case 'AE':
+    case 'AS':
       return getValueInlineString(dataSet, attr, options);
-    case "AT":
+    case 'AT':
       return getValueInlineAttributeTag(dataSet, attr);
-    case "DS":
+    case 'DS':
       return getValueInlineFloatString(dataSet, attr);
-    case "CS":
-    case "DA":
-    case "DT":
+    case 'CS':
+    case 'DA':
+    case 'DT':
       return getValueInlineString(dataSet, attr, options);
-    case "FL":
+    case 'FL':
       return getValueInlineFloat(dataSet, attr);
-    case "FD":
+    case 'FD':
       return getValueInlineFloatDouble(dataSet, attr);
-    case "IS":
+    case 'IS':
       return getValueInlineIntString(dataSet, attr);
-    case "LO":
-    case "LT":
+    case 'LO':
+    case 'LT':
       return getValueInlineString(dataSet, attr, options);
-    case "OB":
-    case "OF":
-    case "OW":
+    case 'OB':
+    case 'OF':
+    case 'OW':
       return getValueInlineBinary(dataSet, attr);
-    case "PN":
+    case 'PN':
       return getValuePatientName(dataSet, attr);
-    case "SH":
+    case 'SH':
       return getValueInlineString(dataSet, attr, options);
-    case "SL":
+    case 'SL':
       return getValueInlineSignedLong(dataSet, attr);
-    case "SS":
+    case 'SS':
       return getValueInlineSignedShort(dataSet, attr);
-    case "ST":
-    case "TM":
-    case "UI":
+    case 'ST':
+    case 'TM':
+    case 'UI':
       return getValueInlineString(dataSet, attr, options);
-    case "UL":
+    case 'UL':
       return getValueInlineUnsignedLong(dataSet, attr);
-    case "UN":
+    case 'UN':
       return getValueInlineBinary(dataSet, attr);
-    case "US":
+    case 'US':
       return getValueInlineUnsignedShort(dataSet, attr);
-    case "UT":
+    case 'UT':
       return getValueInlineString(dataSet, attr, options);
     default:
       return getValueInlineBinary(dataSet, attr);
   }
 };
 
-const isPrivate = (attr) => {
+const isPrivate = attr => {
   const { tag } = attr;
   const ch = tag.substr(4, 1);
   const chHex = parseInt(ch, 16);
   return chHex % 2 == 1;
 };
 
-const RawEncapsulatedDocument = "x00420011";
+const RawEncapsulatedDocument = 'x00420011';
 
 const isValueInline = (attr, options) => {
   if (isPrivate(attr)) {
@@ -187,30 +182,15 @@ 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
-    );
+  if (attr.tag === 'x7fe00010' && !parentAttr) {
+    const BulkDataURI = await extractImageFrames(dataSet, attr, vr, callback, options);
     return { BulkDataURI };
   }
-  if (attr.tag === "xfffee00d") return undefined;
+  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 = [];
@@ -227,11 +207,8 @@ const getValue = async (
   if (isValueInline(attr, options)) {
     return getValueInline(dataSet, attr, vr, options);
   }
-  const binaryValue = dataSet.byteArray.slice(
-    attr.dataOffset,
-    attr.dataOffset + attr.length
-  );
-  const mimeType = attr.tag == "x00420011" && dataSet.string("x00420012");
+  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 });
   return { BulkDataURI, vr };

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

@@ -1,4 +1,4 @@
-const staticWadoUtil = require("@radicalimaging/static-wado-util");
+const staticWadoUtil = require('@radicalimaging/static-wado-util');
 
 /**
  * Configure static-wado-creator commander program.
@@ -8,8 +8,7 @@ const staticWadoUtil = require("@radicalimaging/static-wado-util");
  */
 async function configureProgram(defaults) {
   const configurationFile = await staticWadoUtil.loadConfiguration(defaults, process.argv);
-  console.log("Loaded configuration from", configurationFile);
-  staticWadoUtil.configureCommands(defaults);
+  return staticWadoUtil.configureCommands(defaults);
 }
 
 exports.configureProgram = configureProgram;

package/lib/rejectMain.js

@@ -1,5 +1,5 @@
-const StaticWado = require("./StaticWado");
-const adaptProgramOpts = require("./util/adaptProgramOpts");
+const StaticWado = require('./StaticWado');
+const adaptProgramOpts = require('./util/adaptProgramOpts');
 
 module.exports = function rejectMain(args, options) {
   const finalOptions = adaptProgramOpts(options, {

package/lib/serverMain.js

@@ -0,0 +1,21 @@
+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,13 +1,30 @@
-const path = require("path");
+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 imageFrameRootPath = path.join(sopInstanceRootPath, "frames");
+    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,

package/lib/util/adaptProgramOpts.js

@@ -1,5 +1,5 @@
 const assignDefined = (dest, src) => {
-  Object.keys(src).forEach((key) => {
+  Object.keys(src).forEach(key => {
     const val = src[key];
     if (val !== undefined) {
       dest[key] = val;

package/lib/util/compressionOptionParser.js

@@ -1,12 +1,12 @@
-const { program } = require("@radicalimaging/static-wado-util");
-const { getDestinationTranscoder } = require("../operation/adapter/transcodeImage");
+const { program } = require('@radicalimaging/static-wado-util');
+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);
+    console.log('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,87 @@
+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,6 +1,6 @@
-const { JSONReader, JSONWriter, Stats } = require("@radicalimaging/static-wado-util");
-const { Tags } = require("@radicalimaging/static-wado-util");
-const StudyData = require("../operation/StudyData");
+const { JSONReader, JSONWriter, Stats } = require('@radicalimaging/static-wado-util');
+const { Tags } = require('@radicalimaging/static-wado-util');
+const StudyData = require('../operation/StudyData');
 
 /**
  * CompleteStudyWriter takes the deduplicated data values, all loaded into the study parameter,
@@ -8,13 +8,13 @@ const StudyData = require("../operation/StudyData");
  * written out as.
  * The studyData object is then removed, so that a new one can be created if required.
  */
-const CompleteStudyWriter = (options) => {
+const CompleteStudyWriter = options => {
   async function ret() {
     const { studyData } = this;
     if (!studyData) return;
 
     if (!studyData.numberOfInstances) {
-      console.log("studyData.deduplicated is empty");
+      console.log('studyData.deduplicated is empty');
       delete this.studyData;
       return;
     }
@@ -22,15 +22,23 @@ 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);
       delete this.studyData;
       Stats.StudyStats.summarize();
@@ -38,32 +46,44 @@ const CompleteStudyWriter = (options) => {
     }
 
     const isDirtyMetadata = await studyData.dirtyMetadata();
-    if (!isDirtyMetadata) {
-      console.log("Study metadata", studyData.studyInstanceUid, "is clean.");
+    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");
+      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);
+    await JSONWriter(options.directoryName, 'studies', allStudies);
     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 +101,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

@@ -1,9 +1,9 @@
-const hashFactory = require("node-object-hash");
+const hashFactory = require('node-object-hash');
 
 const hasher = hashFactory.hasher();
-const { JSONWriter } = require("@radicalimaging/static-wado-util");
-const { Tags } = require("@radicalimaging/static-wado-util");
-const TagLists = require("../model/TagLists");
+const { JSONWriter } = require('@radicalimaging/static-wado-util');
+const { Tags } = require('@radicalimaging/static-wado-util');
+const TagLists = require('../model/TagLists');
 
 async function writeDeduplicatedFile(dir, data, hashValueSrc) {
   const hashValue = hashValueSrc || hasher.hash(data);
@@ -19,15 +19,15 @@ const perInstanceWriter = async (id, data) => {
 };
 
 /** Writes out JSON files to the given file name.  Automatically GZips them, and adds the extension */
-const DeduplicateWriter = (options) =>
+const DeduplicateWriter = options =>
   async function DeduplicateWriterInstance(id, data) {
     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");
+      console.log('Not writing single instance deduplicated');
     }
     studyData.addDeduplicated(data, id.filename);
   };

package/lib/writer/ExpandUriPath.js

@@ -1,14 +1,15 @@
 const ExpandUriPath = (id, path, options) => {
   const { prependBulkDataUri, expandBulkDataUri, includeSeries } = options;
-  let expandedRelative = "";
+  let expandedRelative = '';
   if (expandBulkDataUri) {
-    let expandedRelativeSeries = "";
+    let expandedRelativeSeries = '';
     if (includeSeries) {
       expandedRelativeSeries = `series/${id.seriesInstanceUid}/`;
     }
     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}`;
 };