Chore/kill yalc with fire (#629)

* init * more shifting * Move @babel dependencies up to workspace root * Begin updating dependent libraries to use sync'd webpack builds w/ watches * Commit changes before a long weekend * Split packages into platform and extensions * Consolidate how/where we specify file/module type entrypoints * Make it possible to pass in extensions as App props * Resolve viewer's modules * Target for UMD bundle * Add Webpack Stylus loader * Provide WebPack build options for microscopy, vtk, and ui * Better entrypoint for extensions * Push changes up to switch PCs * Fix ESM symlink build for Viewers * Shift docs to root * Specify additional lerna config props * Begin providing basic readme info * Rename example extension folder * Shift links to bottom of doc * First attempt at a netlify deploy preview * Attempt to fix deploy preview build * push workspace enabled to initial command; remove second yarn install; use npx to call gitbook cli commands * Try to use global gitbook-cli * Export node_modules path * More agressive with modifying PATH * Follow deploy log output advice * try again to set bin path * Try swapping bash with a new shell * Try bash -l instead of exec bash * Annd let's try again * and again * We may have figured it out johnny, boy * We need to pull cornerstone-wado-image-loader files from hoisted node_modules * Attempt to fix ticks/escapes * Change copy syntax; try running tests on viewers from root for circleci * Lower version to match circleci image * Try alternative jest-canvas-mock location and version file syntax * Run version command instead of calling node directly * Try alternative jest transform * Set path and enable workspaces * Add codecov flags * Use cpx so our copying finishes? * Get all platform unit tests to run * Run and report individually and in parallel * Try once relying on codecov yaml to split w/ flags * Add projects to split by flags * Generate separate reports * Trigger codecov after everything has finished running; these may not support flags * Use recommended flags from issue comments for codecov * Fix typo * Remove clear flag * Shift back to calling codecov from root * Generate example for codecov issue * Try fixing paths * Simplify * Try using codecov orb * Bump circleci version * Upload core and viewer * Use full string paths * Remove individual codecov calls * Fix dir * Combine files before upload * Escape anchors * tryfix syntax * Escape string literal * Combine lines to reduce path * long paths * Use home alias * Fix filename * Try to see the contents of our cat'd file * Also upload `core` * Try running with aliased folder * Fix path; split PR and Merge unit tests into separate jobs * Set default threshold * Fix typo * Changing to scoped package names * Adding note * Catch more updates * chore(release): publish %s [skip ci] - @ohif/extension-cornerstone@0.0.39-alpha.0 - @ohif/extension-dicom-html@0.0.4-alpha.0 - @ohif/extension-dicom-microscopy@0.0.9-alpha.0 - @ohif/extension-dicom-pdf@0.0.8-alpha.0 - @ohif/extension-vtk@0.1.4-alpha.0 - @ohif/core@0.11.1-alpha.0 - @ohif/i18n@0.2.3-alpha.0 - @ohif/ui@0.2.18-alpha.0 - @ohif/viewer@0.0.22-alpha.0 * Clean up primary readme * Support for dev and dev:* commands * Shift build command; satisfy default PWA build * Remove old scripts * Clean up UI to set webpack scripts * Tidy up project links * Clean duplicate code in UI project * Update UI project's docs * Clean up ui and i18n config * Reduce duplicate code in `@ohif/core` * Fix @ohif/ui versions * bump @ohif/core versions * Redux testkit dep * Remove unused/duplicate config files for projects/packages * ohif-core --> @ohif/core * Safer publish command * chore(release): publish %s [skip ci] - @ohif/extension-cornerstone@0.0.39-alpha.1 - @ohif/extension-dicom-html@0.0.4-alpha.1 - @ohif/extension-dicom-microscopy@0.0.9-alpha.1 - @ohif/extension-dicom-pdf@0.0.8-alpha.1 - @ohif/extension-vtk@0.1.4-alpha.1 - @ohif/core@0.11.1-alpha.1 - @ohif/i18n@0.2.3-alpha.1 - @ohif/ui@0.2.18-alpha.1 - @ohif/viewer@0.0.22-alpha.1 * test version bump * Add global prettier config * chore(release): publish %s [skip ci] - @ohif/viewer@0.0.22-alpha.2 * test lerna publish * Update package.jsons * Fix build scripts * catch changes * chore(release): publish %s [skip ci] - @ohif/extension-cornerstone@0.0.39-alpha.2 - @ohif/extension-dicom-html@0.0.4-alpha.2 - @ohif/extension-dicom-microscopy@0.0.9-alpha.2 - @ohif/extension-dicom-pdf@0.0.8-alpha.2 - @ohif/extension-vtk@0.1.4-alpha.2 - @ohif/core@0.11.1-alpha.2 - @ohif/i18n@0.2.3-alpha.2 - @ohif/ui@0.2.18-alpha.2 - @ohif/viewer@0.0.22-alpha.3 * fix eslint issues caused by eslint 6 and our react-app config * Publish with canary tag * chore(release): publish %s [skip ci] - @ohif/extension-cornerstone@0.0.39-alpha.3 - @ohif/extension-dicom-html@0.0.4-alpha.3 - @ohif/extension-dicom-microscopy@0.0.9-alpha.3 - @ohif/extension-dicom-pdf@0.0.8-alpha.3 - @ohif/extension-vtk@0.1.4-alpha.3 - @ohif/core@0.11.1-alpha.3 - @ohif/i18n@0.2.3-alpha.3 - @ohif/ui@0.2.18-alpha.3 - @ohif/viewer@0.0.22-alpha.4 * chore(release): publish %s [skip ci] - @ohif/extension-cornerstone@0.0.39-alpha.4 - @ohif/extension-dicom-html@0.0.4-alpha.4 - @ohif/extension-dicom-microscopy@0.0.9-alpha.4 - @ohif/extension-dicom-pdf@0.0.8-alpha.4 - @ohif/extension-vtk@0.1.4-alpha.4 - @ohif/core@0.11.1-alpha.4 - @ohif/i18n@0.2.3-alpha.4 - @ohif/ui@0.2.18-alpha.4 - @ohif/viewer@0.0.22-alpha.5 * Simplify build * chore(release): publish %s [skip ci] - @ohif/extension-cornerstone@0.0.39-alpha.5 - @ohif/extension-dicom-html@0.0.4-alpha.5 - @ohif/extension-dicom-microscopy@0.0.9-alpha.5 - @ohif/extension-dicom-pdf@0.0.8-alpha.5 - @ohif/extension-vtk@0.1.4-alpha.5 - @ohif/core@0.11.1-alpha.5 - @ohif/i18n@0.2.3-alpha.5 - @ohif/ui@0.2.18-alpha.5 - @ohif/viewer@0.0.22-alpha.6 * chore(release): publish %s [skip ci] - @ohif/extension-cornerstone@0.0.39-alpha.6 - @ohif/extension-dicom-html@0.0.4-alpha.6 - @ohif/extension-dicom-microscopy@0.0.9-alpha.6 - @ohif/extension-dicom-pdf@0.0.8-alpha.6 - @ohif/extension-vtk@0.1.4-alpha.6 - @ohif/core@0.11.1-alpha.6 - @ohif/i18n@0.2.3-alpha.6 - @ohif/ui@0.2.18-alpha.6 - @ohif/viewer@0.0.22-alpha.7 * Split version and publish * chore(release): publish %s [skip ci] - @ohif/extension-cornerstone@0.0.39-alpha.7 - @ohif/extension-dicom-html@0.0.4-alpha.7 - @ohif/extension-dicom-microscopy@0.0.9-alpha.7 - @ohif/extension-dicom-pdf@0.0.8-alpha.7 - @ohif/extension-vtk@0.1.4-alpha.7 - @ohif/core@0.11.1-alpha.7 - @ohif/i18n@0.2.3-alpha.7 - @ohif/ui@0.2.18-alpha.7 - @ohif/viewer@0.0.22-alpha.8 * Try simplify netlify build * react-viewerbase --> @ohif/ui * add test for stylus loader * Try new way to specify publish path * Use an output folder that won't be ignored * Try move command * fiddle with paths * Dig for some information * Make sure we're in root for our commands * Remove discovery * Setup script-tag example * Fix typo * Move config folder * Update cornerstone extension to use shared/root webpack configs * capture changes * Update extension webpack configs * Don't check in docz output * Fix babel runtime resolution issue * Simplify ui build steps * Push in progress * Shift directories * Get viewer dev path to work * Fix viewer commonjs build * Fix build pwa config for viewers * Make sure our package specific command can be called from root * Update notes * Fix imports and misc. merge notes * Bump wado-image-loader version * Switch up commands to remove webworkers copy * Fix CI config * Fix more broken package references * Add react-dropzone * Persist so e2e test can use * Fix lockfile * Use cypress orb to simplify CI * Fix config * Try again * Install yarn latest for orb * Install yarn a different way * Wait on correct port * Run tests in viewer project * Fix cypress config * Make Cypress happier - use default location * Simplify e2e testing * Capture UI changes since fork * Catch core up * Grab latest deps after merge * Fix broken import * Make sure cornerstone-wado-image-loader resolves to 3+ * Note regarding orbs * Fix refresh on 404 routes * Fix odd error for cornerstone-wado-image-loader * Different target for UMD * Simplify dev script * Try to get fancy with netlify output * Let's do it again * Try to fix measurementTools issue * See if we can get our lerna magic to work on merge to monorepo branch
2019-08-13 15:36:46 -04:00
1 parent cac911f08e
commit 08ff214ea6
@@ -0,0 +1,16 @@
+/**
+ * Overridable namespace to allow getting study boxes data externally.
+ *
+ * The function must handle the first parameter as a studyInformation object containing at least the
+ * studyInstanceUid attribute.
+ *
+ * Shall return a promise that will be resolved with an object containing those attributes:
+ * - studyInstanceUid {String}: copy of studyInformation.studyInstanceUid
+ * - modalities {String}: 2 uppercase letters for each modality split by any non-alphabetical char(s)
+ * - studyDate {String}: date formatted as YYYYMMDD
+ * - studyDescription {String}: study description string
+ */
+// TODO: What is this for?
+const getStudyBoxData = false;
+
+export default getStudyBoxData;
@@ -0,0 +1,26 @@
+import { QIDO, WADO } from './services/';
+import {
+  deleteStudyMetadataPromise,
+  retrieveStudyMetadata,
+} from './retrieveStudyMetadata.js';
+
+import getStudyBoxData from './getStudyBoxData';
+import retrieveStudiesMetadata from './retrieveStudiesMetadata.js';
+import searchStudies from './searchStudies';
+import sortStudy from './sortStudy';
+
+const studies = {
+  services: {
+    QIDO,
+    WADO,
+  },
+  loadingDict: {},
+  retrieveStudyMetadata,
+  deleteStudyMetadataPromise,
+  retrieveStudiesMetadata,
+  getStudyBoxData,
+  searchStudies,
+  sortStudy,
+};
+
+export default studies;
@@ -0,0 +1,41 @@
+import log from '../log.js';
+import { retrieveStudyMetadata } from './retrieveStudyMetadata';
+
+/**
+ * Retrieves metaData for multiple studies at once.
+ *
+ * This function calls retrieveStudyMetadata several times, asynchronously,
+ * and waits for all of the results to be returned.
+ *
+ * @param studyInstanceUids The UIDs of the Studies to be retrieved
+ * @return Promise
+ */
+export default function retrieveStudiesMetadata(
+  server,
+  studyInstanceUids,
+  seriesInstanceUids
+) {
+  // Create an empty array to store the Promises for each metaData retrieval call
+  const promises = [];
+
+  // Loop through the array of studyInstanceUids
+  studyInstanceUids.forEach(function(studyInstanceUid) {
+    // Send the call and resolve or reject the related promise based on its outcome
+    const promise = retrieveStudyMetadata(
+      server,
+      studyInstanceUid,
+      seriesInstanceUids
+    );
+
+    // Add the current promise to the array of promises
+    promises.push(promise);
+  });
+
+  // When all of the promises are complete, this callback runs
+  const promise = Promise.all(promises);
+
+  // Warn the error on console if some retrieval failed
+  promise.catch(error => log.warn(error));
+
+  return promise;
+}
@@ -0,0 +1,57 @@
+import RetrieveMetadata from './services/wado/retrieveMetadata.js';
+
+const module = 'RetrieveStudyMetadata';
+// Cache for promises. Prevents unnecessary subsequent calls to the server
+const StudyMetaDataPromises = new Map();
+
+/**
+ * Retrieves study metadata
+ *
+ * @param {Object} server
+ * @param {string} studyInstanceUid The UID of the Study to be retrieved
+ * @returns {Promise} that will be resolved with the metadata or rejected with the error
+ */
+export function retrieveStudyMetadata(server, studyInstanceUid) {
+  // @TODO: Whenever a study metadata request has failed, its related promise will be rejected once and for all
+  // and further requests for that metadata will always fail. On failure, we probably need to remove the
+  // corresponding promise from the "StudyMetaDataPromises" map...
+
+  if (!server) {
+    throw new Error(`${module}: Required 'server' parameter not provided.`);
+  }
+  if (!studyInstanceUid) {
+    throw new Error(
+      `${module}: Required 'studyInstanceUid' parameter not provided.`
+    );
+  }
+
+  // Already waiting on result? Return cached promise
+  if (StudyMetaDataPromises.has(studyInstanceUid)) {
+    return StudyMetaDataPromises.get(studyInstanceUid);
+  }
+
+  // Create a promise to handle the data retrieval
+  const promise = new Promise((resolve, reject) => {
+    RetrieveMetadata(server, studyInstanceUid).then(function(data) {
+      resolve(data);
+    }, reject);
+  });
+
+  // Store the promise in cache
+  StudyMetaDataPromises.set(studyInstanceUid, promise);
+
+  return promise;
+}
+
+/**
+ * Delete the cached study metadata retrieval promise to ensure that the browser will
+ * re-retrieve the study metadata when it is next requested
+ *
+ * @param {String} studyInstanceUid The UID of the Study to be removed from cache
+ *
+ */
+export function deleteStudyMetadataPromise(studyInstanceUid) {
+  if (StudyMetaDataPromises.has(studyInstanceUid)) {
+    StudyMetaDataPromises.delete(studyInstanceUid);
+  }
+}
@@ -0,0 +1,35 @@
+import { retrieveStudyMetadata } from './retrieveStudyMetadata.js';
+
+const fakeDicomWebServer = {};
+
+// Testing Promises: https://jestjs.io/docs/en/asynchronous#promises
+describe('retrieveStudyMetadata.js', () => {
+  it('throws an exception if no server parameter is provided', () => {
+    const callWithNoServer = () => {
+      retrieveStudyMetadata(null, 'fake-study-instance-uid');
+    };
+
+    expect(callWithNoServer).toThrow(Error);
+  });
+
+  it('throws an exception if no studyInstanceUid parameter is provided', () => {
+    const callWithNoStudyInstanceUid = () => {
+      retrieveStudyMetadata(fakeDicomWebServer, null);
+    };
+
+    expect(callWithNoStudyInstanceUid).toThrow(Error);
+  });
+
+  it('caches and returns the same promise for identical studyInstanceUIDs', () => {
+    const firstPromise = retrieveStudyMetadata(
+      fakeDicomWebServer,
+      'fake-study-instance-uid'
+    );
+    const secondPromise = retrieveStudyMetadata(
+      fakeDicomWebServer,
+      'fake-study-instance-uid'
+    );
+
+    expect(firstPromise).toBe(secondPromise);
+  });
+});
@@ -0,0 +1,26 @@
+import Studies from './services/qido/studies';
+
+const studySearchPromises = new Map();
+
+/**
+ * Search for studies information by the given filter
+ *
+ * @param {Object} filter Filter that will be used on search
+ * @returns {Promise} resolved with an array of studies information or rejected with an error
+ */
+export default function searchStudies(server, filter) {
+  const promiseKeyObj = {
+    qidoRoot: server.qidoRoot,
+    filter,
+  };
+  const promiseKey = JSON.stringify(promiseKeyObj);
+  if (studySearchPromises.has(promiseKey)) {
+    return studySearchPromises.get(promiseKey);
+  } else {
+    const promise = Studies(server, filter);
+
+    studySearchPromises.set(promiseKey, promise);
+
+    return promise;
+  }
+}
@@ -0,0 +1,15 @@
+// DICOMWeb instance, study, and metadata retrieval
+import Instances from './qido/instances.js';
+import Studies from './qido/studies.js';
+import RetrieveMetadata from './wado/retrieveMetadata.js';
+
+const WADO = {
+  RetrieveMetadata,
+};
+
+const QIDO = {
+  Studies,
+  Instances,
+};
+
+export { QIDO, WADO };
@@ -0,0 +1,103 @@
+import DICOMWeb from '../../../DICOMWeb/';
+import { api } from 'dicomweb-client';
+
+/**
+ * Parses data returned from a QIDO search and transforms it into
+ * an array of series that are present in the study
+ *
+ * @param server The DICOM server
+ * @param studyInstanceUid
+ * @param resultData
+ * @returns {Array} Series List
+ */
+function resultDataToStudyMetadata(server, studyInstanceUid, resultData) {
+  const seriesMap = {};
+  const seriesList = [];
+
+  resultData.forEach(function(instance) {
+    // Use seriesMap to cache series data
+    // If the series instance UID has already been used to
+    // process series data, continue using that series
+    var seriesInstanceUid = DICOMWeb.getString(instance['0020000E']);
+    var series = seriesMap[seriesInstanceUid];
+
+    // If no series data exists in the seriesMap cache variable,
+    // process any available series data
+    if (!series) {
+      series = {
+        seriesInstanceUid: seriesInstanceUid,
+        seriesNumber: DICOMWeb.getString(instance['00200011']),
+        instances: [],
+      };
+
+      // Save this data in the seriesMap cache variable
+      seriesMap[seriesInstanceUid] = series;
+      seriesList.push(series);
+    }
+
+    // The uri for the dicomweb
+    // NOTE: DCM4CHEE seems to return the data zipped
+    // NOTE: Orthanc returns the data with multi-part mime which cornerstoneWADOImageLoader doesn't
+    //       know how to parse yet
+    //var uri = DICOMWeb.getString(instance['00081190']);
+    //uri = uri.replace('wado-rs', 'dicom-web');
+
+    // manually create a WADO-URI from the UIDs
+    // NOTE: Haven't been able to get Orthanc's WADO-URI to work yet - maybe its not configured?
+    var sopInstanceUid = DICOMWeb.getString(instance['00080018']);
+    var uri =
+      server.wadoUriRoot +
+      '?requestType=WADO&studyUID=' +
+      studyInstanceUid +
+      '&seriesUID=' +
+      seriesInstanceUid +
+      '&objectUID=' +
+      sopInstanceUid +
+      '&contentType=application%2Fdicom';
+
+    // Add this instance to the current series
+    series.instances.push({
+      sopClassUid: DICOMWeb.getString(instance['00080016']),
+      sopInstanceUid: sopInstanceUid,
+      uri: uri,
+      instanceNumber: DICOMWeb.getString(instance['00200013']),
+    });
+  });
+  return seriesList;
+}
+
+/**
+ * Retrieve a set of instances using a QIDO call
+ * @param server
+ * @param studyInstanceUid
+ * @throws ECONNREFUSED
+ * @returns {{wadoUriRoot: String, studyInstanceUid: String, seriesList: Array}}
+ */
+export default function Instances(server, studyInstanceUid) {
+  // TODO: Are we using this function anywhere?? Can we remove it?
+
+  const config = {
+    url: server.qidoRoot,
+    headers: DICOMWeb.getAuthorizationHeader(server),
+  };
+  const dicomWeb = new api.DICOMwebClient(config);
+  const queryParams = getQIDOQueryParams(
+    filter,
+    server.qidoSupportsIncludeField
+  );
+  const options = {
+    studyInstanceUID: studyInstanceUid,
+  };
+
+  return dicomWeb.searchForInstances(options).then(result => {
+    return {
+      wadoUriRoot: server.wadoUriRoot,
+      studyInstanceUid: studyInstanceUid,
+      seriesList: resultDataToStudyMetadata(
+        server,
+        studyInstanceUid,
+        result.data
+      ),
+    };
+  });
+}
@@ -0,0 +1,130 @@
+import { api } from 'dicomweb-client';
+import DICOMWeb from '../../../DICOMWeb/';
+
+/**
+ * Creates a QIDO date string for a date range query
+ * Assumes the year is positive, at most 4 digits long.
+ *
+ * @param date The Date object to be formatted
+ * @returns {string} The formatted date string
+ */
+function dateToString(date) {
+  if (!date) return '';
+  let year = date.getFullYear().toString();
+  let month = (date.getMonth() + 1).toString();
+  let day = date.getDate().toString();
+  year = '0'.repeat(4 - year.length).concat(year);
+  month = '0'.repeat(2 - month.length).concat(month);
+  day = '0'.repeat(2 - day.length).concat(day);
+  return ''.concat(year, month, day);
+}
+
+/**
+ * Produces a QIDO URL given server details and a set of specified search filter
+ * items
+ *
+ * @param filter
+ * @param serverSupportsQIDOIncludeField
+ * @returns {string} The URL with encoded filter query data
+ */
+function getQIDOQueryParams(filter, serverSupportsQIDOIncludeField) {
+  const commaSeparatedFields = [
+    '00081030', // Study Description
+    '00080060', //Modality
+    // Add more fields here if you want them in the result
+  ].join(',');
+
+  const parameters = {
+    PatientName: filter.patientName,
+    PatientID: filter.patientId,
+    AccessionNumber: filter.accessionNumber,
+    StudyDescription: filter.studyDescription,
+    ModalitiesInStudy: filter.modalitiesInStudy,
+    limit: filter.limit,
+    offset: filter.offset,
+    fuzzymatching: filter.fuzzymatching,
+    includefield: serverSupportsQIDOIncludeField ? commaSeparatedFields : 'all',
+  };
+
+  // build the StudyDate range parameter
+  if (filter.studyDateFrom || filter.studyDateTo) {
+    const dateFrom = dateToString(new Date(filter.studyDateFrom));
+    const dateTo = dateToString(new Date(filter.studyDateTo));
+    parameters.StudyDate = `${dateFrom}-${dateTo}`;
+  }
+
+  // Build the StudyInstanceUID parameter
+  if (filter.studyInstanceUid) {
+    let studyUids = filter.studyInstanceUid;
+    studyUids = Array.isArray(studyUids) ? studyUids.join() : studyUids;
+    studyUids = studyUids.replace(/[^0-9.]+/g, '\\');
+    parameters.StudyInstanceUID = studyUids;
+  }
+
+  // Clean query params of undefined values.
+  const params = {};
+  Object.keys(parameters).forEach(key => {
+    if (parameters[key] !== undefined && parameters[key] !== '') {
+      params[key] = parameters[key];
+    }
+  });
+
+  return params;
+}
+
+/**
+ * Parses resulting data from a QIDO call into a set of Study MetaData
+ *
+ * @param resultData
+ * @returns {Array} An array of Study MetaData objects
+ */
+function resultDataToStudies(resultData) {
+  const studies = [];
+
+  if (!resultData || !resultData.length) return;
+
+  resultData.forEach(study =>
+    studies.push({
+      studyInstanceUid: DICOMWeb.getString(study['0020000D']),
+      // 00080005 = SpecificCharacterSet
+      studyDate: DICOMWeb.getString(study['00080020']),
+      studyTime: DICOMWeb.getString(study['00080030']),
+      accessionNumber: DICOMWeb.getString(study['00080050']),
+      referringPhysicianName: DICOMWeb.getString(study['00080090']),
+      // 00081190 = URL
+      patientName: DICOMWeb.getName(study['00100010']),
+      patientId: DICOMWeb.getString(study['00100020']),
+      patientBirthdate: DICOMWeb.getString(study['00100030']),
+      patientSex: DICOMWeb.getString(study['00100040']),
+      studyId: DICOMWeb.getString(study['00200010']),
+      numberOfStudyRelatedSeries: DICOMWeb.getString(study['00201206']),
+      numberOfStudyRelatedInstances: DICOMWeb.getString(study['00201208']),
+      studyDescription: DICOMWeb.getString(study['00081030']),
+      // modality: DICOMWeb.getString(study['00080060']),
+      // modalitiesInStudy: DICOMWeb.getString(study['00080061']),
+      modalities: DICOMWeb.getString(
+        DICOMWeb.getModalities(study['00080060'], study['00080061'])
+      ),
+    })
+  );
+
+  return studies;
+}
+
+export default function Studies(server, filter) {
+  const config = {
+    url: server.qidoRoot,
+    headers: DICOMWeb.getAuthorizationHeader(server),
+  };
+
+  const dicomWeb = new api.DICOMwebClient(config);
+  const queryParams = getQIDOQueryParams(
+    filter,
+    server.qidoSupportsIncludeField
+  );
+  const options = {
+    queryParams,
+  };
+
+  return dicomWeb.searchForStudies(options).then(resultDataToStudies);
+}
@@ -0,0 +1,469 @@
+import { api } from 'dicomweb-client';
+import DICOMWeb from '../../../DICOMWeb/';
+
+const WADOProxy = {
+  convertURL: (url, server) => {
+    // TODO: Remove all WADOProxy stuff from this file
+    return url;
+  },
+};
+
+function parseFloatArray(obj) {
+  const result = [];
+
+  if (!obj) {
+    return result;
+  }
+
+  const objs = obj.split('\\');
+  for (let i = 0; i < objs.length; i++) {
+    result.push(parseFloat(objs[i]));
+  }
+
+  return result;
+}
+
+/**
+ * Simple cache schema for retrieved color palettes.
+ */
+const paletteColorCache = {
+  count: 0,
+  maxAge: 24 * 60 * 60 * 1000, // 24h cache?
+  entries: {},
+  isValidUID: function(paletteUID) {
+    return typeof paletteUID === 'string' && paletteUID.length > 0;
+  },
+  get: function(paletteUID) {
+    let entry = null;
+    if (this.entries.hasOwnProperty(paletteUID)) {
+      entry = this.entries[paletteUID];
+      // check how the entry is...
+      if (Date.now() - entry.time > this.maxAge) {
+        // entry is too old... remove entry.
+        delete this.entries[paletteUID];
+        this.count--;
+        entry = null;
+      }
+    }
+    return entry;
+  },
+  add: function(entry) {
+    if (this.isValidUID(entry.uid)) {
+      let paletteUID = entry.uid;
+      if (this.entries.hasOwnProperty(paletteUID) !== true) {
+        this.count++; // increment cache entry count...
+      }
+      entry.time = Date.now();
+      this.entries[paletteUID] = entry;
+      // @TODO: Add logic to get rid of old entries and reduce memory usage...
+    }
+  },
+};
+
+/** Returns a WADO url for an instance
+ *
+ * @param studyInstanceUid
+ * @param seriesInstanceUid
+ * @param sopInstanceUid
+ * @returns  {string}
+ */
+function buildInstanceWadoUrl(
+  server,
+  studyInstanceUid,
+  seriesInstanceUid,
+  sopInstanceUid
+) {
+  // TODO: This can be removed, since DICOMWebClient has the same function. Not urgent, though
+  const params = [];
+
+  params.push('requestType=WADO');
+  params.push(`studyUID=${studyInstanceUid}`);
+  params.push(`seriesUID=${seriesInstanceUid}`);
+  params.push(`objectUID=${sopInstanceUid}`);
+  params.push('contentType=application/dicom');
+  params.push('transferSyntax=*');
+
+  const paramString = params.join('&');
+
+  return `${server.wadoUriRoot}?${paramString}`;
+}
+
+function buildInstanceWadoRsUri(
+  server,
+  studyInstanceUid,
+  seriesInstanceUid,
+  sopInstanceUid
+) {
+  return `${
+    server.wadoRoot
+  }/studies/${studyInstanceUid}/series/${seriesInstanceUid}/instances/${sopInstanceUid}`;
+}
+
+function buildInstanceFrameWadoRsUri(
+  server,
+  studyInstanceUid,
+  seriesInstanceUid,
+  sopInstanceUid,
+  frame
+) {
+  const baseWadoRsUri = buildInstanceWadoRsUri(
+    server,
+    studyInstanceUid,
+    seriesInstanceUid,
+    sopInstanceUid
+  );
+  frame = frame != null || 1;
+
+  return `${baseWadoRsUri}/frames/${frame}`;
+}
+
+/**
+ * Parses the SourceImageSequence, if it exists, in order
+ * to return a ReferenceSOPInstanceUID. The ReferenceSOPInstanceUID
+ * is used to refer to this image in any accompanying DICOM-SR documents.
+ *
+ * @param instance
+ * @returns {String} The ReferenceSOPInstanceUID
+ */
+function getSourceImageInstanceUid(instance) {
+  // TODO= Parse the whole Source Image Sequence
+  // This is a really poor workaround for now.
+  // Later we should probably parse the whole sequence.
+  var SourceImageSequence = instance['00082112'];
+  if (
+    SourceImageSequence &&
+    SourceImageSequence.Value &&
+    SourceImageSequence.Value.length
+  ) {
+    return SourceImageSequence.Value[0]['00081155'].Value[0];
+  }
+}
+
+function getPaletteColor(server, instance, tag, lutDescriptor) {
+  const numLutEntries = lutDescriptor[0];
+  const bits = lutDescriptor[2];
+
+  let uri = WADOProxy.convertURL(instance[tag].BulkDataURI, server);
+
+  // TODO: Workaround for dcm4chee behind SSL-terminating proxy returning
+  // incorrect bulk data URIs
+  if (server.wadoRoot.indexOf('https') === 0 && !uri.includes('https')) {
+    uri = uri.replace('http', 'https');
+  }
+
+  const config = {
+    url: server.wadoRoot, //BulkDataURI is absolute, so this isn't used
+    headers: DICOMWeb.getAuthorizationHeader(server),
+  };
+  const dicomWeb = new api.DICOMwebClient(config);
+  const options = {
+    BulkDataURI: uri,
+  };
+
+  const readUInt16 = (byteArray, position) => {
+    return byteArray[position] + byteArray[position + 1] * 256;
+  };
+
+  const arrayBufferToPaletteColorLUT = result => {
+    const arraybuffer = result[0]
+    const byteArray = new Uint8Array(arraybuffer)
+    const lut = []
+
+    for (let i = 0; i < numLutEntries; i++) {
+      if (bits === 16) {
+        lut[i] = readUInt16(byteArray, i * 2);
+      } else {
+        lut[i] = byteArray[i];
+      }
+    }
+
+    return lut;
+  };
+
+  return dicomWeb.retrieveBulkData(options).then(arrayBufferToPaletteColorLUT);
+}
+
+/**
+ * Fetch palette colors for instances with "PALETTE COLOR" photometricInterpretation.
+ *
+ * @param server {Object} Current server;
+ * @param instance {Object} The retrieved instance metadata;
+ * @returns {String} The ReferenceSOPInstanceUID
+ */
+async function getPaletteColors(server, instance, lutDescriptor) {
+  let paletteUID = DICOMWeb.getString(instance['00281199']);
+
+  return new Promise((resolve, reject) => {
+    let entry;
+    if (paletteColorCache.isValidUID(paletteUID)) {
+      entry = paletteColorCache.get(paletteUID);
+
+      if (entry) {
+        return resolve(entry);
+      }
+    }
+
+    // no entry in cache... Fetch remote data.
+    const r = getPaletteColor(server, instance, '00281201', lutDescriptor);
+    const g = getPaletteColor(server, instance, '00281202', lutDescriptor);
+    const b = getPaletteColor(server, instance, '00281203', lutDescriptor);
+
+    const promises = [r, g, b];
+
+    Promise.all(promises).then(args => {
+      entry = {
+        red: args[0],
+        green: args[1],
+        blue: args[2],
+      };
+
+      // when paletteUID is present, the entry can be cached...
+      entry.uid = paletteUID;
+      paletteColorCache.add(entry);
+
+      resolve(entry);
+    });
+  });
+}
+
+function getFrameIncrementPointer(element) {
+  const frameIncrementPointerNames = {
+    '00181065': 'frameTimeVector',
+    '00181063': 'frameTime',
+  };
+
+  if (!element || !element.Value || !element.Value.length) {
+    return;
+  }
+
+  const value = element.Value[0];
+  return frameIncrementPointerNames[value];
+}
+
+function getRadiopharmaceuticalInfo(instance) {
+  const modality = DICOMWeb.getString(instance['00080060']);
+
+  if (modality !== 'PT') {
+    return;
+  }
+
+  const radiopharmaceuticalInfo = instance['00540016'];
+  if (
+    radiopharmaceuticalInfo === undefined ||
+    !radiopharmaceuticalInfo.Value ||
+    !radiopharmaceuticalInfo.Value.length
+  ) {
+    return;
+  }
+
+  const firstPetRadiopharmaceuticalInfo = radiopharmaceuticalInfo.Value[0];
+  return {
+    radiopharmaceuticalStartTime: DICOMWeb.getString(
+      firstPetRadiopharmaceuticalInfo['00181072']
+    ),
+    radionuclideTotalDose: DICOMWeb.getNumber(
+      firstPetRadiopharmaceuticalInfo['00181074']
+    ),
+    radionuclideHalfLife: DICOMWeb.getNumber(
+      firstPetRadiopharmaceuticalInfo['00181075']
+    ),
+  };
+}
+
+/**
+ * Parses result data from a WADO search into Study MetaData
+ * Returns an object populated with study metadata, including the
+ * series list.
+ *
+ * @param server
+ * @param studyInstanceUid
+ * @param resultData
+ * @returns {{seriesList: Array, patientName: *, patientId: *, accessionNumber: *, studyDate: *, modalities: *, studyDescription: *, imageCount: *, studyInstanceUid: *}}
+ */
+async function resultDataToStudyMetadata(server, studyInstanceUid, resultData) {
+  if (!resultData.length) {
+    return;
+  }
+
+  const anInstance = resultData[0];
+  if (!anInstance) {
+    return;
+  }
+
+  // TODO: Pass a reference ID to the server instead of including the URLs here
+  const studyData = {
+    seriesList: [],
+    studyInstanceUid,
+    wadoUriRoot: server.wadoUriRoot,
+    wadoRoot: server.wadoRoot,
+    qidoRoot: server.qidoRoot,
+    patientName: DICOMWeb.getName(anInstance['00100010']),
+    patientId: DICOMWeb.getString(anInstance['00100020']),
+    patientAge: DICOMWeb.getNumber(anInstance['00101010']),
+    patientSize: DICOMWeb.getNumber(anInstance['00101020']),
+    patientWeight: DICOMWeb.getNumber(anInstance['00101030']),
+    accessionNumber: DICOMWeb.getString(anInstance['00080050']),
+    studyDate: DICOMWeb.getString(anInstance['00080020']),
+    modalities: DICOMWeb.getString(anInstance['00080061']),
+    studyDescription: DICOMWeb.getString(anInstance['00081030']),
+    imageCount: DICOMWeb.getString(anInstance['00201208']),
+    studyInstanceUid: DICOMWeb.getString(anInstance['0020000D']),
+    institutionName: DICOMWeb.getString(anInstance['00080080']),
+  };
+
+  const seriesMap = {};
+
+  await Promise.all(
+    resultData.map(async function(instance) {
+      const seriesInstanceUid = DICOMWeb.getString(instance['0020000E']);
+      let series = seriesMap[seriesInstanceUid];
+
+      if (!series) {
+        series = {
+          seriesDescription: DICOMWeb.getString(instance['0008103E']),
+          modality: DICOMWeb.getString(instance['00080060']),
+          seriesInstanceUid: seriesInstanceUid,
+          seriesNumber: DICOMWeb.getNumber(instance['00200011']),
+          seriesDate: DICOMWeb.getString(instance['00080021']),
+          seriesTime: DICOMWeb.getString(instance['00080031']),
+          instances: [],
+        };
+        seriesMap[seriesInstanceUid] = series;
+        studyData.seriesList.push(series);
+      }
+
+      const sopInstanceUid = DICOMWeb.getString(instance['00080018']);
+      const wadouri = buildInstanceWadoUrl(
+        server,
+        studyInstanceUid,
+        seriesInstanceUid,
+        sopInstanceUid
+      );
+      const baseWadoRsUri = buildInstanceWadoRsUri(
+        server,
+        studyInstanceUid,
+        seriesInstanceUid,
+        sopInstanceUid
+      );
+      const wadorsuri = buildInstanceFrameWadoRsUri(
+        server,
+        studyInstanceUid,
+        seriesInstanceUid,
+        sopInstanceUid
+      );
+
+      const instanceSummary = {
+        imageType: DICOMWeb.getString(instance['00080008']),
+        sopClassUid: DICOMWeb.getString(instance['00080016']),
+        modality: DICOMWeb.getString(instance['00080060']),
+        sopInstanceUid,
+        instanceNumber: DICOMWeb.getNumber(instance['00200013']),
+        imagePositionPatient: DICOMWeb.getString(instance['00200032']),
+        imageOrientationPatient: DICOMWeb.getString(instance['00200037']),
+        frameOfReferenceUID: DICOMWeb.getString(instance['00200052']),
+        sliceLocation: DICOMWeb.getNumber(instance['00201041']),
+        samplesPerPixel: DICOMWeb.getNumber(instance['00280002']),
+        photometricInterpretation: DICOMWeb.getString(instance['00280004']),
+        planarConfiguration: DICOMWeb.getNumber(instance['00280006']),
+        rows: DICOMWeb.getNumber(instance['00280010']),
+        columns: DICOMWeb.getNumber(instance['00280011']),
+        pixelSpacing: DICOMWeb.getString(instance['00280030']),
+        pixelAspectRatio: DICOMWeb.getString(instance['00280034']),
+        bitsAllocated: DICOMWeb.getNumber(instance['00280100']),
+        bitsStored: DICOMWeb.getNumber(instance['00280101']),
+        highBit: DICOMWeb.getNumber(instance['00280102']),
+        pixelRepresentation: DICOMWeb.getNumber(instance['00280103']),
+        smallestPixelValue: DICOMWeb.getNumber(instance['00280106']),
+        largestPixelValue: DICOMWeb.getNumber(instance['00280107']),
+        windowCenter: DICOMWeb.getString(instance['00281050']),
+        windowWidth: DICOMWeb.getString(instance['00281051']),
+        rescaleIntercept: DICOMWeb.getNumber(instance['00281052']),
+        rescaleSlope: DICOMWeb.getNumber(instance['00281053']),
+        rescaleType: DICOMWeb.getNumber(instance['00281054']),
+        sourceImageInstanceUid: getSourceImageInstanceUid(instance),
+        laterality: DICOMWeb.getString(instance['00200062']),
+        viewPosition: DICOMWeb.getString(instance['00185101']),
+        acquisitionDateTime: DICOMWeb.getString(instance['0008002A']),
+        numberOfFrames: DICOMWeb.getNumber(instance['00280008']),
+        frameIncrementPointer: getFrameIncrementPointer(instance['00280009']),
+        frameTime: DICOMWeb.getNumber(instance['00181063']),
+        frameTimeVector: parseFloatArray(
+          DICOMWeb.getString(instance['00181065'])
+        ),
+        sliceThickness: DICOMWeb.getNumber(instance['00180050']),
+        spacingBetweenSlices: DICOMWeb.getString(instance['00180088']),
+        lossyImageCompression: DICOMWeb.getString(instance['00282110']),
+        derivationDescription: DICOMWeb.getString(instance['00282111']),
+        lossyImageCompressionRatio: DICOMWeb.getString(instance['00282112']),
+        lossyImageCompressionMethod: DICOMWeb.getString(instance['00282114']),
+        echoNumber: DICOMWeb.getString(instance['00180086']),
+        contrastBolusAgent: DICOMWeb.getString(instance['00180010']),
+        radiopharmaceuticalInfo: getRadiopharmaceuticalInfo(instance),
+        baseWadoRsUri: baseWadoRsUri,
+        wadouri: WADOProxy.convertURL(wadouri, server),
+        wadorsuri: WADOProxy.convertURL(wadorsuri, server),
+        imageRendering: server.imageRendering,
+        thumbnailRendering: server.thumbnailRendering,
+      };
+
+      // Get additional information if the instance uses "PALETTE COLOR" photometric interpretation
+      if (instanceSummary.photometricInterpretation === 'PALETTE COLOR') {
+        const redPaletteColorLookupTableDescriptor = parseFloatArray(
+          DICOMWeb.getString(instance['00281101'])
+        );
+        const greenPaletteColorLookupTableDescriptor = parseFloatArray(
+          DICOMWeb.getString(instance['00281102'])
+        );
+        const bluePaletteColorLookupTableDescriptor = parseFloatArray(
+          DICOMWeb.getString(instance['00281103'])
+        );
+        const palettes = await getPaletteColors(
+          server,
+          instance,
+          redPaletteColorLookupTableDescriptor
+        );
+
+        if (palettes) {
+          if (palettes.uid) {
+            instanceSummary.paletteColorLookupTableUID = palettes.uid;
+          }
+
+          instanceSummary.redPaletteColorLookupTableData = palettes.red;
+          instanceSummary.greenPaletteColorLookupTableData = palettes.green;
+          instanceSummary.bluePaletteColorLookupTableData = palettes.blue;
+          instanceSummary.redPaletteColorLookupTableDescriptor = redPaletteColorLookupTableDescriptor;
+          instanceSummary.greenPaletteColorLookupTableDescriptor = greenPaletteColorLookupTableDescriptor;
+          instanceSummary.bluePaletteColorLookupTableDescriptor = bluePaletteColorLookupTableDescriptor;
+        }
+      }
+
+      series.instances.push(instanceSummary);
+    })
+  );
+
+  return studyData;
+}
+
+/**
+ * Retrieve Study MetaData from a DICOM server using a WADO call
+ *
+ * @param server
+ * @param studyInstanceUid
+ * @returns {Promise}
+ */
+async function RetrieveMetadata(server, studyInstanceUid) {
+  const config = {
+    url: server.wadoRoot,
+    headers: DICOMWeb.getAuthorizationHeader(server),
+  };
+  const dicomWeb = new api.DICOMwebClient(config);
+  const options = {
+    studyInstanceUID: studyInstanceUid,
+  };
+
+  return dicomWeb.retrieveStudyMetadata(options).then(result => {
+    return resultDataToStudyMetadata(server, studyInstanceUid, result);
+  });
+}
+
+export default RetrieveMetadata;
@@ -0,0 +1,17 @@
+/**
+ * Sorts the series and instances inside a study instance by their series
+ * and instance numbers in ascending order.
+ *
+ * @param {Object} study The study instance
+ */
+export default function sortStudy(study) {
+  if (!study || !study.seriesList) {
+    throw new Error('Insufficient study data was provided to sortStudy');
+  }
+
+  study.seriesList.sort((a, b) => a.seriesNumber - b.seriesNumber);
+
+  study.seriesList.forEach(series => {
+    series.instances.sort((a, b) => a.instanceNumber - b.instanceNumber);
+  });
+}