cloudmr-ux 2.0.7 → 3.0.1

package/dist/core/features/jobs/jobActionCreation.js

@@ -0,0 +1,242 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import axios from 'axios';
+import { createAsyncThunk } from '@reduxjs/toolkit';
+import { getFileExtension } from "../../common/utilities/SystemUtilities";
+import { is_safe_twix } from "../../common/utilities/file-transformation/anonymize";
+import { AuthenticatedHttpClient } from '../../common/utilities/AuthenticatedRequests';
+import { getEndpoints } from '../../config/AppConfig';
+export var getUpstreamJobs = createAsyncThunk('GetJobs', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                endpoints = getEndpoints();
+                return [4 /*yield*/, AuthenticatedHttpClient.get(endpoints.JOBS_RETRIEVE_API)];
+            case 1:
+                response = _a.sent();
+                return [2 /*return*/, response.data];
+        }
+    });
+}); });
+export var renameUpstreamJob = createAsyncThunk('RenameJob', function (arg) { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                endpoints = getEndpoints();
+                return [4 /*yield*/, AuthenticatedHttpClient.post(endpoints.JOBS_RENAME_API, arg.jobReference)];
+            case 1:
+                response = _a.sent();
+                if (response.status === 200)
+                    getUpstreamJobs();
+                return [2 /*return*/];
+        }
+    });
+}); });
+export var deleteUpstreamJob = createAsyncThunk('DeleteJob', function (arg) { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                endpoints = getEndpoints();
+                return [4 /*yield*/, AuthenticatedHttpClient["delete"]("".concat(endpoints.JOBS_DELETE_API, "?id=").concat(arg.jobId))];
+            case 1:
+                response = _a.sent();
+                if (response.status === 200)
+                    getUpstreamJobs();
+                return [2 /*return*/];
+        }
+    });
+}); });
+export var uploadJob = createAsyncThunk('UploadJob', function (_a, thunkAPI) {
+    var uploadToken = _a.uploadToken, file = _a.file, fileAlias = _a.fileAlias, onProgress = _a.onProgress, onUploaded = _a.onUploaded, uploadTarget = _a.uploadTarget;
+    return __awaiter(void 0, void 0, void 0, function () {
+        // thunkAPI.dispatch(setupSetters.setUploadProgress({target: uploadTarget, progress: 0}));
+        // @ts-ignore
+        function uploadPartWithRetries(partUrl, part, cancelTokenSource, index, retries) {
+            if (retries === void 0) { retries = 2; }
+            return __awaiter(this, void 0, void 0, function () {
+                var response, error_1, newCancelTokenSource;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 2, , 7]);
+                            return [4 /*yield*/, AuthenticatedHttpClient.put(partUrl, part, {
+                                    headers: {
+                                        'Content-Type': ""
+                                    },
+                                    onUploadProgress: function (progressEvent) {
+                                        totalUploadedParts_1[index] = progressEvent.loaded;
+                                        var totalUploaded = totalUploadedParts_1.reduce(function (a, b) { return a + b; }, 0);
+                                        var totalProgress = totalUploaded / totalSize_1;
+                                        onProgress && onProgress(totalProgress);
+                                        // thunkAPI.dispatch(setupSetters.setUploadProgress({
+                                        //     target: uploadTarget,
+                                        //     progress: totalProgress
+                                        // }));
+                                    },
+                                    cancelToken: cancelTokenSource.token
+                                })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                        case 2:
+                            error_1 = _a.sent();
+                            if (!axios.isCancel(error_1)) return [3 /*break*/, 3];
+                            console.log('Upload cancelled:', partUrl);
+                            return [3 /*break*/, 6];
+                        case 3:
+                            if (!(retries > 0)) return [3 /*break*/, 5];
+                            console.log("Retrying upload for part: ".concat(partUrl, ", attempts remaining: ").concat(retries));
+                            // Cancel the current request before retrying
+                            cancelTokenSource.cancel('Cancelling the current request before retry.');
+                            newCancelTokenSource = axios.CancelToken.source();
+                            return [4 /*yield*/, uploadPartWithRetries(partUrl, part, newCancelTokenSource, index, retries - 1)];
+                        case 4: return [2 /*return*/, _a.sent()];
+                        case 5: throw error_1; // rethrow the error after exhausting retries
+                        case 6: return [3 /*break*/, 7];
+                        case 7: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        var endpoints, FILE_CHUNK_SIZE, payload, initResponse, _b, uploadId, partUrls_1, Key, fileParts, i, part, totalSize_1, totalUploadedParts_1, uploadedParts, finalizeResponse, e_1;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    endpoints = getEndpoints();
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 6, , 7]);
+                    FILE_CHUNK_SIZE = 10 * 1024 * 1024;
+                    return [4 /*yield*/, createPayload(uploadToken, file, fileAlias)];
+                case 2:
+                    payload = _c.sent();
+                    if (payload === undefined)
+                        return [2 /*return*/, { code: 403, response: 'file not found', file: undefined, uploadTarget: uploadTarget }
+                            // thunkAPI.dispatch(setupSetters.setUploadProgress({target: uploadTarget, progress: 0}));
+                            // @ts-ignore
+                        ];
+                    return [4 /*yield*/, AuthenticatedHttpClient.post(payload.destination, payload.lambdaFile, payload.config)];
+                case 3:
+                    initResponse = _c.sent();
+                    console.log(initResponse);
+                    _b = initResponse.data, uploadId = _b.uploadId, partUrls_1 = _b.partUrls, Key = _b.Key;
+                    fileParts = [];
+                    for (i = 0; i < file.size; i += FILE_CHUNK_SIZE) {
+                        part = file.slice(i, i + FILE_CHUNK_SIZE);
+                        fileParts.push(part);
+                    }
+                    totalSize_1 = payload.file.size;
+                    totalUploadedParts_1 = new Array(fileParts.length).fill(0);
+                    return [4 /*yield*/, Promise.all(fileParts.map(function (part, index) { return __awaiter(void 0, void 0, void 0, function () {
+                            var partUrl, cancelTokenSource, partResponse, etag;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        partUrl = partUrls_1[index];
+                                        cancelTokenSource = axios.CancelToken.source();
+                                        return [4 /*yield*/, uploadPartWithRetries(partUrl, part, cancelTokenSource, index)];
+                                    case 1:
+                                        partResponse = _a.sent();
+                                        etag = partResponse === null || partResponse === void 0 ? void 0 : partResponse.headers['etag'].replace(/"/g, '');
+                                        return [2 /*return*/, { partNumber: index + 1, etag: etag }];
+                                }
+                            });
+                        }); }))];
+                case 4:
+                    uploadedParts = _c.sent();
+                    return [4 /*yield*/, axios.post(endpoints.JOB_UPLOAD_FINALIZE, {
+                            uploadId: uploadId,
+                            parts: uploadedParts,
+                            Key: Key
+                        }, payload.config)];
+                case 5:
+                    finalizeResponse = _c.sent();
+                    console.log(finalizeResponse);
+                    console.log('all uploads completed');
+                    if (onUploaded)
+                        onUploaded(initResponse, file);
+                    thunkAPI.dispatch(getUpstreamJobs());
+                    return [2 /*return*/, { code: 200, response: initResponse.data.response, file: payload.lambdaFile, uploadTarget: uploadTarget }];
+                case 6:
+                    e_1 = _c.sent();
+                    console.log("Following error encountered during uploading:");
+                    console.error(e_1);
+                    return [2 /*return*/, { code: 500, response: e_1.response, file: undefined, uploadTarget: uploadTarget }];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+});
+var createPayload = function (uploadToken, file, fileAlias) { return __awaiter(void 0, void 0, void 0, function () {
+    var endpoints, lambdaFile, fileExtension, safe, UploadHeaders;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                endpoints = getEndpoints();
+                if (!file) return [3 /*break*/, 3];
+                lambdaFile = {
+                    "filename": fileAlias,
+                    "filetype": file.type,
+                    "filesize": "".concat(file.size),
+                    "filemd5": '',
+                    "file": file
+                };
+                console.log(file.type);
+                fileExtension = getFileExtension(file.name);
+                if (!(fileExtension === 'dat')) return [3 /*break*/, 2];
+                return [4 /*yield*/, is_safe_twix(file)];
+            case 1:
+                safe = _a.sent();
+                if (!safe) {
+                    alert('This file contains PIH data. Please anonymize the file before uploading');
+                    return [2 /*return*/, undefined];
+                }
+                _a.label = 2;
+            case 2:
+                UploadHeaders = {
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                };
+                return [2 /*return*/, { destination: endpoints.JOB_UPLOAD_INIT, lambdaFile: lambdaFile, file: file, config: UploadHeaders }];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };

package/dist/core/features/jobs/jobsSlice.d.ts

@@ -0,0 +1,57 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { UploadedFile } from "../data/dataSlice";
+export interface Job {
+    id: number;
+    alias: string;
+    status: string;
+    pipeline_id: string;
+    createdAt: string;
+    updatedAt: string;
+    setup: any;
+    files: UploadedFile[];
+    logs?: LogItem[];
+    slices?: number;
+}
+export interface LogItem {
+    type: string;
+    when: string;
+    what: string;
+}
+interface JobsState {
+    jobs: Array<Job>;
+    loading: boolean;
+    submittingText: string;
+}
+export declare const jobsSlice: import("@reduxjs/toolkit").Slice<JobsState, {
+    /**
+     * Delete job referenced by its index
+     * @param state
+     * @param action
+     */
+    renameJob(state: JobsState, action: PayloadAction<{
+        index: number;
+        alias: string;
+    }>): void;
+    deleteJob(state: JobsState, action: PayloadAction<{
+        index: number;
+    }>): void;
+    resetSubmissionState(state: JobsState): void;
+    setSubmittingText(state: import("immer").WritableDraft<JobsState>, action: PayloadAction<string>): void;
+}, "job", "job", import("@reduxjs/toolkit").SliceSelectors<JobsState>>;
+export declare const jobActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    /**
+     * Delete job referenced by its index
+     * @param state
+     * @param action
+     */
+    renameJob(state: JobsState, action: PayloadAction<{
+        index: number;
+        alias: string;
+    }>): void;
+    deleteJob(state: JobsState, action: PayloadAction<{
+        index: number;
+    }>): void;
+    resetSubmissionState(state: JobsState): void;
+    setSubmittingText(state: import("immer").WritableDraft<JobsState>, action: PayloadAction<string>): void;
+}, "job">;
+export {};

package/dist/core/features/jobs/jobsSlice.js

@@ -0,0 +1,54 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { getUpstreamJobs } from './jobActionCreation';
+import { convertTimestamp } from "../../common/utilities/CalendarHelper";
+var initialState = {
+    jobs: [],
+    loading: true,
+    submittingText: 'Submitting Jobs...'
+};
+export var jobsSlice = createSlice({
+    name: 'job',
+    initialState: initialState,
+    reducers: {
+        // submitJob(state: JobsState, action: PayloadAction<SNR>){
+        //     state.jobs.push({
+        //         setup:action.payload, alias: "", createdAt: "", files: [], id: 0, status: "", updatedAt: ""
+        //     });
+        // },
+        /**
+         * Delete job referenced by its index
+         * @param state
+         * @param action
+         */
+        renameJob: function (state, action) {
+            state.jobs[action.payload.index].alias = action.payload.alias;
+        },
+        deleteJob: function (state, action) {
+            state.jobs.splice(action.payload.index, 1);
+        },
+        resetSubmissionState: function (state) {
+            state.submittingText = 'Submitting jobs...';
+        },
+        setSubmittingText: function (state, action) {
+            state.submittingText = action.payload;
+        }
+    },
+    extraReducers: function (builder) { return (builder.addCase(getUpstreamJobs.pending, function (state, action) {
+        state.loading = true;
+    }),
+        builder.addCase(getUpstreamJobs.fulfilled, function (state, action) {
+            var data = [];
+            var payloadData = action.payload;
+            if (payloadData.jobs.length > 0) {
+                payloadData.jobs.forEach(function (element) {
+                    element.createdAt = convertTimestamp(element.createdAt);
+                    data.push(element);
+                });
+            }
+            state.jobs = data;
+            // state.jobs = [sampleJob]
+            state.loading = false;
+            state.submittingText = 'Jobs submitted!';
+        })); }
+});
+export var jobActions = jobsSlice.actions;

package/dist/core/features/rois/resultActionCreation.d.ts

@@ -0,0 +1,21 @@
+import { Job } from "../jobs/jobsSlice";
+export declare const getPipelineROI: import("@reduxjs/toolkit").AsyncThunk<{
+    rois: any;
+    pipeline_id: string;
+}, {
+    pipeline: string;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare function niiToVolume(nii: any): {
+    url: any;
+    name: string;
+    alias: any;
+};
+export declare const loadResult: import("@reduxjs/toolkit").AsyncThunk<{
+    pipelineID: string;
+    job: Job;
+    volumes: any[];
+    niis: any[];
+    result: any;
+}, {
+    job: Job;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;

package/dist/core/features/rois/resultActionCreation.js

@@ -0,0 +1,114 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { getEndpoints } from "../../config/AppConfig";
+import { AuthenticatedHttpClient } from "../../common/utilities/AuthenticatedRequests";
+export var getPipelineROI = createAsyncThunk("GetROI", function (_a) {
+    var pipeline = _a.pipeline;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var endpoints, config, response;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    endpoints = getEndpoints();
+                    config = {
+                        params: {
+                            pipeline_id: pipeline
+                        }
+                    };
+                    return [4 /*yield*/, AuthenticatedHttpClient.get(endpoints.ROI_GET, config)];
+                case 1:
+                    response = _b.sent();
+                    // console.log(response);
+                    return [2 /*return*/, { rois: response.data, pipeline_id: pipeline }];
+            }
+        });
+    });
+});
+export function niiToVolume(nii) {
+    return {
+        //URL is for NiiVue blob loading
+        url: nii.link,
+        //name is for NiiVue name replacer (needs proper extension like .nii)
+        name: nii.filename.split("/").pop(),
+        //alias is for user selection in toolbar
+        alias: nii.name
+    };
+}
+export var loadResult = createAsyncThunk("LoadResult", function (_a) {
+    var job = _a.job;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var endpoints, volumes, file, result, niis;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    endpoints = getEndpoints();
+                    volumes = [];
+                    file = job.files[0];
+                    return [4 /*yield*/, AuthenticatedHttpClient.post(endpoints.UNZIP, JSON.parse(file.location), {
+                            timeout: 100000000
+                        })];
+                case 1:
+                    result = (_b.sent()).data;
+                    niis = result.data;
+                    // console.log(niis);
+                    niis.forEach(function (value) {
+                        // console.log(value);
+                        volumes.push({
+                            //URL is for NiiVue blob loading
+                            url: value.link,
+                            //name is for NiiVue name replacer (needs proper extension like .nii)
+                            name: value.filename.split("/").pop(),
+                            //alias is for user selection in toolbar
+                            alias: value.name
+                        });
+                    });
+                    return [2 /*return*/, { pipelineID: job.pipeline_id, job: job, volumes: volumes, niis: niis, result: result }];
+            }
+        });
+    });
+}, {
+    // Adding extra information to the meta field
+    getPendingMeta: function (_a) {
+        var arg = _a.arg, requestId = _a.requestId;
+        // console.log('Pending Meta:');
+        return {
+            jobId: arg.job.id,
+            requestId: requestId
+        };
+    }
+});

