feat(GoogleCloud): Initial commits to include the Healthcare API Adapter (#584)

* This is a React port of https://github.com/quantumsoftgroup/healthcare-api-adapter - It still needs some UI cleanup.
This commit is contained in:
Egor Lezhnin authored and Erik Ziegler committed 2019-07-10 09:26:19 +02:00
1 parent 4095629310
commit 4a09f33446
26 files changed
+1451 -46

No files matched your search

+5 -1
View File
@@ -1,7 +1,11 @@
import './ToolbarRow.css';
import React, { Component } from 'react';
import { ExpandableToolMenu, RoundedButtonGroup, ToolbarButton } from 'react-viewerbase';
import {
ExpandableToolMenu,
RoundedButtonGroup,
ToolbarButton,
} from 'react-viewerbase';
import { commandsManager, extensionManager } from './../App.js';
import ConnectedCineDialog from './ConnectedCineDialog';
@@ -0,0 +1,22 @@
import { connect } from 'react-redux';
import DicomFileUploader from './DicomFileUploader.js';
const isActive = a => a.active === true;
const mapStateToProps = state => {
const activeServer = state.servers.servers.find(isActive);
const { authority, client_id } = window.config.oidc[0];
const oidcStorageKey = `oidc.user:${authority}:${client_id}`;
return {
oidcStorageKey,
url: activeServer && activeServer.qidoRoot,
};
};
const ConnectedDicomFileUploader = connect(
mapStateToProps,
null
)(DicomFileUploader);
export default ConnectedDicomFileUploader;
@@ -0,0 +1,34 @@
import { connect } from 'react-redux';
import DicomStorePickerWindow from './DicomStorePickerWindow.js';
const isActive = a => a.active === true;
const mapStateToProps = state => {
const activeServer = state.servers.servers.find(isActive);
const { authority, client_id } = window.config.oidc[0];
const oidcStorageKey = `oidc.user:${authority}:${client_id}`;
return {
oidcStorageKey,
url: activeServer && activeServer.qidoRoot,
};
};
const mapDispatchToProps = dispatch => {
return {
setServers: servers => {
const action = {
type: 'SET_SERVERS',
servers,
};
dispatch(action);
},
};
};
const ConnectedDicomStorePicker = connect(
mapStateToProps,
mapDispatchToProps
)(DicomStorePickerWindow);
export default ConnectedDicomStorePicker;
+52
View File
@@ -0,0 +1,52 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import api from './api/GoogleCloudApi';
import DatasetsList from './DatasetsList';
import './googleCloud.css';
export default class DatasetPicker extends Component {
constructor(props) {
super(props);
this.state = {
error: null,
loading: false,
datasets: [],
};
}
static propTypes = {
project: PropTypes.object,
location: PropTypes.object,
onSelect: PropTypes.func,
oidcKey: PropTypes.string,
};
static defaultProps = {};
async componentDidMount() {
api.setOidcStorageKey(this.props.oidcKey);
const response = await api.loadDatasets(
this.props.project.projectId,
this.props.location.locationId
);
this.loading = false;
if (response.isError) {
this.error = response.message;
return;
}
this.setState({ datasets: response.data.datasets || [] });
}
render() {
const { datasets, loading, error } = this.state;
const { onSelect } = this.props;
return (
<DatasetsList
datasets={datasets}
loading={loading}
error={error}
onSelect={onSelect}
></DatasetsList>
);
}
}
+156
View File
@@ -0,0 +1,156 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import DicomStorePicker from './DicomStorePicker';
import DatasetPicker from './DatasetPicker';
import ProjectPicker from './ProjectPicker';
import LocationPicker from './LocationPicker';
import GoogleCloudApi from './api/GoogleCloudApi';
import './googleCloud.css';
export default class DatasetSelector extends Component {
constructor(props) {
super(props);
this.state = {
project: null,
location: null,
dataset: null,
unloading: false,
};
}
static propTypes = {
id: PropTypes.string,
event: PropTypes.string,
oidcKey: PropTypes.string,
canClose: PropTypes.string,
setServers: PropTypes.func.isRequired,
};
static defaultProps = {};
onProjectSelect = project => {
this.setState({
project: project,
});
};
onLocationSelect = location => {
this.setState({
location: location,
});
};
onDatasetSelect = dataset => {
this.setState({
dataset: dataset,
});
};
onProjectClick = () => {
this.setState({
dataset: null,
location: null,
project: null,
});
};
onLocationClick = () => {
this.setState({
dataset: null,
location: null,
});
};
onDatasetClick = () => {
this.setState({
dataset: null,
});
};
onDicomStoreSelect = dicomStoreJson => {
const dicomStore = dicomStoreJson.name;
const parts = dicomStore.split('/');
const result = {
wadoUriRoot: GoogleCloudApi.urlBase + `/${dicomStore}/dicomWeb`,
qidoRoot: GoogleCloudApi.urlBase + `/${dicomStore}/dicomWeb`,
wadoRoot: GoogleCloudApi.urlBase + `/${dicomStore}/dicomWeb`,
project: parts[1],
location: parts[3],
dataset: parts[5],
dicomStore: parts[7],
};
this.props.setServers(result);
};
render() {
const { project, location, dataset } = this.state;
const {
onProjectClick,
onLocationClick,
onDatasetClick,
onProjectSelect,
onLocationSelect,
onDatasetSelect,
onDicomStoreSelect,
} = this;
return (
<>
<span className="gcp-picker--title">Google Cloud Healthcare API</span>
{project && (
<div className="gcp-picker--path">
<span onClick={onProjectClick}>{project.name}</span>
{project && location && (
<>
<span onClick={onLocationClick}>
{' '}
-> {location.name.split('/')[3]}
</span>
{project && location && dataset && (
<span onClick={onDatasetClick}>
{' '}
-> {dataset.name.split('/')[5]}
</span>
)}
</>
)}
</div>
)}
{!project && (
<ProjectPicker
oidcKey={this.props.oidcKey}
onSelect={onProjectSelect}
></ProjectPicker>
)}
{project && !location && (
<>
<LocationPicker
oidcKey={this.props.oidcKey}
project={project}
onSelect={onLocationSelect}
></LocationPicker>
</>
)}
{project && location && !dataset && (
<>
<DatasetPicker
oidcKey={this.props.oidcKey}
project={project}
location={location}
onSelect={onDatasetSelect}
></DatasetPicker>
</>
)}
{project && location && dataset && (
<>
<DicomStorePicker
oidcKey={this.props.oidcKey}
dataset={dataset}
onSelect={onDicomStoreSelect}
></DicomStorePicker>
</>
)}
</>
);
}
}
+57
View File
@@ -0,0 +1,57 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import './googleCloud.css';
export default class DatasetsList extends Component {
constructor(props) {
super(props);
this.state = {
search: '',
};
}
static propTypes = {
datasets: PropTypes.array,
loading: PropTypes.bool,
error: PropTypes.string,
onSelect: PropTypes.func,
};
static defaultProps = {};
renderTableRow(dataset) {
return (
<tr
key={dataset.name}
className={
this.state.highlightedItem === dataset.name
? 'studylistStudy noselect active'
: 'studylistStudy noselect'
}
onMouseEnter={() => {
this.onHighlightItem(dataset.name);
}}
onClick={() => {
this.props.onSelect(dataset);
}}
>
<td>{dataset.name.split('/')[5]}</td>
</tr>
);
}
onHighlightItem(dataset) {
this.setState({ highlightedItem: dataset });
}
render() {
return (
<table id="tblDatasetList" className="studyListToolbar table noselect">
<tbody id="DatasetList">
{this.props.datasets.map(dataset => {
return this.renderTableRow(dataset);
})}
</tbody>
</table>
);
}
}
+38
View File
@@ -0,0 +1,38 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import DicomUploader from './DicomUploader';
class DicomFileUploader extends Component {
static propTypes = {
url: PropTypes.string,
oidcStorageKey: PropTypes.string.isRequired,
onClose: PropTypes.func,
};
state = {
uploaded: false,
};
constructor(props) {
super(props);
this.element = React.createRef();
}
render() {
if (this.props.url != null) {
return (
<div className="gcp-window">
<DicomUploader
url={this.props.url}
oidcKey={this.props.oidcStorageKey}
></DicomUploader>
<button className="btn btn-primary" onClick={this.props.onClose}>
close
</button>
</div>
);
}
return <></>;
}
}
export default DicomFileUploader;
+57
View File
@@ -0,0 +1,57 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import './googleCloud.css';
export default class DicomStoreList extends Component {
constructor(props) {
super(props);
this.state = {
search: '',
};
}
static propTypes = {
stores: PropTypes.array,
loading: PropTypes.bool,
error: PropTypes.string,
onSelect: PropTypes.func,
};
static defaultProps = {};
renderTableRow(store) {
return (
<tr
key={store.name}
className={
this.state.highlightedItem === store.name
? 'studylistStudy noselect active'
: 'studylistStudy noselect'
}
onMouseEnter={() => {
this.onHighlightItem(store.name);
}}
onClick={() => {
this.props.onSelect(store);
}}
>
<td className="project">{store.name.split('/')[7]}</td>
</tr>
);
}
onHighlightItem(store) {
this.setState({ highlightedItem: store });
}
render() {
return (
<table id="tblStoreList" className="studyListToolbar table noselect">
<tbody id="StoreList">
{this.props.stores.map(store => {
return this.renderTableRow(store);
})}
</tbody>
</table>
);
}
}
+50
View File
@@ -0,0 +1,50 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import api from './api/GoogleCloudApi';
import DicomStoreList from './DicomStoreList';
import './googleCloud.css';
export default class DicomStorePicker extends Component {
constructor(props) {
super(props);
this.state = {
error: null,
loading: false,
stores: [],
locations: [],
};
}
static propTypes = {
dataset: PropTypes.object,
onSelect: PropTypes.func,
};
static defaultProps = {};
async componentDidMount() {
const { authority, client_id } = window.config.oidc[0];
const oidcStorageKey = `oidc.user:${authority}:${client_id}`;
api.setOidcStorageKey(oidcStorageKey);
const response = await api.loadDicomStores(this.props.dataset.name);
this.loading = false;
if (response.isError) {
this.error = response.message;
return;
}
this.setState({ stores: response.data.dicomStores || [] });
}
render() {
const { stores, loading, error } = this.state;
const { onSelect } = this.props;
return (
<DicomStoreList
stores={stores}
loading={loading}
error={error}
onSelect={onSelect}
></DicomStoreList>
);
}
}
+57
View File
@@ -0,0 +1,57 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import DatasetSelector from './DatasetSelector';
import './googleCloud.css';
class DicomStorePickerWindow extends Component {
static propTypes = {
url: PropTypes.string,
oidcStorageKey: PropTypes.string.isRequired,
setServers: PropTypes.func.isRequired,
onClose: PropTypes.func,
};
constructor(props) {
super(props);
this.element = React.createRef();
this.handleEvent = this.handleEvent.bind(this);
}
componentDidMount() {}
handleEvent(data) {
const servers = [
{
name: data.dicomStore,
imageRendering: 'wadors',
thumbnailRendering: 'wadors',
qidoSupportsIncludeField: false,
requestOptions: { requestFromBrowser: true },
type: 'dicomWeb',
qidoRoot: data.qidoRoot,
wadoRoot: data.wadoRoot,
wadoUriRoot: data.wadoUriRoot,
active: true,
},
];
this.props.setServers(servers);
}
render() {
return (
<div className="gcp-window">
<DatasetSelector
setServers={this.handleEvent}
oidcKey={this.props.oidcStorageKey}
url={this.props.url}
></DatasetSelector>
<button className="btn btn-primary" onClick={this.props.onClose}>
close
</button>
</div>
);
}
}
export default DicomStorePickerWindow;
+204
View File
@@ -0,0 +1,204 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import { formatFileSize } from './utils/helpers';
import CancellationToken from './utils/CancellationToken';
import dicomUploader from './api/DicomUploadService';
import './googleCloud.css';
export default class DicomUploader extends Component {
constructor(props) {
super(props);
this.state = {
status: 'Upload',
isCancelled: false,
errorsCount: 0,
files: null,
uploadedVolume: null,
wholeVolumeStr: null,
isFilesListHidden: true,
timeLeft: null,
uploadedList: null,
totalCount: 0,
successfullyUploadedCount: 0,
lastFile: '',
uploadContext: null, // this is probably not needed, but we use this variable to destinguish between different downloads
};
this.uploadFiles = this.uploadFiles.bind(this);
}
static propTypes = {
id: PropTypes.string,
event: PropTypes.string,
url: PropTypes.string,
oidcKey: PropTypes.string,
};
static defaultProps = {};
filesLeft() {
return (
this.state.uploadedList.length + ' of ' + this.state.totalCount + ' files'
);
}
volumeLeft() {
let left = formatFileSize(this.state.uploadedVolume);
return left + ' of ' + this.state.wholeVolumeStr;
}
percents() {
return parseInt(
(100 * this.state.uploadedList.length) /
Object.keys(this.state.files).length
);
}
isFinished() {
return (
this.state.isCancelled ||
Object.keys(this.state.files).length === this.state.uploadedList.length
);
}
errorsMessage() {
const errors = this.state.errorsCount === 1 ? ' error' : ' errors';
return (
this.state.errorsCount + errors + ' while uploading, click for more info'
);
}
uploadFiles(files) {
const filesArray = Array.from(files.target.files);
const filesDict = {};
filesArray.forEach((file, i) => {
const fileDesc = {
id: i,
name: file.name,
path: file.webkitRelativePath || file.name,
size: file.size,
error: null,
processed: false,
processedInUI: false,
};
filesDict[i] = fileDesc;
file.fileId = i;
});
const wholeVolume = filesArray.map(f => f.size).reduce((a, b) => a + b);
const uploadContext = Math.random();
this.setState({
status: 'Uploading...',
files: filesDict,
uploadedList: [],
uploadedVolume: 0,
lastFile: filesArray[0].name,
totalCount: filesArray.length,
wholeVolumeStr: formatFileSize(wholeVolume),
uploadContext: uploadContext,
cancellationToken: new CancellationToken(),
});
const cancellationToken = new CancellationToken();
const uploadCallback = (fileId, error) =>
uploadContext === this.state.uploadContext &&
this.uploadCallback.call(this, fileId, error);
dicomUploader.setOidcStorageKey(this.props.oidcKey);
dicomUploader.smartUpload(
files.target.files,
this.props.url,
this.props.oidcKey,
uploadCallback,
cancellationToken
);
}
uploadCallback(fileId, error) {
const file = this.state.files[fileId];
file.processed = true;
if (!error) {
let uploadedVolume = this.state.uploadedVolume + file.size;
this.setState({ uploadedVolume: uploadedVolume });
} else {
file.error = error;
this.setState({ errorsCount: this.state.errorsCount + 1 });
}
this.setState({ lastFile: file.name });
let uploadedList = this.state.uploadedList;
uploadedList.push(file);
this.setState({ uploadedList: uploadedList });
}
renderTableRow(file) {
let error = <></>;
if (file.error != null) {
error = (
<>
<font color="red">{file.error}</font>
</>
);
}
return (
<tr key={file.id}>
<td className="project">
{file.name} {error}
</td>
</tr>
);
}
render() {
if (this.state.files == null) {
return (
<div className="gcp-dicom-uploader">
<div className="button">
<label htmlFor="file">
<img src="./assets/Button_File.svg" alt="upload file"></img>
</label>
<input
className="gcp-invisible-input"
accept=".dcm"
onChange={this.uploadFiles}
type="file"
id="file"
multiple
/>
</div>
<div className="button">
<label htmlFor="folder">
<img src="./assets/Button_Folder.svg" alt="upload folder"></img>
</label>
<input
className="gcp-invisible-input"
type="file"
onChange={this.uploadFiles}
id="folder"
webkitdirectory="true"
mozdirectory="true"
multiple
/>
</div>
</div>
);
} else {
return (
<>
<table
id="tblProjectList"
className="studyListToolbar table noselect"
>
<thead>
<tr>
<th className="gcp-picker--path">
{this.percents()}% {this.filesLeft()}
</th>
</tr>
</thead>
<tbody id="ProjectList">
{this.state.uploadedList.map(file => {
return this.renderTableRow(file);
})}
</tbody>
</table>
</>
);
}
}
}
+50
View File
@@ -0,0 +1,50 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import api from './api/GoogleCloudApi';
import LocationsList from './LocationsList';
import './googleCloud.css';
export default class LocationPicker extends Component {
constructor(props) {
super(props);
this.state = {
error: null,
loading: false,
locations: [],
};
}
static propTypes = {
project: PropTypes.object,
onSelect: PropTypes.func,
oidcKey: PropTypes.string,
};
async componentDidMount() {
api.setOidcStorageKey(this.props.oidcKey);
const response = await api.loadLocations(this.props.project.projectId);
this.loading = false;
if (response.isError) {
this.error = response.message;
return;
}
this.setState({ locations: response.data.locations || [] });
}
static defaultProps = {};
render() {
const { locations, loading, error } = this.state;
const { onSelect } = this.props;
return (
<LocationsList
locations={locations}
loading={loading}
error={error}
onSelect={onSelect}
></LocationsList>
);
}
}
+56
View File
@@ -0,0 +1,56 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import './googleCloud.css';
export default class LocationsList extends Component {
constructor(props) {
super(props);
this.state = {
search: '',
};
}
static propTypes = {
locations: PropTypes.array,
loading: PropTypes.bool,
error: PropTypes.string,
onSelect: PropTypes.func,
};
static defaultProps = {};
renderTableRow(location) {
return (
<tr
key={location.locationId}
className={
this.state.highlightedItem === location.locationId
? 'studylistStudy noselect active'
: 'studylistStudy noselect'
}
onMouseEnter={() => {
this.onHighlightItem(location.locationId);
}}
onClick={() => {
this.props.onSelect(location);
}}
>
<td>{location.name.split('/')[3]}</td>
</tr>
);
}
onHighlightItem(locationId) {
this.setState({ highlightedItem: locationId });
}
render() {
return (
<table id="tblLocationList" className="studyListToolbar table noselect">
<tbody id="LocationList">
{this.props.locations.map(project => {
return this.renderTableRow(project);
})}
</tbody>
</table>
);
}
}
+46
View File
@@ -0,0 +1,46 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import api from './api/GoogleCloudApi';
import ProjectsList from './ProjectsList';
import './googleCloud.css';
export default class ProjectPicker extends Component {
constructor(props) {
super(props);
this.state = {
error: null,
loading: false,
projects: [],
};
}
static propTypes = {
onSelect: PropTypes.func,
oidcKey: PropTypes.string,
};
static defaultProps = {};
async componentDidMount() {
api.setOidcStorageKey(this.props.oidcKey);
const response = await api.loadProjects();
this.loading = false;
if (response.isError) {
this.error = response.message;
return;
}
this.setState({ projects: response.data.projects || [] });
}
render() {
const { projects, loading, error } = this.state;
const { onSelect } = this.props;
return (
<ProjectsList
projects={projects}
loading={loading}
error={error}
onSelect={onSelect}
></ProjectsList>
);
}
}
+59
View File
@@ -0,0 +1,59 @@
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import './googleCloud.css';
export default class ProjectsList extends Component {
constructor(props) {
super(props);
this.state = {
search: '',
highlightedItem: null,
};
}
static propTypes = {
projects: PropTypes.array,
loading: PropTypes.bool,
error: PropTypes.string,
onSelect: PropTypes.func.isRequired,
};
static defaultProps = {};
renderTableRow(project) {
return (
<tr
key={project.projectId}
className={
this.state.highlightedItem === project.projectId
? 'studylistStudy noselect active'
: 'studylistStudy noselect'
}
onMouseEnter={() => {
this.onHighlightItem(project.projectId);
}}
onClick={() => {
this.onHighlightItem(project.projectId);
this.props.onSelect(project);
}}
>
<td>{project.name}</td>
</tr>
);
}
onHighlightItem(project) {
this.setState({ highlightedItem: project });
}
render() {
return (
<table id="tblProjectList" className="studyListToolbar table noselect">
<tbody id="ProjectList">
{this.props.projects.map(project => {
return this.renderTableRow(project);
})}
</tbody>
</table>
);
}
}
+92
View File
@@ -0,0 +1,92 @@
import { httpErrorToStr, getOidcToken, checkDicomFile } from '../utils/helpers';
const DICOM = require('dicomweb-client');
class DicomUploadService {
setOidcStorageKey(oidcStorageKey) {
/* eslint-disable */
if (!oidcStorageKey) console.error('OIDC storage key is empty');
this.oidcStorageKey = oidcStorageKey;
}
async smartUpload(files, url, authToken, uploadCallback, cancellationToken) {
/* eslint-disable */
const CHUNK_SIZE = 1; // Only one file per request is supported so far
const MAX_PARALLEL_JOBS = 50; // FIXME: tune MAX_PARALLEL_JOBS number
//
let filesArray = Array.from(files);
if (filesArray.length === 0) {
console.warn('No files are supplied for uploading');
return;
}
let parallelJobsCount = Math.min(filesArray.length, MAX_PARALLEL_JOBS);
let completed = false;
const processJob = async (resolve, reject) => {
while (filesArray.length > 0) {
if (cancellationToken.get()) return;
let chunk = filesArray.slice(0, CHUNK_SIZE);
filesArray = filesArray.slice(CHUNK_SIZE);
let error = null;
try {
if (chunk.length > 1) throw new Error('Not implemented');
if (chunk.length === 1)
await this.simpleUpload(chunk[0], url, authToken);
} catch (err) {
// It looks like a stupid bug of Babel that err is not an actual Exception object
error = httpErrorToStr(err);
}
chunk.forEach(file => uploadCallback(file.fileId, error));
if (!completed && filesArray.length === 0) {
completed = true;
resolve();
return;
}
}
};
await new Promise(resolve => {
for (let i = 0; i < parallelJobsCount; i++) {
processJob(resolve);
}
});
}
async simpleUpload(file, url, authToken) {
/* eslint-disable */
const client = this.getClient(url);
const loadedFile = await this.readFile(file);
const content = loadedFile.content;
if (!checkDicomFile(content))
throw new Error('The file has a wrong DICOM header');
await client.storeInstances({ datasets: [content] });
}
readFile(file) {
const promise = new Promise((resolve, reject) => {
var reader = new FileReader();
reader.onload = () => {
resolve({
name: file.name,
size: file.size,
type: file.type,
content: reader.result,
});
};
reader.onerror = error => reject(error);
reader.readAsArrayBuffer(file);
});
return promise;
}
getClient(url) {
if (!this.oidcStorageKey) throw new Error('OIDC storage key is not set');
const accessToken = getOidcToken(this.oidcStorageKey);
if (!accessToken) throw new Error('OIDC access_token is not set');
return new DICOM.api.DICOMwebClient({
url,
headers: { Authorization: 'Bearer ' + accessToken },
});
}
}
export default new DicomUploadService();
+98
View File
@@ -0,0 +1,98 @@
import { getOidcToken } from '../utils/helpers';
class GoogleCloudApi {
setOidcStorageKey(oidcStorageKey) {
if (!oidcStorageKey) console.error('OIDC storage key is empty');
this.oidcStorageKey = oidcStorageKey;
}
get fetchConfig() {
if (!this.oidcStorageKey) throw new Error('OIDC storage key is not set');
const accessToken = getOidcToken(this.oidcStorageKey);
if (!accessToken) throw new Error('OIDC access_token is not set');
return {
method: 'GET',
headers: {
Authorization: 'Bearer ' + accessToken,
},
};
}
get urlBase() {
return `https://healthcare.googleapis.com/v1beta1`;
}
get urlBaseProject() {
return this.urlBase + `/projects`;
}
async doRequest(urlStr, config = {}, params = {}) {
var url = new URL(urlStr);
let data = null;
url.search = new URLSearchParams(params);
try {
const response = await fetch(url, { ...this.fetchConfig, config });
try {
data = await response.json();
} catch (err) {}
if (response.status >= 200 && response.status < 300 && data != null) {
if (data.nextPageToken != null) {
params.pageToken = data.nextPageToken;
let subPage = await this.doRequest(urlStr, config, params);
for (var key in data) {
if (data.hasOwnProperty(key)) {
data[key] = data[key].concat(subPage.data[key]);
}
}
}
return {
isError: false,
status: response.status,
data: data,
};
} else {
return {
isError: true,
status: response.status,
message:
(data && data.error && data.error.message) || 'Unknown error',
};
}
} catch (err) {
if (data && data.error) {
return {
isError: true,
status: err.status,
message: err.response.data.error.message || 'Unspecified error',
};
}
return {
isError: true,
message: (err && err.message) || 'Oops! Something went wrong',
};
}
}
async loadProjects() {
return this.doRequest(
'https://cloudresourcemanager.googleapis.com/v1/projects'
);
}
async loadLocations(projectId) {
return this.doRequest(this.urlBaseProject + `/${projectId}/locations`);
}
async loadDatasets(projectId, locationId) {
return this.doRequest(
this.urlBaseProject + `/${projectId}/locations/${locationId}/datasets`
);
}
async loadDicomStores(dataset) {
return this.doRequest(this.urlBase + `/${dataset}/dicomStores`);
}
}
export default new GoogleCloudApi();
+49
View File
@@ -0,0 +1,49 @@
.gcp-files-selector {
display: flex;
justify-content: space-between;
}
.gcp-files-selector__btn-dir,
.gcp-files-selector__btn-file {
height: 80px !important;
width: 228px !important;
font-size: 14px;
border-radius: 8px;
margin: 0 !important;
}
.gcp-files-selector__btn-dir {
background-image: url('/assets/Button_Folder.svg');
}
.gcp-files-selector__btn-file {
background-image: url('/assets/Button_File.svg');
}
.gcp-window {
background-color: #000000;
}
.gcp-invisible-input {
position: absolute;
display: none;
z-index: -1000;
max-width: 0 !important;
max-height: 0 !important;
}
.gcp-hidden {
display: none;
}
.gcp-picker--title {
color: #ffffff;
font-size: 24px;
font-weight: 28px;
text-align: center;
margin: 20px auto;
}
.gcp-picker--path {
color: #ffffff;
font-size: 16px;
font-weight: 28px;
text-align: leaft;
margin: 20px auto;
}
@@ -0,0 +1,13 @@
export default class CancellationToken {
constructor() {
this.cancelled = false;
}
get() {
return this.cancelled;
}
set(value) {
this.cancelled = value;
}
}
+40
View File
@@ -0,0 +1,40 @@
export function formatFileSize(size) {
if (size === 0) return '0 B';
const n = Math.floor(Math.log(size) / Math.log(1024));
return (
(size / Math.pow(1024, n)).toFixed(2) * 1 +
' ' +
['B', 'kB', 'MB', 'GB', 'TB'][n]
);
}
export function httpErrorToStr(error) {
if (!error) return 'Unknown error';
if (error.response) {
try {
const jsonResponse = JSON.parse(error.response);
if (
jsonResponse.error &&
jsonResponse.error.code &&
jsonResponse.error.message
)
return jsonResponse.error.code + ' - ' + jsonResponse.error.message;
} catch (err) {
return error.response;
}
}
return error.message || 'Unknown error.';
}
export function getOidcToken(oidcStorageKey) {
const oidcConfigStr = sessionStorage.getItem(oidcStorageKey);
if (oidcConfigStr) return JSON.parse(oidcConfigStr).access_token;
}
/* eslint-disable */
export function checkDicomFile(arrayBuffer) {
if (arrayBuffer.length <= 132) return false;
const arr = new Uint8Array(arrayBuffer.slice(128, 132));
// bytes from 128 to 132 must be "DICM"
return Array.from('DICM').every((char, i) => char.charCodeAt(0) === arr[i]);
}
+102 -10
View File
@@ -5,11 +5,16 @@ import { withRouter } from 'react-router-dom';
import { StudyList } from 'react-viewerbase';
import ConnectedHeader from '../connectedComponents/ConnectedHeader.js';
import moment from 'moment';
import ConnectedDicomFilesUploader from '../googleCloud/ConnectedDicomFilesUploader';
import ConnectedDicomStorePicker from '../googleCloud/ConnectedDicomStorePicker';
class StudyListWithData extends Component {
state = {
studies: null,
searchData: {},
studies: [],
error: null,
modalComponentId: null,
showStudyList: true,
};
static propTypes = {
@@ -39,11 +44,31 @@ class StudyListWithData extends Component {
componentDidMount() {
// TODO: Avoid using timepoints here
//const params = { studyInstanceUids, seriesInstanceUids, timepointId, timepointsFilter={} };
if (!this.props.server && window.config.enableGoogleCloudAdapter) {
this.setState({
modalComponentId: 'DicomStorePicker',
showStudyList: false,
});
} else {
this.searchForStudies({
...StudyListWithData.defaultSearchData,
...(this.props.filters || {}),
});
}
}
this.searchForStudies({
...StudyListWithData.defaultSearchData,
...(this.props.filters || {}),
});
componentDidUpdate(prevProps) {
if (!this.state.searchData && !this.state.studies) {
this.searchForStudies();
}
if (this.props.server !== prevProps.server) {
this.setState({
modalComponentId: null,
showStudyList: true,
searchData: null,
studies: null,
});
}
}
searchForStudies = (searchData = StudyListWithData.defaultSearchData) => {
@@ -123,6 +148,17 @@ class StudyListWithData extends Component {
//console.log('onImport');
};
openModal = modalComponentId => {
this.setState({
modalComponentId,
showStudyList: false,
});
};
closeModal = () => {
this.setState({ modalComponentId: null });
};
onSelectItem = studyInstanceUID => {
this.props.history.push(`/viewer/${studyInstanceUID}`);
};
@@ -131,16 +167,63 @@ class StudyListWithData extends Component {
this.searchForStudies(searchData);
};
update = () => {
this.setState({
modalComponentId: null,
showStudyList: true,
});
};
render() {
if (this.state.error) {
return <div>Error: {JSON.stringify(this.state.error)}</div>;
} else if (this.state.studies === null) {
} else if (this.state.studies === null && !this.state.modalComponentId) {
return <div>Loading...</div>;
}
return (
<>
<ConnectedHeader home={true} user={this.props.user} />
let healthCareApiButtons = '';
let healthCareApiWindows = '';
if (window.config.enableGoogleCloudAdapter) {
if (this.state.modalComponentId) {
if (this.state.modalComponentId === 'DicomStorePicker') {
healthCareApiWindows = (
<ConnectedDicomStorePicker onClose={this.update} />
);
} else if (this.state.modalComponentId === 'DicomFilesUploader') {
healthCareApiWindows = (
<ConnectedDicomFilesUploader onClose={this.update} />
);
}
healthCareApiWindows = (
<>
<div className="col-md-4 col-md-offset-2 layoutChooser pagination-area">
{healthCareApiWindows}
</div>
</>
);
}
healthCareApiButtons = (
<>
<div className="form-inline form-group pull-right">
<button
className="btn btn-primary "
onClick={() => this.openModal('DicomStorePicker')}
>
Change Dicom Store
</button>
<button
className="btn btn-primary"
onClick={() => this.openModal('DicomFilesUploader')}
>
Upload Studies
</button>
</div>
</>
);
}
let studyList = <></>;
studyList = (
<div name="paginationArea">
<StudyList
studies={this.state.studies}
studyListFunctionsEnabled={false}
@@ -152,7 +235,16 @@ class StudyListWithData extends Component {
StudyListWithData.studyListDateFilterNumDays
}
onSearch={this.onSearch}
/>
>
{healthCareApiButtons}
{healthCareApiWindows}
</StudyList>
</div>
);
return (
<>
<ConnectedHeader home={true} user={this.props.user} />
{studyList}
</>
);
}