src/store/project/project-reducer.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import * as _ from "lodash";
   6
   7 import { projectActions, ProjectAction } from "./project-action";
   8 import { TreeItem, TreeItemStatus } from "../../components/tree/tree";
   9 import { ProjectResource } from "../../models/project";
  10
  11 export type ProjectState = {
  12     items: Array<TreeItem<ProjectResource>>,
  13     currentItemId: string,
  14     creator: ProjectCreator
  15 };
  16
  17 interface ProjectCreator {
  18     opened: boolean;
  19     pending: boolean;
  20     ownerUuid: string;
  21     error?: string;
  22 }
  23
  24 export function findTreeItem<T>(tree: Array<TreeItem<T>>, itemId: string): TreeItem<T> | undefined {
  25     let item;
  26     for (const t of tree) {
  27         item = t.id === itemId
  28             ? t
  29             : findTreeItem(t.items ? t.items : [], itemId);
  30         if (item) {
  31             break;
  32         }
  33     }
  34     return item;
  35 }
  36
  37 export function getActiveTreeItem<T>(tree: Array<TreeItem<T>>): TreeItem<T> | undefined {
  38     let item;
  39     for (const t of tree) {
  40         item = t.active
  41             ? t
  42             : getActiveTreeItem(t.items ? t.items : []);
  43         if (item) {
  44             break;
  45         }
  46     }
  47     return item;
  48 }
  49
  50 export function getTreePath<T>(tree: Array<TreeItem<T>>, itemId: string): Array<TreeItem<T>> {
  51     for (const item of tree) {
  52         if (item.id === itemId) {
  53             return [item];
  54         } else {
  55             const branch = getTreePath(item.items || [], itemId);
  56             if (branch.length > 0) {
  57                 return [item, ...branch];
  58             }
  59         }
  60     }
  61     return [];
  62 }
  63
  64 function resetTreeActivity<T>(tree: Array<TreeItem<T>>) {
  65     for (const t of tree) {
  66         t.active = false;
  67         resetTreeActivity(t.items ? t.items : []);
  68     }
  69 }
  70
  71 function updateProjectTree(tree: Array<TreeItem<ProjectResource>>, projects: ProjectResource[], parentItemId?: string): Array<TreeItem<ProjectResource>> {
  72     let treeItem;
  73     if (parentItemId) {
  74         treeItem = findTreeItem(tree, parentItemId);
  75         if (treeItem) {
  76             treeItem.status = TreeItemStatus.LOADED;
  77         }
  78     }
  79     const items = projects.map(p => ({
  80         id: p.uuid,
  81         open: false,
  82         active: false,
  83         status: TreeItemStatus.INITIAL,
  84         data: p,
  85         items: []
  86     } as TreeItem<ProjectResource>));
  87
  88     if (treeItem) {
  89         treeItem.items = items;
  90         return tree;
  91     }
  92
  93     return items;
  94 }
  95
  96 const updateCreator = (state: ProjectState, creator: Partial<ProjectCreator>) => ({
  97     ...state,
  98     creator: {
  99         ...state.creator,
 100         ...creator
 101     }
 102 });
 103
 104 const initialState: ProjectState = {
 105     items: [],
 106     currentItemId: "",
 107     creator: {
 108         opened: false,
 109         pending: false,
 110         ownerUuid: ""
 111     }
 112 };
 113
 114
 115 export const projectsReducer = (state: ProjectState = initialState, action: ProjectAction) => {
 116     return projectActions.match(action, {
 117         OPEN_PROJECT_CREATOR: ({ ownerUuid }) => updateCreator(state, { ownerUuid, opened: true, pending: false }),
 118         CLOSE_PROJECT_CREATOR: () => updateCreator(state, { opened: false }),
 119         CREATE_PROJECT: () => updateCreator(state, { error: undefined }),
 120         CREATE_PROJECT_SUCCESS: () => updateCreator(state, { opened: false, ownerUuid: "" }),
 121         REMOVE_PROJECT: () => state,
 122         PROJECTS_REQUEST: itemId => {
 123             const items = _.cloneDeep(state.items);
 124             const item = findTreeItem(items, itemId);
 125             if (item) {
 126                 item.status = TreeItemStatus.PENDING;
 127                 state.items = items;
 128             }
 129             return { ...state, items };
 130         },
 131         PROJECTS_SUCCESS: ({ projects, parentItemId }) => {
 132             const items = _.cloneDeep(state.items);
 133             return {
 134                 ...state,
 135                 items: updateProjectTree(items, projects, parentItemId)
 136             };
 137         },
 138         TOGGLE_PROJECT_TREE_ITEM_OPEN: itemId => {
 139             const items = _.cloneDeep(state.items);
 140             const item = findTreeItem(items, itemId);
 141             if (item) {
 142                 item.open = !item.open;
 143             }
 144             return {
 145                 ...state,
 146                 items,
 147                 currentItemId: itemId
 148             };
 149         },
 150         TOGGLE_PROJECT_TREE_ITEM_ACTIVE: itemId => {
 151             const items = _.cloneDeep(state.items);
 152             resetTreeActivity(items);
 153             const item = findTreeItem(items, itemId);
 154             if (item) {
 155                 item.active = true;
 156             }
 157             return {
 158                 ...state,
 159                 items,
 160                 currentItemId: itemId
 161             };
 162         },
 163         RESET_PROJECT_TREE_ACTIVITY: () => {
 164             const items = _.cloneDeep(state.items);
 165             resetTreeActivity(items);
 166             return {
 167                 ...state,
 168                 items,
 169                 currentItemId: ""
 170             };
 171         },
 172         default: () => state
 173     });
 174 };