# 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;
};
</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> {
<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}>
import { resourceActionSet } from './views-components/context-menu/action-sets/resource-action-set';
import { favoriteActionSet } from "./views-components/context-menu/action-sets/favorite-action-set";
-addMenuActionSet(ContextMenuKind.RootProject, rootProjectActionSet);
-addMenuActionSet(ContextMenuKind.Project, projectActionSet);
-addMenuActionSet(ContextMenuKind.Resource, resourceActionSet);
-addMenuActionSet(ContextMenuKind.Favorite, favoriteActionSet);
+addMenuActionSet(ContextMenuKind.ROOT_PROJECT, rootProjectActionSet);
+addMenuActionSet(ContextMenuKind.PROJECT, projectActionSet);
+addMenuActionSet(ContextMenuKind.RESOURCE, resourceActionSet);
+addMenuActionSet(ContextMenuKind.FAVORITE, favoriteActionSet);
fetchConfig()
.then(config => {
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 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 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);
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}`
);
});
});
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 `/projects/${resource.uuid}`;
- case ResourceKind.Collection: return `/collections/${resource.uuid}`;
+ case ResourceKind.PROJECT: return `/projects/${resource.uuid}`;
+ case ResourceKind.COLLECTION: return `/collections/${resource.uuid}`;
default: return resource.href;
}
};
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));
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();
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 };
};
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,
};
export enum ContextMenuKind {
- RootProject = "RootProject",
- Project = "Project",
- Resource = "Resource",
- Favorite = "Favorite"
+ ROOT_PROJECT = "RootProject",
+ PROJECT = "Project",
+ RESOURCE = "Resource",
+ FAVORITE = "Favorite"
}
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"
}
onContextMenu={(event) => this.openContextMenu(event, {
uuid: authService.getUuid() || "",
name: "",
- kind: ContextMenuKind.RootProject
+ kind: ContextMenuKind.ROOT_PROJECT
})}>
<ProjectTree
projects={this.props.projects}
onContextMenu={(event, item) => this.openContextMenu(event, {
uuid: item.data.uuid,
name: item.data.name,
- kind: ContextMenuKind.Project
+ kind: ContextMenuKind.PROJECT
})}
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>}
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 => {
this.props.dispatch<any>(setProjectItem(item.uuid, ItemMode.ACTIVE));
- this.props.dispatch<any>(loadDetails(item.uuid, ResourceKind.Project));
+ this.props.dispatch<any>(loadDetails(item.uuid, ResourceKind.PROJECT));
}}
{...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,
this.props.dispatch<any>(loadDetails(item.uuid, item.kind as ResourceKind));
}}
onItemDoubleClick={item => {
- 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 });
this.openContextMenu(event, {
uuid: breadcrumb.itemId,
name: breadcrumb.label,
- kind: ContextMenuKind.Project
+ kind: ContextMenuKind.PROJECT
});
}
};