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     ownerUuid: string;
  20     error?: 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         ownerUuid: ""
 109     }
 110 };
 111
 112
 113 export const projectsReducer = (state: ProjectState = initialState, action: ProjectAction) => {
 114     return projectActions.match(action, {
 115         OPEN_PROJECT_CREATOR: ({ ownerUuid }) => updateCreator(state, { ownerUuid, opened: true }),
 116         CLOSE_PROJECT_CREATOR: () => updateCreator(state, { opened: false }),
 117         CREATE_PROJECT: () => updateCreator(state, { error: undefined }),
 118         CREATE_PROJECT_SUCCESS: () => updateCreator(state, { opened: false, ownerUuid: "" }),
 119         REMOVE_PROJECT: () => state,
 120         PROJECTS_REQUEST: itemId => {
 121             const items = _.cloneDeep(state.items);
 122             const item = findTreeItem(items, itemId);
 123             if (item) {
 124                 item.status = TreeItemStatus.PENDING;
 125                 state.items = items;
 126             }
 127             return { ...state, items };
 128         },
 129         PROJECTS_SUCCESS: ({ projects, parentItemId }) => {
 130             const items = _.cloneDeep(state.items);
 131             return {
 132                 ...state,
 133                 items: updateProjectTree(items, projects, parentItemId)
 134             };
 135         },
 136         TOGGLE_PROJECT_TREE_ITEM_OPEN: itemId => {
 137             const items = _.cloneDeep(state.items);
 138             const item = findTreeItem(items, itemId);
 139             if (item) {
 140                 item.open = !item.open;
 141             }
 142             return {
 143                 ...state,
 144                 items,
 145                 currentItemId: itemId
 146             };
 147         },
 148         TOGGLE_PROJECT_TREE_ITEM_ACTIVE: itemId => {
 149             const items = _.cloneDeep(state.items);
 150             resetTreeActivity(items);
 151             const item = findTreeItem(items, itemId);
 152             if (item) {
 153                 item.active = true;
 154             }
 155             return {
 156                 ...state,
 157                 items,
 158                 currentItemId: itemId
 159             };
 160         },
 161         RESET_PROJECT_TREE_ACTIVITY: () => {
 162             const items = _.cloneDeep(state.items);
 163             resetTreeActivity(items);
 164             return {
 165                 ...state,
 166                 items,
 167                 currentItemId: ""
 168             };
 169         },
 170         default: () => state
 171     });
 172 };