import { RepositoryResource } from '~/models/repositories';
import { SshKeyResource } from '~/models/ssh-key';
import { VirtualMachinesResource } from '~/models/virtual-machines';
+import { UserResource } from '~/models/user';
+import { ListResults } from '~/services/common-service/common-resource-service';
+import { LinkResource } from '~/models/link';
export const ADVANCED_TAB_DIALOG = 'advancedTabDialog';
interface AdvancedTabDialogData {
apiResponse: any;
- metadata: any;
- user: string;
+ metadata: ListResults<LinkResource> | string;
+ user: UserResource | string;
pythonHeader: string;
pythonExample: string;
cliGetHeader: string;
CREATED_AT = 'created_at'
}
+enum ResourcePrefix {
+ REPOSITORIES = 'repositories',
+ AUTORIZED_KEYS = 'authorized_keys',
+ VIRTUAL_MACHINES = 'virtual_machines'
+}
+
type AdvanceResourceKind = CollectionData | ProcessData | ProjectData | RepositoryData | SshKeyData | VirtualMachineData;
-type AdvanceResourcePrefix = GroupContentsResourcePrefix | 'repositories' | 'authorized_keys' | 'virtual_machines';
+type AdvanceResourcePrefix = GroupContentsResourcePrefix | ResourcePrefix;
-export const openAdvancedTabDialog = (uuid: string, index?: number) =>
+export const openAdvancedTabDialog = (uuid: string) =>
async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
const kind = extractUuidKind(uuid);
switch (kind) {
case ResourceKind.COLLECTION:
const { data: dataCollection, metadata: metaCollection, user: userCollection } = await dispatch<any>(getDataForAdvancedTab(uuid));
- const advanceDataCollection: AdvancedTabDialogData = advancedTabData(uuid, metaCollection, userCollection, collectionApiResponse, dataCollection, CollectionData.COLLECTION, GroupContentsResourcePrefix.COLLECTION, CollectionData.STORAGE_CLASSES_CONFIRMED, dataCollection.storageClassesConfirmed);
+ const advanceDataCollection: AdvancedTabDialogData = advancedTabData({
+ uuid,
+ metadata: metaCollection,
+ user: userCollection,
+ apiResponseKind: collectionApiResponse,
+ data: dataCollection,
+ resourceKind: CollectionData.COLLECTION,
+ resourcePrefix: GroupContentsResourcePrefix.COLLECTION,
+ resourceKindProperty: CollectionData.STORAGE_CLASSES_CONFIRMED,
+ property: dataCollection.storageClassesConfirmed
+ });
dispatch<any>(initAdvancedTabDialog(advanceDataCollection));
break;
case ResourceKind.PROCESS:
const { data: dataProcess, metadata: metaProcess, user: userProcess } = await dispatch<any>(getDataForAdvancedTab(uuid));
- const advancedDataProcess: AdvancedTabDialogData = advancedTabData(uuid, metaProcess, userProcess, containerRequestApiResponse, dataProcess, ProcessData.CONTAINER_REQUEST, GroupContentsResourcePrefix.PROCESS, ProcessData.OUTPUT_NAME, dataProcess.outputName);
+ const advancedDataProcess: AdvancedTabDialogData = advancedTabData({
+ uuid,
+ metadata: metaProcess,
+ user: userProcess,
+ apiResponseKind: containerRequestApiResponse,
+ data: dataProcess,
+ resourceKind: ProcessData.CONTAINER_REQUEST,
+ resourcePrefix: GroupContentsResourcePrefix.PROCESS,
+ resourceKindProperty: ProcessData.OUTPUT_NAME,
+ property: dataProcess.outputName
+ });
dispatch<any>(initAdvancedTabDialog(advancedDataProcess));
break;
case ResourceKind.PROJECT:
const { data: dataProject, metadata: metaProject, user: userProject } = await dispatch<any>(getDataForAdvancedTab(uuid));
- const advanceDataProject: AdvancedTabDialogData = advancedTabData(uuid, metaProject, userProject, groupRequestApiResponse, dataProject, ProjectData.GROUP, GroupContentsResourcePrefix.PROJECT, ProjectData.DELETE_AT, dataProject.deleteAt);
+ const advanceDataProject: AdvancedTabDialogData = advancedTabData({
+ uuid,
+ metadata: metaProject,
+ user: userProject,
+ apiResponseKind: groupRequestApiResponse,
+ data: dataProject,
+ resourceKind: ProjectData.GROUP,
+ resourcePrefix: GroupContentsResourcePrefix.PROJECT,
+ resourceKindProperty: ProjectData.DELETE_AT,
+ property: dataProject.deleteAt
+ });
dispatch<any>(initAdvancedTabDialog(advanceDataProject));
break;
case ResourceKind.REPOSITORY:
- const dataRepository = getState().repositories.items[index!];
- const advanceDataRepository: AdvancedTabDialogData = advancedTabData(uuid, '', '', repositoryApiResponse, dataRepository, RepositoryData.REPOSITORY, 'repositories', RepositoryData.CREATED_AT, dataRepository.createdAt);
+ const dataRepository = getState().repositories.items.find(it => it.uuid === uuid);
+ const advanceDataRepository: AdvancedTabDialogData = advancedTabData({
+ uuid,
+ metadata: '',
+ user: '',
+ apiResponseKind: repositoryApiResponse,
+ data: dataRepository,
+ resourceKind: RepositoryData.REPOSITORY,
+ resourcePrefix: ResourcePrefix.REPOSITORIES,
+ resourceKindProperty: RepositoryData.CREATED_AT,
+ property: dataRepository!.createdAt
+ });
dispatch<any>(initAdvancedTabDialog(advanceDataRepository));
break;
case ResourceKind.SSH_KEY:
- const dataSshKey = getState().auth.sshKeys[index!];
- const advanceDataSshKey: AdvancedTabDialogData = advancedTabData(uuid, '', '', sshKeyApiResponse, dataSshKey, SshKeyData.SSH_KEY, 'authorized_keys', SshKeyData.CREATED_AT, dataSshKey.createdAt);
+ const dataSshKey = getState().auth.sshKeys.find(it => it.uuid === uuid);
+ const advanceDataSshKey: AdvancedTabDialogData = advancedTabData({
+ uuid,
+ metadata: '',
+ user: '',
+ apiResponseKind: sshKeyApiResponse,
+ data: dataSshKey,
+ resourceKind: SshKeyData.SSH_KEY,
+ resourcePrefix: ResourcePrefix.AUTORIZED_KEYS,
+ resourceKindProperty: SshKeyData.CREATED_AT,
+ property: dataSshKey!.createdAt
+ });
dispatch<any>(initAdvancedTabDialog(advanceDataSshKey));
break;
case ResourceKind.VIRTUAL_MACHINE:
- const dataVirtualMachine = getState().virtualMachines.virtualMachines.items[index!];
- const advanceDataVirtualMachine: AdvancedTabDialogData = advancedTabData(uuid, '', '', virtualMachineApiResponse, dataVirtualMachine, VirtualMachineData.VIRTUAL_MACHINE, 'virtual_machines', VirtualMachineData.CREATED_AT, dataVirtualMachine.createdAt);
+ const dataVirtualMachine = getState().virtualMachines.virtualMachines.items.find(it => it.uuid === uuid);
+ const advanceDataVirtualMachine: AdvancedTabDialogData = advancedTabData({
+ uuid,
+ metadata: '',
+ user: '',
+ apiResponseKind: virtualMachineApiResponse,
+ data: dataVirtualMachine,
+ resourceKind: VirtualMachineData.VIRTUAL_MACHINE,
+ resourcePrefix: ResourcePrefix.VIRTUAL_MACHINES,
+ resourceKindProperty: VirtualMachineData.CREATED_AT,
+ property: dataVirtualMachine.createdAt
+ });
dispatch<any>(initAdvancedTabDialog(advanceDataVirtualMachine));
break;
default:
const initAdvancedTabDialog = (data: AdvancedTabDialogData) => dialogActions.OPEN_DIALOG({ id: ADVANCED_TAB_DIALOG, data });
-const advancedTabData = (uuid: string, metadata: any, user: any, apiResponseKind: any, data: any, resourceKind: AdvanceResourceKind,
- resourcePrefix: AdvanceResourcePrefix, resourceKindProperty: AdvanceResourceKind, property: any) => {
+const advancedTabData = (args: {
+ uuid: string, metadata: ListResults<LinkResource> | string, user: UserResource | string, apiResponseKind: any, data: any, resourceKind: AdvanceResourceKind,
+ resourcePrefix: AdvanceResourcePrefix, resourceKindProperty: AdvanceResourceKind, property: any
+}) => {
return {
- uuid,
- user,
- metadata,
- apiResponse: apiResponseKind(data),
- pythonHeader: pythonHeader(resourceKind),
- pythonExample: pythonExample(uuid, resourcePrefix),
- cliGetHeader: cliGetHeader(resourceKind),
- cliGetExample: cliGetExample(uuid, resourceKind),
- cliUpdateHeader: cliUpdateHeader(resourceKind, resourceKindProperty),
- cliUpdateExample: cliUpdateExample(uuid, resourceKind, property, resourceKindProperty),
- curlHeader: curlHeader(resourceKind, resourceKindProperty),
- curlExample: curlExample(uuid, resourcePrefix, property, resourceKind, resourceKindProperty),
+ uuid: args.uuid,
+ user: args.user,
+ metadata: args.metadata,
+ apiResponse: args.apiResponseKind(args.data),
+ pythonHeader: pythonHeader(args.resourceKind),
+ pythonExample: pythonExample(args.uuid, args.resourcePrefix),
+ cliGetHeader: cliGetHeader(args.resourceKind),
+ cliGetExample: cliGetExample(args.uuid, args.resourceKind),
+ cliUpdateHeader: cliUpdateHeader(args.resourceKind, args.resourceKindProperty),
+ cliUpdateExample: cliUpdateExample(args.uuid, args.resourceKind, args.property, args.resourceKindProperty),
+ curlHeader: curlHeader(args.resourceKind, args.resourceKindProperty),
+ curlExample: curlExample(args.uuid, args.resourcePrefix, args.property, args.resourceKind, args.resourceKindProperty),
};
};
export const openPublicKeyDialog = (name: string, publicKey: string) =>
dialogActions.OPEN_DIALOG({ id: SSH_KEY_PUBLIC_KEY_DIALOG, data: { name, publicKey } });
-export const openSshKeyAttributesDialog = (index: number) =>
+export const openSshKeyAttributesDialog = (uuid: string) =>
(dispatch: Dispatch, getState: () => RootState) => {
- const sshKey = getState().auth.sshKeys[index];
+ const sshKey = getState().auth.sshKeys.find(it => it.uuid === uuid);
dispatch(dialogActions.OPEN_DIALOG({ id: SSH_KEY_ATTRIBUTES_DIALOG, data: { sshKey } }));
};
}));
};
-export const openRepositoryContextMenu = (event: React.MouseEvent<HTMLElement>, index: number, repository: RepositoryResource) =>
+export const openRepositoryContextMenu = (event: React.MouseEvent<HTMLElement>, repository: RepositoryResource) =>
(dispatch: Dispatch, getState: () => RootState) => {
dispatch<any>(openContextMenu(event, {
name: '',
uuid: repository.uuid,
ownerUuid: repository.ownerUuid,
kind: ResourceKind.REPOSITORY,
- menuKind: ContextMenuKind.REPOSITORY,
- index
+ menuKind: ContextMenuKind.REPOSITORY
}));
};
-export const openVirtualMachinesContextMenu = (event: React.MouseEvent<HTMLElement>, index: number, repository: VirtualMachinesResource) =>
+export const openVirtualMachinesContextMenu = (event: React.MouseEvent<HTMLElement>, repository: VirtualMachinesResource) =>
(dispatch: Dispatch, getState: () => RootState) => {
dispatch<any>(openContextMenu(event, {
name: '',
uuid: repository.uuid,
ownerUuid: repository.ownerUuid,
kind: ResourceKind.VIRTUAL_MACHINE,
- menuKind: ContextMenuKind.VIRTUAL_MACHINE,
- index
+ menuKind: ContextMenuKind.VIRTUAL_MACHINE
}));
};
-export const openSshKeyContextMenu = (event: React.MouseEvent<HTMLElement>, index: number, sshKey: SshKeyResource) =>
+export const openSshKeyContextMenu = (event: React.MouseEvent<HTMLElement>, sshKey: SshKeyResource) =>
(dispatch: Dispatch) => {
dispatch<any>(openContextMenu(event, {
name: '',
uuid: sshKey.uuid,
ownerUuid: sshKey.ownerUuid,
kind: ResourceKind.SSH_KEY,
- menuKind: ContextMenuKind.SSH_KEY,
- index
+ menuKind: ContextMenuKind.SSH_KEY
}));
};
dispatch(dialogActions.OPEN_DIALOG({ id: REPOSITORIES_SAMPLE_GIT_DIALOG, data: { uuidPrefix } }));
};
-export const openRepositoryAttributes = (index: number) =>
+export const openRepositoryAttributes = (uuid: string) =>
(dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const repositoryData = getState().repositories.items[index];
+ const repositoryData = getState().repositories.items.find(it => it.uuid === uuid);
dispatch(dialogActions.OPEN_DIALOG({ id: REPOSITORY_ATTRIBUTES_DIALOG, data: { repositoryData } }));
};
dispatch<any>(navigateToVirtualMachines);
};
-export const openVirtualMachineAttributes = (index: number) =>
+export const openVirtualMachineAttributes = (uuid: string) =>
async (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
- const virtualMachineData = getState().virtualMachines.virtualMachines.items[index];
+ const virtualMachineData = getState().virtualMachines.virtualMachines.items.find(it => it.uuid === uuid);
dispatch(dialogActions.OPEN_DIALOG({ id: VIRTUAL_MACHINE_ATTRIBUTES_DIALOG, data: { virtualMachineData } }));
};
export const repositoryActionSet: ContextMenuActionSet = [[{
name: "Attributes",
icon: AttributesIcon,
- execute: (dispatch, { index }) => {
- dispatch<any>(openRepositoryAttributes(index!));
+ execute: (dispatch, { uuid }) => {
+ dispatch<any>(openRepositoryAttributes(uuid));
}
}, {
name: "Share",
name: "Advanced",
icon: AdvancedIcon,
execute: (dispatch, resource) => {
- dispatch<any>(openAdvancedTabDialog(resource.uuid, resource.index));
+ dispatch<any>(openAdvancedTabDialog(resource.uuid));
}
}, {
name: "Remove",
export const sshKeyActionSet: ContextMenuActionSet = [[{
name: "Attributes",
icon: AttributesIcon,
- execute: (dispatch, { index }) => {
- dispatch<any>(openSshKeyAttributesDialog(index!));
+ execute: (dispatch, { uuid }) => {
+ dispatch<any>(openSshKeyAttributesDialog(uuid));
}
}, {
name: "Advanced",
icon: AdvancedIcon,
- execute: (dispatch, { uuid, index }) => {
- dispatch<any>(openAdvancedTabDialog(uuid, index));
+ execute: (dispatch, { uuid }) => {
+ dispatch<any>(openAdvancedTabDialog(uuid));
}
}, {
name: "Remove",
export const virtualMachineActionSet: ContextMenuActionSet = [[{
name: "Attributes",
icon: AttributesIcon,
- execute: (dispatch, { index }) => {
- dispatch<any>(openVirtualMachineAttributes(index!));
+ execute: (dispatch, { uuid }) => {
+ dispatch<any>(openVirtualMachineAttributes(uuid));
}
}, {
name: "Advanced",
icon: AdvancedIcon,
- execute: (dispatch, { uuid, index }) => {
- dispatch<any>(openAdvancedTabDialog(uuid, index));
+ execute: (dispatch, { uuid }) => {
+ dispatch<any>(openAdvancedTabDialog(uuid));
}
}, {
name: "Remove",
import { WithDialogProps } from "~/store/dialog/with-dialog";
import { withDialog } from '~/store/dialog/with-dialog';
import { VIRTUAL_MACHINE_ATTRIBUTES_DIALOG } from "~/store/virtual-machines/virtual-machines-actions";
-import { StyleRulesCallback, WithStyles, withStyles } from '@material-ui/core/styles';
+import { WithStyles, withStyles } from '@material-ui/core/styles';
import { ArvadosTheme } from '~/common/custom-theme';
import { compose } from "redux";
import { VirtualMachinesResource } from "~/models/virtual-machines";
type CssRules = 'rightContainer' | 'leftContainer' | 'spacing';
-const styles: StyleRulesCallback<CssRules> = (theme: ArvadosTheme) => ({
+const styles = withStyles<CssRules>((theme: ArvadosTheme) => ({
rightContainer: {
textAlign: 'right',
paddingRight: theme.spacing.unit * 2,
spacing: {
paddingTop: theme.spacing.unit * 2
},
-});
+}));
interface VirtualMachineAttributesDataProps {
virtualMachineData: VirtualMachinesResource;
export const VirtualMachineAttributesDialog = compose(
withDialog(VIRTUAL_MACHINE_ATTRIBUTES_DIALOG),
- withStyles(styles))(
+ styles)(
(props: WithDialogProps<VirtualMachineAttributesProps> & VirtualMachineAttributesProps) =>
<Dialog open={props.open}
onClose={props.closeDialog}
const mapDispatchToProps = (dispatch: Dispatch): Pick<RepositoriesActionProps, 'onOptionsMenuOpen' | 'loadRepositories' | 'openRepositoriesSampleGitDialog' | 'openRepositoryCreateDialog'> => ({
loadRepositories: () => dispatch<any>(loadRepositoriesData()),
- onOptionsMenuOpen: (event, index, repository) => {
- dispatch<any>(openRepositoryContextMenu(event, index, repository));
+ onOptionsMenuOpen: (event, repository) => {
+ dispatch<any>(openRepositoryContextMenu(event, repository));
},
openRepositoriesSampleGitDialog: () => dispatch<any>(openRepositoriesSampleGitDialog()),
openRepositoryCreateDialog: () => dispatch<any>(openRepositoryCreateDialog())
interface RepositoriesActionProps {
loadRepositories: () => void;
- onOptionsMenuOpen: (event: React.MouseEvent<HTMLElement>, index: number, repository: RepositoryResource) => void;
+ onOptionsMenuOpen: (event: React.MouseEvent<HTMLElement>, repository: RepositoryResource) => void;
openRepositoriesSampleGitDialog: () => void;
openRepositoryCreateDialog: () => void;
}
<TableCell className={classes.cloneUrls}>{repository.cloneUrls.join("\n")}</TableCell>
<TableCell className={classes.moreOptions}>
<Tooltip title="More options" disableFocusListener>
- <IconButton onClick={event => onOptionsMenuOpen(event, index, repository)} className={classes.moreOptionsButton}>
+ <IconButton onClick={event => onOptionsMenuOpen(event, repository)} className={classes.moreOptionsButton}>
<MoreOptionsIcon />
</IconButton>
</Tooltip>
export interface SshKeyPanelRootActionProps {
openSshKeyCreateDialog: () => void;
- openRowOptions: (event: React.MouseEvent<HTMLElement>, index: number, sshKey: SshKeyResource) => void;
+ openRowOptions: (event: React.MouseEvent<HTMLElement>, sshKey: SshKeyResource) => void;
openPublicKeyDialog: (name: string, publicKey: string) => void;
}
</TableCell>
<TableCell>
<Tooltip title="More options" disableFocusListener>
- <IconButton onClick={event => openRowOptions(event, index, sshKey)}>
+ <IconButton onClick={event => openRowOptions(event, sshKey)}>
<MoreOptionsIcon />
</IconButton>
</Tooltip>
openSshKeyCreateDialog: () => {
dispatch<any>(openSshKeyCreateDialog());
},
- openRowOptions: (event, index, sshKey) => {
- dispatch<any>(openSshKeyContextMenu(event, index, sshKey));
+ openRowOptions: (event, sshKey) => {
+ dispatch<any>(openSshKeyContextMenu(event, sshKey));
},
openPublicKeyDialog: (name: string, publicKey: string) => {
dispatch<any>(openPublicKeyDialog(name, publicKey));
import { saveRequestedDate, loadVirtualMachinesData } from '~/store/virtual-machines/virtual-machines-actions';
import { RootState } from '~/store/store';
import { ListResults } from '~/services/common-service/common-resource-service';
-import { HelpIcon, MoreOptionsIcon, AddIcon } from '~/components/icon/icon';
+import { HelpIcon, MoreOptionsIcon } from '~/components/icon/icon';
import { VirtualMachineLogins, VirtualMachinesResource } from '~/models/virtual-machines';
import { Routes } from '~/routes/routes';
import { openVirtualMachinesContextMenu } from '~/store/context-menu/context-menu-actions';
const mapDispatchToProps = (dispatch: Dispatch): Pick<VirtualMachinesPanelActionProps, 'loadVirtualMachinesData' | 'saveRequestedDate' | 'onOptionsMenuOpen'> => ({
saveRequestedDate: () => dispatch<any>(saveRequestedDate()),
loadVirtualMachinesData: () => dispatch<any>(loadVirtualMachinesData()),
- onOptionsMenuOpen: (event, index, virtualMachine) => {
- dispatch<any>(openVirtualMachinesContextMenu(event, index, virtualMachine));
+ onOptionsMenuOpen: (event, virtualMachine) => {
+ dispatch<any>(openVirtualMachinesContextMenu(event, virtualMachine));
},
});
interface VirtualMachinesPanelActionProps {
saveRequestedDate: () => void;
loadVirtualMachinesData: () => string;
- onOptionsMenuOpen: (event: React.MouseEvent<HTMLElement>, index: number, virtualMachine: VirtualMachinesResource) => void;
+ onOptionsMenuOpen: (event: React.MouseEvent<HTMLElement>, virtualMachine: VirtualMachinesResource) => void;
}
type VirtualMachineProps = VirtualMachinesPanelActionProps & VirtualMachinesPanelDataProps & WithStyles<CssRules>;
<TableCell>["{props.logins.items[0].username}"]</TableCell>
<TableCell className={props.classes.moreOptions}>
<Tooltip title="More options" disableFocusListener>
- <IconButton onClick={event => props.onOptionsMenuOpen(event, index, it)} className={props.classes.moreOptionsButton}>
+ <IconButton onClick={event => props.onOptionsMenuOpen(event, it)} className={props.classes.moreOptionsButton}>
<MoreOptionsIcon />
</IconButton>
</Tooltip>