package/dist/core/features/rois/resultSlice.d.ts

@@ -0,0 +1,24 @@
+import { ROIState } from "./roiTypes";
+import { Job } from "../jobs/jobsSlice";
+import { PayloadAction } from "@reduxjs/toolkit";
+export declare const initialState: ROIState;
+export declare const resultSlice: import("@reduxjs/toolkit").Slice<ROIState, {
+    setPipelineID(state: ROIState, action: PayloadAction<Job>): void;
+    selectVolume(state: ROIState, action: PayloadAction<number>): void;
+    setOpenPanel(state: ROIState, action: PayloadAction<number[]>): void;
+}, "job", "job", import("@reduxjs/toolkit").SliceSelectors<ROIState>>;
+declare const _default: import("@reduxjs/toolkit").CaseReducerActions<{
+    setPipelineID(state: ROIState, action: {
+        payload: Job;
+        type: string;
+    }): void;
+    selectVolume(state: ROIState, action: {
+        payload: number;
+        type: string;
+    }): void;
+    setOpenPanel(state: ROIState, action: {
+        payload: number[];
+        type: string;
+    }): void;
+}, "job">;
+export default _default;

package/dist/core/features/rois/resultSlice.js

@@ -0,0 +1,68 @@
+import { createSlice } from "@reduxjs/toolkit";
+import { loadResult, getPipelineROI } from "./resultActionCreation";
+export var initialState = {
+    rois: {},
+    niis: { "-1": [] },
+    resultLoading: -1,
+    loading: false,
+    activeJob: undefined,
+    selectedVolume: 2,
+    openPanel: [0]
+};
+export var resultSlice = createSlice({
+    name: "job",
+    initialState: initialState,
+    reducers: {
+        setPipelineID: function (state, action) {
+            state.activeJob = action.payload;
+        },
+        selectVolume: function (state, action) {
+            state.selectedVolume = action.payload;
+        },
+        setOpenPanel: function (state, action) {
+            state.openPanel = action.payload;
+        }
+    },
+    extraReducers: function (builder) { return (builder.addCase(getPipelineROI.pending, function (state, action) {
+        state.loading = true;
+    }),
+        builder.addCase(getPipelineROI.fulfilled, function (state, action) {
+            var _a = action.payload, rois = _a.rois, pipeline_id = _a.pipeline_id;
+            state.rois[pipeline_id] = [];
+            if (rois.length > 0) {
+                rois.forEach(function (element) {
+                    if (state.rois[pipeline_id] == undefined)
+                        state.rois[pipeline_id] = [];
+                    state.rois[pipeline_id].push(element);
+                });
+            }
+            state.loading = false;
+        }),
+        builder.addCase(loadResult.pending, function (state, action) {
+            // @ts-ignore
+            state.resultLoading = action.meta.jobId;
+        }),
+        builder.addCase(loadResult.fulfilled, function (state, action) {
+            var _a;
+            // console.log(action.payload);
+            state.activeJob = action.payload.job;
+            //@ts-ignore
+            state.activeJob.setup = { alias: "-", version: "v0" };
+            //@ts-ignore
+            state.activeJob.setup.task = action.payload.result.headers.options;
+            //@ts-ignore
+            state.activeJob.logs =
+                action.payload.result.log || action.payload.result.headers.log;
+            //@ts-ignore
+            state.activeJob.slices = (_a = action.payload.result.info) === null || _a === void 0 ? void 0 : _a.slices;
+            //@ts-ignore
+            state.niis[state.activeJob.pipeline_id] = action.payload.niis;
+            state.selectedVolume = 1;
+            //ts-ignore
+            state.resultLoading = -1;
+        }),
+        builder.addCase(loadResult.rejected, function (state, action) {
+            state.resultLoading = -1;
+        })); }
+});
+export default resultSlice.actions;

