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.toggled = true;
 143                 item.open = !item.open;
 144             }
 145             return {
 146                 ...state,
 147                 items,
 148                 currentItemId: itemId
 149             };
 150         },
 151         TOGGLE_PROJECT_TREE_ITEM_ACTIVE: itemId => {
 152             const items = _.cloneDeep(state.items);
 153             resetTreeActivity(items);
 154             const item = findTreeItem(items, itemId);
 155             if (item) {
 156                 item.toggled = true;
 157                 item.active = true;
 158             }
 159             return {
 160                 ...state,
 161                 items,
 162                 currentItemId: itemId
 163             };
 164         },
 165         RESET_PROJECT_TREE_ACTIVITY: () => {
 166             const items = _.cloneDeep(state.items);
 167             resetTreeActivity(items);
 168             return {
 169                 ...state,
 170                 items,
 171                 currentItemId: ""
 172             };
 173         },
 174         default: () => state
 175     });
 176 };