# SPDX-License-Identifier: AGPL-3.0
REACT_APP_ARVADOS_CONFIG_URL=/config.json
-REACT_APP_ARVADOS_API_HOST=https://qr1hi.arvadosapi.com
\ No newline at end of file
+REACT_APP_ARVADOS_API_HOST=qr1hi.arvadosapi.com
+HTTPS=true
\ No newline at end of file
export const API_HOST = process.env.REACT_APP_ARVADOS_API_HOST;
-export const serverApi: AxiosInstance = Axios.create({
- baseURL: API_HOST + '/arvados/v1'
-});
+export const authClient: AxiosInstance = Axios.create();
+export const apiClient: AxiosInstance = Axios.create();
export function setServerApiAuthorizationHeader(token: string) {
- serverApi.defaults.headers.common = {
- 'Authorization': `OAuth2 ${token}`
- };}
+ [authClient, apiClient].forEach(client => {
+ client.defaults.headers.common = {
+ Authorization: `OAuth2 ${token}`
+ };
+ });
+}
export function removeServerApiAuthorizationHeader() {
- delete serverApi.defaults.headers.common.Authorization;
+ [authClient, apiClient].forEach(client => {
+ delete client.defaults.headers.common.Authorization;
+ });
}
export const setBaseUrl = (url: string) => {
- serverApi.defaults.baseURL = url + "/arvados/v1";
+ authClient.defaults.baseURL = url;
+ apiClient.defaults.baseURL = url + "/arvados/v1";
};
API_HOST: string;
}
-const defaultConfig: Config = {
- API_HOST: process.env.REACT_APP_ARVADOS_API_HOST || ""
-};
-
export const fetchConfig = () => {
return Axios
.get<Config>(CONFIG_URL + "?nocache=" + (new Date()).getTime())
.then(response => response.data)
- .catch(() => Promise.resolve(defaultConfig));
+ .catch(() => Promise.resolve(getDefaultConfig()))
+ .then(mapConfig);
};
+const mapConfig = (config: Config): Config => ({
+ ...config,
+ API_HOST: addProtocol(config.API_HOST)
+});
+
+const getDefaultConfig = (): Config => ({
+ API_HOST: process.env.REACT_APP_ARVADOS_API_HOST || ""
+});
+
+const addProtocol = (url: string) => `${window.location.protocol}//${url}`;
export const resourceLabel = (type: string) => {
switch (type) {
- case ResourceKind.Collection:
+ case ResourceKind.COLLECTION:
return "Data collection";
- case ResourceKind.Project:
+ case ResourceKind.PROJECT:
return "Project";
- case ResourceKind.Process:
+ case ResourceKind.PROCESS:
return "Process";
default:
return "Unknown";
}
export enum SortDirection {
- Asc = "asc",
- Desc = "desc",
- None = "none"
+ ASC = "asc",
+ DESC = "desc",
+ NONE = "none"
}
export const isColumnConfigurable = <T>(column: DataColumn<T>) => {
export const toggleSortDirection = <T>(column: DataColumn<T>): DataColumn<T> => {
return column.sortDirection
- ? column.sortDirection === SortDirection.Asc
- ? { ...column, sortDirection: SortDirection.Desc }
- : { ...column, sortDirection: SortDirection.Asc }
+ ? column.sortDirection === SortDirection.ASC
+ ? { ...column, sortDirection: SortDirection.DESC }
+ : { ...column, sortDirection: SortDirection.ASC }
: column;
};
export const resetSortDirection = <T>(column: DataColumn<T>): DataColumn<T> => {
- return column.sortDirection ? { ...column, sortDirection: SortDirection.None } : column;
+ return column.sortDirection ? { ...column, sortDirection: SortDirection.NONE } : column;
};
it("passes sorting props to <TableSortLabel />", () => {
const columns: DataColumns<string> = [{
name: "Column 1",
- sortDirection: SortDirection.Asc,
+ sortDirection: SortDirection.ASC,
selected: true,
render: (item) => <Typography>{item}</Typography>
}];
it("passes filter props to <DataTableFilter />", () => {
const columns: DataColumns<string> = [{
name: "Column 1",
- sortDirection: SortDirection.Asc,
+ sortDirection: SortDirection.ASC,
selected: true,
filters: [{ name: "Filter 1", selected: true }],
render: (item) => <Typography>{item}</Typography>
</DataTableFilters>
: sortDirection
? <TableSortLabel
- active={sortDirection !== SortDirection.None}
- direction={sortDirection !== SortDirection.None ? sortDirection : undefined}
+ active={sortDirection !== SortDirection.NONE}
+ direction={sortDirection !== SortDirection.NONE ? sortDirection : undefined}
onClick={() =>
onSortToggle &&
onSortToggle(column)}>
});
export enum TreeItemStatus {
- Initial,
- Pending,
- Loaded
+ INITIAL,
+ PENDING,
+ LOADED
}
export interface TreeItem<T> {
open: boolean;
active: boolean;
status: TreeItemStatus;
- toggled?: boolean;
items?: Array<TreeItem<T>>;
}
<ListItem button className={list} style={{ paddingLeft: (level + 1) * 20 }}
onClick={() => toggleItemActive(it.id, it.status)}
onContextMenu={this.handleRowContextMenu(it)}>
- {it.status === TreeItemStatus.Pending ?
+ {it.status === TreeItemStatus.PENDING ?
<CircularProgress size={10} className={loader} /> : null}
<i onClick={() => this.props.toggleItemOpen(it.id, it.status)}
className={toggableIconContainer}>
<ListItemIcon className={this.getToggableIconClassNames(it.open, it.active)}>
- {it.toggled && it.items && it.items.length === 0 ? <span /> : <SidePanelRightArrowIcon />}
+ {it.status !== TreeItemStatus.INITIAL && it.items && it.items.length === 0 ? <span /> : <SidePanelRightArrowIcon />}
</ListItemIcon>
</i>
{render(it, level)}
import { Resource, ResourceKind } from "./resource";
export interface CollectionResource extends Resource {
- kind: ResourceKind.Collection;
+ kind: ResourceKind.COLLECTION;
name: string;
description: string;
properties: any;
import { Resource, ResourceKind } from "./resource";
export enum ContainerRequestState {
- Uncommitted = "Uncommitted",
- Committed = "Committed",
- Final = "Final"
+ UNCOMMITTED = "Uncommitted",
+ COMMITTED = "Committed",
+ FINAL = "Final"
}
export interface ContainerRequestResource extends Resource {
- kind: ResourceKind.ContainerRequest;
+ kind: ResourceKind.CONTAINER_REQUEST;
name: string;
description: string;
properties: any;
import { Resource, ResourceKind } from "./resource";
export interface GroupResource extends Resource {
- kind: ResourceKind.Group;
+ kind: ResourceKind.GROUP;
name: string;
groupClass: GroupClass | null;
description: string;
}
export enum GroupClass {
- Project = "project"
+ PROJECT = "project"
}
\ No newline at end of file
import { GroupResource, GroupClass } from "./group";
export interface ProjectResource extends GroupResource {
- groupClass: GroupClass.Project;
+ groupClass: GroupClass.PROJECT;
}
export const getProjectUrl = (uuid: string) => {
}
export enum ResourceKind {
- Collection = "arvados#collection",
- ContainerRequest = "arvados#containerRequest",
- Group = "arvados#group",
- Process = "arvados#containerRequest",
- Project = "arvados#group",
- Workflow = "arvados#workflow"
+ COLLECTION = "arvados#collection",
+ CONTAINER_REQUEST = "arvados#containerRequest",
+ GROUP = "arvados#group",
+ PROCESS = "arvados#containerRequest",
+ PROJECT = "arvados#group",
+ WORKFLOW = "arvados#workflow"
}
groupClass: null,
href: "",
isTrashed: false,
- kind: ResourceKind.Group,
+ kind: ResourceKind.GROUP,
modifiedAt: "",
modifiedByClientUuid: "",
modifiedByUserUuid: "",
});
export const mockProjectResource = (data: Partial<ProjectResource> = {}): ProjectResource =>
- mockGroupResource({ ...data, groupClass: GroupClass.Project }) as ProjectResource;
+ mockGroupResource({ ...data, groupClass: GroupClass.PROJECT }) as ProjectResource;
export const mockCommonResource = (data: Partial<Resource>): Resource => ({
createdAt: "",
import { Resource, ResourceKind } from "./resource";
export interface WorkflowResource extends Resource {
- kind: ResourceKind.Workflow;
+ kind: ResourceKind.WORKFLOW;
name: string;
description: string;
definition: string;
export class AuthService {
- constructor(protected serverApi: AxiosInstance) { }
+ constructor(
+ protected authClient: AxiosInstance,
+ protected apiClient: AxiosInstance) { }
public saveApiToken(token: string) {
localStorage.setItem(API_TOKEN_KEY, token);
public login() {
const currentUrl = `${window.location.protocol}//${window.location.host}/token`;
- window.location.assign(`${API_HOST}/login?return_to=${currentUrl}`);
+ window.location.assign(`${this.authClient.defaults.baseURL || ""}/login?return_to=${currentUrl}`);
}
public logout() {
const currentUrl = `${window.location.protocol}//${window.location.host}`;
- window.location.assign(`${API_HOST}/logout?return_to=${currentUrl}`);
+ window.location.assign(`${this.authClient.defaults.baseURL || ""}/logout?return_to=${currentUrl}`);
}
public getUserDetails = (): Promise<User> => {
- return this.serverApi
+ return this.apiClient
.get<UserDetailsResponse>('/users/current')
.then(resp => ({
email: resp.data.email,
addAsc(attribute: "name") {
const linkOrder = this.linkOrder.addAsc(attribute);
const contentOrder = this.contentOrder
- .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Collection).addAsc(attribute))
- .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Process).addAsc(attribute))
- .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Project).addAsc(attribute));
+ .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.COLLECTION).addAsc(attribute))
+ .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.PROCESS).addAsc(attribute))
+ .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.PROJECT).addAsc(attribute));
return FavoriteOrderBuilder.create(linkOrder, contentOrder);
}
addDesc(attribute: "name") {
const linkOrder = this.linkOrder.addDesc(attribute);
const contentOrder = this.contentOrder
- .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Collection).addDesc(attribute))
- .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Process).addDesc(attribute))
- .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Project).addDesc(attribute));
+ .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.COLLECTION).addDesc(attribute))
+ .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.PROCESS).addDesc(attribute))
+ .concat(OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.PROJECT).addDesc(attribute));
return FavoriteOrderBuilder.create(linkOrder, contentOrder);
}
}
export enum GroupContentsResourcePrefix {
- Collection = "collections",
- Project = "groups",
- Process = "container_requests"
+ COLLECTION = "collections",
+ PROJECT = "groups",
+ PROCESS = "container_requests"
}
export class ProjectService extends GroupsService<ProjectResource> {
create(data: Partial<ProjectResource>) {
- const projectData = { ...data, groupClass: GroupClass.Project };
+ const projectData = { ...data, groupClass: GroupClass.PROJECT };
return super.create(projectData);
}
: FilterBuilder.create())
.concat(FilterBuilder
.create<ProjectResource>()
- .addEqual("groupClass", GroupClass.Project));
+ .addEqual("groupClass", GroupClass.PROJECT));
}
}
import { AuthService } from "./auth-service/auth-service";
import { GroupsService } from "./groups-service/groups-service";
-import { serverApi } from "../common/api/server-api";
+import { authClient, apiClient } from "../common/api/server-api";
import { ProjectService } from "./project-service/project-service";
import { LinkService } from "./link-service/link-service";
import { FavoriteService } from "./favorite-service/favorite-service";
-export const authService = new AuthService(serverApi);
-export const groupsService = new GroupsService(serverApi);
-export const projectService = new ProjectService(serverApi);
-export const linkService = new LinkService(serverApi);
-export const favoriteService = new FavoriteService(linkService, groupsService);
+export const authService = new AuthService(authClient, apiClient);
+export const groupsService = new GroupsService(apiClient);
+export const projectService = new ProjectService(apiClient);
+export const linkService = new LinkService(apiClient);
+export const favoriteService = new FavoriteService(linkService, groupsService);
\ No newline at end of file
USER_OWNER_UUID_KEY,
USER_UUID_KEY
} from "../../services/auth-service/auth-service";
-import { API_HOST } from "../../common/api/server-api";
import 'jest-localstorage-mock';
window.location.assign = jest.fn();
authReducer(initialState, authActions.LOGIN());
expect(window.location.assign).toBeCalledWith(
- `${API_HOST}/login?return_to=${window.location.protocol}//${window.location.host}/token`
+ `/login?return_to=${window.location.protocol}//${window.location.host}/token`
);
});
window.location.assign = jest.fn();
authReducer(initialState, authActions.LOGOUT());
expect(window.location.assign).toBeCalledWith(
- `${API_HOST}/logout?return_to=${location.protocol}//${location.host}`
+ `/logout?return_to=${location.protocol}//${location.host}`
);
});
});
import { unionize, ofType, UnionOf } from "unionize";
import { CommonResourceService } from "../../common/api/common-resource-service";
+import { apiClient } from "../../common/api/server-api";
import { Dispatch } from "redux";
-import { serverApi } from "../../common/api/server-api";
import { ResourceKind } from "../../models/resource";
import { CollectionResource } from "../../models/collection";
export const loadCollection = (uuid: string, kind: ResourceKind) =>
(dispatch: Dispatch) => {
dispatch(collectionPanelActions.LOAD_COLLECTION({ uuid, kind }));
- return new CommonResourceService(serverApi, "collections")
+ return new CommonResourceService(apiClient, "collections")
.get(uuid)
.then(item => {
dispatch(collectionPanelActions.LOAD_COLLECTION_SUCCESS({ item: item as CollectionResource }));
name: "Column 1",
render: jest.fn(),
selected: true,
- sortDirection: SortDirection.Asc
+ sortDirection: SortDirection.ASC
}, {
name: "Column 2",
render: jest.fn(),
selected: true,
- sortDirection: SortDirection.None,
+ sortDirection: SortDirection.NONE,
}];
const state = dataExplorerReducer({ "Data explorer": { ...initialDataExplorer, columns } },
dataExplorerActions.TOGGLE_SORT({ id: "Data explorer", columnName: "Column 2" }));
import { unionize, ofType, UnionOf } from "unionize";
import { CommonResourceService } from "../../common/api/common-resource-service";
import { Dispatch } from "redux";
-import { serverApi } from "../../common/api/server-api";
+import { apiClient } from "../../common/api/server-api";
import { Resource, ResourceKind } from "../../models/resource";
export const detailsPanelActions = unionize({
const getService = (kind: ResourceKind) => {
switch (kind) {
- case ResourceKind.Project:
- return new CommonResourceService(serverApi, "groups");
- case ResourceKind.Collection:
- return new CommonResourceService(serverApi, "collections");
+ case ResourceKind.PROJECT:
+ return new CommonResourceService(apiClient, "groups");
+ case ResourceKind.COLLECTION:
+ return new CommonResourceService(apiClient, "collections");
default:
- return new CommonResourceService(serverApi, "");
+ return new CommonResourceService(apiClient, "");
}
};
limit: dataExplorer.rowsPerPage,
offset: dataExplorer.page * dataExplorer.rowsPerPage,
order: sortColumn!.name === FavoritePanelColumnNames.NAME
- ? sortColumn!.sortDirection === SortDirection.Asc
+ ? sortColumn!.sortDirection === SortDirection.ASC
? order.addDesc("name")
: order.addAsc("name")
: order,
const getOrder = (direction: SortDirection) => {
const order = OrderBuilder.create<LinkResource>();
const addRule = (builder: OrderBuilder<GroupContentsResource | LinkResource>, direction: SortDirection) =>
- direction === SortDirection.Asc
+ direction === SortDirection.ASC
? builder.addAsc("name")
: builder.addDesc("name");
return [
- OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Collection),
- OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Process),
- OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Project)
+ OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.COLLECTION),
+ OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.PROCESS),
+ OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.PROJECT)
].reduce((acc, b) =>
acc.concat(addRule(b, direction)), addRule(OrderBuilder.create(), direction));
};
export const getResourceUrl = <T extends Resource>(resource: T): string => {
switch (resource.kind) {
- case ResourceKind.Project: return getProjectUrl(resource.uuid);
- case ResourceKind.Collection: return getCollectionUrl(resource.uuid);
+ case ResourceKind.PROJECT: return getProjectUrl(resource.uuid);
+ case ResourceKind.COLLECTION: return getCollectionUrl(resource.uuid);
default: return resource.href;
}
};
if (treeItem) {
- if (itemMode === ItemMode.OPEN || itemMode === ItemMode.BOTH) {
- dispatch(projectActions.TOGGLE_PROJECT_TREE_ITEM_OPEN(treeItem.data.uuid));
- }
-
const resourceUrl = getResourceUrl(treeItem.data);
if (itemMode === ItemMode.ACTIVE || itemMode === ItemMode.BOTH) {
dispatch(projectActions.TOGGLE_PROJECT_TREE_ITEM_ACTIVE(treeItem.data.uuid));
}
- const promise = treeItem.status === TreeItemStatus.Loaded
+ const promise = treeItem.status === TreeItemStatus.LOADED
? Promise.resolve()
: dispatch<any>(getProjectList(itemId));
promise
.then(() => dispatch<any>(() => {
+ if (itemMode === ItemMode.OPEN || itemMode === ItemMode.BOTH) {
+ dispatch(projectActions.TOGGLE_PROJECT_TREE_ITEM_OPEN(treeItem.data.uuid));
+ }
dispatch(dataExplorerActions.RESET_PAGINATION({id: PROJECT_PANEL_ID}));
dispatch(dataExplorerActions.REQUEST_ITEMS({id: PROJECT_PANEL_ID}));
}));
const typeFilters = getColumnFilters(columns, ProjectPanelColumnNames.TYPE);
const statusFilters = getColumnFilters(columns, ProjectPanelColumnNames.STATUS);
const sortColumn = dataExplorer.columns.find(({ sortDirection }) => Boolean(sortDirection && sortDirection !== "none"));
- const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.Asc ? SortDirection.Asc : SortDirection.Desc;
+ const sortDirection = sortColumn && sortColumn.sortDirection === SortDirection.ASC ? SortDirection.ASC : SortDirection.DESC;
if (typeFilters.length > 0) {
groupsService
.contents(state.projects.currentItemId, {
.create()
.addIsA("uuid", typeFilters.map(f => f.type)))
.concat(FilterBuilder
- .create<ProcessResource>(GroupContentsResourcePrefix.Process)
+ .create<ProcessResource>(GroupContentsResourcePrefix.PROCESS)
.addIn("state", statusFilters.map(f => f.type)))
.concat(getSearchFilter(dataExplorer.searchValue))
})
const getOrder = (attribute: "name" | "createdAt", direction: SortDirection) =>
[
- OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Collection),
- OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Process),
- OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Project)
+ OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.COLLECTION),
+ OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.PROCESS),
+ OrderBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.PROJECT)
].reduce((acc, b) =>
- acc.concat(direction === SortDirection.Asc
+ acc.concat(direction === SortDirection.ASC
? b.addAsc(attribute)
: b.addDesc(attribute)), OrderBuilder.create());
const getSearchFilter = (searchValue: string) =>
searchValue
? [
- FilterBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Collection),
- FilterBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Process),
- FilterBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.Project)]
+ FilterBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.COLLECTION),
+ FilterBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.PROCESS),
+ FilterBuilder.create<GroupContentsResource>(GroupContentsResourcePrefix.PROJECT)]
.reduce((acc, b) =>
acc.concat(b.addILike("name", searchValue)), FilterBuilder.create())
: FilterBuilder.create();
id: "2",
items: [],
data: mockProjectResource({ uuid: "2" }),
- status: 0
+ status: TreeItemStatus.INITIAL
}
],
currentItemId: "",
id: "1",
open: true,
active: true,
- status: 1
+ status: TreeItemStatus.PENDING
}],
currentItemId: "1",
creator: { opened: false, pending: false, ownerUuid: "" },
id: "1",
open: true,
active: false,
- status: 1
+ status: TreeItemStatus.PENDING
}],
currentItemId: "",
creator: { opened: false, pending: false, ownerUuid: "" },
id: "1",
open: true,
active: false,
- status: 1
+ status: TreeItemStatus.PENDING
}],
currentItemId: "1",
creator: { opened: false, pending: false, ownerUuid: "" }
id: "1",
open: true,
active: true,
- status: 1,
- toggled: true
+ status: TreeItemStatus.PENDING,
}],
currentItemId: "1",
creator: { opened: false, pending: false, ownerUuid: "" },
id: "1",
open: true,
active: false,
- status: 1,
- toggled: false,
+ status: TreeItemStatus.PENDING,
}],
currentItemId: "1",
creator: { opened: false, pending: false, ownerUuid: "" }
id: "1",
open: false,
active: false,
- status: 1,
- toggled: true
+ status: TreeItemStatus.PENDING,
}],
currentItemId: "1",
creator: { opened: false, pending: false, ownerUuid: "" },
active: false,
data: "",
open: false,
- status: TreeItemStatus.Initial
+ status: TreeItemStatus.INITIAL
});
it("should return an array that matches path to the given item", () => {
if (parentItemId) {
treeItem = findTreeItem(tree, parentItemId);
if (treeItem) {
- treeItem.status = TreeItemStatus.Loaded;
+ treeItem.status = TreeItemStatus.LOADED;
}
}
const items = projects.map(p => ({
id: p.uuid,
open: false,
active: false,
- status: TreeItemStatus.Initial,
+ status: TreeItemStatus.INITIAL,
data: p,
items: []
} as TreeItem<ProjectResource>));
const items = _.cloneDeep(state.items);
const item = findTreeItem(items, itemId);
if (item) {
- item.status = TreeItemStatus.Pending;
+ item.status = TreeItemStatus.PENDING;
state.items = items;
}
return { ...state, items };
const items = _.cloneDeep(state.items);
const item = findTreeItem(items, itemId);
if (item) {
- item.toggled = true;
item.open = !item.open;
}
return {
resetTreeActivity(items);
const item = findTreeItem(items, itemId);
if (item) {
- item.toggled = true;
item.active = true;
}
return {
};
export enum SidePanelIdentifiers {
- Projects = "Projects",
- SharedWithMe = "SharedWithMe",
- Workflows = "Workflows",
- RecentOpen = "RecentOpen",
- Favourites = "Favourites",
- Trash = "Trash"
+ PROJECTS = "Projects",
+ SHARED_WITH_ME = "SharedWithMe",
+ WORKFLOWS = "Workflows",
+ RECENT_OPEN = "RecentOpen",
+ FAVORITES = "Favourites",
+ TRASH = "Trash"
}
export const sidePanelData = [
{
- id: SidePanelIdentifiers.Projects,
+ id: SidePanelIdentifiers.PROJECTS,
name: "Projects",
icon: ProjectsIcon,
open: false,
openAble: true
},
{
- id: SidePanelIdentifiers.SharedWithMe,
+ id: SidePanelIdentifiers.SHARED_WITH_ME,
name: "Shared with me",
icon: ShareMeIcon,
active: false,
},
{
- id: SidePanelIdentifiers.Workflows,
+ id: SidePanelIdentifiers.WORKFLOWS,
name: "Workflows",
icon: WorkflowIcon,
active: false,
},
{
- id: SidePanelIdentifiers.RecentOpen,
+ id: SidePanelIdentifiers.RECENT_OPEN,
name: "Recent open",
icon: RecentIcon,
active: false,
},
{
- id: SidePanelIdentifiers.Favourites,
+ id: SidePanelIdentifiers.FAVORITES,
name: "Favorites",
icon: FavoriteIcon,
active: false,
}
},
{
- id: SidePanelIdentifiers.Trash,
+ id: SidePanelIdentifiers.TRASH,
name: "Trash",
icon: TrashIcon,
active: false,
getDetails() {
return <div>
- <DetailsAttribute label='Type' value={resourceLabel(ResourceKind.Collection)} />
+ <DetailsAttribute label='Type' value={resourceLabel(ResourceKind.COLLECTION)} />
<DetailsAttribute label='Size' value='---' />
<DetailsAttribute label='Owner' value={this.item.ownerUuid} />
<DetailsAttribute label='Last modified' value={formatDate(this.item.modifiedAt)} />
const getItem = (resource: DetailsResource): DetailsData => {
const res = resource || { kind: undefined, name: 'Projects' };
switch (res.kind) {
- case ResourceKind.Project:
+ case ResourceKind.PROJECT:
return new ProjectDetails(res);
- case ResourceKind.Collection:
+ case ResourceKind.COLLECTION:
return new CollectionDetails(res);
- case ResourceKind.Process:
+ case ResourceKind.PROCESS:
return new ProcessDetails(res);
default:
return new EmptyDetails(res as EmptyResource);
getDetails() {
return <div>
- <DetailsAttribute label='Type' value={resourceLabel(ResourceKind.Process)} />
+ <DetailsAttribute label='Type' value={resourceLabel(ResourceKind.PROCESS)} />
<DetailsAttribute label='Size' value='---' />
<DetailsAttribute label='Owner' value={this.item.ownerUuid} />
getDetails() {
return <div>
- <DetailsAttribute label='Type' value={resourceLabel(ResourceKind.Project)} />
+ <DetailsAttribute label='Type' value={resourceLabel(ResourceKind.PROJECT)} />
{/* Missing attr */}
<DetailsAttribute label='Size' value='---' />
<DetailsAttribute label='Owner' value={this.item.ownerUuid} />
url: "",
owner: r.ownerUuid,
lastModified: r.modifiedAt,
- status: r.kind === ResourceKind.Process ? r.state : undefined
+ status: r.kind === ResourceKind.PROCESS ? r.state : undefined
};
}
const renderIcon = (item: FavoritePanelItem) => {
switch (item.kind) {
- case ResourceKind.Project:
+ case ResourceKind.PROJECT:
return <ProjectIcon />;
- case ResourceKind.Collection:
+ case ResourceKind.COLLECTION:
return <CollectionIcon />;
- case ResourceKind.Process:
+ case ResourceKind.PROCESS:
return <ProcessIcon />;
default:
return <DefaultIcon />;
{
name: FavoritePanelColumnNames.NAME,
selected: true,
- sortDirection: SortDirection.Asc,
+ sortDirection: SortDirection.ASC,
render: renderName,
width: "450px"
},
selected: true,
filters: [
{
- name: ContainerRequestState.Committed,
+ name: ContainerRequestState.COMMITTED,
selected: true,
- type: ContainerRequestState.Committed
+ type: ContainerRequestState.COMMITTED
},
{
- name: ContainerRequestState.Final,
+ name: ContainerRequestState.FINAL,
selected: true,
- type: ContainerRequestState.Final
+ type: ContainerRequestState.FINAL
},
{
- name: ContainerRequestState.Uncommitted,
+ name: ContainerRequestState.UNCOMMITTED,
selected: true,
- type: ContainerRequestState.Uncommitted
+ type: ContainerRequestState.UNCOMMITTED
}
],
render: renderStatus,
selected: true,
filters: [
{
- name: resourceLabel(ResourceKind.Collection),
+ name: resourceLabel(ResourceKind.COLLECTION),
selected: true,
- type: ResourceKind.Collection
+ type: ResourceKind.COLLECTION
},
{
- name: resourceLabel(ResourceKind.Process),
+ name: resourceLabel(ResourceKind.PROCESS),
selected: true,
- type: ResourceKind.Process
+ type: ResourceKind.PROCESS
},
{
- name: resourceLabel(ResourceKind.Project),
+ name: resourceLabel(ResourceKind.PROJECT),
selected: true,
- type: ResourceKind.Project
+ type: ResourceKind.PROJECT
}
],
render: item => renderType(item.kind),
{
name: FavoritePanelColumnNames.LAST_MODIFIED,
selected: true,
- sortDirection: SortDirection.None,
+ sortDirection: SortDirection.NONE,
render: item => renderDate(item.lastModified),
width: "150px"
}
url: "",
owner: r.ownerUuid,
lastModified: r.modifiedAt,
- status: r.kind === ResourceKind.Process ? r.state : undefined
+ status: r.kind === ResourceKind.PROCESS ? r.state : undefined
};
}
const renderIcon = (item: ProjectPanelItem) => {
switch (item.kind) {
- case ResourceKind.Project:
+ case ResourceKind.PROJECT:
return <ProjectIcon />;
- case ResourceKind.Collection:
+ case ResourceKind.COLLECTION:
return <CollectionIcon />;
- case ResourceKind.Process:
+ case ResourceKind.PROCESS:
return <ProcessIcon />;
default:
return <DefaultIcon />;
{
name: ProjectPanelColumnNames.NAME,
selected: true,
- sortDirection: SortDirection.Asc,
+ sortDirection: SortDirection.ASC,
render: renderName,
width: "450px"
},
selected: true,
filters: [
{
- name: ContainerRequestState.Committed,
+ name: ContainerRequestState.COMMITTED,
selected: true,
- type: ContainerRequestState.Committed
+ type: ContainerRequestState.COMMITTED
},
{
- name: ContainerRequestState.Final,
+ name: ContainerRequestState.FINAL,
selected: true,
- type: ContainerRequestState.Final
+ type: ContainerRequestState.FINAL
},
{
- name: ContainerRequestState.Uncommitted,
+ name: ContainerRequestState.UNCOMMITTED,
selected: true,
- type: ContainerRequestState.Uncommitted
+ type: ContainerRequestState.UNCOMMITTED
}
],
render: renderStatus,
selected: true,
filters: [
{
- name: resourceLabel(ResourceKind.Collection),
+ name: resourceLabel(ResourceKind.COLLECTION),
selected: true,
- type: ResourceKind.Collection
+ type: ResourceKind.COLLECTION
},
{
- name: resourceLabel(ResourceKind.Process),
+ name: resourceLabel(ResourceKind.PROCESS),
selected: true,
- type: ResourceKind.Process
+ type: ResourceKind.PROCESS
},
{
- name: resourceLabel(ResourceKind.Project),
+ name: resourceLabel(ResourceKind.PROJECT),
selected: true,
- type: ResourceKind.Project
+ type: ResourceKind.PROJECT
}
],
render: item => renderType(item.kind),
{
name: ProjectPanelColumnNames.LAST_MODIFIED,
selected: true,
- sortDirection: SortDirection.None,
+ sortDirection: SortDirection.NONE,
render: item => renderDate(item.lastModified),
width: "150px"
}
})}
toggleActive={itemId => {
this.props.dispatch<any>(setProjectItem(itemId, ItemMode.ACTIVE));
- this.props.dispatch<any>(loadDetails(itemId, ResourceKind.Project));
- this.props.dispatch<any>(sidePanelActions.TOGGLE_SIDE_PANEL_ITEM_ACTIVE(SidePanelIdentifiers.Projects));
+ this.props.dispatch<any>(loadDetails(itemId, ResourceKind.PROJECT));
+ this.props.dispatch<any>(sidePanelActions.TOGGLE_SIDE_PANEL_ITEM_ACTIVE(SidePanelIdentifiers.PROJECTS));
}} />
</SidePanel>
</Drawer>}
}
renderCollectionPanel = (props: RouteComponentProps<{ id: string }>) => <CollectionPanel
- onItemRouteChange={(collectionId) => this.props.dispatch<any>(loadCollection(collectionId, ResourceKind.Collection))}
+ onItemRouteChange={(collectionId) => this.props.dispatch<any>(loadCollection(collectionId, ResourceKind.COLLECTION))}
onContextMenu={(event, item) => {
this.openContextMenu(event, {
uuid: item.uuid,
renderProjectPanel = (props: RouteComponentProps<{ id: string }>) => <ProjectPanel
onItemRouteChange={itemId => this.props.dispatch<any>(setProjectItem(itemId, ItemMode.ACTIVE))}
onContextMenu={(event, item) => {
- const kind = item.kind === ResourceKind.Project ? ContextMenuKind.PROJECT : ContextMenuKind.RESOURCE;
+
+ const kind = item.kind === ResourceKind.PROJECT ? ContextMenuKind.PROJECT : ContextMenuKind.RESOURCE;
this.openContextMenu(event, {
uuid: item.uuid,
name: item.name,
}}
onItemDoubleClick={item => {
switch (item.kind) {
- case ResourceKind.Collection:
+ case ResourceKind.COLLECTION:
this.props.dispatch<any>(loadCollection(item.uuid, item.kind as ResourceKind));
this.props.dispatch(push(getCollectionUrl(item.uuid)));
default:
this.props.dispatch<any>(setProjectItem(item.uuid, ItemMode.ACTIVE));
this.props.dispatch<any>(loadDetails(item.uuid, item.kind as ResourceKind));
}
+
}}
{...props} />
renderFavoritePanel = (props: RouteComponentProps<{ id: string }>) => <FavoritePanel
onItemRouteChange={() => this.props.dispatch<any>(dataExplorerActions.REQUEST_ITEMS({ id: FAVORITE_PANEL_ID }))}
onContextMenu={(event, item) => {
- const kind = item.kind === ResourceKind.Project ? ContextMenuKind.PROJECT : ContextMenuKind.RESOURCE;
+ const kind = item.kind === ResourceKind.PROJECT ? ContextMenuKind.PROJECT : ContextMenuKind.RESOURCE;
this.openContextMenu(event, {
uuid: item.uuid,
name: item.name,
}}
onItemDoubleClick={item => {
switch (item.kind) {
- case ResourceKind.Collection:
+ case ResourceKind.COLLECTION:
this.props.dispatch<any>(loadCollection(item.uuid, item.kind as ResourceKind));
this.props.dispatch(push(getCollectionUrl(item.uuid)));
default:
- this.props.dispatch<any>(loadDetails(item.uuid, ResourceKind.Project));
+ this.props.dispatch<any>(loadDetails(item.uuid, ResourceKind.PROJECT));
this.props.dispatch<any>(setProjectItem(item.uuid, ItemMode.ACTIVE));
- this.props.dispatch<any>(sidePanelActions.TOGGLE_SIDE_PANEL_ITEM_ACTIVE(SidePanelIdentifiers.Projects));
+ this.props.dispatch<any>(sidePanelActions.TOGGLE_SIDE_PANEL_ITEM_ACTIVE(SidePanelIdentifiers.PROJECTS));
}
+
}}
{...props} />
mainAppBarActions: MainAppBarActionProps = {
onBreadcrumbClick: ({ itemId }: NavBreadcrumb) => {
this.props.dispatch<any>(setProjectItem(itemId, ItemMode.BOTH));
- this.props.dispatch<any>(loadDetails(itemId, ResourceKind.Project));
+ this.props.dispatch<any>(loadDetails(itemId, ResourceKind.PROJECT));
},
onSearch: searchText => {
this.setState({ searchText });