Arvados-DCO-1.1-Signed-off-by: Daniel Kutyła <daniel.kutyla@contractors.roche.com>
});
});
});
+
+ describe('Frozen projects', () => {
+ beforeEach(() => {
+ cy.createGroup(activeUser.token, {
+ name: `Main project ${Math.floor(Math.random() * 999999)}`,
+ group_class: 'project',
+ }).as('mainProject');
+
+ cy.createGroup(adminUser.token, {
+ name: `Admin project ${Math.floor(Math.random() * 999999)}`,
+ group_class: 'project',
+ }).as('adminProject').then((mainProject) => {
+ cy.shareWith(adminUser.token, activeUser.user.uuid, mainProject.uuid, 'can_write');
+ });
+
+ cy.get('@mainProject').then((mainProject) => {
+ cy.createGroup(adminUser.token, {
+ name : `Sub project ${Math.floor(Math.random() * 999999)}`,
+ group_class: 'project',
+ owner_uuid: mainProject.uuid,
+ }).as('subProject');
+
+ cy.createCollection(adminUser.token, {
+ name: `Main collection ${Math.floor(Math.random() * 999999)}`,
+ owner_uuid: mainProject.uuid,
+ manifest_text: "./subdir 37b51d194a7513e45b56f6524f2d51f2+3 0:3:foo\n. 37b51d194a7513e45b56f6524f2d51f2+3 0:3:bar\n"
+ }).as('mainCollection');
+ });
+ });
+
+ it('should be able to froze own project', () => {
+ cy.getAll('@mainProject').then(([mainProject]) => {
+ cy.loginAs(activeUser);
+
+ cy.get('[data-cy=project-panel]').contains(mainProject.name).rightclick();
+
+ cy.get('[data-cy=context-menu]').contains('Freeze').click();
+
+ cy.get('[data-cy=project-panel]').contains(mainProject.name).rightclick();
+
+ cy.get('[data-cy=context-menu]').contains('Freeze').should('not.exist');
+ });
+ });
+
+ it('should not be able to modify items within the frozen project', () => {
+ cy.getAll('@mainProject', '@mainCollection').then(([mainProject, mainCollection]) => {
+ cy.loginAs(activeUser);
+
+ cy.get('[data-cy=project-panel]').contains(mainProject.name).rightclick();
+
+ cy.get('[data-cy=context-menu]').contains('Freeze').click();
+
+ cy.get('[data-cy=project-panel]').contains(mainProject.name).click();
+
+ cy.get('[data-cy=project-panel]').contains(mainCollection.name).rightclick();
+
+ cy.get('[data-cy=context-menu]').contains('Move to trash').should('not.exist');
+ });
+ });
+
+ it('should not be able to froze not owned project', () => {
+ cy.getAll('@adminProject').then(([adminProject]) => {
+ cy.loginAs(activeUser);
+
+ cy.get('[data-cy=side-panel-tree]').contains('Shared with me').click();
+
+ cy.get('main').contains(adminProject.name).rightclick();
+
+ cy.get('[data-cy=context-menu]').contains('Freeze').click();
+
+ cy.get('main').contains(adminProject.name).rightclick();
+
+ cy.get('[data-cy=context-menu]').contains('Freeze').should('exist');
+ });
+ });
+
+ it('should be able to unfroze project if user is an admin', () => {
+ cy.getAll('@adminProject').then(([adminProject]) => {
+ cy.loginAs(adminUser);
+
+ cy.get('main').contains(adminProject.name).rightclick();
+
+ cy.get('[data-cy=context-menu]').contains('Freeze').click();
+
+ cy.wait(1000);
+
+ cy.get('main').contains(adminProject.name).rightclick();
+
+ cy.get('[data-cy=context-menu]').contains('Unfreeze').click();
+
+ cy.get('main').contains(adminProject.name).rightclick();
+
+ cy.get('[data-cy=context-menu]').contains('Freeze').should('exist');
+ });
+ });
+ });
});
+
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { ProjectResource } from "models/project";
+import { getResource } from "store/resources/resources";
+
+export const resourceIsFrozen = (resource: any, resources): boolean => {
+ let isFrozen: boolean = !!resource.frozenByUuid;
+ let ownerUuid: string | undefined = resource?.ownerUuid;
+
+ while(!isFrozen && !!ownerUuid) {
+ const parentResource: ProjectResource | undefined = getResource<ProjectResource>(ownerUuid)(resources);
+ isFrozen = !!parentResource?.frozenByUuid;
+ ownerUuid = parentResource?.ownerUuid;
+ }
+
+ return isFrozen;
+}
\ No newline at end of file
import ChevronRightIcon from '@material-ui/icons/ChevronRight';
import { withStyles } from '@material-ui/core';
import { IllegalNamingWarning } from '../warning/warning';
-import { IconType } from 'components/icon/icon';
+import { IconType, LockIcon } from 'components/icon/icon';
import grey from '@material-ui/core/colors/grey';
export interface Breadcrumb {
label: string;
icon?: IconType;
+ isFrozen?: boolean;
}
type CssRules = "item" | "currentItem" | "label" | "icon";
onClick={() => onClick(item)}
onContextMenu={event => onContextMenu(event, item)}>
<Icon className={classes.icon} />
+ {
+ item.isFrozen ? <LockIcon className={classes.icon} /> : null
+ }
<Typography
noWrap
color="inherit"
import CheckCircleOutline from '@material-ui/icons/CheckCircleOutline';
import RemoveCircleOutline from '@material-ui/icons/RemoveCircleOutline';
import NotInterested from '@material-ui/icons/NotInterested';
+import Lock from '@material-ui/icons/Lock'
+import LockOpen from '@material-ui/icons/LockOpen'
// Import FontAwesome icons
import { library } from '@fortawesome/fontawesome-svg-core';
export const PaginationRightArrowIcon: IconType = (props) => <ChevronRight {...props} />;
export const ProcessIcon: IconType = (props) => <BubbleChart {...props} />;
export const ProjectIcon: IconType = (props) => <Folder {...props} />;
+export const LockIcon: IconType = (props) => <Lock {...props} />;
+export const UnlockIcon: IconType = (props) => <LockOpen {...props} />;
export const FilterGroupIcon: IconType = (props) => <Pageview {...props} />;
export const ProjectsIcon: IconType = (props) => <Inbox {...props} />;
export const ProvenanceGraphIcon: IconType = (props) => <DeviceHub {...props} />;
import servicesProvider from 'common/service-provider';
import { addMenuActionSet, ContextMenuKind } from 'views-components/context-menu/context-menu';
import { rootProjectActionSet } from "views-components/context-menu/action-sets/root-project-action-set";
-import { filterGroupActionSet, projectActionSet, readOnlyProjectActionSet } from "views-components/context-menu/action-sets/project-action-set";
+import { filterGroupActionSet, frozenActionSet, projectActionSet, readOnlyProjectActionSet } from "views-components/context-menu/action-sets/project-action-set";
import { resourceActionSet } from 'views-components/context-menu/action-sets/resource-action-set';
import { favoriteActionSet } from "views-components/context-menu/action-sets/favorite-action-set";
import { collectionFilesActionSet, readOnlyCollectionFilesActionSet } from 'views-components/context-menu/action-sets/collection-files-action-set';
addMenuActionSet(ContextMenuKind.COLLECTION_ADMIN, collectionAdminActionSet);
addMenuActionSet(ContextMenuKind.PROCESS_ADMIN, processResourceAdminActionSet);
addMenuActionSet(ContextMenuKind.PROJECT_ADMIN, projectAdminActionSet);
+addMenuActionSet(ContextMenuKind.FROZEN_PROJECT, [
+ [
+ ...frozenActionSet.reduce((prev, next) => prev.concat(next), []),
+ ...readOnlyProjectActionSet.reduce((prev, next) => prev.concat(next), []),
+ ]
+]);
addMenuActionSet(ContextMenuKind.FILTER_GROUP_ADMIN, filterGroupAdminActionSet);
addMenuActionSet(ContextMenuKind.PERMISSION_EDIT, permissionEditActionSet);
addMenuActionSet(ContextMenuKind.WORKFLOW, workflowActionSet);
import { GroupClass, GroupResource } from "./group";
export interface ProjectResource extends GroupResource {
+ frozenByUuid: null|string;
groupClass: GroupClass.PROJECT | GroupClass.FILTER | GroupClass.ROLE;
}
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { propertiesActions } from "store/properties/properties-actions";
+import { BREADCRUMBS } from "./breadcrumbs-actions";
+
+export const breadcrumbsMiddleware = store => next => action => {
+ propertiesActions.match(action, {
+ SET_PROPERTY: () => {
+
+ if (action.payload.key === BREADCRUMBS && Array.isArray(action.payload.value)) {
+ action.payload.value = action.payload
+ .value.map((value)=> ({ ...value, isFrozen: !!store.getState().resources[value.uuid]?.frozenByUuid }));
+ }
+
+ next(action);
+ },
+ default: () => next(action)
+ });
+};
import { GroupClass, GroupResource } from 'models/group';
import { GroupContentsResource } from 'services/groups-service/groups-service';
import { LinkResource } from 'models/link';
+import { resourceIsFrozen } from 'common/frozen-resources';
export const contextMenuActions = unionize({
OPEN_CONTEXT_MENU: ofType<{ position: ContextMenuPosition, resource: ContextMenuResource }>(),
isEditable?: boolean;
outputUuid?: string;
workflowUuid?: string;
+ isAdmin?: boolean;
+ isFrozen?: boolean;
storageClassesDesired?: string[];
properties?: { [key: string]: string | string[] };
};
const { isAdmin: isAdminUser, uuid: userUuid } = getState().auth.user!;
const kind = extractUuidKind(uuid);
const resource = getResourceWithEditableStatus<GroupResource & EditableResource>(uuid, userUuid)(getState().resources);
+ const isFrozen = resourceIsFrozen(resource, getState().resources);
+ const isEditable = (isAdminUser || (resource || {} as EditableResource).isEditable) && !readonly && !isFrozen;
- const isEditable = (isAdminUser || (resource || {} as EditableResource).isEditable) && !readonly;
switch (kind) {
case ResourceKind.PROJECT:
+ if (resource && !!(resource as any).frozenByUuid) {
+ return ContextMenuKind.FROZEN_PROJECT;
+ }
+
return (isAdminUser && !readonly)
? (resource && resource.groupClass !== GroupClass.FILTER)
? ContextMenuKind.PROJECT_ADMIN
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { Dispatch } from "redux";
+import { ServiceRepository } from "services/services";
+import { projectPanelActions } from "store/project-panel/project-panel-action";
+import { RootState } from "store/store";
+
+export const lockProject = (uuid: string) =>
+ async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
+ const userUUID = getState().auth.user!.uuid;
+
+ const updatedProject = await services.projectService.update(uuid, {
+ frozenByUuid: userUUID
+ });
+
+ dispatch(projectPanelActions.REQUEST_ITEMS());
+ return updatedProject;
+ };
+
+export const unlockProject = (uuid: string) =>
+ async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
+
+ const updatedProject = await services.projectService.update(uuid, {
+ frozenByUuid: null
+ });
+
+ dispatch(projectPanelActions.REQUEST_ITEMS());
+ return updatedProject;
+ };
\ No newline at end of file
import { Config } from 'common/config';
import { pluginConfig } from 'plugins';
import { MiddlewareListReducer } from 'common/plugintypes';
+import { breadcrumbsMiddleware } from './breadcrumbs/breadcrumbs-middleware';
declare global {
interface Window {
publicFavoritesMiddleware,
collectionsContentAddress,
subprocessMiddleware,
+ breadcrumbsMiddleware,
];
const reduceMiddlewaresFn: (a: Middleware[],
import { toggleDetailsPanel } from 'store/details-panel/details-panel-action';
import { copyToClipboardAction, openInNewTabAction } from "store/open-in-new-tab/open-in-new-tab.actions";
import { openWebDavS3InfoDialog } from "store/collections/collection-info-actions";
+import { ToggleLockAction } from "../actions/lock-action";
+import { lockProject, unlockProject } from "store/projects/project-lock-actions";
export const readOnlyProjectActionSet: ContextMenuActionSet = [[
{
]
];
+export const frozenActionSet: ContextMenuActionSet = [
+ [
+ {
+ component: ToggleLockAction,
+ name: 'ToggleLockAction',
+ execute: (dispatch, resource) => {
+ if (resource.isFrozen) {
+ dispatch<any>(unlockProject(resource.uuid));
+ } else {
+ dispatch<any>(lockProject(resource.uuid));
+ }
+
+ }
+ }
+ ]
+];
+
export const projectActionSet: ContextMenuActionSet = [
[
...filterGroupActionSet.reduce((prev, next) => prev.concat(next), []),
dispatch<any>(openProjectCreateDialog(resource.uuid));
}
},
+ ...frozenActionSet.reduce((prev, next) => prev.concat(next), []),
]
];
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import React from "react";
+import { ListItemIcon, ListItemText, ListItem } from "@material-ui/core";
+import { LockIcon, UnlockIcon } from "components/icon/icon";
+import { connect } from "react-redux";
+import { RootState } from "store/store";
+import { ProjectResource } from "models/project";
+import { withRouter, RouteComponentProps } from "react-router";
+
+const mapStateToProps = (state: RootState, props: { onClick: () => {} }) => ({
+ isAdmin: state.auth.user!.isAdmin,
+ isLocked: !!(state.resources[state.contextMenu.resource!.uuid] as ProjectResource).frozenByUuid,
+ onClick: props.onClick
+});
+
+export const ToggleLockAction = withRouter(connect(mapStateToProps)((props: { isLocked: boolean, isAdmin: boolean, onClick: () => void } & RouteComponentProps) =>
+ props.isLocked && !props.isAdmin ? null :
+ < ListItem
+ button
+ onClick={props.onClick} >
+ <ListItemIcon>
+ {props.isLocked
+ ? <UnlockIcon />
+ : <LockIcon />}
+ </ListItemIcon>
+ <ListItemText style={{ textDecoration: 'none' }}>
+ {props.isLocked
+ ? <>Unfreeze project</>
+ : <>Freeze project</>}
+ </ListItemText>
+ </ListItem >));
PROJECT = "Project",
FILTER_GROUP = "FilterGroup",
READONLY_PROJECT = 'ReadOnlyProject',
+ FROZEN_PROJECT = 'FrozenProject',
PROJECT_ADMIN = "ProjectAdmin",
FILTER_GROUP_ADMIN = "FilterGroupAdmin",
RESOURCE = "Resource",
import { FavoriteStar, PublicFavoriteStar } from '../favorite-star/favorite-star';
import { Resource, ResourceKind, TrashableResource } from 'models/resource';
import {
+ LockIcon,
ProjectIcon,
FilterGroupIcon,
CollectionIcon,
import { getUserUuid } from 'common/getuser';
import { VirtualMachinesResource } from 'models/virtual-machines';
import { CopyToClipboardSnackbar } from 'components/copy-to-clipboard-snackbar/copy-to-clipboard-snackbar';
+import { ProjectResource } from 'models/project';
const renderName = (dispatch: Dispatch, item: GroupContentsResource) => {
<Typography variant="caption">
<FavoriteStar resourceUuid={item.uuid} />
<PublicFavoriteStar resourceUuid={item.uuid} />
+ {
+ item.kind === ResourceKind.PROJECT && <FrozenProject item={item} />
+ }
</Typography>
</Grid>
</Grid>;
};
+const FrozenProject = (props: {item: ProjectResource}) => {
+ const [fullUsername, setFullusername] = React.useState<any>(null);
+ const getFullName = React.useCallback(() => {
+ if (props.item.frozenByUuid) {
+ setFullusername(<UserNameFromID uuid={props.item.frozenByUuid} />);
+ }
+ }, [props.item, setFullusername])
+
+ if (props.item.frozenByUuid) {
+
+ return <Tooltip onOpen={getFullName} enterDelay={500} title={<span>Project was frozen by {fullUsername}</span>}>
+ <LockIcon style={{ fontSize: "inherit" }}/>
+ </Tooltip>;
+ } else {
+ return null;
+ }
+}
+
export const ResourceName = connect(
(state: RootState, props: { uuid: string }) => {
const resource = getResource<GroupContentsResource>(props.uuid)(state.resources);
export const UserNameFromID =
compose(userFromID)(
- (props: { uuid: string, userFullname: string, dispatch: Dispatch }) => {
+ (props: { uuid: string, displayAsText?: string, userFullname: string, dispatch: Dispatch }) => {
const { uuid, userFullname, dispatch } = props;
if (userFullname === '') {
import { pluginConfig } from 'plugins';
import { ElementListReducer } from 'common/plugintypes';
import { Location } from 'history';
+import { ProjectResource } from 'models/project';
type CssRules = 'button' | 'menuItem' | 'icon';
if (currentItemId === currentUserUUID) {
enabled = true;
} else if (matchProjectRoute(location ? location.pathname : '')) {
- const currentProject = getResource<GroupResource>(currentItemId)(resources);
- if (currentProject &&
+ const currentProject = getResource<ProjectResource>(currentItemId)(resources);
+ if (currentProject && currentProject.writableBy &&
currentProject.writableBy.indexOf(currentUserUUID || '') >= 0 &&
+ !currentProject.frozenByUuid &&
!isProjectTrashed(currentProject, resources) &&
currentProject.groupClass !== GroupClass.FILTER) {
enabled = true;
import { GroupContentsResource } from 'services/groups-service/groups-service';
import { GroupClass, GroupResource } from 'models/group';
import { CollectionResource } from 'models/collection';
+import { resourceIsFrozen } from 'common/frozen-resources';
type CssRules = 'root' | "button";
}
handleContextMenu = (event: React.MouseEvent<HTMLElement>, resourceUuid: string) => {
- const { resources } = this.props;
+ const { resources, isAdmin } = this.props;
const resource = getResource<GroupContentsResource>(resourceUuid)(resources);
// When viewing the contents of a filter group, all contents should be treated as read only.
let readonly = false;
isTrashed: ('isTrashed' in resource) ? resource.isTrashed : false,
kind: resource.kind,
menuKind,
+ isAdmin,
+ isFrozen: resourceIsFrozen(resource, resources),
description: resource.description,
storageClassesDesired: (resource as CollectionResource).storageClassesDesired,
properties: ('properties' in resource) ? resource.properties : {},
projects / arvados-workbench2.git / commitdiff