--- /dev/null
+import { RootState } from '~/store/store';
+
+export const getUserUuid = (state: RootState) => {
+ const user = state.auth.user;
+ if (user) {
+ return user.uuid;
+ } else {
+ return undefined;
+ }
+};
const addChild = (parentId: string, childId: string) => <T>(tree: Tree<T>): Tree<T> => {
+ if (childId === "") {
+ return tree;
+ }
const node = getNode(parentId)(tree);
if (node) {
const children = node.children.some(id => id === childId)
//
// SPDX-License-Identifier: AGPL-3.0
-import { getUserFullname, User, UserPrefs, UserResource } from '~/models/user';
+import { getUserFullname, User, UserPrefs } from '~/models/user';
import { AxiosInstance } from "axios";
import { ApiActions } from "~/services/api/api-actions";
import * as uuid from "uuid/v4";
return localStorage.getItem(HOME_CLUSTER) || undefined;
}
- public getUuid() {
- return localStorage.getItem(USER_UUID_KEY) || undefined;
- }
-
- public getOwnerUuid() {
- return localStorage.getItem(USER_OWNER_UUID_KEY) || undefined;
- }
-
- public getIsAdmin(): boolean {
- return localStorage.getItem(USER_IS_ADMIN) === 'true';
- }
-
- public getIsActive(): boolean {
- return localStorage.getItem(USER_IS_ACTIVE) === 'true';
- }
-
- public getUser(): User | undefined {
- const email = localStorage.getItem(USER_EMAIL_KEY);
- const firstName = localStorage.getItem(USER_FIRST_NAME_KEY);
- const lastName = localStorage.getItem(USER_LAST_NAME_KEY);
- const uuid = this.getUuid();
- const ownerUuid = this.getOwnerUuid();
- const isAdmin = this.getIsAdmin();
- const isActive = this.getIsActive();
- const username = localStorage.getItem(USER_USERNAME);
- const prefs = JSON.parse(localStorage.getItem(USER_PREFS) || '{"profile": {}}');
-
- return email && firstName && lastName && uuid && ownerUuid && username && prefs
- ? { email, firstName, lastName, uuid, ownerUuid, isAdmin, isActive, username, prefs }
- : undefined;
- }
-
- public saveUser(user: User | UserResource) {
- localStorage.setItem(USER_EMAIL_KEY, user.email);
- localStorage.setItem(USER_FIRST_NAME_KEY, user.firstName);
- localStorage.setItem(USER_LAST_NAME_KEY, user.lastName);
- localStorage.setItem(USER_UUID_KEY, user.uuid);
- localStorage.setItem(USER_OWNER_UUID_KEY, user.ownerUuid);
- localStorage.setItem(USER_IS_ADMIN, JSON.stringify(user.isAdmin));
- localStorage.setItem(USER_IS_ACTIVE, JSON.stringify(user.isActive));
- localStorage.setItem(USER_USERNAME, user.username);
- localStorage.setItem(USER_PREFS, JSON.stringify(user.prefs));
- }
-
public removeUser() {
localStorage.removeItem(USER_EMAIL_KEY);
localStorage.removeItem(USER_FIRST_NAME_KEY);
throw e;
});
}
-
- public getRootUuid() {
- const uuid = this.getOwnerUuid();
- const uuidParts = uuid ? uuid.split('-') : [];
- return uuidParts.length > 1 ? `${uuidParts[0]}-${uuidParts[1]}` : undefined;
- }
public getSessions(): Session[] {
try {
import { dialogActions } from "~/store/dialog/dialog-actions";
import { Dispatch } from "redux";
import { RootState } from "~/store/store";
+import { getUserUuid } from "~/common/getuser";
import { ServiceRepository } from "~/services/services";
-import {snackbarActions, SnackbarKind} from "~/store/snackbar/snackbar-actions";
+import { snackbarActions, SnackbarKind } from "~/store/snackbar/snackbar-actions";
import { FormErrors, reset, startSubmit, stopSubmit } from "redux-form";
import { KeyType } from "~/models/ssh-key";
import {
getAuthorizedKeysServiceError
} from "~/services/authorized-keys-service/authorized-keys-service";
import { setBreadcrumbs } from "~/store/breadcrumbs/breadcrumbs-actions";
-import {
- authActions,
-} from "~/store/auth/auth-action";
+import { authActions } from "~/store/auth/auth-action";
export const SSH_KEY_CREATE_FORM_NAME = 'sshKeyCreateFormName';
export const SSH_KEY_PUBLIC_KEY_DIALOG = 'sshKeyPublicKeyDialog';
export const createSshKey = (data: SshKeyCreateFormDialogData) =>
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const userUuid = getState().auth.user!.uuid;
+ const userUuid = getUserUuid(getState());
const { name, publicKey } = data;
dispatch(startSubmit(SSH_KEY_CREATE_FORM_NAME));
try {
export const loadSshKeysPanel = () =>
async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
try {
- dispatch(setBreadcrumbs([{ label: 'SSH Keys'}]));
+ dispatch(setBreadcrumbs([{ label: 'SSH Keys' }]));
const response = await services.authorizedKeysService.list();
dispatch(authActions.SET_SSH_KEYS(response.items));
} catch (e) {
return;
}
};
-
import { User } from "~/models/user";
import { Session } from "~/models/session";
import { Config } from '~/common/config';
-import { cancelLinking } from '~/store/link-account-panel/link-account-panel-actions';
import { matchTokenRoute, matchFedTokenRoute } from '~/routes/routes';
-import { createServices, setAuthorizationHeader, removeAuthorizationHeader } from "~/services/services";
+import { createServices, setAuthorizationHeader } from "~/services/services";
+import { cancelLinking } from '~/store/link-account-panel/link-account-panel-actions';
export const authActions = unionize({
LOGIN: {},
INIT: ({ user, token }) => {
next(action);
const state: RootState = store.getState();
- if (state.auth.user) {
- services.authService.saveUser(state.auth.user);
- } else {
- services.authService.removeUser();
- }
+
if (state.auth.apiToken) {
services.authService.saveApiToken(state.auth.apiToken);
setAuthorizationHeader(services, state.auth.apiToken);
document.title = `Arvados Workbench (${config.uuidPrefix})`;
next(action);
},
- LOGOUT: ({deleteLinkData}) => {
- next(action)
- if (deleteLinkData) {
- services.linkAccountService.removeAccountToLink();
- }
- services.authService.removeApiToken();
- services.authService.removeUser();
- removeAuthorizationHeader(services);
- services.authService.logout();
- },
+ LOGOUT: ({ deleteLinkData }) => {
+ next(action);
+ if (deleteLinkData) {
+ services.linkAccountService.removeAccountToLink();
+ }
+ services.authService.removeApiToken();
+ services.authService.removeUser();
+ removeAuthorizationHeader(services);
+ services.authService.logout();
+ },
default: () => next(action)
});
};
return { ...state, apiToken: undefined };
},
USER_DETAILS_SUCCESS: (user: User) => {
- return { ...state, user };
+ return { ...state, user, homeCluster: user.uuid.substr(0, 5) };
},
SET_SSH_KEYS: (sshKeys: SshKeyResource[]) => {
return { ...state, sshKeys };
import { Dispatch } from 'redux';
import { RootState } from '~/store/store';
+import { getUserUuid } from "~/common/getuser";
import { Breadcrumb } from '~/components/breadcrumbs/breadcrumbs';
import { getResource } from '~/store/resources/resources';
import { TreePicker } from '../tree-picker/tree-picker';
const path = getState().router.location!.pathname;
const currentUuid = path.split('/')[2];
const uuidKind = extractUuidKind(currentUuid);
-
+
if (uuidKind === ResourceKind.COLLECTION) {
const collectionItem = await services.collectionService.get(currentUuid);
dispatch(setBreadcrumbs(breadcrumbs, collectionItem));
export const setProjectBreadcrumbs = (uuid: string) =>
(dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
const ancestors = getSidePanelTreeNodeAncestorsIds(uuid)(getState().treePicker);
- const rootUuid = services.authService.getUuid();
+ const rootUuid = getUserUuid(getState());
if (uuid === rootUuid || ancestors.find(uuid => uuid === rootUuid)) {
dispatch(setSidePanelBreadcrumbs(uuid));
} else {
import { MiddlewareAPI, Dispatch } from 'redux';
import { DataExplorerMiddlewareService } 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';
}
try {
api.dispatch(progressIndicatorActions.START_WORKING(this.getId()));
- const userUuid = api.getState().auth.user!.uuid;
+ const userUuid = getUserUuid(api.getState());
const pathname = api.getState().router.location!.pathname;
const contentAddress = pathname.split('/')[2];
const response = await this.services.collectionService.list({
.addIn('uuid', groupUuids)
.getFilters()
});
- responseUsers.items.map(it=>{
- api.dispatch<any>(ownerNameActions.SET_OWNER_NAME({name: it.uuid === userUuid ? 'User: Me' : `User: ${it.firstName} ${it.lastName}`, uuid: it.uuid}));
+ responseUsers.items.map(it => {
+ api.dispatch<any>(ownerNameActions.SET_OWNER_NAME({ name: it.uuid === userUuid ? 'User: Me' : `User: ${it.firstName} ${it.lastName}`, uuid: it.uuid }));
});
- responseGroups.items.map(it=>{
- api.dispatch<any>(ownerNameActions.SET_OWNER_NAME({name: `Project: ${it.name}`, uuid: it.uuid}));
+ responseGroups.items.map(it => {
+ api.dispatch<any>(ownerNameActions.SET_OWNER_NAME({ name: `Project: ${it.name}`, uuid: it.uuid }));
});
api.dispatch<any>(setBreadcrumbs([{ label: 'Projects', uuid: userUuid }]));
api.dispatch<any>(updateFavorites(response.items.map(item => item.uuid)));
snackbarActions.OPEN_SNACKBAR({
message: 'Could not fetch collection with this content address.',
kind: SnackbarKind.ERROR
- });
\ No newline at end of file
+ });
import { Dispatch } from "redux";
import { reset, startSubmit, stopSubmit, initialize, FormErrors } from 'redux-form';
import { RootState } from '~/store/store';
+import { getUserUuid } from "~/common/getuser";
import { dialogActions } from "~/store/dialog/dialog-actions";
import { ServiceRepository } from '~/services/services';
import { getCommonResourceServiceError, CommonResourceServiceError } from "~/services/common-service/common-resource-service";
const router = getState();
const properties = getState().properties;
if (isItemNotInProject(properties) || !isProjectOrRunProcessRoute(router)) {
- const userUuid = getState().auth.user!.uuid;
+ const userUuid = getUserUuid(getState());
dispatch(initialize(COLLECTION_CREATE_FORM_NAME, { userUuid }));
} else {
dispatch(initialize(COLLECTION_CREATE_FORM_NAME, { ownerUuid }));
import { DataExplorerMiddlewareService } from "~/store/data-explorer/data-explorer-middleware-service";
import { FavoritePanelColumnNames } from "~/views/favorite-panel/favorite-panel";
import { RootState } from "../store";
+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";
const responseLinks = await this.services.linkService.list({
filters: new FilterBuilder()
.addEqual("linkClass", 'star')
- .addEqual('tailUuid', this.services.authService.getUuid()!)
+ .addEqual('tailUuid', getUserUuid(api.getState()))
.addEqual('tailKind', ResourceKind.USER)
.getFilters()
}).then(results => results);
response.itemsAvailable++;
response.items.push(it);
});
-
+
api.dispatch(progressIndicatorActions.PERSIST_STOP_WORKING(this.getId()));
api.dispatch(resourcesActions.SET_RESOURCES(response.items));
await api.dispatch<any>(loadMissingProcessesInformation(response.items));
import { unionize, ofType, UnionOf } from "~/common/unionize";
import { Dispatch } from "redux";
import { RootState } from "../store";
+import { getUserUuid } from "~/common/getuser";
import { checkFavorite } from "./favorites-reducer";
import { snackbarActions, SnackbarKind } from "../snackbar/snackbar-actions";
import { ServiceRepository } from "~/services/services";
export const toggleFavorite = (resource: { uuid: string; name: string }) =>
(dispatch: Dispatch, getState: () => RootState, services: ServiceRepository): Promise<any> => {
+ const userUuid = getUserUuid(getState());
+ if (!userUuid) {
+ return Promise.reject("No user");
+ }
dispatch(progressIndicatorActions.START_WORKING("toggleFavorite"));
- const userUuid = getState().auth.user!.uuid;
dispatch(favoritesActions.TOGGLE_FAVORITE({ resourceUuid: resource.uuid }));
const isFavorite = checkFavorite(resource.uuid, getState().favorites);
dispatch(snackbarActions.OPEN_SNACKBAR({
export const updateFavorites = (resourceUuids: string[]) =>
(dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const userUuid = getState().auth.user!.uuid;
+ const userUuid = getUserUuid(getState());
+ if (!userUuid) {
+ return;
+ }
dispatch(favoritesActions.CHECK_PRESENCE_IN_FAVORITES(resourceUuids));
services.favoriteService
.checkPresenceInFavorites(userUuid, resourceUuids)
import { Dispatch } from "redux";
import { RootState } from "~/store/store";
+import { getUserUuid } from "~/common/getuser";
import { ServiceRepository, createServices, setAuthorizationHeader } from "~/services/services";
import { setBreadcrumbs } from "~/store/breadcrumbs/breadcrumbs-actions";
import { snackbarActions, SnackbarKind } from "~/store/snackbar/snackbar-actions";
const svc = createServices(config, { progressFn: () => { }, errorFn: () => { } });
setAuthorizationHeader(svc, token);
return svc;
-}
+};
export const checkForLinkStatus = () =>
(dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
export const startLinking = (t: LinkAccountType) =>
(dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
- const accountToLink = { type: t, userUuid: services.authService.getUuid(), token: services.authService.getApiToken() } as AccountToLink;
+ const accountToLink = { type: t, userUuid: getUserUuid(getState()), token: services.authService.getApiToken() } as AccountToLink;
services.linkAccountService.saveAccountToLink(accountToLink);
const auth = getState().auth;
export const loadMyAccountPanel = () =>
(dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
- dispatch(setBreadcrumbs([{ label: 'User profile'}]));
+ dispatch(setBreadcrumbs([{ label: 'User profile' }]));
};
export const saveEditedUser = (resource: any) =>
async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
try {
await services.userService.update(resource.uuid, resource);
- services.authService.saveUser(resource);
dispatch(authActions.USER_DETAILS_SUCCESS(resource));
dispatch(initialize(MY_ACCOUNT_FORM, resource));
dispatch(snackbarActions.OPEN_SNACKBAR({ message: "Profile has been updated.", hideDuration: 2000, kind: SnackbarKind.SUCCESS }));
- } catch(e) {
+ } catch (e) {
return;
}
};
import { Dispatch } from "redux";
import { RootState } from "~/store/store";
+import { getUserUuid } from "~/common/getuser";
import { ServiceRepository } from "~/services/services";
import { mockProjectResource } from "~/models/test-utils";
import { treePickerActions, receiveTreePickerProjectsData } from "~/store/tree-picker/tree-picker-actions";
import { TreePickerId } from '~/models/tree';
export const resetPickerProjectTree = () => (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- dispatch<any>(treePickerActions.RESET_TREE_PICKER({pickerId: TreePickerId.PROJECTS}));
- dispatch<any>(treePickerActions.RESET_TREE_PICKER({pickerId: TreePickerId.SHARED_WITH_ME}));
- dispatch<any>(treePickerActions.RESET_TREE_PICKER({pickerId: TreePickerId.FAVORITES}));
+ dispatch<any>(treePickerActions.RESET_TREE_PICKER({ pickerId: TreePickerId.PROJECTS }));
+ dispatch<any>(treePickerActions.RESET_TREE_PICKER({ pickerId: TreePickerId.SHARED_WITH_ME }));
+ dispatch<any>(treePickerActions.RESET_TREE_PICKER({ pickerId: TreePickerId.FAVORITES }));
dispatch<any>(initPickerProjectTree());
};
export const initPickerProjectTree = () => (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const uuid = services.authService.getUuid();
+ const uuid = getUserUuid(getState());
dispatch<any>(getPickerTreeProjects(uuid));
dispatch<any>(getSharedWithMeProjectsPickerTree(uuid));
[mockProjectResource({ uuid, name: kind })],
kind
);
-};
\ No newline at end of file
+};
import { Dispatch } from "redux";
import { reset, startSubmit, stopSubmit, initialize, FormErrors, formValueSelector, change } from 'redux-form';
import { RootState } from '~/store/store';
+import { getUserUuid } from "~/common/getuser";
import { dialogActions } from "~/store/dialog/dialog-actions";
import { getCommonResourceServiceError, CommonResourceServiceError } from '~/services/common-service/common-resource-service';
import { ProjectResource } from '~/models/project';
if (properties.breadcrumbs) {
return Boolean(properties.breadcrumbs[0].label !== 'Projects');
} else {
- return ;
+ return;
}
};
const router = getState();
const properties = getState().properties;
if (isItemNotInProject(properties) || !isProjectOrRunProcessRoute(router)) {
- const userUuid = getState().auth.user!.uuid;
+ const userUuid = getUserUuid(getState());
dispatch(initialize(PROJECT_CREATE_FORM_NAME, { userUuid }));
} else {
dispatch(initialize(PROJECT_CREATE_FORM_NAME, { ownerUuid }));
(dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
const properties = { ...PROJECT_CREATE_FORM_SELECTOR(getState(), 'properties') };
properties[data.key] = data.value;
- dispatch(change(PROJECT_CREATE_FORM_NAME, 'properties', properties ));
+ dispatch(change(PROJECT_CREATE_FORM_NAME, 'properties', properties));
};
export const removePropertyFromCreateProjectForm = (key: string) =>
(dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
const properties = { ...PROJECT_CREATE_FORM_SELECTOR(getState(), 'properties') };
delete properties[key];
- dispatch(change(PROJECT_CREATE_FORM_NAME, 'properties', properties ));
- };
\ No newline at end of file
+ dispatch(change(PROJECT_CREATE_FORM_NAME, 'properties', properties));
+ };
import { startSubmit, stopSubmit, initialize, FormErrors } from 'redux-form';
import { ServiceRepository } from '~/services/services';
import { RootState } from '~/store/store';
+import { getUserUuid } from "~/common/getuser";
import { getCommonResourceServiceError, CommonResourceServiceError } from "~/services/common-service/common-resource-service";
import { MoveToFormDialogData } from '~/store/move-to-dialog/move-to-dialog';
import { resetPickerProjectTree } from '~/store/project-tree-picker/project-tree-picker-actions';
export const moveProject = (resource: MoveToFormDialogData) =>
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const userUuid = getState().auth.user!.uuid;
+ const userUuid = getUserUuid(getState());
+ if (!userUuid) {
+ return;
+ }
dispatch(startSubmit(PROJECT_MOVE_FORM_NAME));
try {
const newProject = await services.projectService.update(resource.uuid, { ownerUuid: resource.ownerUuid });
import { Dispatch } from "redux";
import { bindDataExplorerActions } from '~/store/data-explorer/data-explorer-action';
import { RootState } from '~/store/store';
+import { getUserUuid } from "~/common/getuser";
import { ServiceRepository } from "~/services/services";
import { navigateToRepositories } from "~/store/navigation/navigation-action";
import { unionize, ofType, UnionOf } from "~/common/unionize";
export const openRepositoryCreateDialog = () =>
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const userUuid = await services.authService.getUuid();
+ const userUuid = getUserUuid(getState());
const user = await services.userService.get(userUuid!);
dispatch(reset(REPOSITORY_CREATE_FORM_NAME));
dispatch(dialogActions.OPEN_DIALOG({ id: REPOSITORY_CREATE_FORM_NAME, data: { user } }));
export const createRepository = (repository: RepositoryResource) =>
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const userUuid = await services.authService.getUuid();
+ const userUuid = getUserUuid(getState());
const user = await services.userService.get(userUuid!);
dispatch(startSubmit(REPOSITORY_CREATE_FORM_NAME));
try {
import { unionize, ofType, UnionOf } from "~/common/unionize";
import { ServiceRepository } from "~/services/services";
import { RootState } from '~/store/store';
+import { getUserUuid } from "~/common/getuser";
import { WorkflowResource, getWorkflowInputs, parseWorkflowDefinition } from '~/models/workflow';
import { getFormValues, initialize } from 'redux-form';
import { RUN_PROCESS_BASIC_FORM, RunProcessBasicFormData } from '~/views/run-process-panel/run-process-basic-form';
const basicForm = getFormValues(RUN_PROCESS_BASIC_FORM)(state) as RunProcessBasicFormData;
const inputsForm = getFormValues(RUN_PROCESS_INPUTS_FORM)(state) as WorkflowInputsData;
const advancedForm = getFormValues(RUN_PROCESS_ADVANCED_FORM)(state) as RunProcessAdvancedFormData || DEFAULT_ADVANCED_FORM_VALUES;
- const userUuid = getState().auth.user!.uuid;
+ const userUuid = getUserUuid(getState());
const pathname = getState().runProcessPanel.processPathname;
const { processOwnerUuid, selectedWorkflow } = state.runProcessPanel;
if (selectedWorkflow) {
import { getNode, getNodeAncestorsIds, initTreeNode, TreeNodeStatus } from "~/models/tree";
import { Dispatch } from "redux";
import { RootState } from "~/store/store";
+import { getUserUuid } from "~/common/getuser";
import { ServiceRepository } from "~/services/services";
import { treePickerActions } from "~/store/tree-picker/tree-picker-actions";
import { FilterBuilder } from "~/services/api/filter-builder";
};
export const activateSearchBarTreeBranch = (id: string) =>
- async (dispatch: Dispatch, _: void, services: ServiceRepository) => {
- const ancestors = await services.ancestorsService.ancestors(id, services.authService.getUuid() || '');
+ async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
+ const userUuid = getUserUuid(getState());
+ if (!userUuid) {
+ return;
+ }
+ const ancestors = await services.ancestorsService.ancestors(id, userUuid);
for (const ancestor of ancestors) {
await dispatch<any>(loadSearchBarTreeProjects(ancestor.uuid));
}));
dispatch(resourcesActions.SET_RESOURCES(items));
};
-
import { Dispatch } from 'redux';
import { treePickerActions } from "~/store/tree-picker/tree-picker-actions";
import { RootState } from '~/store/store';
+import { getUserUuid } from "~/common/getuser";
import { ServiceRepository } from '~/services/services';
import { FilterBuilder } from '~/services/api/filter-builder';
import { resourcesActions } from '~/store/resources/resources-actions';
export const isSidePanelTreeCategory = (id: string) => SIDE_PANEL_CATEGORIES.some(category => category === id);
export const initSidePanelTree = () =>
- (dispatch: Dispatch, _: () => RootState, { authService }: ServiceRepository) => {
- const rootProjectUuid = authService.getUuid() || '';
+ (dispatch: Dispatch, getState: () => RootState, { authService }: ServiceRepository) => {
+ const rootProjectUuid = getUserUuid(getState());
+ if (!rootProjectUuid) {
+ return;
+ }
const nodes = SIDE_PANEL_CATEGORIES.map(id => initTreeNode({ id, value: id }));
const projectsNode = initTreeNode({ id: rootProjectUuid, value: SidePanelTreeCategory.PROJECTS });
const sharedNode = initTreeNode({ id: SidePanelTreeCategory.SHARED_WITH_ME, value: SidePanelTreeCategory.SHARED_WITH_ME });
};
export const activateSidePanelTreeBranch = (id: string) =>
- async (dispatch: Dispatch, _: void, services: ServiceRepository) => {
- const ancestors = await services.ancestorsService.ancestors(id, services.authService.getUuid() || '');
- const isShared = ancestors.every(({ uuid }) => uuid !== services.authService.getUuid());
+ async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
+ const userUuid = getUserUuid(getState());
+ if (!userUuid) {
+ return;
+ }
+ const ancestors = await services.ancestorsService.ancestors(id, userUuid);
+ const isShared = ancestors.every(({ uuid }) => uuid !== userUuid);
if (isShared) {
await dispatch<any>(loadSidePanelTreeProjects(SidePanelTreeCategory.SHARED_WITH_ME));
}
import { treePickerReducer } from './tree-picker/tree-picker-reducer';
import { resourcesReducer } from '~/store/resources/resources-reducer';
import { propertiesReducer } from './properties/properties-reducer';
-import { RootState } from './store';
import { fileUploaderReducer } from './file-uploader/file-uploader-reducer';
import { TrashPanelMiddlewareService } from "~/store/trash-panel/trash-panel-middleware-service";
import { TRASH_PANEL_ID } from "~/store/trash-panel/trash-panel-action";
listResultsToDataExplorerItemsMeta
} from "../data-explorer/data-explorer-middleware-service";
import { RootState } from "../store";
+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";
.addOrder(sortDirection, columnName, GroupContentsResourcePrefix.PROJECT);
}
+ const userUuid = getUserUuid(api.getState());
+ if (!userUuid) {
+ return;
+ }
try {
api.dispatch(progressIndicatorActions.START_WORKING(this.getId()));
- const userUuid = this.services.authService.getUuid()!;
const listResults = await this.services.groupsService
.contents(userUuid, {
...dataExplorerToListParams(dataExplorer),
message: 'Could not fetch trash contents.',
kind: SnackbarKind.ERROR
});
-
import { TreeNode, initTreeNode, getNodeDescendants, TreeNodeStatus, getNode, TreePickerId, Tree } from '~/models/tree';
import { Dispatch } from 'redux';
import { RootState } from '~/store/store';
+import { getUserUuid } from "~/common/getuser";
import { ServiceRepository } from '~/services/services';
import { FilterBuilder } from '~/services/api/filter-builder';
import { pipe, values } from 'lodash/fp';
export const initUserProject = (pickerId: string) =>
async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
- const uuid = services.authService.getUuid();
+ const uuid = getUserUuid(getState());
if (uuid) {
dispatch(receiveTreePickerData({
id: '',
};
export const loadUserProject = (pickerId: string, includeCollections = false, includeFiles = false) =>
async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
- const uuid = services.authService.getUuid();
+ const uuid = getUserUuid(getState());
if (uuid) {
dispatch(loadProject({ id: uuid, pickerId, includeCollections, includeFiles }));
}
export const loadFavoritesProject = (params: LoadFavoritesProjectParams) =>
async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
const { pickerId, includeCollections = false, includeFiles = false } = params;
- const uuid = services.authService.getUuid();
+ const uuid = getUserUuid(getState());
if (uuid) {
const filters = pipe(
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id, pickerId: TreePickerId.PROJECTS }));
- const ownerUuid = id.length === 0 ? services.authService.getUuid() || '' : id;
+
+ const ownerUuid = id.length === 0 ? getUserUuid(getState()) || '' : id;
const { items } = await services.projectService.list(buildParams(ownerUuid));
dispatch<any>(receiveTreePickerProjectsData(id, items, TreePickerId.PROJECTS));
export const loadFavoriteTreePickerProjects = (id: string) =>
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const parentId = services.authService.getUuid() || '';
+ const parentId = getUserUuid(getState()) || '';
if (id === '') {
dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id: parentId, pickerId: TreePickerId.FAVORITES }));
export const loadPublicFavoriteTreePickerProjects = (id: string) =>
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const parentId = services.authService.getUuid() || '';
+ const parentId = getUserUuid(getState()) || '';
if (id === '') {
dispatch(treePickerActions.LOAD_TREE_PICKER_NODE({ id: parentId, pickerId: TreePickerId.PUBLIC_FAVORITES }));
.addAsc('name')
.getOrder()
};
-};
\ No newline at end of file
+};
import { Dispatch } from "redux";
import { bindDataExplorerActions } from '~/store/data-explorer/data-explorer-action';
import { RootState } from '~/store/store';
+import { getUserUuid } from "~/common/getuser";
import { ServiceRepository } from "~/services/services";
import { dialogActions } from '~/store/dialog/dialog-actions';
import { startSubmit, reset } from "redux-form";
dispatch<any>(authActions.INIT({ user: data, token: `v2/${client.uuid}/${client.apiToken}` }));
location.reload();
dispatch<any>(navigateToRootProject);
- }
+ }
};
export const openUserCreateDialog = () =>
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const userUuid = await services.authService.getUuid();
+ const userUuid = getUserUuid(getState());
const user = await services.userService.get(userUuid!);
const virtualMachines = await services.virtualMachineService.list();
dispatch(reset(USER_CREATE_FORM_NAME));
import { Dispatch } from 'redux';
import { RootState } from "~/store/store";
+import { getUserUuid } from "~/common/getuser";
import { loadDetailsPanel } from '~/store/details-panel/details-panel-action';
import { snackbarActions, SnackbarKind } from '~/store/snackbar/snackbar-actions';
import { favoritePanelActions, loadFavoritePanel } from '~/store/favorite-panel/favorite-panel-action';
export const loadProject = (uuid: string) =>
handleFirstTimeLoad(
async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
- const userUuid = services.authService.getUuid();
+ const userUuid = getUserUuid(getState());
dispatch(setIsProjectPanelTrashed(false));
if (userUuid) {
if (extractUuidKind(uuid) === ResourceKind.USER && userUuid !== uuid) {
export const loadCollection = (uuid: string) =>
handleFirstTimeLoad(
async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
- const userUuid = services.authService.getUuid();
+ const userUuid = getUserUuid(getState());
if (userUuid) {
const match = await loadGroupContentsResource({ uuid, userUuid, services });
match({
import { ListItemTextIcon } from "~/components/list-item-text-icon/list-item-text-icon";
import { ProjectIcon, FavoriteIcon, ProjectsIcon, ShareMeIcon, PublicFavoriteIcon } from '~/components/icon/icon';
import { RootState } from "~/store/store";
+import { getUserUuid } from "~/common/getuser";
import { ServiceRepository } from "~/services/services";
import { WrappedFieldProps } from 'redux-form';
import { TreePickerId } from '~/models/tree';
if (pickerId === TreePickerId.PROJECTS) {
dispatch<any>(loadProjectTreePickerProjects(id));
} else if (pickerId === TreePickerId.FAVORITES) {
- dispatch<any>(loadFavoriteTreePickerProjects(id === services.authService.getUuid() ? '' : id));
+ dispatch<any>(loadFavoriteTreePickerProjects(id === getUserUuid(getState()) ? '' : id));
} else if (pickerId === TreePickerId.PUBLIC_FAVORITES) {
- dispatch<any>(loadPublicFavoriteTreePickerProjects(id === services.authService.getUuid() ? '' : id));
+ dispatch<any>(loadPublicFavoriteTreePickerProjects(id === getUserUuid(getState()) ? '' : id));
// TODO: load sharedWithMe
}
} else {
<Typography variant='caption' color='error'>
{props.meta.error}
</Typography>}
- </div>;
\ No newline at end of file
+ </div>;
import { RootState } from '~/store/store';
import { Dispatch } from 'redux';
import { connect } from 'react-redux';
-import { startLinking, cancelLinking, linkAccount, linkAccountPanelActions } from '~/store/link-account-panel/link-account-panel-actions';
+import { startLinking, linkAccount, linkAccountPanelActions, cancelLinking } from '~/store/link-account-panel/link-account-panel-actions';
import { LinkAccountType } from '~/models/link-account';
import {
LinkAccountPanelRoot,