import Person from '@material-ui/icons/Person';
import PersonAdd from '@material-ui/icons/PersonAdd';
import PlayArrow from '@material-ui/icons/PlayArrow';
+import Public from '@material-ui/icons/Public';
import RateReview from '@material-ui/icons/RateReview';
import RestoreFromTrash from '@material-ui/icons/History';
import Search from '@material-ui/icons/Search';
export const ProvenanceGraphIcon: IconType = (props) => <DeviceHub {...props} />;
export const RemoveIcon: IconType = (props) => <Delete {...props} />;
export const RemoveFavoriteIcon: IconType = (props) => <Star {...props} />;
+export const PublicFavoriteIcon: IconType = (props) => <Public {...props} />;
export const RenameIcon: IconType = (props) => <Edit {...props} />;
export const RestoreFromTrashIcon: IconType = (props) => <RestoreFromTrash {...props} />;
export const ReRunProcessIcon: IconType = (props) => <Cached {...props} />;
import { groupMemberActionSet } from '~/views-components/context-menu/action-sets/group-member-action-set';
import { linkActionSet } from '~/views-components/context-menu/action-sets/link-action-set';
import { loadFileViewersConfig } from '~/store/file-viewers/file-viewers-actions';
+import { collectionAdminActionSet } from '~/views-components/context-menu/action-sets/collection-admin-action-set';
+import { processResourceAdminActionSet } from '~/views-components/context-menu/action-sets/process-resource-admin-action-set';
+import { projectAdminActionSet } from '~/views-components/context-menu/action-sets/project-admin-action-set';
console.log(`Starting arvados [${getBuildInfo()}]`);
addMenuActionSet(ContextMenuKind.API_CLIENT_AUTHORIZATION, apiClientAuthorizationActionSet);
addMenuActionSet(ContextMenuKind.GROUPS, groupActionSet);
addMenuActionSet(ContextMenuKind.GROUP_MEMBER, groupMemberActionSet);
+addMenuActionSet(ContextMenuKind.COLLECTION_ADMIN, collectionAdminActionSet);
+addMenuActionSet(ContextMenuKind.PROCESS_ADMIN, processResourceAdminActionSet);
+addMenuActionSet(ContextMenuKind.PROJECT_ADMIN, projectAdminActionSet);
fetchConfig()
.then(({ config, apiHost }) => {
export enum TreePickerId {
PROJECTS = 'Projects',
SHARED_WITH_ME = 'Shared with me',
- FAVORITES = 'Favorites'
+ FAVORITES = 'Favorites',
+ PUBLIC_FAVORITES = 'Public Favorites'
}
export const createTree = <T>(): Tree<T> => ({});
const projectMatch = Routes.matchProjectRoute(pathname);
const collectionMatch = Routes.matchCollectionRoute(pathname);
const favoriteMatch = Routes.matchFavoritesRoute(pathname);
+ const publicFavoritesMatch = Routes.matchPublicFavorites(pathname);
const trashMatch = Routes.matchTrashRoute(pathname);
const processMatch = Routes.matchProcessRoute(pathname);
const processLogMatch = Routes.matchProcessLogRoute(pathname);
store.dispatch(WorkbenchActions.loadCollection(collectionMatch.params.id));
} else if (favoriteMatch) {
store.dispatch(WorkbenchActions.loadFavorites());
+ } else if (publicFavoritesMatch) {
+ store.dispatch(WorkbenchActions.loadPublicFavorites());
} else if (trashMatch) {
store.dispatch(WorkbenchActions.loadTrash());
} else if (processMatch) {
API_CLIENT_AUTHORIZATIONS: `/api_client_authorizations`,
GROUPS: '/groups',
GROUP_DETAILS: `/group/:id(${RESOURCE_UUID_PATTERN})`,
- LINKS: '/links'
+ LINKS: '/links',
+ PUBLIC_FAVORITES: '/public-favorites'
};
export const getResourceUrl = (uuid: string) => {
export const matchGroupDetailsRoute = (route: string) =>
matchPath<ResourceRouteParams>(route, { path: Routes.GROUP_DETAILS });
-
+
export const matchLinksRoute = (route: string) =>
matchPath(route, { path: Routes.LINKS });
+
+export const matchPublicFavorites = (route: string) =>
+ matchPath(route, { path: Routes.PUBLIC_FAVORITES });
import { SshKeyResource } from '~/models/ssh-key';
import { VirtualMachinesResource } from '~/models/virtual-machines';
import { KeepServiceResource } from '~/models/keep-services';
-import { ApiClientAuthorization } from '~/models/api-client-authorization';
import { ProcessResource } from '~/models/process';
export const contextMenuActions = unionize({
}
};
-export const resourceKindToContextMenuKind = (uuid: string) => {
+export const resourceKindToContextMenuKind = (uuid: string, isAdmin?: boolean) => {
const kind = extractUuidKind(uuid);
switch (kind) {
case ResourceKind.PROJECT:
- return ContextMenuKind.PROJECT;
+ return !isAdmin ? ContextMenuKind.PROJECT : ContextMenuKind.PROJECT_ADMIN;
case ResourceKind.COLLECTION:
- return ContextMenuKind.COLLECTION_RESOURCE;
+ return !isAdmin ? ContextMenuKind.COLLECTION_RESOURCE : ContextMenuKind.COLLECTION_ADMIN;
case ResourceKind.PROCESS:
- return ContextMenuKind.PROCESS_RESOURCE;
+ return !isAdmin ? ContextMenuKind.PROCESS_RESOURCE : ContextMenuKind.PROCESS_ADMIN;
case ResourceKind.USER:
return ContextMenuKind.ROOT_PROJECT;
case ResourceKind.LINK:
}
if (uuid === SidePanelTreeCategory.FAVORITES) {
dispatch<any>(navigateToFavorites);
+ } else if (uuid === SidePanelTreeCategory.PUBLIC_FAVORITES) {
+ dispatch(navigateToPublicFavorites);
} else if (uuid === SidePanelTreeCategory.SHARED_WITH_ME) {
dispatch(navigateToSharedWithMe);
} else if (uuid === SidePanelTreeCategory.WORKFLOWS) {
export const navigateToTrash = push(Routes.TRASH);
+export const navigateToPublicFavorites = push(Routes.PUBLIC_FAVORITES);
+
export const navigateToWorkflows = push(Routes.WORKFLOWS);
export const navigateToProject = compose(push, getProjectUrl);
import { resourcesDataActions } from "~/store/resources-data/resources-data-actions";
import { getSortColumn } from "~/store/data-explorer/data-explorer-reducer";
import { serializeResourceTypeFilters } from '~/store/resource-type-filters/resource-type-filters';
+import { updatePublicFavorites } from '~/store/public-favorites/public-favorites-actions';
export class ProjectPanelMiddlewareService extends DataExplorerMiddlewareService {
constructor(private services: ServiceRepository, id: string) {
api.dispatch(progressIndicatorActions.PERSIST_STOP_WORKING(this.getId()));
const resourceUuids = response.items.map(item => item.uuid);
api.dispatch<any>(updateFavorites(resourceUuids));
+ api.dispatch<any>(updatePublicFavorites(resourceUuids));
api.dispatch(updateResources(response.items));
api.dispatch<any>(updateResourceData(resourceUuids));
await api.dispatch<any>(loadMissingProcessesInformation(response.items));
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { bindDataExplorerActions } from "~/store/data-explorer/data-explorer-action";
+
+export const PUBLIC_FAVORITE_PANEL_ID = "publicFavoritePanel";
+export const publicFavoritePanelActions = bindDataExplorerActions(PUBLIC_FAVORITE_PANEL_ID);
+
+export const loadPublicFavoritePanel = () => publicFavoritePanelActions.REQUEST_ITEMS();
\ No newline at end of file
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { ServiceRepository } from '~/services/services';
+import { MiddlewareAPI, Dispatch } from 'redux';
+import { DataExplorerMiddlewareService, getDataExplorerColumnFilters } from '~/store/data-explorer/data-explorer-middleware-service';
+import { RootState } from '~/store/store';
+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 { 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 { progressIndicatorActions } from '~/store/progress-indicator/progress-indicator-actions';
+import { loadMissingProcessesInformation } from '~/store/project-panel/project-panel-middleware-service';
+import { updatePublicFavorites } from '~/store/public-favorites/public-favorites-actions';
+
+export class PublicFavoritesMiddlewareService extends DataExplorerMiddlewareService {
+ constructor(private services: ServiceRepository, id: string) {
+ super(id);
+ }
+
+ async requestItems(api: MiddlewareAPI<Dispatch, RootState>) {
+ const dataExplorer = getDataExplorer(api.getState().dataExplorer, this.getId());
+ if (!dataExplorer) {
+ api.dispatch(favoritesPanelDataExplorerIsNotSet());
+ } else {
+ const columns = dataExplorer.columns as DataColumns<string>;
+ const sortColumn = getSortColumn(dataExplorer);
+ 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().config.uuidPrefix;
+ const uuid = `${uuidPrefix}-j7d0g-fffffffffffffff`;
+ const response = await this.services.linkService.list({
+ limit: dataExplorer.rowsPerPage,
+ offset: dataExplorer.page * dataExplorer.rowsPerPage,
+ filters: new FilterBuilder()
+ .addEqual('linkClass', LinkClass.STAR)
+ .addILike("name", dataExplorer.searchValue)
+ .addEqual('ownerUuid', uuid)
+ .addIsA("headUuid", typeFilters)
+ .getFilters()
+ });
+ api.dispatch(progressIndicatorActions.PERSIST_STOP_WORKING(this.getId()));
+ api.dispatch(resourcesActions.SET_RESOURCES(response.items));
+ api.dispatch(publicFavoritePanelActions.SET_ITEMS({
+ items: response.items.map(resource => resource.uuid),
+ itemsAvailable: response.itemsAvailable,
+ page: Math.floor(response.offset / response.limit),
+ rowsPerPage: response.limit
+ }));
+ api.dispatch<any>(updatePublicFavorites(response.items.map(item => item.headUuid)));
+ } catch (e) {
+ api.dispatch(progressIndicatorActions.PERSIST_STOP_WORKING(this.getId()));
+ api.dispatch(publicFavoritePanelActions.SET_ITEMS({
+ items: [],
+ itemsAvailable: 0,
+ page: 0,
+ rowsPerPage: dataExplorer.rowsPerPage
+ }));
+ api.dispatch(couldNotFetchPublicFavorites());
+ }
+ }
+ }
+}
+
+const favoritesPanelDataExplorerIsNotSet = () =>
+ snackbarActions.OPEN_SNACKBAR({
+ message: 'Favorites panel is not ready.',
+ kind: SnackbarKind.ERROR
+ });
+
+const couldNotFetchPublicFavorites = () =>
+ snackbarActions.OPEN_SNACKBAR({
+ message: 'Could not fetch public favorites contents.',
+ kind: SnackbarKind.ERROR
+ });
\ No newline at end of file
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { unionize, ofType, UnionOf } from "~/common/unionize";
+import { Dispatch } from "redux";
+import { RootState } from "../store";
+import { checkPublicFavorite } from "./public-favorites-reducer";
+import { snackbarActions, SnackbarKind } from "~/store/snackbar/snackbar-actions";
+import { ServiceRepository } from "~/services/services";
+import { progressIndicatorActions } from "~/store/progress-indicator/progress-indicator-actions";
+import { getResource } from '~/store/resources/resources';
+import { LinkResource } from "~/models/link";
+
+export const publicFavoritesActions = unionize({
+ TOGGLE_PUBLIC_FAVORITE: ofType<{ resourceUuid: string }>(),
+ CHECK_PRESENCE_IN_PUBLIC_FAVORITES: ofType<string[]>(),
+ UPDATE_PUBLIC_FAVORITES: ofType<Record<string, boolean>>()
+});
+
+export type PublicFavoritesAction = UnionOf<typeof publicFavoritesActions>;
+
+export const togglePublicFavorite = (resource: { uuid: string; name: string }) =>
+ (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository): Promise<any> => {
+ dispatch(progressIndicatorActions.START_WORKING("togglePublicFavorite"));
+ const uuidPrefix = getState().config.uuidPrefix;
+ const uuid = `${uuidPrefix}-j7d0g-fffffffffffffff`;
+ dispatch(publicFavoritesActions.TOGGLE_PUBLIC_FAVORITE({ resourceUuid: resource.uuid }));
+ const isPublicFavorite = checkPublicFavorite(resource.uuid, getState().publicFavorites);
+ dispatch(snackbarActions.OPEN_SNACKBAR({
+ message: isPublicFavorite
+ ? "Removing from public favorites..."
+ : "Adding to public favorites...",
+ kind: SnackbarKind.INFO
+ }));
+
+ const promise: any = isPublicFavorite
+ ? services.favoriteService.delete({ userUuid: uuid, resourceUuid: resource.uuid })
+ : services.favoriteService.create({ userUuid: uuid, resource });
+
+ return promise
+ .then(() => {
+ dispatch(publicFavoritesActions.UPDATE_PUBLIC_FAVORITES({ [resource.uuid]: !isPublicFavorite }));
+ dispatch(snackbarActions.CLOSE_SNACKBAR());
+ dispatch(snackbarActions.OPEN_SNACKBAR({
+ message: isPublicFavorite
+ ? "Removed from public favorites"
+ : "Added to public favorites",
+ hideDuration: 2000,
+ kind: SnackbarKind.SUCCESS
+ }));
+ dispatch(progressIndicatorActions.STOP_WORKING("togglePublicFavorite"));
+ })
+ .catch((e: any) => {
+ dispatch(progressIndicatorActions.STOP_WORKING("togglePublicFavorite"));
+ throw e;
+ });
+ };
+
+export const updatePublicFavorites = (resourceUuids: string[]) =>
+ async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
+ const uuidPrefix = getState().config.uuidPrefix;
+ const uuid = `${uuidPrefix}-j7d0g-fffffffffffffff`;
+ dispatch(publicFavoritesActions.CHECK_PRESENCE_IN_PUBLIC_FAVORITES(resourceUuids));
+ services.favoriteService
+ .checkPresenceInFavorites(uuid, resourceUuids)
+ .then((results: any) => {
+ dispatch(publicFavoritesActions.UPDATE_PUBLIC_FAVORITES(results));
+ });
+ };
+
+export const getHeadUuid = (uuid: string) =>
+ (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
+ const resource = getResource<LinkResource>(uuid)(getState().resources);
+ return resource!.headUuid;
+ };
+
+export const getIsAdmin = () =>
+ (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
+ const resource = getState().auth.user!.isAdmin;
+ return resource;
+ };
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { PublicFavoritesAction, publicFavoritesActions } from "./public-favorites-actions";
+
+export type PublicFavoritesState = Record<string, boolean>;
+
+export const publicFavoritesReducer = (state: PublicFavoritesState = {}, action: PublicFavoritesAction) =>
+ publicFavoritesActions.match(action, {
+ UPDATE_PUBLIC_FAVORITES: publicFavorites => ({ ...state, ...publicFavorites }),
+ default: () => state
+ });
+
+export const checkPublicFavorite = (uuid: string, state: PublicFavoritesState) => state[uuid] === true;
\ No newline at end of file
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';
export class SharedWithMeMiddlewareService extends DataExplorerMiddlewareService {
constructor(private services: ServiceRepository, id: string) {
excludeHomeProject: true,
});
api.dispatch<any>(updateFavorites(response.items.map(item => item.uuid)));
+ api.dispatch<any>(updatePublicFavorites(response.items.map(item => item.uuid)));
api.dispatch(updateResources(response.items));
await api.dispatch<any>(loadMissingProcessesInformation(response.items));
api.dispatch(setItems(response));
export enum SidePanelTreeCategory {
PROJECTS = 'Projects',
SHARED_WITH_ME = 'Shared with me',
+ PUBLIC_FAVORITES = 'Public Favorites',
WORKFLOWS = 'Workflows',
FAVORITES = 'Favorites',
TRASH = 'Trash'
};
const SIDE_PANEL_CATEGORIES = [
+ SidePanelTreeCategory.PUBLIC_FAVORITES,
SidePanelTreeCategory.WORKFLOWS,
SidePanelTreeCategory.FAVORITES,
SidePanelTreeCategory.TRASH,
import { Dispatch } from 'redux';
import { isSidePanelTreeCategory, SidePanelTreeCategory } from '~/store/side-panel-tree/side-panel-tree-actions';
-import { navigateToFavorites, navigateTo, navigateToTrash, navigateToSharedWithMe, navigateToWorkflows } from '../navigation/navigation-action';
+import { navigateToFavorites, navigateTo, navigateToTrash, navigateToSharedWithMe, navigateToWorkflows, navigateToPublicFavorites } from '~/store/navigation/navigation-action';
import {snackbarActions, SnackbarKind} from '~/store/snackbar/snackbar-actions';
export const navigateFromSidePanel = (id: string) =>
switch (id) {
case SidePanelTreeCategory.FAVORITES:
return navigateToFavorites;
+ case SidePanelTreeCategory.PUBLIC_FAVORITES:
+ return navigateToPublicFavorites;
case SidePanelTreeCategory.TRASH:
return navigateToTrash;
case SidePanelTreeCategory.SHARED_WITH_ME:
import { ComputeNodeMiddlewareService } from '~/store/compute-nodes/compute-nodes-middleware-service';
import { API_CLIENT_AUTHORIZATION_PANEL_ID } from '~/store/api-client-authorizations/api-client-authorizations-actions';
import { ApiClientAuthorizationMiddlewareService } from '~/store/api-client-authorizations/api-client-authorizations-middleware-service';
+import { PublicFavoritesMiddlewareService } from '~/store/public-favorites-panel/public-favorites-middleware-service';
+import { PUBLIC_FAVORITE_PANEL_ID } from '~/store/public-favorites-panel/public-favorites-action';
+import { publicFavoritesReducer } from '~/store/public-favorites/public-favorites-reducer';
const composeEnhancers =
(process.env.NODE_ENV === 'development' &&
const apiClientAuthorizationMiddlewareService = dataExplorerMiddleware(
new ApiClientAuthorizationMiddlewareService(services, API_CLIENT_AUTHORIZATION_PANEL_ID)
);
+ const publicFavoritesMiddleware = dataExplorerMiddleware(
+ new PublicFavoritesMiddlewareService(services, PUBLIC_FAVORITE_PANEL_ID)
+ );
const middlewares: Middleware[] = [
routerMiddleware(history),
thunkMiddleware.withExtraArgument(services),
groupDetailsPanelMiddleware,
linkPanelMiddleware,
computeNodeMiddleware,
- apiClientAuthorizationMiddlewareService
+ apiClientAuthorizationMiddlewareService,
+ publicFavoritesMiddleware
];
const enhancer = composeEnhancers(applyMiddleware(...middlewares));
return createStore(rootReducer, enhancer);
detailsPanel: detailsPanelReducer,
dialog: dialogReducer,
favorites: favoritesReducer,
+ publicFavorites: publicFavoritesReducer,
form: formReducer,
processLogsPanel: processLogsPanelReducer,
properties: propertiesReducer,
import { ProjectResource } from "~/models/project";
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";
items
}));
api.dispatch<any>(updateFavorites(items));
+ api.dispatch<any>(updatePublicFavorites(items));
api.dispatch(updateResources(listResults.items));
} catch (e) {
api.dispatch(progressIndicatorActions.PERSIST_STOP_WORKING(this.getId()));
import { OrderBuilder } from '~/services/api/order-builder';
import { ProjectResource } from '~/models/project';
import { mapTree } from '../../models/tree';
+import { LinkResource, LinkClass } from "~/models/link";
export const treePickerActions = unionize({
LOAD_TREE_PICKER_NODE: ofType<{ id: string, pickerId: string }>(),
home: `${pickerId}_home`,
shared: `${pickerId}_shared`,
favorites: `${pickerId}_favorites`,
+ publicFavorites: `${pickerId}_publicFavorites`
});
export const getAllNodes = <Value>(pickerId: string, filter = (node: TreeNode<Value>) => true) => (state: TreePicker) =>
export const initProjectsTreePicker = (pickerId: string) =>
async (dispatch: Dispatch, _: () => RootState, services: ServiceRepository) => {
- const { home, shared, favorites } = getProjectsTreePickerIds(pickerId);
+ const { home, shared, favorites, publicFavorites } = getProjectsTreePickerIds(pickerId);
dispatch<any>(initUserProject(home));
dispatch<any>(initSharedProject(shared));
dispatch<any>(initFavoritesProject(favorites));
+ dispatch<any>(initPublicFavoritesProject(publicFavorites));
};
interface ReceiveTreePickerDataParams<T> {
}));
};
+export const PUBLIC_FAVORITES_PROJECT_ID = 'Public Favorites';
+export const initPublicFavoritesProject = (pickerId: string) =>
+ async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
+ dispatch(receiveTreePickerData({
+ id: '',
+ pickerId,
+ data: [{ uuid: PUBLIC_FAVORITES_PROJECT_ID, name: PUBLIC_FAVORITES_PROJECT_ID }],
+ extractNodeData: value => ({
+ id: value.uuid,
+ status: TreeNodeStatus.INITIAL,
+ value,
+ }),
+ }));
+ };
+
interface LoadFavoritesProjectParams {
pickerId: string;
includeCollections?: boolean;
}
};
+export const loadPublicFavoritesProject = (params: LoadFavoritesProjectParams) =>
+ async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
+ const { pickerId, includeCollections = false, includeFiles = false } = params;
+ const uuidPrefix = getState().config.uuidPrefix;
+ const uuid = `${uuidPrefix}-j7d0g-fffffffffffffff`;
+ if (uuid) {
+
+ const filters = pipe(
+ (fb: FilterBuilder) => includeCollections
+ ? fb.addIsA('headUuid', [ResourceKind.PROJECT, ResourceKind.COLLECTION])
+ : fb.addIsA('headUuid', [ResourceKind.PROJECT]),
+ fb => fb
+ .addEqual('linkClass', LinkClass.STAR)
+ .addEqual('ownerUuid', uuid)
+ .addLike('name', '')
+ .getFilters(),
+ )(new FilterBuilder());
+
+ const { items } = await services.linkService.list({ filters });
+
+ dispatch<any>(receiveTreePickerData<LinkResource>({
+ id: 'Public Favorites',
+ pickerId,
+ data: items,
+ extractNodeData: item => ({
+ id: item.headUuid,
+ value: item,
+ status: item.headKind === ResourceKind.PROJECT
+ ? TreeNodeStatus.INITIAL
+ : includeFiles
+ ? TreeNodeStatus.INITIAL
+ : TreeNodeStatus.LOADED
+ }),
+ }));
+ }
+ };
+
export const receiveTreePickerProjectsData = (id: string, projects: ProjectResource[], pickerId: string) =>
(dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
dispatch(treePickerActions.LOAD_TREE_PICKER_NODE_SUCCESS({
};
+export const loadPublicFavoriteTreePickerProjects = (id: string) =>
+ async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
+ const parentId = services.authService.getUuid() || '';
+
+ if (id === '') {
+ dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id: parentId, pickerId: TreePickerId.PUBLIC_FAVORITES }));
+ const { items } = await services.favoriteService.list(parentId);
+ dispatch<any>(receiveTreePickerProjectsData(parentId, items as ProjectResource[], TreePickerId.PUBLIC_FAVORITES));
+ } else {
+ dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id, pickerId: TreePickerId.PUBLIC_FAVORITES }));
+ const { items } = await services.projectService.list(buildParams(id));
+ dispatch<any>(receiveTreePickerProjectsData(id, items, TreePickerId.PUBLIC_FAVORITES));
+ }
+
+ };
+
const buildParams = (ownerUuid: string) => {
return {
filters: new FilterBuilder()
import * as groupDetailsPanelActions from '~/store/group-details-panel/group-details-panel-actions';
import { groupDetailsPanelColumns } from '~/views/group-details-panel/group-details-panel';
import { DataTableFetchMode } from "~/components/data-table/data-table";
+import { loadPublicFavoritePanel, publicFavoritePanelActions } from '~/store/public-favorites-panel/public-favorites-action';
+import { publicFavoritePanelColumns } from '~/views/public-favorites-panel/public-favorites-panel';
export const WORKBENCH_LOADING_SCREEN = 'workbenchLoadingScreen';
if (user) {
dispatch(projectPanelActions.SET_COLUMNS({ columns: projectPanelColumns }));
dispatch(favoritePanelActions.SET_COLUMNS({ columns: favoritePanelColumns }));
+ dispatch(publicFavoritePanelActions.SET_COLUMNS({ columns: publicFavoritePanelColumns }));
dispatch(trashPanelActions.SET_COLUMNS({ columns: trashPanelColumns }));
dispatch(sharedWithMePanelActions.SET_COLUMNS({ columns: projectPanelColumns }));
dispatch(workflowPanelActions.SET_COLUMNS({ columns: workflowPanelColumns }));
dispatch(setSidePanelBreadcrumbs(SidePanelTreeCategory.WORKFLOWS));
});
+export const loadPublicFavorites = () =>
+ handleFirstTimeLoad(
+ (dispatch: Dispatch) => {
+ dispatch<any>(activateSidePanelTreeItem(SidePanelTreeCategory.PUBLIC_FAVORITES));
+ dispatch<any>(loadPublicFavoritePanel());
+ dispatch<any>(setSidePanelBreadcrumbs(SidePanelTreeCategory.PUBLIC_FAVORITES));
+ });
+
export const loadSearchResults = handleFirstTimeLoad(
async (dispatch: Dispatch<any>) => {
await dispatch(loadSearchResultsPanel());
import { openCollectionCopyDialog } from "~/store/collections/collection-copy-actions";
import { ToggleTrashAction } from "~/views-components/context-menu/actions/trash-action";
import { toggleCollectionTrashed } from "~/store/trash/trash-actions";
-import { detailsPanelActions } from '~/store/details-panel/details-panel-action';
import { openSharingDialog } from '~/store/sharing-dialog/sharing-dialog-actions';
import { openAdvancedTabDialog } from "~/store/advanced-tab/advanced-tab";
import { toggleDetailsPanel } from '~/store/details-panel/details-panel-action';
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { ContextMenuActionSet } from "../context-menu-action-set";
+import { ToggleFavoriteAction } from "../actions/favorite-action";
+import { toggleFavorite } from "~/store/favorites/favorites-actions";
+import { RenameIcon, ShareIcon, MoveToIcon, CopyIcon, DetailsIcon, AdvancedIcon } from "~/components/icon/icon";
+import { openCollectionUpdateDialog } from "~/store/collections/collection-update-actions";
+import { favoritePanelActions } from "~/store/favorite-panel/favorite-panel-action";
+import { openMoveCollectionDialog } from '~/store/collections/collection-move-actions';
+import { openCollectionCopyDialog } from "~/store/collections/collection-copy-actions";
+import { ToggleTrashAction } from "~/views-components/context-menu/actions/trash-action";
+import { toggleCollectionTrashed } from "~/store/trash/trash-actions";
+import { openSharingDialog } from '~/store/sharing-dialog/sharing-dialog-actions';
+import { openAdvancedTabDialog } from "~/store/advanced-tab/advanced-tab";
+import { toggleDetailsPanel } from '~/store/details-panel/details-panel-action';
+import { TogglePublicFavoriteAction } from "~/views-components/context-menu/actions/public-favorite-action";
+import { publicFavoritePanelActions } from "~/store/public-favorites-panel/public-favorites-action";
+import { togglePublicFavorite } from "~/store/public-favorites/public-favorites-actions";
+
+export const collectionAdminActionSet: ContextMenuActionSet = [[
+ {
+ icon: RenameIcon,
+ name: "Edit collection",
+ execute: (dispatch, resource) => {
+ dispatch<any>(openCollectionUpdateDialog(resource));
+ }
+ },
+ {
+ icon: ShareIcon,
+ name: "Share",
+ execute: (dispatch, { uuid }) => {
+ dispatch<any>(openSharingDialog(uuid));
+ }
+ },
+ {
+ component: ToggleFavoriteAction,
+ execute: (dispatch, resource) => {
+ dispatch<any>(toggleFavorite(resource)).then(() => {
+ dispatch<any>(favoritePanelActions.REQUEST_ITEMS());
+ });
+ }
+ },
+ {
+ component: TogglePublicFavoriteAction,
+ execute: (dispatch, resource) => {
+ dispatch<any>(togglePublicFavorite(resource)).then(() => {
+ dispatch<any>(publicFavoritePanelActions.REQUEST_ITEMS());
+ });
+ }
+ },
+ {
+ icon: MoveToIcon,
+ name: "Move to",
+ execute: (dispatch, resource) => dispatch<any>(openMoveCollectionDialog(resource))
+ },
+ {
+ icon: CopyIcon,
+ name: "Copy to project",
+ execute: (dispatch, resource) => {
+ dispatch<any>(openCollectionCopyDialog(resource));
+ }
+
+ },
+ {
+ icon: DetailsIcon,
+ name: "View details",
+ execute: dispatch => {
+ dispatch<any>(toggleDetailsPanel());
+ }
+ },
+ // {
+ // icon: ProvenanceGraphIcon,
+ // name: "Provenance graph",
+ // execute: (dispatch, resource) => {
+ // // add code
+ // }
+ // },
+ {
+ icon: AdvancedIcon,
+ name: "Advanced",
+ execute: (dispatch, resource) => {
+ dispatch<any>(openAdvancedTabDialog(resource.uuid));
+ }
+ },
+ {
+ component: ToggleTrashAction,
+ execute: (dispatch, resource) => {
+ dispatch<any>(toggleCollectionTrashed(resource.uuid, resource.isTrashed!!));
+ }
+ },
+ // {
+ // icon: RemoveIcon,
+ // name: "Remove",
+ // execute: (dispatch, resource) => {
+ // // add code
+ // }
+ // }
+]];
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { ContextMenuActionSet } from "../context-menu-action-set";
+import { ToggleFavoriteAction } from "../actions/favorite-action";
+import { toggleFavorite } from "~/store/favorites/favorites-actions";
+import { RenameIcon, ShareIcon, MoveToIcon, CopyIcon, DetailsIcon, RemoveIcon } from "~/components/icon/icon";
+import { favoritePanelActions } from "~/store/favorite-panel/favorite-panel-action";
+import { openMoveProcessDialog } from '~/store/processes/process-move-actions';
+import { openProcessUpdateDialog } from "~/store/processes/process-update-actions";
+import { openCopyProcessDialog } from '~/store/processes/process-copy-actions';
+import { openSharingDialog } from "~/store/sharing-dialog/sharing-dialog-actions";
+import { openRemoveProcessDialog } from "~/store/processes/processes-actions";
+import { toggleDetailsPanel } from '~/store/details-panel/details-panel-action';
+import { TogglePublicFavoriteAction } from "~/views-components/context-menu/actions/public-favorite-action";
+import { togglePublicFavorite } from "~/store/public-favorites/public-favorites-actions";
+import { publicFavoritePanelActions } from "~/store/public-favorites-panel/public-favorites-action";
+
+export const processResourceAdminActionSet: ContextMenuActionSet = [[
+ {
+ icon: RenameIcon,
+ name: "Edit process",
+ execute: (dispatch, resource) => {
+ dispatch<any>(openProcessUpdateDialog(resource));
+ }
+ },
+ {
+ icon: ShareIcon,
+ name: "Share",
+ execute: (dispatch, { uuid }) => {
+ dispatch<any>(openSharingDialog(uuid));
+ }
+ },
+ {
+ component: ToggleFavoriteAction,
+ execute: (dispatch, resource) => {
+ dispatch<any>(toggleFavorite(resource)).then(() => {
+ dispatch<any>(favoritePanelActions.REQUEST_ITEMS());
+ });
+ }
+ },
+ {
+ component: TogglePublicFavoriteAction,
+ execute: (dispatch, resource) => {
+ dispatch<any>(togglePublicFavorite(resource)).then(() => {
+ dispatch<any>(publicFavoritePanelActions.REQUEST_ITEMS());
+ });
+ }
+ },
+ {
+ icon: MoveToIcon,
+ name: "Move to",
+ execute: (dispatch, resource) => {
+ dispatch<any>(openMoveProcessDialog(resource));
+ }
+ },
+ {
+ icon: CopyIcon,
+ name: "Copy to project",
+ execute: (dispatch, resource) => {
+ dispatch<any>(openCopyProcessDialog(resource));
+ }
+ },
+ {
+ icon: DetailsIcon,
+ name: "View details",
+ execute: dispatch => {
+ dispatch<any>(toggleDetailsPanel());
+ }
+ },
+ {
+ name: "Remove",
+ icon: RemoveIcon,
+ execute: (dispatch, resource) => {
+ dispatch<any>(openRemoveProcessDialog(resource.uuid));
+ }
+ }
+]];
// SPDX-License-Identifier: AGPL-3.0
import { ContextMenuActionSet } from "../context-menu-action-set";
-import { NewProjectIcon, RenameIcon, CopyIcon, MoveToIcon, DetailsIcon, AdvancedIcon } from '~/components/icon/icon';
+import { NewProjectIcon, RenameIcon, MoveToIcon, DetailsIcon, AdvancedIcon } from '~/components/icon/icon';
import { ToggleFavoriteAction } from "../actions/favorite-action";
import { toggleFavorite } from "~/store/favorites/favorites-actions";
import { favoritePanelActions } from "~/store/favorite-panel/favorite-panel-action";
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { ContextMenuActionSet } from "../context-menu-action-set";
+import { NewProjectIcon, RenameIcon, MoveToIcon, DetailsIcon, AdvancedIcon } from '~/components/icon/icon';
+import { ToggleFavoriteAction } from "../actions/favorite-action";
+import { toggleFavorite } from "~/store/favorites/favorites-actions";
+import { favoritePanelActions } from "~/store/favorite-panel/favorite-panel-action";
+import { openMoveProjectDialog } from '~/store/projects/project-move-actions';
+import { openProjectCreateDialog } from '~/store/projects/project-create-actions';
+import { openProjectUpdateDialog } from '~/store/projects/project-update-actions';
+import { ToggleTrashAction } from "~/views-components/context-menu/actions/trash-action";
+import { toggleProjectTrashed } from "~/store/trash/trash-actions";
+import { ShareIcon } from '~/components/icon/icon';
+import { openSharingDialog } from "~/store/sharing-dialog/sharing-dialog-actions";
+import { openAdvancedTabDialog } from "~/store/advanced-tab/advanced-tab";
+import { toggleDetailsPanel } from '~/store/details-panel/details-panel-action';
+import { TogglePublicFavoriteAction } from "~/views-components/context-menu/actions/public-favorite-action";
+import { togglePublicFavorite } from "~/store/public-favorites/public-favorites-actions";
+import { publicFavoritePanelActions } from "~/store/public-favorites-panel/public-favorites-action";
+
+export const projectAdminActionSet: ContextMenuActionSet = [[
+ {
+ icon: NewProjectIcon,
+ name: "New project",
+ execute: (dispatch, resource) => {
+ dispatch<any>(openProjectCreateDialog(resource.uuid));
+ }
+ },
+ {
+ icon: RenameIcon,
+ name: "Edit project",
+ execute: (dispatch, resource) => {
+ dispatch<any>(openProjectUpdateDialog(resource));
+ }
+ },
+ {
+ icon: ShareIcon,
+ name: "Share",
+ execute: (dispatch, { uuid }) => {
+ dispatch<any>(openSharingDialog(uuid));
+ }
+ },
+ {
+ component: ToggleFavoriteAction,
+ execute: (dispatch, resource) => {
+ dispatch<any>(toggleFavorite(resource)).then(() => {
+ dispatch<any>(favoritePanelActions.REQUEST_ITEMS());
+ });
+ }
+ },
+ {
+ component: TogglePublicFavoriteAction,
+ execute: (dispatch, resource) => {
+ dispatch<any>(togglePublicFavorite(resource)).then(() => {
+ dispatch<any>(publicFavoritePanelActions.REQUEST_ITEMS());
+ });
+ }
+ },
+ {
+ icon: MoveToIcon,
+ name: "Move to",
+ execute: (dispatch, resource) => {
+ dispatch<any>(openMoveProjectDialog(resource));
+ }
+ },
+ // {
+ // icon: CopyIcon,
+ // name: "Copy to project",
+ // execute: (dispatch, resource) => {
+ // // add code
+ // }
+ // },
+ {
+ icon: DetailsIcon,
+ name: "View details",
+ execute: dispatch => {
+ dispatch<any>(toggleDetailsPanel());
+ }
+ },
+ {
+ icon: AdvancedIcon,
+ name: "Advanced",
+ execute: (dispatch, resource) => {
+ dispatch<any>(openAdvancedTabDialog(resource.uuid));
+ }
+ },
+ {
+ component: ToggleTrashAction,
+ execute: (dispatch, resource) => {
+ dispatch<any>(toggleProjectTrashed(resource.uuid, resource.ownerUuid, resource.isTrashed!!));
+ }
+ },
+]];
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import * as React from "react";
+import { ListItemIcon, ListItemText, ListItem } from "@material-ui/core";
+import { PublicFavoriteIcon } from "~/components/icon/icon";
+import { connect } from "react-redux";
+import { RootState } from "~/store/store";
+
+const mapStateToProps = (state: RootState, props: { onClick: () => {} }) => ({
+ isPublicFavorite: state.contextMenu.resource !== undefined && state.publicFavorites[state.contextMenu.resource.uuid] === true,
+ onClick: props.onClick
+});
+
+export const TogglePublicFavoriteAction = connect(mapStateToProps)((props: { isPublicFavorite: boolean, onClick: () => void }) =>
+ <ListItem
+ button
+ onClick={props.onClick}>
+ <ListItemIcon>
+ {props.isPublicFavorite
+ ? <PublicFavoriteIcon />
+ : <PublicFavoriteIcon />}
+ </ListItemIcon>
+ <ListItemText style={{ textDecoration: 'none' }}>
+ {props.isPublicFavorite
+ ? <>Remove from public favorites</>
+ : <>Add to public favorites</>}
+ </ListItemText>
+ </ListItem >);
API_CLIENT_AUTHORIZATION = "ApiClientAuthorization",
ROOT_PROJECT = "RootProject",
PROJECT = "Project",
+ PROJECT_ADMIN = "ProjectAdmin",
RESOURCE = "Resource",
FAVORITE = "Favorite",
TRASH = "Trash",
COLLECTION_FILES_ITEM = "CollectionFilesItem",
COLLECTION_FILES_NOT_SELECTED = "CollectionFilesNotSelected",
COLLECTION = 'Collection',
+ COLLECTION_ADMIN = 'CollectionAdmin',
COLLECTION_RESOURCE = 'CollectionResource',
TRASHED_COLLECTION = 'TrashedCollection',
PROCESS = "Process",
+ PROCESS_ADMIN = 'ProcessAdmin',
PROCESS_RESOURCE = 'ProcessResource',
PROCESS_LOGS = "ProcessLogs",
REPOSITORY = "Repository",
interface Props {
id: string;
onRowClick: (item: any) => void;
- onContextMenu?: (event: React.MouseEvent<HTMLElement>, item: any) => void;
+ onContextMenu?: (event: React.MouseEvent<HTMLElement>, item: any, isAdmin?: boolean) => void;
onRowDoubleClick: (item: any) => void;
extractKey?: (item: any) => React.Key;
}
import { toggleIsActive, toggleIsAdmin } from '~/store/users/users-actions';
import { LinkResource } from '~/models/link';
import { navigateTo } from '~/store/navigation/navigation-action';
-import { withResource, getDataFromResource, withResourceData } from '~/views-components/data-explorer/with-resources';
+import { withResourceData } from '~/views-components/data-explorer/with-resources';
const renderName = (item: { name: string; uuid: string, kind: string }) =>
<Grid container alignItems="center" wrap="nowrap" spacing={16}>
<Grid item>
- {renderIcon(item)}
+ {renderIcon(item.kind)}
</Grid>
<Grid item>
<Typography color="primary" style={{ width: 'auto' }}>
return resource || { name: '', uuid: '', kind: '' };
})(renderName);
-const renderIcon = (item: { kind: string }) => {
- switch (item.kind) {
+const renderIcon = (kind: string) => {
+ switch (kind) {
case ResourceKind.PROJECT:
return <ProjectIcon />;
case ResourceKind.COLLECTION:
const renderWorkflowName = (item: { name: string; uuid: string, kind: string, ownerUuid: string }) =>
<Grid container alignItems="center" wrap="nowrap" spacing={16}>
<Grid item>
- {renderIcon(item)}
+ {renderIcon(item.kind)}
</Grid>
<Grid item>
<Typography color="primary" style={{ width: '100px' }}>
const currentLabel = resourceLabel(item.tailKind);
const isUnknow = currentLabel === "Unknown";
return (<div>
- { !isUnknow ? (
- renderLink(dispatch, item.tailUuid, currentLabel)
- ) : (
+ {!isUnknow ? (
+ renderLink(dispatch, item.tailUuid, currentLabel)
+ ) : (
<Typography noWrap color="default">
{item.tailUuid}
</Typography>
- )}
+ )}
</div>);
};
return resource || { uuid: '' };
})(renderUuid);
+const renderLinkNameAndIcon = (item: { name: string; headUuid: string, headKind: string }) =>
+ <Grid container alignItems="center" wrap="nowrap" spacing={16}>
+ <Grid item>
+ {renderIcon(item.headKind)}
+ </Grid>
+ <Grid item>
+ <Typography color="primary" style={{ width: 'auto' }}>
+ {item.name}
+ </Typography>
+ </Grid>
+ <Grid item>
+ <Typography variant="caption">
+ <FavoriteStar resourceUuid={item.headUuid} />
+ </Typography>
+ </Grid>
+ </Grid>;
+
+export const ResourceLinkNameAndIcon = connect(
+ (state: RootState, props: { uuid: string }) => {
+ const resource = getResource<LinkResource>(props.uuid)(state.resources);
+ return resource || { name: '', headUuid: '', headKind: '' };
+ })(renderLinkNameAndIcon);
+
+export const ResourceLinkType = connect(
+ (state: RootState, props: { uuid: string }) => {
+ const resource = getResource<LinkResource>(props.uuid)(state.resources);
+ return { type: resource ? resource.headKind : '' };
+ })((props: { type: string }) => renderType(props.type));
+
// Process Resources
const resourceRunProcess = (dispatch: Dispatch, uuid: string) => {
return (
// SPDX-License-Identifier: AGPL-3.0
import * as React from "react";
-import { FavoriteIcon } from "~/components/icon/icon";
+import { FavoriteIcon, PublicFavoriteIcon } from "~/components/icon/icon";
import { connect } from "react-redux";
import { RootState } from "~/store/store";
import { withStyles, StyleRulesCallback, WithStyles } from "@material-ui/core";
const mapStateToProps = (state: RootState, props: { resourceUuid: string; className?: string; }) => ({
...props,
- visible: state.favorites[props.resourceUuid],
+ isFavoriteVisible: state.favorites[props.resourceUuid],
+ isPublicFavoriteVisible: state.publicFavorites[props.resourceUuid]
});
export const FavoriteStar = connect(mapStateToProps)(
- withStyles(styles)((props: { visible: boolean; className?: string; } & WithStyles<CssRules>) =>
- props.visible ? <FavoriteIcon className={props.className || props.classes.icon} /> : null
- ));
+ withStyles(styles)((props: { isFavoriteVisible: boolean; isPublicFavoriteVisible: boolean; className?: string; } & WithStyles<CssRules>) => {
+ if (props.isPublicFavoriteVisible) {
+ return <PublicFavoriteIcon className={props.className || props.classes.icon} />;
+ } else if (props.isFavoriteVisible) {
+ return <FavoriteIcon className={props.className || props.classes.icon} />;
+ } else {
+ return null;
+ }
+ }));
import { TreePicker, TreePickerProps } from "../tree-picker/tree-picker";
import { TreeItem, TreeItemStatus } from "~/components/tree/tree";
import { ProjectResource } from "~/models/project";
-import { treePickerActions, loadProjectTreePickerProjects, loadFavoriteTreePickerProjects } from "~/store/tree-picker/tree-picker-actions";
+import { treePickerActions, loadProjectTreePickerProjects, loadFavoriteTreePickerProjects, loadPublicFavoriteTreePickerProjects } from "~/store/tree-picker/tree-picker-actions";
import { ListItemTextIcon } from "~/components/list-item-text-icon/list-item-text-icon";
-import { ProjectIcon, FavoriteIcon, ProjectsIcon, ShareMeIcon } from "~/components/icon/icon";
+import { ProjectIcon, FavoriteIcon, ProjectsIcon, ShareMeIcon, PublicFavoriteIcon } from '~/components/icon/icon';
import { RootState } from "~/store/store";
import { ServiceRepository } from "~/services/services";
import { WrappedFieldProps } from 'redux-form';
dispatch<any>(loadProjectTreePickerProjects(id));
} else if (pickerId === TreePickerId.FAVORITES) {
dispatch<any>(loadFavoriteTreePickerProjects(id === services.authService.getUuid() ? '' : id));
- } else {
+ } else if (pickerId === TreePickerId.PUBLIC_FAVORITES) {
+ dispatch<any>(loadPublicFavoriteTreePickerProjects(id === services.authService.getUuid() ? '' : id));
// TODO: load sharedWithMe
}
} else {
<TreePicker {...props} render={renderTreeItem} pickerId={TreePickerId.PROJECTS} />
<TreePicker {...props} render={renderTreeItem} pickerId={TreePickerId.SHARED_WITH_ME} />
<TreePicker {...props} render={renderTreeItem} pickerId={TreePickerId.FAVORITES} />
+ <TreePicker {...props} render={renderTreeItem} pickerId={TreePickerId.PUBLIC_FAVORITES} />
</div>
</div>);
return ProjectsIcon;
case TreePickerId.SHARED_WITH_ME:
return ShareMeIcon;
+ case TreePickerId.PUBLIC_FAVORITES:
+ return PublicFavoriteIcon;
default:
return ProjectIcon;
}
import { CollectionDirectory, CollectionFile, CollectionFileType } from '~/models/collection-file';
import { ResourceKind } from '~/models/resource';
import { TreePickerProps, TreePicker } from "~/views-components/tree-picker/tree-picker";
+import { LinkResource } from "~/models/link";
export interface ProjectsTreePickerRootItem {
id: string;
name: string;
}
-export type ProjectsTreePickerItem = ProjectsTreePickerRootItem | GroupContentsResource | CollectionDirectory | CollectionFile;
+export type ProjectsTreePickerItem = ProjectsTreePickerRootItem | GroupContentsResource | CollectionDirectory | CollectionFile | LinkResource;
type PickedTreePickerProps = Pick<TreePickerProps<ProjectsTreePickerItem>, 'onContextMenu' | 'toggleItemActive' | 'toggleItemOpen' | 'toggleItemSelection'>;
export interface ProjectsTreePickerDataProps {
const mapDispatchToProps = (dispatch: Dispatch, { loadRootItem, includeCollections, includeFiles, relatedTreePickers, ...props }: ProjectsTreePickerProps): PickedTreePickerProps => ({
onContextMenu: () => { return; },
toggleItemActive: (event, item, pickerId) => {
-
+
const { disableActivation = [] } = props;
- if(disableActivation.some(isEqual(item.id))){
+ if (disableActivation.some(isEqual(item.id))) {
return;
}
export const ProjectsTreePicker = connect(mapStateToProps, mapDispatchToProps)(TreePicker);
const getProjectPickerIcon = ({ data }: TreeItem<ProjectsTreePickerItem>, rootIcon: IconType): IconType => {
+ if ('headKind' in data) {
+ switch (data.headKind) {
+ case ResourceKind.COLLECTION:
+ return CollectionIcon;
+ default:
+ return ProjectIcon;
+ }
+ }
if ('kind' in data) {
switch (data.kind) {
case ResourceKind.COLLECTION:
import { getProjectsTreePickerIds, SHARED_PROJECT_ID, FAVORITES_PROJECT_ID } from '~/store/tree-picker/tree-picker-actions';
import { TreeItem } from '~/components/tree/tree';
import { ProjectsTreePickerItem } from './generic-projects-tree-picker';
+import { PublicFavoritesTreePicker } from './public-favorites-tree-picker';
export interface ProjectsTreePickerProps {
pickerId: string;
}
export const ProjectsTreePicker = ({ pickerId, ...props }: ProjectsTreePickerProps) => {
- const { home, shared, favorites } = getProjectsTreePickerIds(pickerId);
+ const { home, shared, favorites, publicFavorites } = getProjectsTreePickerIds(pickerId);
const relatedTreePickers = getRelatedTreePickers(pickerId);
const p = {
...props,
<HomeTreePicker pickerId={home} {...p} />
<SharedTreePicker pickerId={shared} {...p} />
<FavoritesTreePicker pickerId={favorites} {...p} />
+ <PublicFavoritesTreePicker pickerId={publicFavorites} {...p} />
</div>;
};
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { connect } from 'react-redux';
+import { ProjectsTreePicker, ProjectsTreePickerProps } from '~/views-components/projects-tree-picker/generic-projects-tree-picker';
+import { Dispatch } from 'redux';
+import { PublicFavoriteIcon } from '~/components/icon/icon';
+import { loadPublicFavoritesProject } from '~/store/tree-picker/tree-picker-actions';
+
+export const PublicFavoritesTreePicker = connect(() => ({
+ rootItemIcon: PublicFavoriteIcon,
+}), (dispatch: Dispatch): Pick<ProjectsTreePickerProps, 'loadRootItem'> => ({
+ loadRootItem: (_, pickerId, includeCollections, includeFiles) => {
+ dispatch<any>(loadPublicFavoritesProject({ pickerId, includeCollections, includeFiles }));
+ },
+}))(ProjectsTreePicker);
\ No newline at end of file
import { TreeItem } from "~/components/tree/tree";
import { ProjectResource } from "~/models/project";
import { ListItemTextIcon } from "~/components/list-item-text-icon/list-item-text-icon";
-import { ProjectIcon, FavoriteIcon, ProjectsIcon, ShareMeIcon, TrashIcon } from '~/components/icon/icon';
+import { ProjectIcon, FavoriteIcon, ProjectsIcon, ShareMeIcon, TrashIcon, PublicFavoriteIcon } from '~/components/icon/icon';
import { WorkflowIcon } from '~/components/icon/icon';
import { activateSidePanelTreeItem, toggleSidePanelTreeItemCollapse, SIDE_PANEL_TREE, SidePanelTreeCategory } from '~/store/side-panel-tree/side-panel-tree-actions';
import { openSidePanelContextMenu } from '~/store/context-menu/context-menu-actions';
return TrashIcon;
case SidePanelTreeCategory.WORKFLOWS:
return WorkflowIcon;
+ case SidePanelTreeCategory.PUBLIC_FAVORITES:
+ return PublicFavoriteIcon;
default:
return ProjectIcon;
}
interface ProjectPanelDataProps {
currentItemId: string;
resources: ResourcesState;
+ isAdmin: boolean;
}
type ProjectPanelProps = ProjectPanelDataProps & DispatchProp
export const ProjectPanel = withStyles(styles)(
connect((state: RootState) => ({
currentItemId: getProperty(PROJECT_PANEL_CURRENT_UUID)(state.properties),
- resources: state.resources
+ resources: state.resources,
+ isAdmin: state.auth.user!.isAdmin
}))(
class extends React.Component<ProjectPanelProps> {
render() {
}
handleContextMenu = (event: React.MouseEvent<HTMLElement>, resourceUuid: string) => {
- const menuKind = resourceKindToContextMenuKind(resourceUuid);
+ const menuKind = resourceKindToContextMenuKind(resourceUuid, this.props.isAdmin);
const resource = getResource<ProjectResource>(resourceUuid)(this.props.resources);
if (menuKind && resource) {
this.props.dispatch<any>(openContextMenu(event, {
--- /dev/null
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import * as React from 'react';
+import { StyleRulesCallback, WithStyles, withStyles } from '@material-ui/core';
+import { DataExplorer } from "~/views-components/data-explorer/data-explorer";
+import { connect, DispatchProp } from 'react-redux';
+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 {
+ ProcessStatus,
+ ResourceFileSize,
+ ResourceLastModifiedDate,
+ ResourceLinkNameAndIcon,
+ ResourceLinkType
+} from '~/views-components/data-explorer/renderers';
+import { PublicFavoriteIcon } from '~/components/icon/icon';
+import { Dispatch } from 'redux';
+import { openContextMenu, resourceKindToContextMenuKind } 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 { RootState } from '~/store/store';
+import { DataTableDefaultView } from '~/components/data-table-default-view/data-table-default-view';
+import { createTree } from '~/models/tree';
+import { getSimpleObjectTypeFilters } from '~/store/resource-type-filters/resource-type-filters';
+import { PUBLIC_FAVORITE_PANEL_ID } from '~/store/public-favorites-panel/public-favorites-action';
+import { PublicFavoritesState } from '~/store/public-favorites/public-favorites-reducer';
+import { getHeadUuid, getIsAdmin } from '~/store/public-favorites/public-favorites-actions';
+
+type CssRules = "toolbar" | "button";
+
+const styles: StyleRulesCallback<CssRules> = (theme: ArvadosTheme) => ({
+ toolbar: {
+ paddingBottom: theme.spacing.unit * 3,
+ textAlign: "right"
+ },
+ button: {
+ marginLeft: theme.spacing.unit
+ },
+});
+
+export enum FavoritePanelColumnNames {
+ NAME = "Name",
+ STATUS = "Status",
+ TYPE = "Type",
+ OWNER = "Owner",
+ FILE_SIZE = "File size",
+ LAST_MODIFIED = "Last modified"
+}
+
+export interface FavoritePanelFilter extends DataTableFilterItem {
+ type: ResourceKind | ContainerRequestState;
+}
+
+export const publicFavoritePanelColumns: DataColumns<string> = [
+ {
+ name: FavoritePanelColumnNames.NAME,
+ selected: true,
+ configurable: true,
+ sortDirection: SortDirection.NONE,
+ filters: createTree(),
+ render: uuid => <ResourceLinkNameAndIcon uuid={uuid} />
+ },
+ {
+ name: "Status",
+ selected: true,
+ configurable: true,
+ filters: createTree(),
+ render: uuid => <ProcessStatus uuid={uuid} />
+ },
+ {
+ name: FavoritePanelColumnNames.TYPE,
+ selected: true,
+ configurable: true,
+ filters: getSimpleObjectTypeFilters(),
+ render: uuid => <ResourceLinkType uuid={uuid} />
+ },
+ {
+ name: FavoritePanelColumnNames.FILE_SIZE,
+ selected: true,
+ configurable: true,
+ filters: createTree(),
+ render: uuid => <ResourceFileSize uuid={uuid} />
+ },
+ {
+ name: FavoritePanelColumnNames.LAST_MODIFIED,
+ selected: true,
+ configurable: true,
+ sortDirection: SortDirection.DESC,
+ filters: createTree(),
+ render: uuid => <ResourceLastModifiedDate uuid={uuid} />
+ }
+];
+
+interface PublicFavoritePanelDataProps {
+ publicFavorites: PublicFavoritesState;
+}
+
+interface PublicFavoritePanelActionProps {
+ onItemClick: (item: string) => void;
+ onContextMenu: (event: React.MouseEvent<HTMLElement>, item: string) => void;
+ onDialogOpen: (ownerUuid: string) => void;
+ onItemDoubleClick: (item: string) => void;
+}
+const mapStateToProps = ({ publicFavorites }: RootState): PublicFavoritePanelDataProps => ({
+ publicFavorites
+});
+
+const mapDispatchToProps = (dispatch: Dispatch): PublicFavoritePanelActionProps => ({
+ onContextMenu: (event, resourceUuid) => {
+ const isAdmin = dispatch<any>(getIsAdmin());
+ const kind = resourceKindToContextMenuKind(dispatch<any>(getHeadUuid(resourceUuid)), isAdmin);
+ if (kind) {
+ dispatch<any>(openContextMenu(event, {
+ name: '',
+ uuid: dispatch<any>(getHeadUuid(resourceUuid)),
+ ownerUuid: '',
+ kind: ResourceKind.NONE,
+ menuKind: kind
+ }));
+ }
+ dispatch<any>(loadDetailsPanel(dispatch<any>(getHeadUuid(resourceUuid))));
+ },
+ onDialogOpen: (ownerUuid: string) => { return; },
+ onItemClick: (uuid: string) => {
+ dispatch<any>(loadDetailsPanel(dispatch<any>(getHeadUuid(uuid))));
+ },
+ onItemDoubleClick: uuid => {
+ dispatch<any>(navigateTo(dispatch<any>(getHeadUuid(uuid))));
+ }
+});
+
+type FavoritePanelProps = PublicFavoritePanelDataProps & PublicFavoritePanelActionProps & DispatchProp
+ & WithStyles<CssRules> & RouteComponentProps<{ id: string }>;
+
+export const PublicFavoritePanel = withStyles(styles)(
+ connect(mapStateToProps, mapDispatchToProps)(
+ class extends React.Component<FavoritePanelProps> {
+ render() {
+ return <DataExplorer
+ id={PUBLIC_FAVORITE_PANEL_ID}
+ onRowClick={this.props.onItemClick}
+ onRowDoubleClick={this.props.onItemDoubleClick}
+ onContextMenu={this.props.onContextMenu}
+ contextMenuColumn={true}
+ dataTableDefaultView={
+ <DataTableDefaultView
+ icon={PublicFavoriteIcon}
+ messages={['Public favorites list is empty.']} />
+ } />;
+ }
+ }
+ )
+);
import { GroupMemberAttributesDialog } from '~/views-components/groups-dialog/member-attributes-dialog';
import { AddGroupMembersDialog } from '~/views-components/dialog-forms/add-group-member-dialog';
import { PartialCopyToCollectionDialog } from '~/views-components/dialog-forms/partial-copy-to-collection-dialog';
+import { PublicFavoritePanel } from '~/views/public-favorites-panel/public-favorites-panel';
type CssRules = 'root' | 'container' | 'splitter' | 'asidePanel' | 'contentWrapper' | 'content';
<Grid container item xs className={classes.root}>
<Grid container item xs className={classes.container}>
<SplitterLayout customClassName={classes.splitter} percentage={true}
- primaryIndex={0} primaryMinSize={10}
- secondaryInitialSize={getSplitterInitialSize()} secondaryMinSize={40}
- onSecondaryPaneSizeChange={saveSplitterSize}>
+ primaryIndex={0} primaryMinSize={10}
+ secondaryInitialSize={getSplitterInitialSize()} secondaryMinSize={40}
+ onSecondaryPaneSizeChange={saveSplitterSize}>
<Grid container item xs component='aside' direction='column' className={classes.asidePanel}>
<SidePanel />
</Grid>
<Route path={Routes.GROUPS} component={GroupsPanel} />
<Route path={Routes.GROUP_DETAILS} component={GroupDetailsPanel} />
<Route path={Routes.LINKS} component={LinkPanel} />
+ <Route path={Routes.PUBLIC_FAVORITES} component={PublicFavoritePanel} />
</Switch>
</Grid>
</Grid>
projects / arvados-workbench2.git / commitdiff