package/dist/core/features/rois/roiTypes.d.ts

@@ -0,0 +1,44 @@
+import { Job } from '../jobs/jobsSlice';
+export interface ROI {
+    id: number;
+    created_at: string;
+    updated_at: string;
+    location: string;
+    link: string;
+    filename: string;
+    size: null | number;
+    md5: null | string;
+    status: string;
+    database: string;
+    type: string;
+    pivot: {
+        pipeline_id: string;
+        roi_id: string;
+    };
+}
+export interface Volume {
+    name: string;
+    url: string;
+    alias: string;
+}
+export interface NiiFile {
+    filename: string;
+    id: number;
+    dim: number;
+    name: string;
+    type: string;
+    link: string;
+}
+export interface ROIState {
+    rois: {
+        [pipeline_id: string]: ROI[];
+    };
+    resultLoading: number;
+    loading: boolean;
+    niis: {
+        [pipeline_id: string]: NiiFile[];
+    };
+    activeJob?: Job;
+    selectedVolume: number;
+    openPanel: number[];
+}

package/dist/core/features/rois/roiTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/core/features/setup/setupActionCreation.d.ts

@@ -0,0 +1,7 @@
+import { Job } from "../jobs/jobsSlice";
+export declare const submitJobs: import("@reduxjs/toolkit").AsyncThunk<{
+    id: number;
+    status: number;
+}[], {
+    jobQueue: (Job | undefined)[];
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;