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 }
  22
  23 export function findTreeItem<T>(tree: Array<TreeItem<T>>, itemId: string): TreeItem<T> | undefined {
  24     let item;
  25     for (const t of tree) {
  26         item = t.id === itemId
  27             ? t
  28             : findTreeItem(t.items ? t.items : [], itemId);
  29         if (item) {
  30             break;
  31         }
  32     }
  33     return item;
  34 }
  35
  36 export function getActiveTreeItem<T>(tree: Array<TreeItem<T>>): TreeItem<T> | undefined {
  37     let item;
  38     for (const t of tree) {
  39         item = t.active
  40             ? t
  41             : getActiveTreeItem(t.items ? t.items : []);
  42         if (item) {
  43             break;
  44         }
  45     }
  46     return item;
  47 }
  48
  49 export function getTreePath<T>(tree: Array<TreeItem<T>>, itemId: string): Array<TreeItem<T>> {
  50     for (const item of tree) {
  51         if (item.id === itemId) {
  52             return [item];
  53         } else {
  54             const branch = getTreePath(item.items || [], itemId);
  55             if (branch.length > 0) {
  56                 return [item, ...branch];
  57             }
  58         }
  59     }
  60     return [];
  61 }
  62
  63 function resetTreeActivity<T>(tree: Array<TreeItem<T>>) {
  64     for (const t of tree) {
  65         t.active = false;
  66         resetTreeActivity(t.items ? t.items : []);
  67     }
  68 }
  69
  70 function updateProjectTree(tree: Array<TreeItem<ProjectResource>>, projects: ProjectResource[], parentItemId?: string): Array<TreeItem<ProjectResource>> {
  71     let treeItem;
  72     if (parentItemId) {
  73         treeItem = findTreeItem(tree, parentItemId);
  74         if (treeItem) {
  75             treeItem.status = TreeItemStatus.Loaded;
  76         }
  77     }
  78     const items = projects.map(p => ({
  79         id: p.uuid,
  80         open: false,
  81         active: false,
  82         status: TreeItemStatus.Initial,
  83         data: p,
  84         items: []
  85     } as TreeItem<ProjectResource>));
  86
  87     if (treeItem) {
  88         treeItem.items = items;
  89         return tree;
  90     }
  91
  92     return items;
  93 }
  94
  95 const updateCreator = (state: ProjectState, creator: Partial<ProjectCreator>) => ({
  96     ...state,
  97     creator: {
  98         ...state.creator,
  99         ...creator
 100     }
 101 });
 102
 103 const initialState: ProjectState = {
 104     items: [],
 105     currentItemId: "",
 106     creator: {
 107         opened: false,
 108         pending: false,
 109         ownerUuid: ""
 110     }
 111 };
 112
 113
 114 export const projectsReducer = (state: ProjectState = initialState, action: ProjectAction) => {
 115     return projectActions.match(action, {
 116         OPEN_PROJECT_CREATOR: ({ ownerUuid }) => updateCreator(state, { ownerUuid, opened: true, pending: false }),
 117         CLOSE_PROJECT_CREATOR: () => updateCreator(state, { opened: false }),
 118         CREATE_PROJECT: () => updateCreator(state, { opened: false, pending: true }),
 119         CREATE_PROJECT_SUCCESS: () => updateCreator(state, { ownerUuid: "", pending: false }),
 120         CREATE_PROJECT_ERROR: () => updateCreator(state, { ownerUuid: "", pending: false }),
 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 };