tools/arvados_config.yml
cypress/fixtures/files/5mb.bin
cypress/fixtures/files/cat.png
+cypress/fixtures/files/banner.html
+cypress/fixtures/files/tooltips.txt
cypress/fixtures/webdav-propfind-outputs.xml
.yarn/releases/*
package.json
--- /dev/null
+<div>
+ <h1>Hi there</h1>
+ <h3>This is my amazing</h3>
+ <h5 style="color: red">Banner</h5>
+</div>
\ No newline at end of file
--- /dev/null
+{
+ "[data-cy=side-panel-tree]": "This allows you to navigate through the app"
+}
\ No newline at end of file
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+describe('Collection panel tests', function () {
+ let activeUser;
+ let adminUser;
+ let collectionUUID;
+
+ before(function () {
+ // Only set up common users once. These aren't set up as aliases because
+ // aliases are cleaned up after every test. Also it doesn't make sense
+ // to set the same users on beforeEach() over and over again, so we
+ // separate a little from Cypress' 'Best Practices' here.
+ cy.getUser('admin', 'Admin', 'User', true, true)
+ .as('adminUser').then(function () {
+ adminUser = this.adminUser;
+ }
+ );
+ cy.getUser('collectionuser1', 'Collection', 'User', false, true)
+ .as('activeUser').then(function () {
+ activeUser = this.activeUser;
+ });
+ cy.on('uncaught:exception', (err, runnable) => {console.error(err)});
+ });
+
+ beforeEach(function () {
+ cy.clearCookies();
+ cy.clearLocalStorage();
+ });
+
+ it('should re-show the banner', () => {
+ setupTheEnvironment();
+
+ cy.loginAs(adminUser);
+
+ cy.wait(2000);
+
+ cy.get('[data-cy=confirmation-dialog-ok-btn]').click();
+
+ cy.get('[title=Notifications]').click();
+ cy.get('li').contains('Restore Banner').click();
+
+ cy.wait(2000);
+
+ cy.get('[data-cy=confirmation-dialog-ok-btn]').should('be.visible');
+ });
+
+
+ it('should show tooltips and remove tooltips as localStorage key is present', () => {
+ setupTheEnvironment();
+
+ cy.loginAs(adminUser);
+
+ cy.wait(2000);
+
+ cy.get('[data-cy=side-panel-tree]').then(($el) => {
+ const el = $el.get(0) //native DOM element
+ expect(el._tippy).to.exist;
+ });
+
+ cy.wait(2000);
+
+ cy.get('[data-cy=confirmation-dialog-ok-btn]').click();
+
+ cy.get('[title=Notifications]').click();
+ cy.get('li').contains('Disable tooltips').click();
+
+ cy.get('[data-cy=side-panel-tree]').then(($el) => {
+ const el = $el.get(0) //native DOM element
+ expect(el._tippy).to.be.undefined;
+ });
+ });
+
+ const setupTheEnvironment = () => {
+ cy.createCollection(adminUser.token, {
+ name: `BannerTooltipTest${Math.floor(Math.random() * 999999)}`,
+ owner_uuid: adminUser.user.uuid,
+ }).as('bannerCollection');
+
+ cy.getAll('@bannerCollection')
+ .then(function ([bannerCollection]) {
+
+ collectionUUID=bannerCollection.uuid;
+
+ cy.loginAs(adminUser);
+
+ cy.goToPath(`/collections/${bannerCollection.uuid}`);
+
+ cy.get('[data-cy=upload-button]').click();
+
+ cy.fixture('files/banner.html').as('banner');
+ cy.fixture('files/tooltips.txt').as('tooltips');
+
+ cy.getAll('@banner', '@tooltips')
+ .then(([banner, tooltips]) => {
+ console.log(tooltips)
+ cy.get('[data-cy=drag-and-drop]').upload(banner, 'banner.html', false);
+ cy.get('[data-cy=drag-and-drop]').upload(tooltips, 'tooltips.json', false);
+ });
+
+ cy.get('[data-cy=form-submit-btn]').click();
+ cy.get('[data-cy=form-submit-btn]').should('not.exist');
+ cy.get('[data-cy=collection-files-right-panel]')
+ .contains('banner.html').should('exist');
+ cy.get('[data-cy=collection-files-right-panel]')
+ .contains('tooltips.json').should('exist');
+
+ cy.intercept({ method: 'GET', url: '**/arvados/v1/config?nocache=*' }, (req) => {
+ req.reply((res) => {
+ res.body.Workbench.BannerUUID = collectionUUID;
+ });
+ });
+ });
+ }
+});
it('automatically updates the collection UI contents without using the Refresh button', function () {
const collName = `Test Collection ${Math.floor(Math.random() * 999999)}`;
- const fileName = 'foobar'
cy.createCollection(adminUser.token, {
name: collName,
cy.getAll('@testCollection').then(function ([testCollection]) {
cy.loginAs(activeUser);
+
+ const files = [
+ "foobar",
+ "anotherFile",
+ "",
+ "finalName",
+ ];
+
cy.goToPath(`/collections/${testCollection.uuid}`);
cy.get('[data-cy=collection-files-panel]').should('contain', 'This collection is empty');
- cy.get('[data-cy=collection-files-panel]').should('not.contain', fileName);
+ cy.get('[data-cy=collection-files-panel]').should('not.contain', files[0]);
cy.get('[data-cy=collection-info-panel]').should('contain', collName);
- cy.updateCollection(adminUser.token, testCollection.uuid, {
- name: `${collName + ' updated'}`,
- manifest_text: `. 37b51d194a7513e45b56f6524f2d51f2+3 0:3:${fileName}\n`,
- }).as('updatedCollection');
- cy.getAll('@updatedCollection').then(function ([updatedCollection]) {
- expect(updatedCollection.name).to.equal(`${collName + ' updated'}`);
- cy.get('[data-cy=collection-info-panel]').should('contain', updatedCollection.name);
- cy.get('[data-cy=collection-files-panel]').should('contain', fileName);
+ files.map((fileName, i, files) => {
+ cy.updateCollection(adminUser.token, testCollection.uuid, {
+ name: `${collName + ' updated'}`,
+ manifest_text: fileName ? `. 37b51d194a7513e45b56f6524f2d51f2+3 0:3:${fileName}\n` : "",
+ }).as('updatedCollection');
+ cy.getAll('@updatedCollection').then(function ([updatedCollection]) {
+ expect(updatedCollection.name).to.equal(`${collName + ' updated'}`);
+ cy.get('[data-cy=collection-info-panel]').should('contain', updatedCollection.name);
+ fileName
+ ? cy.get('[data-cy=collection-files-panel]').should('contain', fileName)
+ : cy.get('[data-cy=collection-files-panel]').should('not.contain', files[i-1]);;
+ });
});
+
});
- })
+ });
it('makes a copy of an existing collection', function() {
const collName = `Test Collection ${Math.floor(Math.random() * 999999)}`;
});
cy.get('[data-cy=process-details]').should('contain', copiedCrName);
- cy.get('[data-cy=process-details]').find('button').contains('Run Process');
+ cy.get('[data-cy=process-details]').find('button').contains('Run');
+ });
+
+ const getFakeContainer = (fakeContainerUuid) => ({
+ href: `/containers/${fakeContainerUuid}`,
+ kind: "arvados#container",
+ etag: "ecfosljpnxfari9a8m7e4yv06",
+ uuid: fakeContainerUuid,
+ owner_uuid: "zzzzz-tpzed-000000000000000",
+ created_at: "2023-02-13T15:55:47.308915000Z",
+ modified_by_client_uuid: "zzzzz-ozdt8-q6dzdi1lcc03155",
+ modified_by_user_uuid: "zzzzz-tpzed-000000000000000",
+ modified_at: "2023-02-15T19:12:45.987086000Z",
+ command: [
+ "arvados-cwl-runner",
+ "--api=containers",
+ "--local",
+ "--project-uuid=zzzzz-j7d0g-yr18k784zplfeza",
+ "/var/lib/cwl/workflow.json#main",
+ "/var/lib/cwl/cwl.input.json",
+ ],
+ container_image: "4ad7d11381df349e464694762db14e04+303",
+ cwd: "/var/spool/cwl",
+ environment: {},
+ exit_code: null,
+ finished_at: null,
+ locked_by_uuid: null,
+ log: null,
+ output: null,
+ output_path: "/var/spool/cwl",
+ progress: null,
+ runtime_constraints: {
+ API: true,
+ cuda: {
+ device_count: 0,
+ driver_version: "",
+ hardware_capability: "",
+ },
+ keep_cache_disk: 2147483648,
+ keep_cache_ram: 0,
+ ram: 1342177280,
+ vcpus: 1,
+ },
+ runtime_status: {},
+ started_at: null,
+ auth_uuid: null,
+ scheduling_parameters: {
+ max_run_time: 0,
+ partitions: [],
+ preemptible: false,
+ },
+ runtime_user_uuid: "zzzzz-tpzed-vllbpebicy84rd5",
+ runtime_auth_scopes: ["all"],
+ lock_count: 2,
+ gateway_address: null,
+ interactive_session_started: false,
+ output_storage_classes: ["default"],
+ output_properties: {},
+ cost: 0.0,
+ subrequests_cost: 0.0,
+ });
+
+ it('shows cancel button when appropriate', function() {
+ // Ignore collection requests
+ cy.intercept({method: 'GET', url: `**/arvados/v1/collections/*`}, {
+ statusCode: 200,
+ body: {}
+ });
+
+ // Uncommitted container
+ const crUncommitted = `Test process ${Math.floor(Math.random() * 999999)}`;
+ createContainerRequest(
+ activeUser,
+ crUncommitted,
+ 'arvados/jobs',
+ ['echo', 'hello world'],
+ false, 'Uncommitted')
+ .then(function(containerRequest) {
+ // Navigate to process and verify run / cancel button
+ cy.goToPath(`/processes/${containerRequest.uuid}`);
+ cy.waitForDom();
+ cy.get('[data-cy=process-details]').should('contain', crUncommitted);
+ cy.get('[data-cy=process-run-button]').should('exist');
+ cy.get('[data-cy=process-cancel-button]').should('not.exist');
+ });
+
+ // Queued container
+ const crQueued = `Test process ${Math.floor(Math.random() * 999999)}`;
+ const fakeCrUuid = 'zzzzz-dz642-000000000000001';
+ createContainerRequest(
+ activeUser,
+ crQueued,
+ 'arvados/jobs',
+ ['echo', 'hello world'],
+ false, 'Committed')
+ .then(function(containerRequest) {
+ // Fake container uuid
+ cy.intercept({method: 'GET', url: `**/arvados/v1/container_requests/${containerRequest.uuid}`}, (req) => {
+ req.reply((res) => {
+ res.body.output_uuid = fakeCrUuid;
+ res.body.priority = 500;
+ res.body.state = "Committed";
+ });
+ });
+
+ // Fake container
+ const container = getFakeContainer(fakeCrUuid);
+ cy.intercept({method: 'GET', url: `**/arvados/v1/container/${fakeCrUuid}`}, {
+ statusCode: 200,
+ body: {...container, state: "Queued", priority: 500}
+ });
+
+ // Navigate to process and verify cancel button
+ cy.goToPath(`/processes/${containerRequest.uuid}`);
+ cy.waitForDom();
+ cy.get('[data-cy=process-details]').should('contain', crQueued);
+ cy.get('[data-cy=process-cancel-button]').contains('Cancel');
+ });
+
+ // Locked container
+ const crLocked = `Test process ${Math.floor(Math.random() * 999999)}`;
+ const fakeCrLockedUuid = 'zzzzz-dz642-000000000000002';
+ createContainerRequest(
+ activeUser,
+ crLocked,
+ 'arvados/jobs',
+ ['echo', 'hello world'],
+ false, 'Committed')
+ .then(function(containerRequest) {
+ // Fake container uuid
+ cy.intercept({method: 'GET', url: `**/arvados/v1/container_requests/${containerRequest.uuid}`}, (req) => {
+ req.reply((res) => {
+ res.body.output_uuid = fakeCrLockedUuid;
+ res.body.priority = 500;
+ res.body.state = "Committed";
+ });
+ });
+
+ // Fake container
+ const container = getFakeContainer(fakeCrLockedUuid);
+ cy.intercept({method: 'GET', url: `**/arvados/v1/container/${fakeCrLockedUuid}`}, {
+ statusCode: 200,
+ body: {...container, state: "Locked", priority: 500}
+ });
+
+ // Navigate to process and verify cancel button
+ cy.goToPath(`/processes/${containerRequest.uuid}`);
+ cy.waitForDom();
+ cy.get('[data-cy=process-details]').should('contain', crLocked);
+ cy.get('[data-cy=process-cancel-button]').contains('Cancel');
+ });
+
+ // On Hold container
+ const crOnHold = `Test process ${Math.floor(Math.random() * 999999)}`;
+ const fakeCrOnHoldUuid = 'zzzzz-dz642-000000000000003';
+ createContainerRequest(
+ activeUser,
+ crOnHold,
+ 'arvados/jobs',
+ ['echo', 'hello world'],
+ false, 'Committed')
+ .then(function(containerRequest) {
+ // Fake container uuid
+ cy.intercept({method: 'GET', url: `**/arvados/v1/container_requests/${containerRequest.uuid}`}, (req) => {
+ req.reply((res) => {
+ res.body.output_uuid = fakeCrOnHoldUuid;
+ res.body.priority = 0;
+ res.body.state = "Committed";
+ });
+ });
+
+ // Fake container
+ const container = getFakeContainer(fakeCrOnHoldUuid);
+ cy.intercept({method: 'GET', url: `**/arvados/v1/container/${fakeCrOnHoldUuid}`}, {
+ statusCode: 200,
+ body: {...container, state: "Queued", priority: 0}
+ });
+
+ // Navigate to process and verify cancel button
+ cy.goToPath(`/processes/${containerRequest.uuid}`);
+ cy.waitForDom();
+ cy.get('[data-cy=process-details]').should('contain', crOnHold);
+ cy.get('[data-cy=process-run-button]').should('exist');
+ cy.get('[data-cy=process-cancel-button]').should('not.exist');
+ });
});
});
});
});
+ it('creates a project without and with description', function() {
+ const projName = `Test project (${Math.floor(999999 * Math.random())})`;
+ cy.loginAs(activeUser);
+
+ // Create project
+ cy.get('[data-cy=side-panel-button]').click();
+ cy.get('[data-cy=side-panel-new-project]').click();
+ cy.get('[data-cy=form-dialog]')
+ .should('contain', 'New Project')
+ .within(() => {
+ cy.get('[data-cy=name-field]').within(() => {
+ cy.get('input').type(projName);
+ });
+ });
+ cy.get('[data-cy=form-submit-btn]').click();
+
+ const editProjectDescription = (name, type) => {
+ cy.get('[data-cy=side-panel-tree]').contains('Home Projects').click();
+ cy.get('[data-cy=project-panel] tbody tr').contains(name).rightclick();
+ cy.get('[data-cy=context-menu]').contains('Edit').click();
+ cy.get('[data-cy=form-dialog]').within(() => {
+ cy.get('div[contenteditable=true]')
+ .click()
+ .type(type);
+ cy.get('[data-cy=form-submit-btn]').click();
+ });
+ };
+
+ const verifyProjectDescription = (name, description) => {
+ cy.doRequest('GET', '/arvados/v1/groups', null, {
+ filters: `[["name", "=", "${name}"], ["group_class", "=", "project"]]`,
+ })
+ .its('body.items').as('projects')
+ .then(function() {
+ expect(this.projects).to.have.lengthOf(1);
+ expect(this.projects[0].description).to.equal(description);
+ });
+ };
+
+ // Edit description
+ editProjectDescription(projName, 'Test description');
+
+ // Check description is set
+ verifyProjectDescription(projName, "<p>Test description</p>");
+
+ // Clear description
+ editProjectDescription(projName, '{selectall}{backspace}');
+
+ // Check description is null
+ verifyProjectDescription(projName, null);
+
+ // Set description to contain whitespace
+ editProjectDescription(projName, '{selectall}{backspace} x');
+ editProjectDescription(projName, '{backspace}');
+
+ // Check description is null
+ verifyProjectDescription(projName, null);
+
+ });
+
it('creates new project on home project and then a subproject inside it', function() {
const createProject = function(name, parentName) {
cy.get('[data-cy=side-panel-button]').click();
));
});
-});
+ it('sorts displayed items correctly', () => {
+ cy.loginAs(activeUser);
+
+ cy.get('[data-cy=project-panel] button[title="Select columns"]').click();
+ cy.get('div[role=presentation] ul > div[role=button]').contains('Date Created').click();
+ cy.get('div[role=presentation] ul > div[role=button]').contains('Trash at').click();
+ cy.get('div[role=presentation] ul > div[role=button]').contains('Delete at').click();
+ cy.get('div[role=presentation] > div[aria-hidden=true]').click();
+
+ cy.intercept({method: 'GET', url: '**/arvados/v1/groups/*/contents*'}).as('filteredQuery');
+ [
+ {
+ name: "Name",
+ asc: "collections.name asc,container_requests.name asc,groups.name asc",
+ desc: "collections.name desc,container_requests.name desc,groups.name desc"
+ },
+ {
+ name: "Last Modified",
+ asc: "collections.modified_at asc,container_requests.modified_at asc,groups.modified_at asc",
+ desc: "collections.modified_at desc,container_requests.modified_at desc,groups.modified_at desc"
+ },
+ {
+ name: "Date Created",
+ asc: "collections.created_at asc,container_requests.created_at asc,groups.created_at asc",
+ desc: "collections.created_at desc,container_requests.created_at desc,groups.created_at desc"
+
+ },
+ {
+ name: "Trash at",
+ asc: "collections.trash_at asc,container_requests.trash_at asc,groups.trash_at asc",
+ desc: "collections.trash_at desc,container_requests.trash_at desc,groups.trash_at desc"
+
+ },
+ {
+ name: "Delete at",
+ asc: "collections.delete_at asc,container_requests.delete_at asc,groups.delete_at asc",
+ desc: "collections.delete_at desc,container_requests.delete_at desc,groups.delete_at desc"
+
+ },
+ ].forEach((test) => {
+ cy.get('[data-cy=project-panel] table thead th').contains(test.name).click();
+ cy.wait('@filteredQuery').then(interception => {
+ const searchParams = new URLSearchParams((new URL(interception.request.url).search));
+ expect(searchParams.get('order')).to.eq(test.asc);
+ });
+ cy.get('[data-cy=project-panel] table thead th').contains(test.name).click();
+ cy.wait('@filteredQuery').then(interception => {
+ const searchParams = new URLSearchParams((new URL(interception.request.url).search));
+ expect(searchParams.get('order')).to.eq(test.desc);
+ });
+ });
+
+ });
+});
{
prevSubject: 'element',
},
- (subject, file, fileName) => {
+ (subject, file, fileName, binaryMode = true) => {
cy.window().then(window => {
- const blob = b64toBlob(file, '', 512);
+ const blob = binaryMode
+ ? b64toBlob(file, '', 512)
+ : new Blob([file], {type: 'text/plain'});
const testFile = new window.File([blob], fileName);
cy.wrap(subject).trigger('drop', {
"set-value": "2.0.1",
"shell-escape": "^0.2.0",
"sinon": "7.3",
+ "tippy.js": "^6.3.7",
"tslint": "5.20.0",
"tslint-etc": "1.6.0",
"unionize": "2.1.2",
WebDAVDownload: { ExternalURL: '' },
WebShell: { ExternalURL: '' },
Workbench: {
- DisableSharingURLsUI: false,
- ArvadosDocsite: "",
- FileViewersConfigURL: "",
- WelcomePageHTML: "",
- InactivePageHTML: "",
- SSHHelpPageHTML: "",
- SSHHelpHostSuffix: "",
- SiteName: "",
- IdleTimeout: "0s"
- }
+ DisableSharingURLsUI: false,
+ ArvadosDocsite: "",
+ FileViewersConfigURL: "",
+ WelcomePageHTML: "",
+ InactivePageHTML: "",
+ SSHHelpPageHTML: "",
+ SSHHelpHostSuffix: "",
+ SiteName: "",
+ IdleTimeout: "0s"
+ },
},
Workbench: {
DisableSharingURLsUI: false,
//
// SPDX-License-Identifier: AGPL-3.0
-import { customEncodeURI } from "./url";
import { WebDAV } from "./webdav";
describe('WebDAV', () => {
const request = await promise;
expect(open).toHaveBeenCalledWith('PROPFIND', 'http://foo.com/foo');
expect(setRequestHeader).toHaveBeenCalledWith('Authorization', 'Basic');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
it('allows to modify defaults after instantiation', async () => {
const { open, load, setRequestHeader, createRequest } = mockCreateRequest();
- const webdav = new WebDAV(undefined, createRequest);
- webdav.defaults.baseURL = 'http://foo.com/';
- webdav.defaults.headers = { Authorization: 'Basic' };
+ const webdav = new WebDAV({ baseURL: 'http://foo.com/' }, createRequest);
+ webdav.setAuthorization('Basic');
const promise = webdav.propfind('foo');
load();
const request = await promise;
expect(open).toHaveBeenCalledWith('PROPFIND', 'http://foo.com/foo');
expect(setRequestHeader).toHaveBeenCalledWith('Authorization', 'Basic');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
it('PROPFIND', async () => {
- const { open, load, createRequest } = mockCreateRequest();
+ const { open, load, setRequestHeader, createRequest } = mockCreateRequest();
const webdav = new WebDAV(undefined, createRequest);
const promise = webdav.propfind('foo');
load();
const request = await promise;
expect(open).toHaveBeenCalledWith('PROPFIND', 'foo');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
it('PUT', async () => {
- const { open, send, load, progress, createRequest } = mockCreateRequest();
+ const { open, send, load, progress, setRequestHeader, createRequest } = mockCreateRequest();
const webdav = new WebDAV(undefined, createRequest);
const promise = webdav.put('foo', 'Test data');
progress();
const request = await promise;
expect(open).toHaveBeenCalledWith('PUT', 'foo');
expect(send).toHaveBeenCalledWith('Test data');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
it('COPY', async () => {
const { open, setRequestHeader, load, createRequest } = mockCreateRequest();
- const webdav = new WebDAV(undefined, createRequest);
- webdav.defaults.baseURL = 'http://base';
+ const webdav = new WebDAV({ baseURL: 'http://base' }, createRequest);
const promise = webdav.copy('foo', 'foo-copy');
load();
const request = await promise;
expect(open).toHaveBeenCalledWith('COPY', 'http://base/foo');
expect(setRequestHeader).toHaveBeenCalledWith('Destination', 'http://base/foo-copy');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
it('COPY - adds baseURL with trailing slash to Destination header', async () => {
const { open, setRequestHeader, load, createRequest } = mockCreateRequest();
- const webdav = new WebDAV(undefined, createRequest);
- webdav.defaults.baseURL = 'http://base';
+ const webdav = new WebDAV({ baseURL: 'http://base' }, createRequest);
const promise = webdav.copy('foo', 'foo-copy');
load();
const request = await promise;
expect(open).toHaveBeenCalledWith('COPY', 'http://base/foo');
expect(setRequestHeader).toHaveBeenCalledWith('Destination', 'http://base/foo-copy');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
it('COPY - adds baseURL without trailing slash to Destination header', async () => {
const { open, setRequestHeader, load, createRequest } = mockCreateRequest();
- const webdav = new WebDAV(undefined, createRequest);
- webdav.defaults.baseURL = 'http://base';
+ const webdav = new WebDAV({ baseURL: 'http://base' }, createRequest);
const promise = webdav.copy('foo', 'foo-copy');
load();
const request = await promise;
expect(open).toHaveBeenCalledWith('COPY', 'http://base/foo');
expect(setRequestHeader).toHaveBeenCalledWith('Destination', 'http://base/foo-copy');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
it('MOVE', async () => {
const { open, setRequestHeader, load, createRequest } = mockCreateRequest();
- const webdav = new WebDAV(undefined, createRequest);
- webdav.defaults.baseURL = 'http://base';
+ const webdav = new WebDAV({ baseURL: 'http://base' }, createRequest);
const promise = webdav.move('foo', 'foo-moved');
load();
const request = await promise;
expect(open).toHaveBeenCalledWith('MOVE', 'http://base/foo');
expect(setRequestHeader).toHaveBeenCalledWith('Destination', 'http://base/foo-moved');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
it('MOVE - adds baseURL with trailing slash to Destination header', async () => {
const { open, setRequestHeader, load, createRequest } = mockCreateRequest();
- const webdav = new WebDAV(undefined, createRequest);
- webdav.defaults.baseURL = 'http://base';
+ const webdav = new WebDAV({ baseURL: 'http://base' }, createRequest);
const promise = webdav.move('foo', 'foo-moved');
load();
const request = await promise;
expect(open).toHaveBeenCalledWith('MOVE', 'http://base/foo');
expect(setRequestHeader).toHaveBeenCalledWith('Destination', 'http://base/foo-moved');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
it('MOVE - adds baseURL without trailing slash to Destination header', async () => {
const { open, setRequestHeader, load, createRequest } = mockCreateRequest();
- const webdav = new WebDAV(undefined, createRequest);
- webdav.defaults.baseURL = 'http://base';
+ const webdav = new WebDAV({ baseURL: 'http://base' }, createRequest);
const promise = webdav.move('foo', 'foo-moved');
load();
const request = await promise;
expect(open).toHaveBeenCalledWith('MOVE', 'http://base/foo');
expect(setRequestHeader).toHaveBeenCalledWith('Destination', 'http://base/foo-moved');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
it('DELETE', async () => {
- const { open, load, createRequest } = mockCreateRequest();
+ const { open, load, setRequestHeader, createRequest } = mockCreateRequest();
const webdav = new WebDAV(undefined, createRequest);
const promise = webdav.delete('foo');
load();
const request = await promise;
expect(open).toHaveBeenCalledWith('DELETE', 'foo');
+ expect(setRequestHeader).toHaveBeenCalledWith('Cache-Control', 'no-cache');
expect(request).toBeInstanceOf(XMLHttpRequest);
});
});
export class WebDAV {
- defaults: WebDAVDefaults = {
+ private defaults: WebDAVDefaults = {
baseURL: '',
- headers: {},
+ headers: {
+ 'Cache-Control': 'no-cache'
+ },
};
constructor(config?: Partial<WebDAVDefaults>, private createRequest = () => new XMLHttpRequest()) {
if (config) {
- this.defaults = { ...this.defaults, ...config };
+ this.defaults = {
+ ...this.defaults,
+ ...config,
+ headers: {
+ ...this.defaults.headers,
+ ...config.headers
+ },
+ };
}
}
+ getBaseUrl = (): string => this.defaults.baseURL;
+ setAuthorization = (token?) => this.defaults.headers.Authorization = token;
+
propfind = (url: string, config: WebDAVRequestConfig = {}) =>
this.request({
...config, url,
this.defaults.baseURL = this.defaults.baseURL.replace(/\/+$/, '');
r.open(config.method,
`${this.defaults.baseURL
- ? this.defaults.baseURL+'/'
+ ? this.defaults.baseURL + '/'
: ''}${customEncodeURI(config.url)}`);
const headers = { ...this.defaults.headers, ...config.headers };
const { classes, onItemMenuOpen, onUploadDataClick, isWritable, dispatch, collectionPanelFiles, collectionPanel } = props;
const { apiToken, config } = props.auth;
- const webdavClient = new WebDAV();
- webdavClient.defaults.baseURL = config.keepWebServiceUrl;
- webdavClient.defaults.headers = {
- Authorization: `Bearer ${apiToken}`
- };
+ const webdavClient = new WebDAV({
+ baseURL: config.keepWebServiceUrl,
+ headers: {
+ Authorization: `Bearer ${apiToken}`
+ },
+ });
const webDAVRequestConfig: WebDAVRequestConfig = {
headers: {
import { ArvadosTheme } from "common/custom-theme";
interface ColumnSelectorDataProps {
- columns: DataColumns<any>;
- onColumnToggle: (column: DataColumn<any>) => void;
+ columns: DataColumns<any, any>;
+ onColumnToggle: (column: DataColumn<any, any>) => void;
className?: string;
}
color="primary"
checked={column.selected}
className={classes.checkbox} />
- <ListItemText
+ <ListItemText
className={classes.listItemText}>
{column.name}
</ListItemText>
<MenuIcon aria-label="Select columns" />
</IconButton>
</Tooltip>;
-
-
fetchMode: DataTableFetchMode;
items: T[];
itemsAvailable: number;
- columns: DataColumns<T>;
+ columns: DataColumns<T, any>;
searchLabel?: string;
searchValue: string;
rowsPerPage: number;
}
interface DataExplorerActionProps<T> {
- onSetColumns: (columns: DataColumns<T>) => void;
+ onSetColumns: (columns: DataColumns<T, any>) => void;
onSearch: (value: string) => void;
onRowClick: (item: T) => void;
onRowDoubleClick: (item: T) => void;
- onColumnToggle: (column: DataColumn<T>) => void;
+ onColumnToggle: (column: DataColumn<T, any>) => void;
onContextMenu: (event: React.MouseEvent<HTMLElement>, item: T) => void;
- onSortToggle: (column: DataColumn<T>) => void;
- onFiltersChange: (filters: DataTableFilters, column: DataColumn<T>) => void;
+ onSortToggle: (column: DataColumn<T, any>) => void;
+ onFiltersChange: (filters: DataTableFilters, column: DataColumn<T, any>) => void;
onChangePage: (page: number) => void;
onChangeRowsPerPage: (rowsPerPage: number) => void;
onLoadMore: (page: number) => void;
</Tooltip>
</Grid>
- contextMenuColumn: DataColumn<any> = {
+ contextMenuColumn: DataColumn<any, any> = {
name: "Actions",
selected: true,
configurable: false,
import { DataTableFilters } from "../data-table-filters/data-table-filters-tree";
import { createTree } from 'models/tree';
-export interface DataColumn<T> {
+/**
+ *
+ * @template I Type of dataexplorer item reference
+ * @template R Type of resource to use to restrict values of column sort.field
+ */
+export interface DataColumn<I, R> {
key?: React.Key;
name: string;
selected: boolean;
* radio group and only one filter can be selected at a time.
*/
mutuallyExclusiveFilters?: boolean;
- sortDirection?: SortDirection;
+ sort?: {direction: SortDirection, field: keyof R};
filters: DataTableFilters;
- render: (item:
T) => React.ReactElement<any>;
+ render: (item:
I) => React.ReactElement<any>;
renderHeader?: () => React.ReactElement<any>;
}
NONE = "none"
}
-export const toggleSortDirection = <T>(column: DataColumn<T>): DataColumn<T> => {
- return column.sortDirection
- ? column.sortDirection === SortDirection.ASC
- ? { ...column, sortDirection: SortDirection.DESC }
- : { ...column, sortDirection: SortDirection.ASC }
+export const toggleSortDirection = <I, R>(column: DataColumn<I, R>): DataColumn<I, R> => {
+ return column.sort
+ ? column.sort.direction === SortDirection.ASC
+ ? { ...column, sort: {...column.sort, direction: SortDirection.DESC} }
+ : { ...column, sort: {...column.sort, direction: SortDirection.ASC} }
: column;
};
-export const resetSortDirection = <T>(column: DataColumn<T>): DataColumn<T> => {
- return column.sortDirection ? { ...column, sortDirection: SortDirection.NONE } : column;
+export const resetSortDirection = <I, R>(column: DataColumn<I, R>): DataColumn<I, R> => {
+ return column.sort ? { ...column, sort: {...column.sort, direction: SortDirection.NONE} } : column;
};
-export const createDataColumn = <T>(dataColumn: Partial<DataColumn<T>>): DataColumn<T> => ({
+export const createDataColumn = <I, R>(dataColumn: Partial<DataColumn<I, R>>): DataColumn<I, R> => ({
key: '',
name: '',
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
filters: createTree(),
render: () => React.createElement('span'),
...dataColumn,
describe("<DataTable />", () => {
it("shows only selected columns", () => {
- const columns: DataColumns<string> = [
+ const columns: DataColumns<string, string> = [
createDataColumn({
name: "Column 1",
render: () => <span />,
});
it("renders column name", () => {
- const columns: DataColumns<string> = [
+ const columns: DataColumns<string, string> = [
createDataColumn({
name: "Column 1",
render: () => <span />,
});
it("uses renderHeader instead of name prop", () => {
- const columns: DataColumns<string> = [
+ const columns: DataColumns<string, string> = [
createDataColumn({
name: "Column 1",
renderHeader: () => <span>Column Header</span>,
});
it("passes column key prop to corresponding cells", () => {
- const columns: DataColumns<string> = [
+ const columns: DataColumns<string, string> = [
createDataColumn({
name: "Column 1",
key: "column-1-key",
});
it("renders items", () => {
- const columns: DataColumns<string> = [
+ const columns: DataColumns<string, string> = [
createDataColumn({
name: "Column 1",
render: (item) => <Typography>{item}</Typography>,
});
it("passes sorting props to <TableSortLabel />", () => {
- const columns: DataColumns<string> = [
+ const columns: DataColumns<string, string> = [
createDataColumn({
name: "Column 1",
- sortDirection: SortDirection.ASC,
+ sort: {direction: SortDirection.ASC, field: "length"},
selected: true,
configurable: true,
render: (item) => <Typography>{item}</Typography>
});
it("does not display <DataTableFiltersPopover /> if there is no filters provided", () => {
- const columns: DataColumns<string> = [{
+ const columns: DataColumns<string, string> = [{
name: "Column 1",
- sortDirection: SortDirection.ASC,
selected: true,
configurable: true,
filters: [],
() => createTree<DataTableFilterItem>(),
setNode(initTreeNode({ id: 'filter', value: { name: 'filter' } }))
);
- const columns: DataColumns<string> = [{
+ const columns: DataColumns<string, string> = [{
name: "Column 1",
- sortDirection: SortDirection.ASC,
selected: true,
configurable: true,
filters: filters(),
import { SvgIconProps } from '@material-ui/core/SvgIcon';
import ArrowDownwardIcon from '@material-ui/icons/ArrowDownward';
-export type DataColumns<T> = Array<DataColumn<T>>;
+export type DataColumns<I, R> = Array<DataColumn<I, R>>;
export enum DataTableFetchMode {
PAGINATED,
INFINITE
}
-export interface DataTableDataProps<T> {
- items: T[];
- columns: DataColumns<T>;
- onRowClick: (event: React.MouseEvent<HTMLTableRowElement>, item: T) => void;
- onContextMenu: (event: React.MouseEvent<HTMLElement>, item: T) => void;
- onRowDoubleClick: (event: React.MouseEvent<HTMLTableRowElement>, item: T) => void;
- onSortToggle: (column: DataColumn<T>) => void;
- onFiltersChange: (filters: DataTableFilters, column: DataColumn<T>) => void;
- extractKey?: (item: T) => React.Key;
+export interface DataTableDataProps<I> {
+ items: I[];
+ columns: DataColumns<I, any>;
+ onRowClick: (event: React.MouseEvent<HTMLTableRowElement>, item: I) => void;
+ onContextMenu: (event: React.MouseEvent<HTMLElement>, item: I) => void;
+ onRowDoubleClick: (event: React.MouseEvent<HTMLTableRowElement>, item: I) => void;
+ onSortToggle: (column: DataColumn<I, any>) => void;
+ onFiltersChange: (filters: DataTableFilters, column: DataColumn<I, any>) => void;
+ extractKey?: (item: I) => React.Key;
working?: boolean;
defaultViewIcon?: IconType;
defaultViewMessages?: string[];
wordWrap: 'break-word',
paddingRight: '24px',
color: '#737373'
-
+
},
tableCellWorkflows: {
'&:nth-last-child(2)': {
</div>;
}
- renderNoItemsPlaceholder = (columns: DataColumns<T>) => {
+ renderNoItemsPlaceholder = (columns: DataColumns<T, any>) => {
const dirty = columns.some((column) => getTreeDirty('')(column.filters));
return <DataTableDefaultView
icon={this.props.defaultViewIcon}
filtersApplied={dirty} />;
}
- renderHeadCell = (column: DataColumn<T>, index: number) => {
- const { name, key, renderHeader, filters, sortDirection } = column;
+ renderHeadCell = (column: DataColumn<T, any>, index: number) => {
+ const { name, key, renderHeader, filters, sort } = column;
const { onSortToggle, onFiltersChange, classes } = this.props;
return <TableCell className={classes.tableCell} key={key || index}>
{renderHeader ?
filters={filters}>
{name}
</DataTableFiltersPopover>
- : sortDirection
+ : sort
? <TableSortLabel
- active={sortDirection !== SortDirection.NONE}
- direction={sortDirection !== SortDirection.NONE ? sortDirection : undefined}
+ active={sort.direction !== SortDirection.NONE}
+ direction={sort.direction !== SortDirection.NONE ? sort.direction : undefined}
IconComponent={this.ArrowIcon}
hideSortIcon
onClick={() =>
</TableRow>;
}
- mapVisibleColumns = (fn: (column: DataColumn<T>, index: number) => React.ReactElement<any>) => {
+ mapVisibleColumns = (fn: (column: DataColumn<T
, any>, index: number) => React.ReactElement<any>) => {
return this.props.columns.filter(column => column.selected).map(fn);
}
import RemoveCircleOutline from '@material-ui/icons/RemoveCircleOutline';
import NotInterested from '@material-ui/icons/NotInterested';
import Image from '@material-ui/icons/Image';
+import Stop from '@material-ui/icons/Stop';
// Import FontAwesome icons
import { library } from '@fortawesome/fontawesome-svg-core';
export const InactiveIcon: IconType = (props) => <NotInterested {...props} />;
export const ImageIcon: IconType = (props) => <Image {...props} />;
export const StartIcon: IconType = (props) => <PlayArrow {...props} />;
+export const StopIcon: IconType = (props) => <Stop {...props} />;
onChange = (value: any) => {
this.setState({ value });
- this.props.input.onChange(value.toString('html'));
+ this.props.input.onChange(
+ !!value.getEditorState().getCurrentContent().getPlainText().trim()
+ ? value.toString('html')
+ : null
+ );
}
render() {
import { snakeCase } from 'lodash';
import { CollectionResource, defaultCollectionSelectedFields } from 'models/collection';
import { AuthService } from '../auth-service/auth-service';
-import { CollectionService } from './collection-service';
+import { CollectionService, emptyCollectionPdh } from './collection-service';
describe('collection-service', () => {
let collectionService: CollectionService;
webdavClient = {
delete: jest.fn(),
upload: jest.fn(),
+ mkdir: jest.fn(),
} as any;
authService = {} as AuthService;
actions = {
progressFn: jest.fn(),
+ errorFn: jest.fn(),
} as any;
collectionService = new CollectionService(serverApi, webdavClient, authService, actions);
collectionService.update = jest.fn();
describe('deleteFiles', () => {
it('should remove no files', async () => {
// given
+ serverApi.put = jest.fn(() => Promise.resolve({ data: {} }));
const filePaths: string[] = [];
- const collectionUUID = '';
+ const collectionUUID = 'zzzzz-tpzed-5o5tg0l9a57gxxx';
// when
await collectionService.deleteFiles(collectionUUID, filePaths);
// then
- expect(webdavClient.delete).not.toHaveBeenCalled();
+ expect(serverApi.put).toHaveBeenCalledTimes(1);
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${collectionUUID}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {},
+ }
+ );
});
it('should remove only root files', async () => {
// given
+ serverApi.put = jest.fn(() => Promise.resolve({ data: {} }));
const filePaths: string[] = ['/root/1', '/root/1/100', '/root/1/100/test.txt', '/root/2', '/root/2/200', '/root/3/300/test.txt'];
- const collectionUUID = '';
+ const collectionUUID = 'zzzzz-tpzed-5o5tg0l9a57gxxx';
// when
await collectionService.deleteFiles(collectionUUID, filePaths);
// then
- expect(webdavClient.delete).toHaveBeenCalledTimes(3);
- expect(webdavClient.delete).toHaveBeenCalledWith("c=/root/3/300/test.txt");
- expect(webdavClient.delete).toHaveBeenCalledWith("c=/root/2");
- expect(webdavClient.delete).toHaveBeenCalledWith("c=/root/1");
+ expect(serverApi.put).toHaveBeenCalledTimes(1);
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${collectionUUID}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ '/root/3/300/test.txt': '',
+ '/root/2': '',
+ '/root/1': '',
+ },
+ }
+ );
});
- it('should remove files with uuid prefix', async () => {
+ it('should batch remove files', async () => {
+ serverApi.put = jest.fn(() => Promise.resolve({ data: {} }));
// given
- const filePaths: string[] = ['/root/1'];
- const collectionUUID = 'zzzzz-tpzed-5o5tg0l9a57gxxx';
+ const filePaths: string[] = ['/root/1', '/secondFile', 'barefile.txt'];
+ const collectionUUID = 'zzzzz-4zz18-5o5tg0l9a57gxxx';
// when
await collectionService.deleteFiles(collectionUUID, filePaths);
// then
- expect(webdavClient.delete).toHaveBeenCalledTimes(1);
- expect(webdavClient.delete).toHaveBeenCalledWith("c=zzzzz-tpzed-5o5tg0l9a57gxxx/root/1");
+ expect(serverApi.put).toHaveBeenCalledTimes(1);
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${collectionUUID}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ '/root/1': '',
+ '/secondFile': '',
+ '/barefile.txt': '',
+ },
+ }
+ );
+ });
+ });
+
+ describe('renameFile', () => {
+ it('should rename file', async () => {
+ serverApi.put = jest.fn(() => Promise.resolve({ data: {} }));
+ const collectionUuid = 'zzzzz-4zz18-ywq0rvhwwhkjnfq';
+ const collectionPdh = '8cd9ce1dfa21c635b620b1bfee7aaa08+180';
+ const oldPath = '/old/path';
+ const newPath = '/new/filename';
+
+ await collectionService.renameFile(collectionUuid, collectionPdh, oldPath, newPath);
+
+ expect(serverApi.put).toHaveBeenCalledTimes(1);
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${collectionUuid}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ [newPath]: `${collectionPdh}${oldPath}`,
+ [oldPath]: '',
+ },
+ }
+ );
});
});
+
+ describe('copyFiles', () => {
+ it('should batch copy files', async () => {
+ serverApi.put = jest.fn(() => Promise.resolve({ data: {} }));
+ const filePaths: string[] = ['/root/1', '/secondFile', 'barefile.txt'];
+ const sourcePdh = '8cd9ce1dfa21c635b620b1bfee7aaa08+180';
+
+ const destinationUuid = 'zzzzz-4zz18-ywq0rvhwwhkjnfq';
+ const destinationPath = '/destinationPath';
+
+ // when
+ await collectionService.copyFiles(sourcePdh, filePaths, destinationUuid, destinationPath);
+
+ // then
+ expect(serverApi.put).toHaveBeenCalledTimes(1);
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${destinationUuid}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ [`${destinationPath}/1`]: `${sourcePdh}/root/1`,
+ [`${destinationPath}/secondFile`]: `${sourcePdh}/secondFile`,
+ [`${destinationPath}/barefile.txt`]: `${sourcePdh}/barefile.txt`,
+ },
+ }
+ );
+ });
+
+ it('should copy files from rooth', async () => {
+ // Test copying from root paths
+ serverApi.put = jest.fn(() => Promise.resolve({ data: {} }));
+ const filePaths: string[] = ['/'];
+ const sourcePdh = '8cd9ce1dfa21c635b620b1bfee7aaa08+180';
+
+ const destinationUuid = 'zzzzz-4zz18-ywq0rvhwwhkjnfq';
+ const destinationPath = '/destinationPath';
+
+ await collectionService.copyFiles(sourcePdh, filePaths, destinationUuid, destinationPath);
+
+ expect(serverApi.put).toHaveBeenCalledTimes(1);
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${destinationUuid}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ [`${destinationPath}`]: `${sourcePdh}/`,
+ },
+ }
+ );
+ });
+
+ it('should copy files to root path', async () => {
+ // Test copying to root paths
+ serverApi.put = jest.fn(() => Promise.resolve({ data: {} }));
+ const filePaths: string[] = ['/'];
+ const sourcePdh = '8cd9ce1dfa21c635b620b1bfee7aaa08+180';
+
+ const destinationUuid = 'zzzzz-4zz18-ywq0rvhwwhkjnfq';
+ const destinationPath = '/';
+
+ await collectionService.copyFiles(sourcePdh, filePaths, destinationUuid, destinationPath);
+
+ expect(serverApi.put).toHaveBeenCalledTimes(1);
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${destinationUuid}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ "/": `${sourcePdh}/`,
+ },
+ }
+ );
+ });
+ });
+
+ describe('moveFiles', () => {
+ it('should batch move files', async () => {
+ serverApi.put = jest.fn(() => Promise.resolve({ data: {} }));
+ // given
+ const filePaths: string[] = ['/rootFile', '/secondFile', '/subpath/subfile', 'barefile.txt'];
+ const srcCollectionUUID = 'zzzzz-4zz18-5o5tg0l9a57gxxx';
+ const srcCollectionPdh = '8cd9ce1dfa21c635b620b1bfee7aaa08+180';
+
+ const destinationUuid = 'zzzzz-4zz18-ywq0rvhwwhkjnfq';
+ const destinationPath = '/destinationPath';
+
+ // when
+ await collectionService.moveFiles(srcCollectionUUID, srcCollectionPdh, filePaths, destinationUuid, destinationPath);
+
+ // then
+ expect(serverApi.put).toHaveBeenCalledTimes(2);
+ // Verify copy
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${destinationUuid}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ [`${destinationPath}/rootFile`]: `${srcCollectionPdh}/rootFile`,
+ [`${destinationPath}/secondFile`]: `${srcCollectionPdh}/secondFile`,
+ [`${destinationPath}/subfile`]: `${srcCollectionPdh}/subpath/subfile`,
+ [`${destinationPath}/barefile.txt`]: `${srcCollectionPdh}/barefile.txt`,
+ },
+ }
+ );
+ // Verify delete
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${srcCollectionUUID}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ "/rootFile": "",
+ "/secondFile": "",
+ "/subpath/subfile": "",
+ "/barefile.txt": "",
+ },
+ }
+ );
+ });
+
+ it('should batch move files within collection', async () => {
+ serverApi.put = jest.fn(() => Promise.resolve({ data: {} }));
+ // given
+ const filePaths: string[] = ['/one', '/two', '/subpath/subfile', 'barefile.txt'];
+ const srcCollectionUUID = 'zzzzz-4zz18-5o5tg0l9a57gxxx';
+ const srcCollectionPdh = '8cd9ce1dfa21c635b620b1bfee7aaa08+180';
+
+ const destinationPath = '/destinationPath';
+
+ // when
+ await collectionService.moveFiles(srcCollectionUUID, srcCollectionPdh, filePaths, srcCollectionUUID, destinationPath);
+
+ // then
+ expect(serverApi.put).toHaveBeenCalledTimes(1);
+ // Verify copy
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${srcCollectionUUID}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ [`${destinationPath}/one`]: `${srcCollectionPdh}/one`,
+ ['/one']: '',
+ [`${destinationPath}/two`]: `${srcCollectionPdh}/two`,
+ ['/two']: '',
+ [`${destinationPath}/subfile`]: `${srcCollectionPdh}/subpath/subfile`,
+ ['/subpath/subfile']: '',
+ [`${destinationPath}/barefile.txt`]: `${srcCollectionPdh}/barefile.txt`,
+ ['/barefile.txt']: '',
+ },
+ }
+ );
+ });
+
+ it('should abort batch move when copy fails', async () => {
+ // Simulate failure to copy
+ serverApi.put = jest.fn(() => Promise.reject({
+ data: {},
+ response: {
+ "errors": ["error getting snapshot of \"rootFile\" from \"8cd9ce1dfa21c635b620b1bfee7aaa08+180\": file does not exist"]
+ }
+ }));
+ // given
+ const filePaths: string[] = ['/rootFile', '/secondFile', '/subpath/subfile', 'barefile.txt'];
+ const srcCollectionUUID = 'zzzzz-4zz18-5o5tg0l9a57gxxx';
+ const srcCollectionPdh = '8cd9ce1dfa21c635b620b1bfee7aaa08+180';
+
+ const destinationUuid = 'zzzzz-4zz18-ywq0rvhwwhkjnfq';
+ const destinationPath = '/destinationPath';
+
+ // when
+ try {
+ await collectionService.moveFiles(srcCollectionUUID, srcCollectionPdh, filePaths, destinationUuid, destinationPath);
+ } catch {}
+
+ // then
+ expect(serverApi.put).toHaveBeenCalledTimes(1);
+ // Verify copy
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${destinationUuid}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ [`${destinationPath}/rootFile`]: `${srcCollectionPdh}/rootFile`,
+ [`${destinationPath}/secondFile`]: `${srcCollectionPdh}/secondFile`,
+ [`${destinationPath}/subfile`]: `${srcCollectionPdh}/subpath/subfile`,
+ [`${destinationPath}/barefile.txt`]: `${srcCollectionPdh}/barefile.txt`,
+ },
+ }
+ );
+ });
+ });
+
+ describe('createDirectory', () => {
+ it('creates empty directory', async () => {
+ // given
+ const directoryNames = [
+ {in: 'newDir', out: 'newDir'},
+ {in: '/fooDir', out: 'fooDir'},
+ {in: '/anotherPath/', out: 'anotherPath'},
+ {in: 'trailingSlash/', out: 'trailingSlash'},
+ ];
+ const collectionUuid = 'zzzzz-tpzed-5o5tg0l9a57gxxx';
+
+ for (var i = 0; i < directoryNames.length; i++) {
+ serverApi.put = jest.fn(() => Promise.resolve({ data: {} }));
+ // when
+ await collectionService.createDirectory(collectionUuid, directoryNames[i].in);
+ // then
+ expect(serverApi.put).toHaveBeenCalledTimes(1);
+ expect(serverApi.put).toHaveBeenCalledWith(
+ `/collections/${collectionUuid}`, {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: {
+ ["/" + directoryNames[i].out]: emptyCollectionPdh,
+ },
+ }
+ );
+ }
+ });
+ });
+
});
import { extractFilesData } from "./collection-service-files-response";
import { TrashableResourceService } from "services/common-service/trashable-resource-service";
import { ApiActions } from "services/api/api-actions";
-import { customEncodeURI } from "common/url";
import { Session } from "models/session";
+import { CommonService } from "services/common-service/common-service";
export type UploadProgress = (fileId: number, loaded: number, total: number, currentTime: number) => void;
+export const emptyCollectionPdh = 'd41d8cd98f00b204e9800998ecf8427e+0';
+
export class CollectionService extends TrashableResourceService<CollectionResource> {
constructor(serverApi: AxiosInstance, private webdavClient: WebDAV, private authService: AuthService, actions: ApiActions) {
super(serverApi, "collections", actions, [
return Promise.reject();
}
- async deleteFiles(collectionUuid: string, filePaths: string[]) {
- const sortedUniquePaths = Array.from(new Set(filePaths))
- .sort((a, b) => a.length - b.length)
- .reduce((acc, currentPath) => {
- const parentPathFound = acc.find((parentPath) => currentPath.indexOf(`${parentPath}/`) > -1);
-
- if (!parentPathFound) {
- return [...acc, currentPath];
- }
-
- return acc;
- }, []);
-
- for (const path of sortedUniquePaths) {
- if (path.indexOf(collectionUuid) === -1) {
- await this.webdavClient.delete(`c=${collectionUuid}${path}`);
+ private combineFilePath(parts: string[]) {
+ return parts.reduce((path, part) => {
+ // Trim leading and trailing slashes
+ const trimmedPart = part.split('/').filter(Boolean).join('/');
+ if (trimmedPart.length) {
+ const separator = path.endsWith('/') ? '' : '/';
+ return `${path}${separator}${trimmedPart}`;
} else {
- await this.webdavClient.delete(`c=${path}`);
+ return path;
}
- }
- await this.update(collectionUuid, { preserveVersion: true });
+ }, "/");
+ }
+
+ private replaceFiles(collectionUuid: string, fileMap: {}, showErrors?: boolean) {
+ const payload = {
+ collection: {
+ preserve_version: true
+ },
+ replace_files: fileMap
+ };
+
+ return CommonService.defaultResponse(
+ this.serverApi
+ .put<CollectionResource>(`/${this.resourceType}/${collectionUuid}`, payload),
+ this.actions,
+ true, // mapKeys
+ showErrors
+ );
}
async uploadFiles(collectionUuid: string, files: File[], onProgress?: UploadProgress, targetLocation: string = '') {
await this.update(collectionUuid, { preserveVersion: true });
}
- async moveFile(collectionUuid: string, oldPath: string, newPath: string) {
- await this.webdavClient.move(
- `c=${collectionUuid}${oldPath}`,
- `c=${collectionUuid}/${customEncodeURI(newPath)}`
- );
- await this.update(collectionUuid, { preserveVersion: true });
+ async renameFile(collectionUuid: string, collectionPdh: string, oldPath: string, newPath: string) {
+ return this.replaceFiles(collectionUuid, {
+ [this.combineFilePath([newPath])]: `${collectionPdh}${this.combineFilePath([oldPath])}`,
+ [this.combineFilePath([oldPath])]: '',
+ });
}
extendFileURL = (file: CollectionDirectory | CollectionFile) => {
- const baseUrl = this.webdavClient.defaults.baseURL.endsWith('/')
- ? this.webdavClient.defaults.baseURL.slice(0, -1)
- : this.webdavClient.defaults.baseURL;
+ const baseUrl = this.webdavClient.getBaseUrl().endsWith('/')
+ ? this.webdavClient.getBaseUrl().slice(0, -1)
+ : this.webdavClient.getBaseUrl();
const apiToken = this.authService.getApiToken();
const encodedApiToken = apiToken ? encodeURI(apiToken) : '';
const userApiToken = `/t=${encodedApiToken}/`;
};
return this.webdavClient.upload(fileURL, [file], requestConfig);
}
+
+ deleteFiles(collectionUuid: string, files: string[], showErrors?: boolean) {
+ const optimizedFiles = files
+ .sort((a, b) => a.length - b.length)
+ .reduce((acc, currentPath) => {
+ const parentPathFound = acc.find((parentPath) => currentPath.indexOf(`${parentPath}/`) > -1);
+
+ if (!parentPathFound) {
+ return [...acc, currentPath];
+ }
+
+ return acc;
+ }, []);
+
+ const fileMap = optimizedFiles.reduce((obj, filePath) => {
+ return {
+ ...obj,
+ [this.combineFilePath([filePath])]: ''
+ }
+ }, {})
+
+ return this.replaceFiles(collectionUuid, fileMap, showErrors);
+ }
+
+ copyFiles(sourcePdh: string, files: string[], destinationCollectionUuid: string, destinationPath: string, showErrors?: boolean) {
+ const fileMap = files.reduce((obj, sourceFile) => {
+ const sourceFileName = sourceFile.split('/').filter(Boolean).slice(-1).join("");
+ return {
+ ...obj,
+ [this.combineFilePath([destinationPath, sourceFileName])]: `${sourcePdh}${this.combineFilePath([sourceFile])}`
+ };
+ }, {});
+
+ return this.replaceFiles(destinationCollectionUuid, fileMap, showErrors);
+ }
+
+ moveFiles(sourceUuid: string, sourcePdh: string, files: string[], destinationCollectionUuid: string, destinationPath: string, showErrors?: boolean) {
+ if (sourceUuid === destinationCollectionUuid) {
+ const fileMap = files.reduce((obj, sourceFile) => {
+ const sourceFileName = sourceFile.split('/').filter(Boolean).slice(-1).join("");
+ return {
+ ...obj,
+ [this.combineFilePath([destinationPath, sourceFileName])]: `${sourcePdh}${this.combineFilePath([sourceFile])}`,
+ [this.combineFilePath([sourceFile])]: '',
+ };
+ }, {});
+
+ return this.replaceFiles(sourceUuid, fileMap, showErrors)
+ } else {
+ return this.copyFiles(sourcePdh, files, destinationCollectionUuid, destinationPath, showErrors)
+ .then(() => {
+ return this.deleteFiles(sourceUuid, files, showErrors);
+ });
+ }
+ }
+
+ createDirectory(collectionUuid: string, path: string, showErrors?: boolean) {
+ const fileMap = {[this.combineFilePath([path])]: emptyCollectionPdh};
+
+ return this.replaceFiles(collectionUuid, fileMap, showErrors);
+ }
+
}
if (cancelToken) {
cfg.cancelToken = cancelToken;
}
-
+
const response = await CommonResourceService.defaultResponse(
this.serverApi.get(this.resourceType + pathUrl, cfg),
this.actions,
services.apiClient.defaults.headers.common = {
Authorization: `Bearer ${token}`
};
- services.webdavClient.defaults.headers = {
- Authorization: `Bearer ${token}`
- };
+ services.webdavClient.setAuthorization(`Bearer ${token}`);
}
export function removeAuthorizationHeader(services: ServiceRepository) {
delete services.apiClient.defaults.headers.common;
- delete services.webdavClient.defaults.headers.common;
+ services.webdavClient.setAuthorization(undefined);
}
export const createServices = (config: Config, actions: ApiActions, useApiClient?: AxiosInstance) => {
const apiClient = useApiClient || Axios.create({ headers: {} });
apiClient.defaults.baseURL = config.baseUrl;
- const webdavClient = new WebDAV();
- webdavClient.defaults.baseURL = config.keepWebServiceUrl;
+ const webdavClient = new WebDAV({
+ baseURL: config.keepWebServiceUrl
+ });
const apiClientAuthorizationService = new ApiClientAuthorizationService(apiClient, actions);
const authorizedKeysService = new AuthorizedKeysService(apiClient, actions);
//
// SPDX-License-Identifier: AGPL-3.0
-import { DataExplorerMiddlewareService, dataExplorerToListParams, getDataExplorerColumnFilters } from "store/data-explorer/data-explorer-middleware-service";
+import { DataExplorerMiddlewareService, dataExplorerToListParams, getDataExplorerColumnFilters, getOrder } from "store/data-explorer/data-explorer-middleware-service";
import { RootState } from "../store";
import { ServiceRepository } from "services/services";
import { FilterBuilder, joinFilters } from "services/api/filter-builder";
import { resourcesActions } from "store/resources/resources-actions";
import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
import { progressIndicatorActions } from 'store/progress-indicator/progress-indicator-actions';
-import { getDataExplorer, DataExplorer, getSortColumn } from "store/data-explorer/data-explorer-reducer";
+import { getDataExplorer, DataExplorer } from "store/data-explorer/data-explorer-reducer";
import { loadMissingProcessesInformation } from "store/project-panel/project-panel-middleware-service";
import { DataColumns } from "components/data-table/data-table";
import {
serializeOnlyProcessTypeFilters
} from "../resource-type-filters/resource-type-filters";
import { AllProcessesPanelColumnNames } from "views/all-processes-panel/all-processes-panel";
-import { OrderBuilder, OrderDirection } from "services/api/order-builder";
-import { ProcessResource } from "models/process";
-import { SortDirection } from "components/data-table/data-column";
-import { containerRequestFieldsNoMounts } from "models/container-request";
+import { containerRequestFieldsNoMounts, ContainerRequestResource } from "models/container-request";
export class AllProcessesPanelMiddlewareService extends DataExplorerMiddlewareService {
constructor(private services: ServiceRepository, id: string) {
const getParams = ( dataExplorer: DataExplorer ) => ({
...dataExplorerToListParams(dataExplorer),
- order: getOrder(dataExplorer),
+ order: getOrder<ContainerRequestResource>(dataExplorer),
filters: getFilters(dataExplorer)
});
const getFilters = ( dataExplorer: DataExplorer ) => {
- const columns = dataExplorer.columns as DataColumns<string>;
+ const columns = dataExplorer.columns as DataColumns<string, ContainerRequestResource>;
const statusColumnFilters = getDataExplorerColumnFilters(columns, 'Status');
const activeStatusFilter = Object.keys(statusColumnFilters).find(
filterName => statusColumnFilters[filterName].selected
);
};
-const getOrder = (dataExplorer: DataExplorer) => {
- const sortColumn = getSortColumn(dataExplorer);
- const order = new OrderBuilder<ProcessResource>();
- if (sortColumn) {
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC
- ? OrderDirection.ASC
- : OrderDirection.DESC;
-
- const columnName = sortColumn && sortColumn.name === AllProcessesPanelColumnNames.NAME ? "name" : "createdAt";
- return order
- .addOrder(sortDirection, columnName)
- .getOrder();
- } else {
- return order.getOrder();
- }
-};
-
const allProcessesPanelDataExplorerIsNotSet = () =>
snackbarActions.OPEN_SNACKBAR({
message: 'All Processes panel is not ready.',
import { ServiceRepository } from 'services/services';
import { MiddlewareAPI, Dispatch } from 'redux';
-import { DataExplorerMiddlewareService, dataExplorerToListParams, listResultsToDataExplorerItemsMeta } from 'store/data-explorer/data-explorer-middleware-service';
+import { DataExplorerMiddlewareService, dataExplorerToListParams, getOrder, listResultsToDataExplorerItemsMeta } from 'store/data-explorer/data-explorer-middleware-service';
import { RootState } from 'store/store';
import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
import { DataExplorer, getDataExplorer } from 'store/data-explorer/data-explorer-reducer';
import { updateResources } from 'store/resources/resources-actions';
-import { getSortColumn } from "store/data-explorer/data-explorer-reducer";
import { apiClientAuthorizationsActions } from 'store/api-client-authorizations/api-client-authorizations-actions';
-import { OrderDirection, OrderBuilder } from 'services/api/order-builder';
import { ListResults } from 'services/common-service/common-service';
import { ApiClientAuthorization } from 'models/api-client-authorization';
-import { ApiClientAuthorizationPanelColumnNames } from 'views/api-client-authorization-panel/api-client-authorization-panel-root';
-import { SortDirection } from 'components/data-table/data-column';
export class ApiClientAuthorizationMiddlewareService extends DataExplorerMiddlewareService {
constructor(private services: ServiceRepository, id: string) {
export const getParams = (dataExplorer: DataExplorer) => ({
...dataExplorerToListParams(dataExplorer),
- order: getOrder(dataExplorer)
+ order: getOrder<ApiClientAuthorization>(dataExplorer)
});
-const getOrder = (dataExplorer: DataExplorer) => {
- const sortColumn = getSortColumn(dataExplorer);
- const order = new OrderBuilder<ApiClientAuthorization>();
- if (sortColumn) {
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC
- ? OrderDirection.ASC
- : OrderDirection.DESC;
-
- const columnName = sortColumn && sortColumn.name === ApiClientAuthorizationPanelColumnNames.UUID ? "uuid" : "updatedAt";
- return order
- .addOrder(sortDirection, columnName)
- .getOrder();
- } else {
- return order.getOrder();
- }
-};
-
export const setItems = (listResults: ListResults<ApiClientAuthorization>) =>
apiClientAuthorizationsActions.SET_ITEMS({
...listResultsToDataExplorerItemsMeta(listResults),
export const FILE_REMOVE_DIALOG = 'fileRemoveDialog';
-export const openFileRemoveDialog = (filePath: string) =>
+export const openFileRemoveDialog = (fileUuid: string) =>
(dispatch: Dispatch, getState: () => RootState) => {
- const file = getNodeValue(filePath)(getState().collectionPanelFiles);
+ const file = getNodeValue(fileUuid)(getState().collectionPanelFiles);
if (file) {
+ const filePath = getFileFullPath(file);
const isDirectory = file.type === CollectionFileType.DIRECTORY;
const title = isDirectory
? 'Removing directory'
dispatch(startSubmit(RENAME_FILE_DIALOG));
const oldPath = getFileFullPath(file);
const newPath = newFullPath;
- services.collectionService.moveFile(currentCollection.uuid, oldPath, newPath).then(() => {
+ services.collectionService.renameFile(currentCollection.uuid, currentCollection.portableDataHash, oldPath, newPath).then(() => {
dispatch(dialogActions.CLOSE_DIALOG({ id: RENAME_FILE_DIALOG }));
dispatch(snackbarActions.OPEN_SNACKBAR({ message: 'File name changed.', hideDuration: 2000 }));
}).catch(e => {
import { ServiceRepository } from 'services/services';
import { MiddlewareAPI, Dispatch } from 'redux';
-import { DataExplorerMiddlewareService } from 'store/data-explorer/data-explorer-middleware-service';
+import { DataExplorerMiddlewareService, getOrder } from 'store/data-explorer/data-explorer-middleware-service';
import { RootState } from 'store/store';
import { getUserUuid } from "common/getuser";
import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
import { getDataExplorer } from 'store/data-explorer/data-explorer-reducer';
import { resourcesActions } from 'store/resources/resources-actions';
import { FilterBuilder } from 'services/api/filter-builder';
-import { SortDirection } from 'components/data-table/data-column';
-import { OrderDirection, OrderBuilder } from 'services/api/order-builder';
-import { getSortColumn } from "store/data-explorer/data-explorer-reducer";
-import { FavoritePanelColumnNames } from 'views/favorite-panel/favorite-panel';
-import { GroupContentsResource, GroupContentsResourcePrefix } from 'services/groups-service/groups-service';
import { progressIndicatorActions } from 'store/progress-indicator/progress-indicator-actions';
import { collectionsContentAddressActions } from './collections-content-address-panel-actions';
import { navigateTo } from 'store/navigation/navigation-action';
import { ResourceKind, extractUuidKind } from 'models/resource';
import { ownerNameActions } from 'store/owner-name/owner-name-actions';
import { getUserDisplayName } from 'models/user';
+import { CollectionResource } from 'models/collection';
export class CollectionsWithSameContentAddressMiddlewareService extends DataExplorerMiddlewareService {
constructor(private services: ServiceRepository, id: string) {
if (!dataExplorer) {
api.dispatch(collectionPanelDataExplorerIsNotSet());
} else {
- const sortColumn = getSortColumn(dataExplorer);
-
- const contentOrder = new OrderBuilder<GroupContentsResource>();
-
- if (sortColumn && sortColumn.name === FavoritePanelColumnNames.NAME) {
- const direction = sortColumn.sortDirection === SortDirection.ASC
- ? OrderDirection.ASC
- : OrderDirection.DESC;
-
- contentOrder
- .addOrder(direction, "name", GroupContentsResourcePrefix.COLLECTION);
- }
try {
api.dispatch(progressIndicatorActions.START_WORKING(this.getId()));
const userUuid = getUserUuid(api.getState());
.addEqual('portable_data_hash', contentAddress)
.addILike("name", dataExplorer.searchValue)
.getFilters(),
- includeOldVersions: true
+ includeOldVersions: true,
+ order: getOrder<CollectionResource>(dataExplorer)
});
const userUuids = response.items.map(it => {
if (extractUuidKind(it.ownerUuid) === ResourceKind.USER) {
REQUEST_ITEMS: ofType<{ id: string, criteriaChanged?: boolean }>(),
REQUEST_STATE: ofType<{ id: string, criteriaChanged?: boolean }>(),
SET_FETCH_MODE: ofType<({ id: string, fetchMode: DataTableFetchMode })>(),
- SET_COLUMNS: ofType<{ id: string, columns: DataColumns<any> }>(),
+ SET_COLUMNS: ofType<{ id: string, columns: DataColumns<any, any> }>(),
SET_FILTERS: ofType<{ id: string, columnName: string, filters: DataTableFilters }>(),
SET_ITEMS: ofType<{ id: string, items: any[], page: number, rowsPerPage: number, itemsAvailable: number }>(),
APPEND_ITEMS: ofType<{ id: string, items: any[], page: number, rowsPerPage: number, itemsAvailable: number }>(),
dataExplorerActions.REQUEST_ITEMS({ id, criteriaChanged }),
SET_FETCH_MODE: (payload: { fetchMode: DataTableFetchMode }) =>
dataExplorerActions.SET_FETCH_MODE({ ...payload, id }),
- SET_COLUMNS: (payload: { columns: DataColumns<any> }) =>
+ SET_COLUMNS: (payload: { columns: DataColumns<any, any> }) =>
dataExplorerActions.SET_COLUMNS({ ...payload, id }),
SET_FILTERS: (payload: { columnName: string, filters: DataTableFilters }) =>
dataExplorerActions.SET_FILTERS({ ...payload, id }),
import { Dispatch, MiddlewareAPI } from 'redux';
import { RootState } from '../store';
import { DataColumns } from 'components/data-table/data-table';
-import { DataExplorer } from './data-explorer-reducer';
+import { DataExplorer, getSortColumn } from './data-explorer-reducer';
import { ListResults } from 'services/common-service/common-service';
import { createTree } from 'models/tree';
import { DataTableFilters } from 'components/data-table-filters/data-table-filters-tree';
+import { OrderBuilder, OrderDirection } from 'services/api/order-builder';
+import { SortDirection } from 'components/data-table/data-column';
+import { Resource } from 'models/resource';
export abstract class DataExplorerMiddlewareService {
protected readonly id: string;
}
public getColumnFilters<T>(
- columns: DataColumns<T>,
+ columns: DataColumns<T, any>,
columnName: string
): DataTableFilters {
return getDataExplorerColumnFilters(columns, columnName);
}
export const getDataExplorerColumnFilters = <T>(
- columns: DataColumns<T>,
+ columns: DataColumns<T, any>,
columnName: string
): DataTableFilters => {
const column = columns.find((c) => c.name === columnName);
offset: dataExplorer.page * dataExplorer.rowsPerPage,
});
+export const getOrder = <T extends Resource = Resource>(dataExplorer: DataExplorer) => {
+ const sortColumn = getSortColumn<T>(dataExplorer);
+ const order = new OrderBuilder<T>();
+ if (sortColumn && sortColumn.sort) {
+ const sortDirection = sortColumn.sort.direction === SortDirection.ASC
+ ? OrderDirection.ASC
+ : OrderDirection.DESC;
+
+ return order
+ .addOrder(sortDirection, sortColumn.sort.field)
+ .getOrder();
+ } else {
+ return order.getOrder();
+ }
+};
+
export const listResultsToDataExplorerItemsMeta = <R>({
itemsAvailable,
offset,
class ServiceMock extends DataExplorerMiddlewareService {
constructor(private config: {
id: string,
- columns: DataColumns<any>,
+ columns: DataColumns<any, any>,
requestItems: (api: MiddlewareAPI) => Promise<void>
}) {
super(config.id);
describe('data-explorer-reducer', () => {
it('should set columns', () => {
- const columns: DataColumns<any> = [{
+ const columns: DataColumns<any, any> = [{
name: "Column 1",
filters: [],
render: jest.fn(),
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE
+ sort: {direction: SortDirection.NONE, field: "name"}
}];
const state = dataExplorerReducer(undefined,
dataExplorerActions.SET_COLUMNS({ id: "Data explorer", columns }));
});
it('should toggle sorting', () => {
- const columns: DataColumns<any> = [{
+ const columns: DataColumns<any, any> = [{
name: "Column 1",
filters: [],
render: jest.fn(),
selected: true,
- sortDirection: SortDirection.ASC,
+ sort: {direction: SortDirection.ASC, field: "name"},
configurable: true
}, {
name: "Column 2",
render: jest.fn(),
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "name"},
}];
const state = dataExplorerReducer({ "Data explorer": { ...initialDataExplorer, columns } },
dataExplorerActions.TOGGLE_SORT({ id: "Data explorer", columnName: "Column 2" }));
- expect(state["Data explorer"].columns[0].sortDirection).toEqual("none");
- expect(state["Data explorer"].columns[1].sortDirection).toEqual("asc");
+ expect(state["Data explorer"].columns[0].sort.direction).toEqual("none");
+ expect(state["Data explorer"].columns[1].sort.direction).toEqual("asc");
});
it('should set filters', () => {
- const columns: DataColumns<any> = [{
+ const columns: DataColumns<any, any> = [{
name: "Column 1",
filters: [],
render: jest.fn(),
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE
+ sort: {direction: SortDirection.NONE, field: "name"}
}];
const filters: DataTableFilterItem[] = [{
export interface DataExplorer {
fetchMode: DataTableFetchMode;
- columns: DataColumns<any>;
+ columns: DataColumns<any, any>;
items: any[];
itemsAvailable: number;
page: number;
return returnValue;
};
-export const getSortColumn = (dataExplorer: DataExplorer) =>
+export const getSortColumn = <R>(dataExplorer: DataExplorer): DataColumn<any, R> | undefined =>
dataExplorer.columns.find(
- (c: any) => !!c.sortDirection && c.sortDirection !== SortDirection.NONE
+ (c: DataColumn<any, R>) => !!c.sort && c.sort.direction !== SortDirection.NONE
);
const update = (
) => ({ ...state, [id]: updateFn(getDataExplorer(state, id)) });
const canUpdateColumns = (
- prevColumns: DataColumns<any>,
- nextColumns: DataColumns<any>
+ prevColumns: DataColumns<any, any>,
+ nextColumns: DataColumns<any, any>
) => {
if (prevColumns.length !== nextColumns.length) {
return true;
};
const setColumns =
- (columns: DataColumns<any>) => (dataExplorer: DataExplorer) => ({
+ (columns: DataColumns<any, any>) => (dataExplorer: DataExplorer) => ({
...dataExplorer,
columns: canUpdateColumns(dataExplorer.columns, columns)
? columns
});
const mapColumns =
- (mapFn: (column: DataColumn<any>) => DataColumn<any>) =>
+ (mapFn: (column: DataColumn<any, any>) => DataColumn<any, any>) =>
(dataExplorer: DataExplorer) => ({
...dataExplorer,
columns: dataExplorer.columns.map(mapFn),
});
-const toggleSort = (columnName: string) => (column: DataColumn<any>) =>
+const toggleSort = (columnName: string) => (column: DataColumn<any, any>) =>
column.name === columnName
? toggleSortDirection(column)
: resetSortDirection(column);
-const toggleColumn = (columnName: string) => (column: DataColumn<any>) =>
+const toggleColumn = (columnName: string) => (column: DataColumn<any, any>) =>
column.name === columnName
? { ...column, selected: !column.selected }
: column;
const setFilters =
(columnName: string, filters: DataTableFilters) =>
- (column: DataColumn<any>) =>
+ (column: DataColumn<any, any>) =>
column.name === columnName ? { ...column, filters } : column;
import { getUserUuid } from "common/getuser";
import { DataColumns } from "components/data-table/data-table";
import { ServiceRepository } from "services/services";
-import { SortDirection } from "components/data-table/data-column";
import { FilterBuilder } from "services/api/filter-builder";
import { updateFavorites } from "../favorites/favorites-actions";
import { favoritePanelActions } from "./favorite-panel-action";
import { Dispatch, MiddlewareAPI } from "redux";
-import { OrderBuilder, OrderDirection } from "services/api/order-builder";
-import { LinkResource } from "models/link";
-import { GroupContentsResource, GroupContentsResourcePrefix } from "services/groups-service/groups-service";
import { resourcesActions } from "store/resources/resources-actions";
import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
import { progressIndicatorActions } from 'store/progress-indicator/progress-indicator-actions';
import { getDataExplorer } from "store/data-explorer/data-explorer-reducer";
import { loadMissingProcessesInformation } from "store/project-panel/project-panel-middleware-service";
-import { getSortColumn } from "store/data-explorer/data-explorer-reducer";
import { getDataExplorerColumnFilters } from 'store/data-explorer/data-explorer-middleware-service';
import { serializeSimpleObjectTypeFilters } from '../resource-type-filters/resource-type-filters';
import { ResourceKind } from "models/resource";
import { LinkClass } from "models/link";
+import { GroupContentsResource } from "services/groups-service/groups-service";
export class FavoritePanelMiddlewareService extends DataExplorerMiddlewareService {
constructor(private services: ServiceRepository, id: string) {
if (!dataExplorer) {
api.dispatch(favoritesPanelDataExplorerIsNotSet());
} else {
- const columns = dataExplorer.columns as DataColumns<string>;
- const sortColumn = getSortColumn(dataExplorer);
+ const columns = dataExplorer.columns as DataColumns<string, GroupContentsResource>;
const typeFilters = serializeSimpleObjectTypeFilters(getDataExplorerColumnFilters(columns, FavoritePanelColumnNames.TYPE));
-
- const linkOrder = new OrderBuilder<LinkResource>();
- const contentOrder = new OrderBuilder<GroupContentsResource>();
-
- if (sortColumn && sortColumn.name === FavoritePanelColumnNames.NAME) {
- const direction = sortColumn.sortDirection === SortDirection.ASC
- ? OrderDirection.ASC
- : OrderDirection.DESC;
-
- linkOrder.addOrder(direction, "name");
- contentOrder
- .addOrder(direction, "name", GroupContentsResourcePrefix.COLLECTION)
- .addOrder(direction, "name", GroupContentsResourcePrefix.PROCESS)
- .addOrder(direction, "name", GroupContentsResourcePrefix.PROJECT);
- }
try {
api.dispatch(progressIndicatorActions.START_WORKING(this.getId()));
const responseLinks = await this.services.linkService.list({
import { OrderBuilder, OrderDirection } from 'services/api/order-builder';
import { GroupResource, GroupClass } from 'models/group';
import { SortDirection } from 'components/data-table/data-column';
-import { GroupsPanelColumnNames } from 'views/groups-panel/groups-panel';
import { progressIndicatorActions } from "store/progress-indicator/progress-indicator-actions";
export class GroupsPanelMiddlewareService extends DataExplorerMiddlewareService {
} else {
try {
api.dispatch(progressIndicatorActions.START_WORKING(this.getId()));
+ const sortColumn = getSortColumn<GroupResource>(dataExplorer);
const order = new OrderBuilder<GroupResource>();
- const sortColumn = getSortColumn(dataExplorer);
- if (sortColumn) {
+ if (sortColumn && sortColumn.sort) {
const direction =
- sortColumn.sortDirection === SortDirection.ASC && sortColumn.name === GroupsPanelColumnNames.GROUP
+ sortColumn.sort.direction === SortDirection.ASC
? OrderDirection.ASC
: OrderDirection.DESC;
- order.addOrder(direction, 'name');
+ order.addOrder(direction, sortColumn.sort.field);
}
const filters = new FilterBuilder()
.addEqual('group_class', GroupClass.ROLE)
import { ServiceRepository } from 'services/services';
import { MiddlewareAPI, Dispatch } from 'redux';
-import { DataExplorerMiddlewareService, dataExplorerToListParams, listResultsToDataExplorerItemsMeta } from 'store/data-explorer/data-explorer-middleware-service';
+import { DataExplorerMiddlewareService, dataExplorerToListParams, getOrder, listResultsToDataExplorerItemsMeta } from 'store/data-explorer/data-explorer-middleware-service';
import { RootState } from 'store/store';
import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
import { DataExplorer, getDataExplorer } from 'store/data-explorer/data-explorer-reducer';
import { updateResources } from 'store/resources/resources-actions';
-import { SortDirection } from 'components/data-table/data-column';
-import { OrderDirection, OrderBuilder } from 'services/api/order-builder';
import { ListResults } from 'services/common-service/common-service';
-import { getSortColumn } from "store/data-explorer/data-explorer-reducer";
import { LinkResource } from 'models/link';
import { linkPanelActions } from 'store/link-panel/link-panel-actions';
-import { LinkPanelColumnNames } from 'views/link-panel/link-panel-root';
export class LinkMiddlewareService extends DataExplorerMiddlewareService {
constructor(private services: ServiceRepository, id: string) {
export const getParams = (dataExplorer: DataExplorer) => ({
...dataExplorerToListParams(dataExplorer),
- order: getOrder(dataExplorer)
+ order: getOrder<LinkResource>(dataExplorer)
});
-const getOrder = (dataExplorer: DataExplorer) => {
- const sortColumn = getSortColumn(dataExplorer);
- const order = new OrderBuilder<LinkResource>();
- if (sortColumn) {
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC
- ? OrderDirection.ASC
- : OrderDirection.DESC;
-
- const columnName = sortColumn && sortColumn.name === LinkPanelColumnNames.NAME ? "name" : "modifiedAt";
- return order
- .addOrder(sortDirection, columnName)
- .getOrder();
- } else {
- return order.getOrder();
- }
-};
-
export const setItems = (listResults: ListResults<LinkResource>) =>
linkPanelActions.SET_ITEMS({
...listResultsToDataExplorerItemsMeta(listResults),
}
};
+export const isProcessRunnable = ({ containerRequest }: Process): boolean => (
+ containerRequest.state === ContainerRequestState.UNCOMMITTED
+);
+
+export const isProcessResumable = ({ containerRequest, container }: Process): boolean => (
+ containerRequest.state === ContainerRequestState.COMMITTED &&
+ containerRequest.priority === 0 &&
+ // Don't show run button when container is present & running or cancelled
+ !(container && (container.state === ContainerState.RUNNING ||
+ container.state === ContainerState.CANCELLED ||
+ container.state === ContainerState.COMPLETE))
+);
+
+export const isProcessCancelable = ({ containerRequest, container }: Process): boolean => (
+ containerRequest.priority !== null &&
+ containerRequest.priority > 0 &&
+ container !== undefined &&
+ (container.state === ContainerState.QUEUED ||
+ container.state === ContainerState.LOCKED ||
+ container.state === ContainerState.RUNNING)
+);
+
const isSubprocess = (containerUuid: string) => (resource: Resource) =>
resource.kind === ResourceKind.CONTAINER_REQUEST
&& (resource as ContainerRequestResource).requestingContainerUuid === containerUuid;
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
try {
const process = await services.containerRequestService.update(uuid, { priority: 0 });
+ dispatch<any>(updateResources([process]));
+ if (process.containerUuid) {
+ const container = await services.containerService.get(process.containerUuid, false);
+ dispatch<any>(updateResources([container]));
+ }
return process;
} catch (e) {
throw new Error('Could not cancel the process.');
}
};
+export const resumeOnHoldWorkflow = (uuid: string) =>
+ async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
+ try {
+ const process = await services.containerRequestService.update(uuid, { priority: 500 });
+ dispatch<any>(updateResources([process]));
+ if (process.containerUuid) {
+ const container = await services.containerService.get(process.containerUuid, false);
+ dispatch<any>(updateResources([container]));
+ }
+ return process;
+ } catch (e) {
+ throw new Error('Could not resume the process.');
+ }
+ };
+
export const startWorkflow = (uuid: string) =>
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
try {
});
export const getFilters = (dataExplorer: DataExplorer) => {
- const columns = dataExplorer.columns as DataColumns<string>;
+ const columns = dataExplorer.columns as DataColumns<string, ProjectResource>;
const typeFilters = serializeResourceTypeFilters(getDataExplorerColumnFilters(columns, ProjectPanelColumnNames.TYPE));
const statusColumnFilters = getDataExplorerColumnFilters(columns, 'Status');
const activeStatusFilter = Object.keys(statusColumnFilters).find(
);
};
-export const getOrder = (dataExplorer: DataExplorer) => {
- const sortColumn = getSortColumn(dataExplorer);
+const getOrder = (dataExplorer: DataExplorer) => {
+ const sortColumn = getSortColumn<ProjectResource>(dataExplorer);
const order = new OrderBuilder<ProjectResource>();
- if (sortColumn) {
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC
+ if (sortColumn && sortColumn.sort) {
+ const sortDirection = sortColumn.sort.direction === SortDirection.ASC
? OrderDirection.ASC
: OrderDirection.DESC;
- const columnName = sortColumn && sortColumn.name === ProjectPanelColumnNames.NAME ? "name" : "createdAt";
return order
- .addOrder(sortDirection, columnName, GroupContentsResourcePrefix.COLLECTION)
- .addOrder(sortDirection, columnName, GroupContentsResourcePrefix.PROCESS)
- .addOrder(sortDirection, columnName, GroupContentsResourcePrefix.PROJECT)
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.COLLECTION)
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.PROCESS)
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.PROJECT)
.getOrder();
} else {
return order.getOrder();
import { getDataExplorer } from 'store/data-explorer/data-explorer-reducer';
import { resourcesActions } from 'store/resources/resources-actions';
import { FilterBuilder } from 'services/api/filter-builder';
-import { SortDirection } from 'components/data-table/data-column';
-import { OrderDirection, OrderBuilder } from 'services/api/order-builder';
-import { getSortColumn } from "store/data-explorer/data-explorer-reducer";
import { FavoritePanelColumnNames } from 'views/favorite-panel/favorite-panel';
import { publicFavoritePanelActions } from 'store/public-favorites-panel/public-favorites-action';
import { DataColumns } from 'components/data-table/data-table';
import { serializeSimpleObjectTypeFilters } from '../resource-type-filters/resource-type-filters';
-import { LinkResource, LinkClass } from 'models/link';
-import { GroupContentsResource, GroupContentsResourcePrefix } from 'services/groups-service/groups-service';
+import { LinkClass } from 'models/link';
import { progressIndicatorActions } from 'store/progress-indicator/progress-indicator-actions';
import { updatePublicFavorites } from 'store/public-favorites/public-favorites-actions';
+import { GroupContentsResource } from 'services/groups-service/groups-service';
export class PublicFavoritesMiddlewareService extends DataExplorerMiddlewareService {
constructor(private services: ServiceRepository, id: string) {
if (!dataExplorer) {
api.dispatch(favoritesPanelDataExplorerIsNotSet());
} else {
- const columns = dataExplorer.columns as DataColumns<string>;
- const sortColumn = getSortColumn(dataExplorer);
+ const columns = dataExplorer.columns as DataColumns<string, GroupContentsResource>;
const typeFilters = serializeSimpleObjectTypeFilters(getDataExplorerColumnFilters(columns, FavoritePanelColumnNames.TYPE));
-
- const linkOrder = new OrderBuilder<LinkResource>();
- const contentOrder = new OrderBuilder<GroupContentsResource>();
-
- if (sortColumn && sortColumn.name === FavoritePanelColumnNames.NAME) {
- const direction = sortColumn.sortDirection === SortDirection.ASC
- ? OrderDirection.ASC
- : OrderDirection.DESC;
-
- linkOrder.addOrder(direction, "name");
- contentOrder
- .addOrder(direction, "name", GroupContentsResourcePrefix.COLLECTION)
- .addOrder(direction, "name", GroupContentsResourcePrefix.PROCESS)
- .addOrder(direction, "name", GroupContentsResourcePrefix.PROJECT);
- }
try {
api.dispatch(progressIndicatorActions.START_WORKING(this.getId()));
const uuidPrefix = api.getState().auth.config.uuidPrefix;
import { DataColumns } from 'components/data-table/data-table';
import { serializeResourceTypeFilters } from 'store//resource-type-filters/resource-type-filters';
import { ProjectPanelColumnNames } from 'views/project-panel/project-panel';
-import { Resource, ResourceKind } from 'models/resource';
+import { ResourceKind } from 'models/resource';
import { ContainerRequestResource } from 'models/container-request';
export class SearchResultsMiddlewareService extends DataExplorerMiddlewareService {
}
}
-const typeFilters = (columns: DataColumns<string>) => serializeResourceTypeFilters(getDataExplorerColumnFilters(columns, ProjectPanelColumnNames.TYPE));
+const typeFilters = (columns: DataColumns<string, GroupContentsResource>) => serializeResourceTypeFilters(getDataExplorerColumnFilters(columns, ProjectPanelColumnNames.TYPE));
export const getParams = (dataExplorer: DataExplorer, query: string, apiRevision: number) => ({
...dataExplorerToListParams(dataExplorer),
});
const getOrder = (dataExplorer: DataExplorer) => {
- const sortColumn = getSortColumn(dataExplorer);
+ const sortColumn = getSortColumn<GroupContentsResource>(dataExplorer);
const order = new OrderBuilder<GroupContentsResource>();
- if (sortColumn) {
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC
+ if (sortColumn && sortColumn.sort) {
+ const sortDirection = sortColumn.sort.direction === SortDirection.ASC
? OrderDirection.ASC
: OrderDirection.DESC;
return order
- .addOrder(sortDirection, sortColumn.name as keyof Resource, GroupContentsResourcePrefix.COLLECTION)
- .addOrder(sortDirection, sortColumn.name as keyof Resource, GroupContentsResourcePrefix.PROCESS)
- .addOrder(sortDirection, sortColumn.name as keyof Resource, GroupContentsResourcePrefix.PROJECT)
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.COLLECTION)
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.PROCESS)
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.PROJECT)
.getOrder();
} else {
return order.getOrder();
import { SortDirection } from 'components/data-table/data-column';
import { OrderBuilder, OrderDirection } from 'services/api/order-builder';
import { ProjectResource } from 'models/project';
-import { ProjectPanelColumnNames } from 'views/project-panel/project-panel';
import { getSortColumn } from "store/data-explorer/data-explorer-reducer";
import { updatePublicFavorites } from 'store/public-favorites/public-favorites-actions';
import { FilterBuilder } from 'services/api/filter-builder';
filters: getFilters(dataExplorer),
});
-export const getOrder = (dataExplorer: DataExplorer) => {
- const sortColumn = getSortColumn(dataExplorer);
+const getOrder = (dataExplorer: DataExplorer) => {
+ const sortColumn = getSortColumn<ProjectResource>(dataExplorer);
const order = new OrderBuilder<ProjectResource>();
- if (sortColumn) {
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC
+ if (sortColumn && sortColumn.sort) {
+ const sortDirection = sortColumn.sort.direction === SortDirection.ASC
? OrderDirection.ASC
: OrderDirection.DESC;
- const columnName = sortColumn && sortColumn.name === ProjectPanelColumnNames.NAME ? "name" : "createdAt";
- if (columnName === 'name') {
- return order
- .addOrder(sortDirection, columnName, GroupContentsResourcePrefix.COLLECTION)
- .addOrder(sortDirection, columnName, GroupContentsResourcePrefix.PROCESS)
- .addOrder(sortDirection, columnName, GroupContentsResourcePrefix.PROJECT)
- .getOrder();
- } else {
- return order
- .addOrder(sortDirection, columnName)
- .getOrder();
- }
+
+ return order
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.COLLECTION)
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.PROCESS)
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.PROJECT)
+ .getOrder();
} else {
return order.getOrder();
}
import { Config } from 'common/config';
import { pluginConfig } from 'plugins';
import { MiddlewareListReducer } from 'common/plugintypes';
+import { tooltipsMiddleware } from './tooltips/tooltips-middleware';
import { sidePanelReducer } from './side-panel/side-panel-reducer'
import { bannerReducer } from './banner/banner-reducer';
routerMiddleware(history),
thunkMiddleware.withExtraArgument(services),
authMiddleware(services),
+ tooltipsMiddleware(services),
projectPanelMiddleware,
favoritePanelMiddleware,
allProcessessPanelMiddleware,
import { ServiceRepository } from 'services/services';
import { MiddlewareAPI, Dispatch } from 'redux';
import {
- DataExplorerMiddlewareService, dataExplorerToListParams, listResultsToDataExplorerItemsMeta, getDataExplorerColumnFilters
+ DataExplorerMiddlewareService, dataExplorerToListParams, listResultsToDataExplorerItemsMeta, getDataExplorerColumnFilters, getOrder
} from 'store/data-explorer/data-explorer-middleware-service';
import { RootState } from 'store/store';
import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
import { DataExplorer, getDataExplorer } from 'store/data-explorer/data-explorer-reducer';
import { updateResources } from 'store/resources/resources-actions';
-import { SortDirection } from 'components/data-table/data-column';
-import { OrderDirection, OrderBuilder } from 'services/api/order-builder';
import { ListResults } from 'services/common-service/common-service';
-import { getSortColumn } from "store/data-explorer/data-explorer-reducer";
import { ProcessResource } from 'models/process';
-import { SubprocessPanelColumnNames } from 'views/subprocess-panel/subprocess-panel-root';
import { FilterBuilder, joinFilters } from 'services/api/filter-builder';
import { subprocessPanelActions } from './subprocess-panel-actions';
import { DataColumns } from 'components/data-table/data-table';
dataExplorer: DataExplorer,
parentContainerRequest: ContainerRequestResource) => ({
...dataExplorerToListParams(dataExplorer),
- order: getOrder(dataExplorer),
+ order: getOrder<ProcessResource>(dataExplorer),
filters: getFilters(dataExplorer, parentContainerRequest)
});
-const getOrder = (dataExplorer: DataExplorer) => {
- const sortColumn = getSortColumn(dataExplorer);
- const order = new OrderBuilder<ProcessResource>();
- if (sortColumn) {
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC
- ? OrderDirection.ASC
- : OrderDirection.DESC;
-
- const columnName = sortColumn && sortColumn.name === SubprocessPanelColumnNames.NAME ? "name" : "modifiedAt";
- return order
- .addOrder(sortDirection, columnName)
- .getOrder();
- } else {
- return order.getOrder();
- }
-};
-
export const getFilters = (
dataExplorer: DataExplorer,
parentContainerRequest: ContainerRequestResource) => {
- const columns = dataExplorer.columns as DataColumns<string>;
+ const columns = dataExplorer.columns as DataColumns<string, ProcessResource>;
const statusColumnFilters = getDataExplorerColumnFilters(columns, 'Status');
const activeStatusFilter = Object.keys(statusColumnFilters).find(
filterName => statusColumnFilters[filterName].selected
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { CollectionDirectory, CollectionFile } from "models/collection-file";
+import { Middleware, Store } from "redux";
+import { ServiceRepository } from "services/services";
+import { RootState } from "store/store";
+import tippy, { createSingleton } from 'tippy.js';
+import 'tippy.js/dist/tippy.css';
+
+let running = false;
+let tooltipsContents = null;
+let tooltipsFetchFailed = false;
+export const TOOLTIP_LOCAL_STORAGE_KEY = "TOOLTIP_LOCAL_STORAGE_KEY";
+
+const tippySingleton = createSingleton([], {delay: 10});
+
+export const tooltipsMiddleware = (services: ServiceRepository): Middleware => (store: Store) => next => action => {
+ const state: RootState = store.getState();
+
+ if (state && state.auth && state.auth.config && state.auth.config.clusterConfig && state.auth.config.clusterConfig.Workbench) {
+ const hideTooltip = localStorage.getItem(TOOLTIP_LOCAL_STORAGE_KEY);
+ const { BannerUUID: bannerUUID } = state.auth.config.clusterConfig.Workbench;
+
+ if (bannerUUID && !tooltipsContents && !hideTooltip && !tooltipsFetchFailed && !running) {
+ running = true;
+ fetchTooltips(services, bannerUUID);
+ } else if (tooltipsContents && !hideTooltip && !tooltipsFetchFailed) {
+ applyTooltips();
+ }
+ }
+
+ return next(action);
+};
+
+const fetchTooltips = (services, bannerUUID) => {
+ services.collectionService.files(bannerUUID)
+ .then(results => {
+ const tooltipsFile: CollectionDirectory | CollectionFile | undefined = results.find(({ name }) => name === 'tooltips.json');
+
+ if (tooltipsFile) {
+ running = true;
+ services.collectionService.getFileContents(tooltipsFile as CollectionFile)
+ .then(data => {
+ tooltipsContents = JSON.parse(data);
+ applyTooltips();
+ })
+ .catch(() => {})
+ .finally(() => {
+ running = false;
+ });
+ } else {
+ tooltipsFetchFailed = true;
+ }
+ })
+ .catch(() => {})
+ .finally(() => {
+ running = false;
+ });
+};
+
+const applyTooltips = () => {
+ const tippyInstances: any[] = Object.keys(tooltipsContents as any)
+ .map((key) => {
+ const content = (tooltipsContents as any)[key]
+ const element = document.querySelector(key);
+
+ if (element) {
+ const hasTippyAttatched = !!(element as any)._tippy;
+
+ if (!hasTippyAttatched && tooltipsContents) {
+ return tippy(element as any, { content });
+ }
+ }
+
+ return null;
+ })
+ .filter(data => !!data);
+
+ if (tippyInstances.length > 0) {
+ tippySingleton.setInstances(tippyInstances);
+ }
+};
\ No newline at end of file
import { trashPanelActions } from "./trash-panel-action";
import { Dispatch, MiddlewareAPI } from "redux";
import { OrderBuilder, OrderDirection } from "services/api/order-builder";
-import { GroupContentsResourcePrefix } from "services/groups-service/groups-service";
-import { ProjectResource } from "models/project";
+import { GroupContentsResource, GroupContentsResourcePrefix } from "services/groups-service/groups-service";
import { ProjectPanelColumnNames } from "views/project-panel/project-panel";
import { updateFavorites } from "store/favorites/favorites-actions";
import { updatePublicFavorites } from 'store/public-favorites/public-favorites-actions';
import { snackbarActions, SnackbarKind } from "store/snackbar/snackbar-actions";
import { updateResources } from "store/resources/resources-actions";
import { progressIndicatorActions } from "store/progress-indicator/progress-indicator-actions";
-import { getSortColumn } from "store/data-explorer/data-explorer-reducer";
+import { DataExplorer, getSortColumn } from "store/data-explorer/data-explorer-reducer";
import { serializeResourceTypeFilters } from 'store//resource-type-filters/resource-type-filters';
import { getDataExplorerColumnFilters } from 'store/data-explorer/data-explorer-middleware-service';
import { joinFilters } from 'services/api/filter-builder';
+import { CollectionResource } from "models/collection";
export class TrashPanelMiddlewareService extends DataExplorerMiddlewareService {
constructor(private services: ServiceRepository, id: string) {
async requestItems(api: MiddlewareAPI<Dispatch, RootState>) {
const dataExplorer = api.getState().dataExplorer[this.getId()];
- const columns = dataExplorer.columns as DataColumns<string>;
- const sortColumn = getSortColumn(dataExplorer);
+ const columns = dataExplorer.columns as DataColumns<string, CollectionResource>;
const typeFilters = serializeResourceTypeFilters(getDataExplorerColumnFilters(columns, ProjectPanelColumnNames.TYPE));
otherFilters,
);
- const order = new OrderBuilder<ProjectResource>();
-
- if (sortColumn) {
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC
- ? OrderDirection.ASC
- : OrderDirection.DESC;
-
- const columnName = sortColumn && sortColumn.name === ProjectPanelColumnNames.NAME ? "name" : "createdAt";
- order
- .addOrder(sortDirection, columnName, GroupContentsResourcePrefix.COLLECTION)
- .addOrder(sortDirection, columnName, GroupContentsResourcePrefix.PROJECT);
- }
-
const userUuid = getUserUuid(api.getState());
if (!userUuid) { return; }
try {
const listResults = await this.services.groupsService
.contents(userUuid, {
...dataExplorerToListParams(dataExplorer),
- order: order.getOrder(),
+ order: getOrder(dataExplorer),
filters,
recursive: true,
includeTrash: true
}
}
+const getOrder = (dataExplorer: DataExplorer) => {
+ const sortColumn = getSortColumn<GroupContentsResource>(dataExplorer);
+ const order = new OrderBuilder<GroupContentsResource>();
+ if (sortColumn && sortColumn.sort) {
+ const sortDirection = sortColumn.sort.direction === SortDirection.ASC
+ ? OrderDirection.ASC
+ : OrderDirection.DESC;
+
+ return order
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.COLLECTION)
+ .addOrder(sortDirection, sortColumn.sort.field, GroupContentsResourcePrefix.PROJECT)
+ .getOrder();
+ } else {
+ return order.getOrder();
+ }
+};
+
const couldNotFetchTrashContents = () =>
snackbarActions.OPEN_SNACKBAR({
message: 'Could not fetch trash contents.',
.getFilters()
});
-export const getOrder = (dataExplorer: DataExplorer) => {
- const sortColumn = getSortColumn(dataExplorer);
+const getOrder = (dataExplorer: DataExplorer) => {
+ const sortColumn = getSortColumn<UserResource>(dataExplorer);
const order = new OrderBuilder<UserResource>();
- if (sortColumn) {
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC
+ if (sortColumn && sortColumn.sort) {
+ const sortDirection = sortColumn.sort.direction === SortDirection.ASC
? OrderDirection.ASC
: OrderDirection.DESC;
- switch (sortColumn.name) {
- case UserPanelColumnNames.NAME:
- order.addOrder(sortDirection, "firstName")
- .addOrder(sortDirection, "lastName");
- break;
- case UserPanelColumnNames.UUID:
- order.addOrder(sortDirection, "uuid");
- break;
- case UserPanelColumnNames.EMAIL:
- order.addOrder(sortDirection, "email");
- break;
- case UserPanelColumnNames.USERNAME:
- order.addOrder(sortDirection, "username");
- break;
+
+ if (sortColumn.name === UserPanelColumnNames.NAME) {
+ order.addOrder(sortDirection, "firstName")
+ .addOrder(sortDirection, "lastName");
+ } else {
+ order.addOrder(sortDirection, sortColumn.sort.field);
}
}
return order.getOrder();
import { ServiceRepository } from 'services/services';
import { MiddlewareAPI, Dispatch } from 'redux';
-import { DataExplorerMiddlewareService, dataExplorerToListParams, listResultsToDataExplorerItemsMeta } from 'store/data-explorer/data-explorer-middleware-service';
+import { DataExplorerMiddlewareService, dataExplorerToListParams, getOrder, listResultsToDataExplorerItemsMeta } from 'store/data-explorer/data-explorer-middleware-service';
import { RootState } from 'store/store';
import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
import { DataExplorer, getDataExplorer } from 'store/data-explorer/data-explorer-reducer';
import { updateResources } from 'store/resources/resources-actions';
import { FilterBuilder } from 'services/api/filter-builder';
-import { SortDirection } from 'components/data-table/data-column';
-import { WorkflowPanelColumnNames } from 'views/workflow-panel/workflow-panel-view';
-import { OrderDirection, OrderBuilder } from 'services/api/order-builder';
import { WorkflowResource } from 'models/workflow';
import { ListResults } from 'services/common-service/common-service';
import { workflowPanelActions } from 'store/workflow-panel/workflow-panel-actions';
-import { getSortColumn } from "store/data-explorer/data-explorer-reducer";
export class WorkflowMiddlewareService extends DataExplorerMiddlewareService {
constructor(private services: ServiceRepository, id: string) {
export const getParams = (dataExplorer: DataExplorer) => ({
...dataExplorerToListParams(dataExplorer),
- order: getOrder(dataExplorer),
+ order: getOrder<WorkflowResource>(dataExplorer),
filters: getFilters(dataExplorer)
});
return filters;
};
-export const getOrder = (dataExplorer: DataExplorer) => {
- const sortColumn = getSortColumn(dataExplorer);
- const order = new OrderBuilder<WorkflowResource>();
- if (sortColumn) {
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC
- ? OrderDirection.ASC
- : OrderDirection.DESC;
- const columnName = sortColumn && sortColumn.name === WorkflowPanelColumnNames.NAME ? "name" : "modifiedAt";
- return order
- .addOrder(sortDirection, columnName)
- .getOrder();
- } else {
- return order.getOrder();
- }
-};
-
export const setItems = (listResults: ListResults<WorkflowResource>) =>
workflowPanelActions.SET_ITEMS({
...listResultsToDataExplorerItemsMeta(listResults),
snackbarActions.OPEN_SNACKBAR({
message: 'Could not fetch workflows.',
kind: SnackbarKind.ERROR
- });
\ No newline at end of file
+ });
const mapDispatchToProps = () => {
return (dispatch: Dispatch, { id, onRowClick, onRowDoubleClick, onContextMenu }: Props) => ({
- onSetColumns: (columns: DataColumns<any>) => {
+ onSetColumns: (columns: DataColumns<any, any>) => {
dispatch(dataExplorerActions.SET_COLUMNS({ id, columns }));
},
dispatch(dataExplorerActions.SET_EXPLORER_SEARCH_VALUE({ id, searchValue }));
},
- onColumnToggle: (column: DataColumn<any>) => {
+ onColumnToggle: (column: DataColumn<any, any>) => {
dispatch(dataExplorerActions.TOGGLE_COLUMN({ id, columnName: column.name }));
},
- onSortToggle: (column: DataColumn<any>) => {
+ onSortToggle: (column: DataColumn<any, any>) => {
dispatch(dataExplorerActions.TOGGLE_SORT({ id, columnName: column.name }));
},
- onFiltersChange: (filters: DataTableFilters, column: DataColumn<any>) => {
+ onFiltersChange: (filters: DataTableFilters, column: DataColumn<any, any>) => {
dispatch(dataExplorerActions.SET_FILTERS({ id, columnName: column.name, filters }));
},
};
export const DataExplorer = connect(mapStateToProps, mapDispatchToProps)(DataExplorerComponent);
-
);
export const SearchBarProjectField = () =>
- <ProjectInput input={{
+ <ProjectInput required={false} input={{
id: "projectObject",
label: "Limit search to Project"
} as ProjectCommandInputParameter}
import bannerActions from "store/banner/banner-action";
import { BANNER_LOCAL_STORAGE_KEY } from "views-components/baner/banner";
import { RootState } from "store/store";
+import { TOOLTIP_LOCAL_STORAGE_KEY } from "store/tooltips/tooltips-middleware";
+import { useCallback } from "react";
const mapStateToProps = (state: RootState): NotificationsMenuProps => ({
isOpen: state.banner.isOpen,
export const NotificationsMenuComponent = (props: NotificationsMenuComponentProps) => {
const { isOpen, openBanner } = props;
- const result = localStorage.getItem(BANNER_LOCAL_STORAGE_KEY);
+ const bannerResult = localStorage.getItem(BANNER_LOCAL_STORAGE_KEY);
+ const tooltipResult = localStorage.getItem(TOOLTIP_LOCAL_STORAGE_KEY);
const menuItems: any[] = [];
- if (!isOpen && result) {
+ if (!isOpen && bannerResult) {
menuItems.push(<MenuItem><span onClick={openBanner}>Restore Banner</span></MenuItem>);
}
+ const toggleTooltips = useCallback(() => {
+ if (tooltipResult) {
+ localStorage.removeItem(TOOLTIP_LOCAL_STORAGE_KEY);
+ } else {
+ localStorage.setItem(TOOLTIP_LOCAL_STORAGE_KEY, 'true');
+ }
+ window.location.reload();
+ }, [tooltipResult]);
+
+ if (tooltipResult) {
+ menuItems.push(<MenuItem><span onClick={toggleTooltips}>Enable tooltips</span></MenuItem>);
+ } else {
+ menuItems.push(<MenuItem><span onClick={toggleTooltips}>Disable tooltips</span></MenuItem>);
+ }
+
if (menuItems.length === 0) {
menuItems.push(<MenuItem>You are up to date</MenuItem>);
}
id="account-menu"
title="Notifications">
{
- menuItems.map(item => item)
+ menuItems.map((item, i) => <div key={i}>{item}</div>)
}
</DropdownMenu>);
}
import { openProcessContextMenu } from 'store/context-menu/context-menu-actions';
import { loadDetailsPanel } from 'store/details-panel/details-panel-action';
import { navigateTo } from 'store/navigation/navigation-action';
-import { ContainerRequestState } from "models/container-request";
+import { ContainerRequestResource, ContainerRequestState } from "models/container-request";
import { RootState } from 'store/store';
import { createTree } from 'models/tree';
import { getInitialProcessStatusFilters, getInitialProcessTypeFilters } from 'store/resource-type-filters/resource-type-filters';
type: ResourceKind | ContainerRequestState;
}
-export const allProcessesPanelColumns: DataColumns<string> = [
+export const allProcessesPanelColumns: DataColumns<string, ContainerRequestResource> = [
{
name: AllProcessesPanelColumnNames.NAME,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "name"},
filters: createTree(),
render: uuid => <ResourceName uuid={uuid} />
},
name: AllProcessesPanelColumnNames.CREATED_AT,
selected: true,
configurable: true,
- sortDirection: SortDirection.DESC,
+ sort: {direction: SortDirection.DESC, field: "createdAt"},
filters: createTree(),
render: uuid => <ResourceCreatedAtDate uuid={uuid} />
},
CommonUuid, TokenApiClientId, TokenApiToken, TokenCreatedByIpAddress, TokenDefaultOwnerUuid, TokenExpiresAt,
TokenLastUsedAt, TokenLastUsedByIpAddress, TokenScopes, TokenUserId
} from 'views-components/data-explorer/renderers';
+import { ApiClientAuthorization } from 'models/api-client-authorization';
type CssRules = 'root';
USER_ID = 'User ID'
}
-export const apiClientAuthorizationPanelColumns: DataColumns<string> = [
+export const apiClientAuthorizationPanelColumns: DataColumns<string, ApiClientAuthorization> = [
{
name: ApiClientAuthorizationPanelColumnNames.UUID,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "uuid"},
filters: createTree(),
render: uuid => <CommonUuid uuid={uuid} />
},
LAST_MODIFIED = "Last modified"
}
-export const collectionContentAddressPanelColumns: DataColumns<string> = [
+export const collectionContentAddressPanelColumns: DataColumns<string, CollectionResource> = [
{
name: CollectionContentAddressPanelColumnNames.COLLECTION_WITH_THIS_ADDRESS,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "uuid"},
filters: createTree(),
render: uuid => <ResourceName uuid={uuid} />
},
name: CollectionContentAddressPanelColumnNames.LAST_MODIFIED,
selected: true,
configurable: true,
- sortDirection: SortDirection.DESC,
+ sort: {direction: SortDirection.DESC, field: "modifiedAt"},
filters: createTree(),
render: uuid => <ResourceLastModifiedDate uuid={uuid} />
}
import { DataColumns } from 'components/data-table/data-table';
import { RouteComponentProps } from 'react-router';
import { DataTableFilterItem } from 'components/data-table-filters/data-table-filters';
-import { SortDirection } from 'components/data-table/data-column';
import { ResourceKind } from 'models/resource';
import { ArvadosTheme } from 'common/custom-theme';
import { FAVORITE_PANEL_ID } from "store/favorite-panel/favorite-panel-action";
type: ResourceKind | ContainerRequestState;
}
-export const favoritePanelColumns: DataColumns<string> = [
+export const favoritePanelColumns: DataColumns<string, GroupContentsResource> = [
{
name: FavoritePanelColumnNames.NAME,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
filters: createTree(),
render: uuid => <ResourceName uuid={uuid} />
},
name: FavoritePanelColumnNames.LAST_MODIFIED,
selected: true,
configurable: true,
- sortDirection: SortDirection.DESC,
filters: createTree(),
render: uuid => <ResourceLastModifiedDate uuid={uuid} />
}
import { getUserUuid } from 'common/getuser';
import { GroupResource, isBuiltinGroup } from 'models/group';
import { ArvadosTheme } from 'common/custom-theme';
+import { PermissionResource } from 'models/permission';
type CssRules = "root" | "content";
const MEMBERS_DEFAULT_MESSAGE = 'Members list is empty.';
const PERMISSIONS_DEFAULT_MESSAGE = 'Permissions list is empty.';
-export const groupDetailsMembersPanelColumns: DataColumns<string> = [
+export const groupDetailsMembersPanelColumns: DataColumns<string, PermissionResource> = [
{
name: GroupDetailsPanelMembersColumnNames.FULL_NAME,
selected: true,
},
];
-export const groupDetailsPermissionsPanelColumns: DataColumns<string> = [
+export const groupDetailsPermissionsPanelColumns: DataColumns<string, PermissionResource> = [
{
name: GroupDetailsPanelPermissionsColumnNames.NAME,
selected: true,
MEMBERS = "Members",
}
-export const groupsPanelColumns: DataColumns<string> = [
+export const groupsPanelColumns: DataColumns<string, GroupResource> = [
{
name: GroupsPanelColumnNames.GROUP,
selected: true,
configurable: true,
- sortDirection: SortDirection.ASC,
+ sort: {direction: SortDirection.ASC, field: "name"},
filters: createTree(),
render: uuid => <ResourceName uuid={uuid} />
},
from 'views-components/data-explorer/renderers';
import { StyleRulesCallback, WithStyles, withStyles } from '@material-ui/core';
import { ArvadosTheme } from 'common/custom-theme';
+import { LinkResource } from 'models/link';
type CssRules = "root";
UUID = "UUID"
}
-export const linkPanelColumns: DataColumns<string> = [
+export const linkPanelColumns: DataColumns<string, LinkResource> = [
{
name: LinkPanelColumnNames.NAME,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "name"},
filters: createTree(),
render: uuid => <ResourceLinkName uuid={uuid} />
},
Button,
} from '@material-ui/core';
import { ArvadosTheme } from 'common/custom-theme';
-import { CloseIcon, MoreOptionsIcon, ProcessIcon, StartIcon } from 'components/icon/icon';
-import { Process } from 'store/processes/process';
+import { CloseIcon, MoreOptionsIcon, ProcessIcon, StartIcon, StopIcon } from 'components/icon/icon';
+import { Process, isProcessRunnable, isProcessResumable, isProcessCancelable } from 'store/processes/process';
import { MPVPanelProps } from 'components/multi-panel-view/multi-panel-view';
import { ProcessDetailsAttributes } from './process-details-attributes';
import { ProcessStatus } from 'views-components/data-explorer/renderers';
-import { ContainerState } from 'models/container';
-import { ContainerRequestState } from 'models/container-request';
+import classNames from 'classnames';
-type CssRules = 'card' | 'content' | 'title' | 'header' | 'cancelButton' | 'avatar' | 'iconHeader' | 'runButton';
+type CssRules = 'card' | 'content' | 'title' | 'header' | 'cancelButton' | 'avatar' | 'iconHeader' | 'actionButton';
const styles: StyleRulesCallback<CssRules> = (theme: ArvadosTheme) => ({
card: {
paddingTop: theme.spacing.unit * 0.5,
color: theme.customs.colors.green700,
},
+ actionButton: {
+ padding: "0px 5px 0 0",
+ marginRight: "5px",
+ fontSize: '0.78rem',
+ },
cancelButton: {
- paddingRight: theme.spacing.unit * 2,
- fontSize: '14px',
color: theme.customs.colors.red900,
- "&:hover": {
- cursor: 'pointer'
- }
- },
- runButton: {
- backgroundColor: theme.customs.colors.green700,
+ borderColor: theme.customs.colors.red900,
'&:hover': {
- backgroundColor: theme.customs.colors.green800,
+ borderColor: theme.customs.colors.red900,
+ },
+ '& svg': {
+ fontSize: '22px',
},
- padding: "0px 5px 0 0",
- marginRight: "5px",
},
});
process: Process;
cancelProcess: (uuid: string) => void;
startProcess: (uuid: string) => void;
+ resumeOnHoldWorkflow: (uuid: string) => void;
onContextMenu: (event: React.MouseEvent<HTMLElement>) => void;
}
type ProcessDetailsCardProps = ProcessDetailsCardDataProps & WithStyles<CssRules> & MPVPanelProps;
export const ProcessDetailsCard = withStyles(styles)(
- ({ cancelProcess, startProcess, onContextMenu, classes, process, doHidePanel, panelName }: ProcessDetailsCardProps) => {
+ ({ cancelProcess, startProcess, resumeOnHoldWorkflow, onContextMenu, classes, process, doHidePanel, panelName }: ProcessDetailsCardProps) => {
+ let runAction: ((uuid: string) => void) | undefined = undefined;
+ if (isProcessRunnable(process)) {
+ runAction = startProcess;
+ } else if (isProcessResumable(process)) {
+ runAction = resumeOnHoldWorkflow;
+ }
+
return <Card className={classes.card}>
<CardHeader
className={classes.header}
</Tooltip>}
action={
<div>
- {process.containerRequest.state === ContainerRequestState.UNCOMMITTED &&
+ {runAction !== undefined &&
<Button
+ data-cy="process-run-button"
variant="contained"
size="small"
color="primary"
- className={classes.runButton}
- onClick={() => startProcess(process.containerRequest.uuid)}>
+ className={classes.actionButton}
+ onClick={() => runAction && runAction(process.containerRequest.uuid)}>
<StartIcon />
- Run Process
+ Run
+ </Button>}
+ {isProcessCancelable(process) &&
+ <Button
+ data-cy="process-cancel-button"
+ variant="outlined"
+ size="small"
+ color="primary"
+ className={classNames(classes.actionButton, classes.cancelButton)}
+ onClick={() => cancelProcess(process.containerRequest.uuid)}>
+ <StopIcon />
+ Cancel
</Button>}
- {process.container && process.container.state === ContainerState.RUNNING &&
- <span className={classes.cancelButton} onClick={() => cancelProcess(process.containerRequest.uuid)}>Cancel</span>}
<ProcessStatus uuid={process.containerRequest.uuid} />
<Tooltip title="More options" disableFocusListener>
<IconButton
onToggle: (status: string) => void;
cancelProcess: (uuid: string) => void;
startProcess: (uuid: string) => void;
+ resumeOnHoldWorkflow: (uuid: string) => void;
onLogFilterChange: (filter: FilterOption) => void;
navigateToLog: (uuid: string) => void;
onCopyToClipboard: (uuid: string) => void;
onContextMenu={event => props.onContextMenu(event, process)}
cancelProcess={props.cancelProcess}
startProcess={props.startProcess}
+ resumeOnHoldWorkflow={props.resumeOnHoldWorkflow}
/>
</MPVPanelContent>
<MPVPanelContent forwardProps xs="auto" data-cy="process-cmd">
updateOutputParams,
loadNodeJson
} from 'store/process-panel/process-panel-actions';
-import { cancelRunningWorkflow, startWorkflow } from 'store/processes/processes-actions';
+import { cancelRunningWorkflow, resumeOnHoldWorkflow, startWorkflow } from 'store/processes/processes-actions';
import { navigateToLogCollection, setProcessLogsPanelFilter } from 'store/process-logs-panel/process-logs-panel-actions';
import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
},
cancelProcess: (uuid) => dispatch<any>(cancelRunningWorkflow(uuid)),
startProcess: (uuid) => dispatch<any>(startWorkflow(uuid)),
+ resumeOnHoldWorkflow: (uuid) => dispatch<any>(resumeOnHoldWorkflow(uuid)),
onLogFilterChange: (filter) => dispatch(setProcessLogsPanelFilter(filter.value)),
navigateToLog: (uuid) => dispatch<any>(navigateToLogCollection(uuid)),
loadInputs: (containerRequest) => dispatch<any>(loadInputs(containerRequest)),
import { GroupClass, GroupResource } from 'models/group';
import { CollectionResource } from 'models/collection';
import { resourceIsFrozen } from 'common/frozen-resources';
+import { ProjectResource } from 'models/project';
type CssRules = 'root' | "button";
type: ResourceKind | ContainerRequestState;
}
-export const projectPanelColumns: DataColumns<string> = [
+export const projectPanelColumns: DataColumns<string, ProjectResource> = [
{
name: ProjectPanelColumnNames.NAME,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "name"},
filters: createTree(),
render: uuid => <ResourceName uuid={uuid} />
},
name: ProjectPanelColumnNames.CREATED_AT,
selected: false,
configurable: true,
- sortDirection: SortDirection.DESC,
+ sort: {direction: SortDirection.NONE, field: "createdAt"},
filters: createTree(),
render: uuid => <ResourceCreatedAtDate uuid={uuid} />
},
name: ProjectPanelColumnNames.LAST_MODIFIED,
selected: true,
configurable: true,
- sortDirection: SortDirection.DESC,
+ sort: {direction: SortDirection.DESC, field: "modifiedAt"},
filters: createTree(),
render: uuid => <ResourceLastModifiedDate uuid={uuid} />
},
name: ProjectPanelColumnNames.TRASH_AT,
selected: false,
configurable: true,
- sortDirection: SortDirection.DESC,
+ sort: {direction: SortDirection.NONE, field: "trashAt"},
filters: createTree(),
render: uuid => <ResourceTrashDate uuid={uuid} />
},
name: ProjectPanelColumnNames.DELETE_AT,
selected: false,
configurable: true,
- sortDirection: SortDirection.DESC,
+ sort: {direction: SortDirection.NONE, field: "deleteAt"},
filters: createTree(),
render: uuid => <ResourceDeleteDate uuid={uuid} />
},
import { DataColumns } from 'components/data-table/data-table';
import { RouteComponentProps } from 'react-router';
import { DataTableFilterItem } from 'components/data-table-filters/data-table-filters';
-import { SortDirection } from 'components/data-table/data-column';
import { ResourceKind } from 'models/resource';
import { ArvadosTheme } from 'common/custom-theme';
import {
type: ResourceKind | ContainerRequestState;
}
-export const publicFavoritePanelColumns: DataColumns<string> = [
+export const publicFavoritePanelColumns: DataColumns<string, GroupContentsResource> = [
{
name: PublicFavoritePanelColumnNames.NAME,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
filters: createTree(),
render: uuid => <ResourceName uuid={uuid} />
},
name: PublicFavoritePanelColumnNames.LAST_MODIFIED,
selected: true,
configurable: true,
- sortDirection: SortDirection.DESC,
filters: createTree(),
render: uuid => <ResourceLastModifiedDate uuid={uuid} />
}
type GenericInputContainerProps = GenericInputProps & {
component: React.ComponentType<GenericInputProps>;
+ required?: boolean;
};
export const GenericInput = ({ component: Component, ...props }: GenericInputContainerProps) => {
return <FormGroup>
<FormLabel
focused={props.meta.active}
- required={isRequiredInput(props.commandInput)}
+ required={props.required !== undefined ? props.required : isRequiredInput(props.commandInput)}
error={props.meta.touched && !!props.meta.error}>
{getInputLabel(props.commandInput)}
</FormLabel>
}
</FormHelperText>
</FormGroup>;
-};
\ No newline at end of file
+};
const require: any = (value?: ProjectResource) => (value === undefined);
export interface ProjectInputProps {
+ required: boolean;
input: ProjectCommandInputParameter;
options?: { showOnlyOwned: boolean, showOnlyWritable: boolean };
}
type DialogContentCssRules = 'root' | 'pickerWrapper';
-export const ProjectInput = ({ input, options }: ProjectInputProps) =>
+export const ProjectInput = ({ required, input, options }: ProjectInputProps) =>
<Field
name={input.id}
commandInput={input}
component={ProjectInputComponent as any}
format={format}
- validate={require}
+ validate={required ? require : undefined}
{...{
- options
+ options,
+ required
}} />;
const format = (value?: ProjectResource) => value ? value.name : '';
export const ProjectInputComponent = connect(mapStateToProps)(
class ProjectInputComponent extends React.Component<GenericInputProps & DispatchProp & HasUserUuid & {
options?: { showOnlyOwned: boolean, showOnlyWritable: boolean };
+ required?: boolean;
}, ProjectInputComponentState> {
state: ProjectInputComponentState = {
open: false,
label="Optional description of this workflow run" />
</Grid>
<Grid item xs={12} md={6}>
- <ProjectInput input={{
+ <ProjectInput required input={{
id: "owner",
label: "Project where the workflow will run"
} as ProjectCommandInputParameter}
import { ArvadosTheme } from 'common/custom-theme';
import { getSearchSessions } from 'store/search-bar/search-bar-actions';
import { camelCase } from 'lodash';
+import { GroupContentsResource } from 'services/groups-service/groups-service';
export enum SearchResultsPanelColumnNames {
CLUSTER = "Cluster",
type: ResourceKind | ContainerRequestState;
}
-export const searchResultsPanelColumns: DataColumns<string> = [
+export const searchResultsPanelColumns: DataColumns<string, GroupContentsResource> = [
{
name: SearchResultsPanelColumnNames.CLUSTER,
selected: true,
name: SearchResultsPanelColumnNames.NAME,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "name"},
filters: createTree(),
render: (uuid: string) => <ResourceName uuid={uuid} />
},
name: SearchResultsPanelColumnNames.LAST_MODIFIED,
selected: true,
configurable: true,
- sortDirection: SortDirection.DESC,
+ sort: {direction: SortDirection.DESC, field: "modifiedAt"},
filters: createTree(),
render: uuid => <ResourceLastModifiedDate uuid={uuid} />
}
import { MPVPanelProps } from 'components/multi-panel-view/multi-panel-view';
import { StyleRulesCallback, Typography, WithStyles, withStyles } from '@material-ui/core';
import { ArvadosTheme } from 'common/custom-theme';
+import { ProcessResource } from 'models/process';
type CssRules = 'iconHeader' | 'cardHeader';
type: ResourceKind | ContainerRequestState;
}
-export const subprocessPanelColumns: DataColumns<string> = [
+export const subprocessPanelColumns: DataColumns<string, ProcessResource> = [
{
name: SubprocessPanelColumnNames.NAME,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "name"},
filters: createTree(),
render: uuid => <ResourceName uuid={uuid} />
},
name: SubprocessPanelColumnNames.CREATED_AT,
selected: true,
configurable: true,
- sortDirection: SortDirection.DESC,
+ sort: {direction: SortDirection.DESC, field: "createdAt"},
filters: createTree(),
render: uuid => <ResourceCreatedAtDate uuid={uuid} />
},
import {
getTrashPanelTypeFilters
} from 'store/resource-type-filters/resource-type-filters';
+import { CollectionResource } from 'models/collection';
type CssRules = "toolbar" | "button" | "root";
</Tooltip>
);
-export const trashPanelColumns: DataColumns<string> = [
+export const trashPanelColumns: DataColumns<string, CollectionResource> = [
{
name: TrashPanelColumnNames.NAME,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "name"},
filters: createTree(),
render: uuid => <ResourceName uuid={uuid} />
},
name: TrashPanelColumnNames.TYPE,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
filters: getTrashPanelTypeFilters(),
render: uuid => <ResourceType uuid={uuid} />,
},
name: TrashPanelColumnNames.FILE_SIZE,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "fileSizeTotal"},
filters: createTree(),
render: uuid => <ResourceFileSize uuid={uuid} />
},
name: TrashPanelColumnNames.TRASHED_DATE,
selected: true,
configurable: true,
- sortDirection: SortDirection.DESC,
+ sort: {direction: SortDirection.DESC, field: "trashAt"},
filters: createTree(),
render: uuid => <ResourceTrashDate uuid={uuid} />
},
name: TrashPanelColumnNames.TO_BE_DELETED,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "deleteAt"},
filters: createTree(),
render: uuid => <ResourceDeleteDate uuid={uuid} />
},
name: '',
selected: true,
configurable: false,
- sortDirection: SortDirection.NONE,
filters: createTree(),
render: uuid => <ResourceRestore uuid={uuid} />
}
USERNAME = "Username"
}
-export const userPanelColumns: DataColumns<string> = [
+export const userPanelColumns: DataColumns<string, UserResource> = [
{
name: UserPanelColumnNames.NAME,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "firstName"},
filters: createTree(),
render: uuid => <UserResourceFullName uuid={uuid} link={true} />
},
name: UserPanelColumnNames.UUID,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "uuid"},
filters: createTree(),
render: uuid => <ResourceUuid uuid={uuid} />
},
name: UserPanelColumnNames.EMAIL,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "email"},
filters: createTree(),
render: uuid => <ResourceEmail uuid={uuid} />
},
name: UserPanelColumnNames.USERNAME,
selected: true,
configurable: false,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "username"},
filters: createTree(),
render: uuid => <ResourceUsername uuid={uuid} />
}
import { getResource, ResourcesState } from 'store/resources/resources';
import { DefaultView } from 'components/default-view/default-view';
import { CopyToClipboardSnackbar } from 'components/copy-to-clipboard-snackbar/copy-to-clipboard-snackbar';
+import { PermissionResource } from 'models/permission';
type CssRules = 'root' | 'emptyRoot' | 'gridItem' | 'label' | 'readOnlyValue' | 'title' | 'description' | 'actions' | 'content' | 'copyIcon';
}
-export const userProfileGroupsColumns: DataColumns<string> = [
+export const userProfileGroupsColumns: DataColumns<string, PermissionResource> = [
{
name: UserProfileGroupsColumnNames.NAME,
selected: true,
// }
// };
-export const workflowPanelColumns: DataColumns<string> = [
+export const workflowPanelColumns: DataColumns<string, WorkflowResource> = [
{
name: WorkflowPanelColumnNames.NAME,
selected: true,
configurable: true,
- sortDirection: SortDirection.ASC,
+ sort: {direction: SortDirection.ASC, field: "name"},
filters: createTree(),
render: (uuid: string) => <ResourceWorkflowName uuid={uuid} />
},
name: WorkflowPanelColumnNames.LAST_MODIFIED,
selected: true,
configurable: true,
- sortDirection: SortDirection.NONE,
+ sort: {direction: SortDirection.NONE, field: "modifiedAt"},
filters: createTree(),
render: (uuid: string) => <ResourceLastModifiedDate uuid={uuid} />
},
ForwardSlashNameSubstitution: /
ManagedProperties:
original_owner_uuid: {Function: original_owner, Protected: true}
- WebDAVCache:
- TTL: 0s
Login:
TrustPrivateNetworks: true
PAM:
languageName: node
linkType: hard
+"@popperjs/core@npm:^2.9.0":
+ version: 2.11.6
+ resolution: "@popperjs/core@npm:2.11.6"
+ checksum: 47fb328cec1924559d759b48235c78574f2d71a8a6c4c03edb6de5d7074078371633b91e39bbf3f901b32aa8af9b9d8f82834856d2f5737a23475036b16817f0
+ languageName: node
+ linkType: hard
+
"@samverschueren/stream-to-observable@npm:^0.3.0":
version: 0.3.1
resolution: "@samverschueren/stream-to-observable@npm:0.3.1"
set-value: 2.0.1
shell-escape: ^0.2.0
sinon: 7.3
+ tippy.js: ^6.3.7
ts-mock-imports: 1.3.7
tslint: 5.20.0
tslint-etc: 1.6.0
languageName: node
linkType: hard
+"tippy.js@npm:^6.3.7":
+ version: 6.3.7
+ resolution: "tippy.js@npm:6.3.7"
+ dependencies:
+ "@popperjs/core": ^2.9.0
+ checksum: cac955318a65288e8d2dca05059878b003c6e66f92c94f7810f5bc5448eb6646abdf7dacc9bd00020e2611592598d0aae3a28ec9a45349a159603c3fdddce5fb
+ languageName: node
+ linkType: hard
+
"tmp@npm:^0.0.33":
version: 0.0.33
resolution: "tmp@npm:0.0.33"
projects / arvados-workbench2.git / commitdiff