Expand project, refactoring

Author: Yadro

src/base/TreeModelHelper.ts

@@ -0,0 +1,77 @@
+import { ITreeItem } from '../types/ITreeItem';
+
+const TreeModelHelper = {
+  modifyItemsWithIdsRecursive<T extends ITreeItem<any>>(
+    treeItems: T[],
+    ids: string[],
+    fn: (treeItem: T, ids: string[]) => void
+  ) {
+    treeItems.forEach((item) => {
+      fn(item, ids);
+      if (Array.isArray(item.children) && item.children.length) {
+        TreeModelHelper.modifyItemsWithIdsRecursive(item.children, ids, fn);
+      }
+    });
+  },
+
+  getItemRecursive<T extends ITreeItem<any>>(
+    tasks: T[],
+    condition: (task: T) => boolean
+  ): T | undefined {
+    for (const task of tasks) {
+      if (condition(task)) {
+        return task;
+      }
+      if (Array.isArray(task.children)) {
+        const found = this.getItemRecursive(task.children, condition);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    return undefined;
+  },
+
+  getFlatItemsRecursive<T extends ITreeItem<any>>(
+    tree: T[],
+    condition: (task: T) => boolean
+  ): T[] {
+    const result: T[] = [];
+
+    this.getFlatItemsRecursiveBase(tree, condition, result);
+
+    return result;
+  },
+
+  getFlatItemsRecursiveBase<T extends ITreeItem<any>>(
+    treeItems: T[],
+    condition: (item: T) => boolean,
+    result: T[]
+  ): T[] {
+    for (const item of treeItems) {
+      if (condition(item)) {
+        result.push(item);
+      }
+      if (Array.isArray(item.children)) {
+        this.getFlatItemsRecursiveBase(item.children, condition, result);
+      }
+    }
+    return result;
+  },
+
+  deleteItems<T extends ITreeItem<any>>(
+    treeItems: T[],
+    condition: (task: T) => boolean
+  ): T[] {
+    const result = treeItems.filter((t) => !condition(t));
+    for (let i = 0; i < result.length; i++) {
+      const task = treeItems[i];
+      if (Array.isArray(task.children)) {
+        treeItems[i].children = this.deleteItems(task.children, condition);
+      }
+    }
+    return result;
+  },
+};
+
+export default TreeModelHelper;

src/base/TreeModelStoreHelper.ts

@@ -4,7 +4,7 @@ const path = require('path');
 import FsHelper from '../../helpers/FsHelper';
 import PromiseQueue from '../../helpers/PromiseQueueHellper';
 
-const APP_DIR = 'YadroTimeTracker';
+const APP_DIR = 'YadroTimeTracker_test';
 
 export default abstract class AbstractFileRepository<T = any> {
   dirWithProfileData: string = 'profile1';

src/base/repositories/AbstractFileRepository.ts

@@ -2,7 +2,7 @@ import { autorun, makeAutoObservable } from 'mobx';
 
 import ProjectModel from './models/ProjectModel';
 import ProjectService from './ProjectService';
-import TreeModelStoreHelper from '../../base/TreeModelStoreHelper';
+import TreeModelHelper from '../../base/TreeModelHelper';
 import { Undefined } from '../../types/CommonTypes';
 import { RootStore } from '../RootStore';
 import GaService from '../../services/gaService/GaService';
@@ -45,7 +45,7 @@ export default class ProjectStore {
   setProjectProps(
     project: ProjectModel,
     title: string,
-    color: string | undefined,
+    color: string | undefined
   ) {
     project.title = title;
     project.color = color || '';
@@ -58,7 +58,29 @@ export default class ProjectStore {
     function compare(project: ProjectModel) {
       return project.key === projectKey;
     }
-    return TreeModelStoreHelper.getItemRecursive(this.projects, compare);
+    return TreeModelHelper.getItemRecursive(this.projects, compare);
+  }
+
+  getExpandedKeys(): string[] {
+    const condition = (project: ProjectModel) => project.expanded;
+
+    return TreeModelHelper.getFlatItemsRecursive(this.projects, condition).map(
+      (task) => task.key
+    );
+  }
+
+  markExpanded(ids: string[]) {
+    const markExpanded = (project: ProjectModel, ids: string[]) => {
+      project.expanded = ids.includes(project.key);
+    };
+
+    TreeModelHelper.modifyItemsWithIdsRecursive<ProjectModel>(
+      this.projects,
+      ids,
+      markExpanded
+    );
+
+    this.set(this.projects.slice());
   }
 
   add(project: ProjectModel) {
@@ -74,7 +96,7 @@ export default class ProjectStore {
       return _project.key === project.key;
     }
 
-    this.projects = TreeModelStoreHelper.deleteItems(this.projects, condition);
+    this.projects = TreeModelHelper.deleteItems(this.projects, condition);
     this.projectService.save(this.projects);
     GaService.event(EEventCategory.Projects, EProjectEvents.Delete);
   }

src/modules/projects/ProjectStore.ts

@@ -24,6 +24,7 @@ export default class ProjectModel extends AbstractModel
   key: string = '';
   title: string = '';
   color: string = '';
+  expanded: boolean = false;
   children?: ProjectModel[] = [];
 
   constructor(props: IJsonProjectItem) {

src/modules/projects/models/ProjectModel.ts

@@ -3,7 +3,7 @@ import { autorun, makeAutoObservable } from 'mobx';
 import TaskService from './TaskService';
 import TaskModel, { ITimeRangeModel } from './models/TaskModel';
 import TasksByProject from '../../modules/tasks/models/TasksByProject';
-import TreeModelStoreHelper from '../../base/TreeModelStoreHelper';
+import TreeModelHelper from '../../base/TreeModelHelper';
 import BadgeService from '../BadgeService';
 import { RootStore } from '../RootStore';
 import GaService from '../../services/gaService/GaService';
@@ -29,8 +29,8 @@ export default class TaskStore {
     });
   }
 
-  set(projectId: string, tasks: TaskModel[]) {
-    this.tasks[projectId] = tasks;
+  set(projectId: string, tasksInProject: TaskModel[]) {
+    this.tasks[projectId] = tasksInProject;
     this.tasksService.save(this.tasks);
   }
 
@@ -59,7 +59,7 @@ export default class TaskStore {
     }
 
     for (const tasks of Object.values(this.tasks)) {
-      const found = TreeModelStoreHelper.getItemRecursive(tasks, condition);
+      const found = TreeModelHelper.getItemRecursive(tasks, condition);
       if (found) {
         return found;
       }
@@ -75,7 +75,7 @@ export default class TaskStore {
     }
 
     for (const tasks of Object.values(this.tasks)) {
-      TreeModelStoreHelper.getFlatItemsRecursiveBase(tasks, condition, result);
+      TreeModelHelper.getFlatItemsRecursiveBase(tasks, condition, result);
     }
     return result;
   }
@@ -100,7 +100,7 @@ export default class TaskStore {
 
     for (const projectKey in this.tasks) {
       if (this.tasks.hasOwnProperty(projectKey)) {
-        this.tasks[projectKey] = TreeModelStoreHelper.deleteItems(
+        this.tasks[projectKey] = TreeModelHelper.deleteItems(
           this.tasks[projectKey],
           condition
         );
@@ -159,22 +159,30 @@ export default class TaskStore {
     }
 
     if (Array.isArray(this.tasks[projectId])) {
-      this.checkTasksRecursive(this.tasks[projectId], taskIds, checkTaskFn);
+      TreeModelHelper.modifyItemsWithIdsRecursive<TaskModel>(
+        this.tasks[projectId],
+        taskIds,
+        checkTaskFn
+      );
+
+      this.set(projectId, this.tasks[projectId].slice());
     }
-    this.tasksService.save(this.tasks);
     GaService.event(EEventCategory.Tasks, ETasksEvents.Check);
   }
 
-  tasksMarkExpanded(projectId: string, taskIds: string[]) {
-    function markExpanded(task: TaskModel, taskIds: string[]) {
+  markExpanded(projectId: string, taskIds: string[]) {
+    const markExpanded = (task: TaskModel, taskIds: string[]) => {
       task.expanded = taskIds.includes(task.key);
-    }
+    };
 
     if (Array.isArray(this.tasks[projectId])) {
-      this.checkTasksRecursive(this.tasks[projectId], taskIds, markExpanded);
+      TreeModelHelper.modifyItemsWithIdsRecursive<TaskModel>(
+        this.tasks[projectId],
+        taskIds,
+        markExpanded
+      );
 
-      this.tasks[projectId] = this.tasks[projectId].slice();
-      this.tasksService.save(this.tasks);
+      this.set(projectId, this.tasks[projectId].slice());
     }
   }
 
@@ -183,7 +191,7 @@ export default class TaskStore {
     condition: (task: TaskModel) => boolean
   ) {
     if (Array.isArray(this.tasks[projectId])) {
-      return TreeModelStoreHelper.getFlatItemsRecursive(
+      return TreeModelHelper.getFlatItemsRecursive(
         this.tasks[projectId],
         condition
       ).map((task) => task.key);
@@ -206,20 +214,7 @@ export default class TaskStore {
       return task.active;
     }
 
-    return TreeModelStoreHelper.getItemRecursive(tasks, condition);
-  }
-
-  private checkTasksRecursive(
-    tasks: TaskModel[],
-    taskIds: string[],
-    fn: (task: TaskModel, taskIds: string[]) => void
-  ) {
-    tasks.forEach((task) => {
-      fn(task, taskIds);
-      if (Array.isArray(task.children)) {
-        this.checkTasksRecursive(task.children, taskIds, fn);
-      }
-    });
+    return TreeModelHelper.getItemRecursive(tasks, condition);
   }
 
   private setupReminder(task?: TaskModel) {

src/modules/tasks/TaskStore.ts

@@ -28,10 +28,7 @@ const TaskList = TreeList(
   {
     checkable: true,
     onExpand(keys: Key[]) {
-      tasksStore.tasksMarkExpanded(
-        projectStore.activeProject,
-        keys as string[]
-      );
+      tasksStore.markExpanded(projectStore.activeProject, keys as string[]);
     },
     getExpandedKeys() {
       return tasksStore.getExpandedKeys(projectStore.activeProject);
@@ -63,6 +60,12 @@ const ProjectList = TreeList(
         />
       );
     },
+    onExpand(keys: Key[]) {
+      projectStore.markExpanded(keys as string[]);
+    },
+    getExpandedKeys() {
+      return projectStore.getExpandedKeys();
+    },
   }
 );