src/store/resource-type-filters/resource-type-filters.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { difference, pipe, values, includes, __ } from 'lodash/fp';
   6 import { createTree, setNode, TreeNodeStatus, TreeNode, Tree } from '~/models/tree';
   7 import { DataTableFilterItem, DataTableFilters } from '~/components/data-table-filters/data-table-filters-tree';
   8 import { ResourceKind } from '~/models/resource';
   9 import { FilterBuilder } from '~/services/api/filter-builder';
  10 import { getSelectedNodes } from '~/models/tree';
  11 import { CollectionType } from '~/models/collection';
  12 import { GroupContentsResourcePrefix } from '~/services/groups-service/groups-service';
  13
  14 export enum ProcessStatusFilter {
  15     ALL = 'All',
  16     RUNNING = 'Running',
  17     FAILED = 'Failed',
  18     COMPLETED = 'Completed',
  19     CANCELLED = 'Cancelled',
  20     LOCKED = 'Locked',
  21     QUEUED = 'Queued'
  22 }
  23
  24 export enum ObjectTypeFilter {
  25     PROJECT = 'Project',
  26     PROCESS = 'Process',
  27     COLLECTION = 'Data Collection',
  28 }
  29
  30 export enum CollectionTypeFilter {
  31     GENERAL_COLLECTION = 'General',
  32     OUTPUT_COLLECTION = 'Output',
  33     LOG_COLLECTION = 'Log',
  34 }
  35
  36 const initFilter = (name: string, parent = '', isSelected?: boolean) =>
  37     setNode<DataTableFilterItem>({
  38         id: name,
  39         value: { name },
  40         parent,
  41         children: [],
  42         active: false,
  43         selected: isSelected !== undefined ? isSelected : true,
  44         expanded: false,
  45         status: TreeNodeStatus.LOADED,
  46     });
  47
  48 export const getSimpleObjectTypeFilters = pipe(
  49     (): DataTableFilters => createTree<DataTableFilterItem>(),
  50     initFilter(ObjectTypeFilter.PROJECT),
  51     initFilter(ObjectTypeFilter.PROCESS),
  52     initFilter(ObjectTypeFilter.COLLECTION),
  53 );
  54
  55 export const getInitialResourceTypeFilters = pipe(
  56     (): DataTableFilters => createTree<DataTableFilterItem>(),
  57     initFilter(ObjectTypeFilter.PROJECT),
  58     initFilter(ObjectTypeFilter.PROCESS),
  59     initFilter(ObjectTypeFilter.COLLECTION),
  60     initFilter(CollectionTypeFilter.GENERAL_COLLECTION, ObjectTypeFilter.COLLECTION),
  61     initFilter(CollectionTypeFilter.OUTPUT_COLLECTION, ObjectTypeFilter.COLLECTION),
  62     initFilter(CollectionTypeFilter.LOG_COLLECTION, ObjectTypeFilter.COLLECTION),
  63 );
  64
  65 export const getInitialProcessStatusFilters = pipe(
  66     (): DataTableFilters => createTree<DataTableFilterItem>(),
  67     initFilter(ProcessStatusFilter.ALL, '', true),
  68     initFilter(ProcessStatusFilter.RUNNING, '', false),
  69     initFilter(ProcessStatusFilter.FAILED, '', false),
  70     initFilter(ProcessStatusFilter.COMPLETED, '', false),
  71     initFilter(ProcessStatusFilter.CANCELLED, '', false),
  72     initFilter(ProcessStatusFilter.QUEUED, '', false),
  73     initFilter(ProcessStatusFilter.LOCKED, '', false),
  74 );
  75
  76 export const getTrashPanelTypeFilters = pipe(
  77     (): DataTableFilters => createTree<DataTableFilterItem>(),
  78     initFilter(ObjectTypeFilter.PROJECT),
  79     initFilter(ObjectTypeFilter.COLLECTION),
  80     initFilter(CollectionTypeFilter.GENERAL_COLLECTION, ObjectTypeFilter.COLLECTION),
  81     initFilter(CollectionTypeFilter.OUTPUT_COLLECTION, ObjectTypeFilter.COLLECTION),
  82     initFilter(CollectionTypeFilter.LOG_COLLECTION, ObjectTypeFilter.COLLECTION),
  83 );
  84
  85 const createFiltersBuilder = (filters: DataTableFilters) =>
  86     ({ fb: new FilterBuilder(), selectedFilters: getSelectedNodes(filters) });
  87
  88 const getMatchingFilters = (values: string[], filters: TreeNode<DataTableFilterItem>[]) =>
  89     filters
  90         .map(f => f.id)
  91         .filter(includes(__, values));
  92
  93 const objectTypeToResourceKind = (type: ObjectTypeFilter) => {
  94     switch (type) {
  95         case ObjectTypeFilter.PROJECT:
  96             return ResourceKind.PROJECT;
  97         case ObjectTypeFilter.PROCESS:
  98             return ResourceKind.PROCESS;
  99         case ObjectTypeFilter.COLLECTION:
 100             return ResourceKind.COLLECTION;
 101     }
 102 };
 103
 104 const serializeObjectTypeFilters = ({ fb, selectedFilters }: ReturnType<typeof createFiltersBuilder>) => {
 105     const collectionFilters = getMatchingFilters(values(CollectionTypeFilter), selectedFilters);
 106     const typeFilters = pipe(
 107         () => new Set(getMatchingFilters(values(ObjectTypeFilter), selectedFilters)),
 108         set => collectionFilters.length > 0
 109             ? set.add(ObjectTypeFilter.COLLECTION)
 110             : set,
 111         set => Array.from(set)
 112     )();
 113
 114     return {
 115         fb: typeFilters.length > 0
 116             ? fb.addIsA('uuid', typeFilters.map(objectTypeToResourceKind))
 117             : fb,
 118         selectedFilters,
 119     };
 120 };
 121
 122 const collectionTypeToPropertyValue = (type: CollectionTypeFilter) => {
 123     switch (type) {
 124         case CollectionTypeFilter.GENERAL_COLLECTION:
 125             return CollectionType.GENERAL;
 126         case CollectionTypeFilter.OUTPUT_COLLECTION:
 127             return CollectionType.OUTPUT;
 128         case CollectionTypeFilter.LOG_COLLECTION:
 129             return CollectionType.LOG;
 130     }
 131 };
 132
 133 const serializeCollectionTypeFilters = ({ fb, selectedFilters }: ReturnType<typeof createFiltersBuilder>) => pipe(
 134     () => getMatchingFilters(values(CollectionTypeFilter), selectedFilters),
 135     filters => filters.map(collectionTypeToPropertyValue),
 136     mappedFilters => ({
 137         fb: buildCollectionTypeFilters({ fb, filters: mappedFilters }),
 138         selectedFilters
 139     })
 140 )();
 141
 142 const COLLECTION_TYPES = values(CollectionType);
 143
 144 const NON_GENERAL_COLLECTION_TYPES = difference(COLLECTION_TYPES, [CollectionType.GENERAL]);
 145
 146 const COLLECTION_PROPERTIES_PREFIX = `${GroupContentsResourcePrefix.COLLECTION}.properties`;
 147
 148 const buildCollectionTypeFilters = ({ fb, filters }: { fb: FilterBuilder, filters: CollectionType[] }) => {
 149     switch (true) {
 150         case filters.length === 0 || filters.length === COLLECTION_TYPES.length:
 151             return fb;
 152         case includes(CollectionType.GENERAL, filters):
 153             return fb.addNotIn('type', difference(NON_GENERAL_COLLECTION_TYPES, filters), COLLECTION_PROPERTIES_PREFIX);
 154         default:
 155             return fb.addIn('type', filters, COLLECTION_PROPERTIES_PREFIX);
 156     }
 157 };
 158
 159 export const serializeResourceTypeFilters = pipe(
 160     createFiltersBuilder,
 161     serializeObjectTypeFilters,
 162     serializeCollectionTypeFilters,
 163     ({ fb }) => fb.getFilters(),
 164 );
 165
 166 export const serializeSimpleObjectTypeFilters = (filters: Tree<DataTableFilterItem>) => {
 167     return getSelectedNodes(filters)
 168         .map(f => f.id)
 169         .map(objectTypeToResourceKind);
 170 };