AbstractTreeModelStore.ts

Author: Dmitry Yadrikhinsky

src/base/AbstractTreeModelStore.ts

@@ -0,0 +1,37 @@
+import { ITreeItem } from '../types/ITreeItem';
+
+export default abstract class AbstractTreeModelStore<T extends ITreeItem<any>> {
+  protected getItemRecursive(
+    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;
+  }
+
+  protected getItemsRecursive(
+    tasks: T[],
+    condition: (task: T) => boolean,
+    result: T[]
+  ): T[] {
+    for (const task of tasks) {
+      if (condition(task)) {
+        result.push(task);
+      }
+      if (Array.isArray(task.children)) {
+        this.getItemsRecursive(task.children, condition, result);
+      }
+    }
+    return result;
+  }
+}

src/models/ProjectModel.ts

@@ -1,13 +1,15 @@
 import AbstractModel from '../base/AbstractModel';
 import { ITreeItem } from '../types/ITreeItem';
 
-interface IProjectItem extends ITreeItem<IProjectItem> {}
+interface IProjectItem extends ITreeItem<IProjectItem> {
+  children?: IProjectItem[];
+}
 
 export default class ProjectModel extends AbstractModel
   implements IProjectItem {
   key: string = '';
   title: string = '';
-  children: ProjectModel[] = [];
+  children?: ProjectModel[] = [];
 
   constructor(props: IProjectItem) {
     super();

src/models/TaskModel.ts

@@ -10,6 +10,7 @@ interface IJsonTaskModel extends ITreeItem<IJsonTaskModel> {
   active: boolean;
   time: string[][];
   datesInProgress: string[];
+  children: IJsonTaskModel[];
 }
 
 export default class TaskModel extends AbstractModel {

src/screens/projects/components/TreeList.tsx

@@ -10,7 +10,7 @@ interface TreeListProps {
   onSelect?: (selectedKeys: Key[]) => void;
 }
 
-export default function TreeList<T extends ITreeItem>(
+export default function TreeList<T extends ITreeItem<any>>(
   getData: () => T[],
   updateData: (items: T[]) => void,
   options?: {

src/services/projects/ProjectStore.ts

@@ -1,24 +1,38 @@
+import { action, makeObservable, observable } from 'mobx';
+
 import ProjectModel from '../../models/ProjectModel';
 import ProjectService from './ProjectService';
-import { makeAutoObservable } from 'mobx';
+import AbstractTreeModelStore from '../../base/AbstractTreeModelStore';
 
-export default class ProjectStore {
+export default class ProjectStore extends AbstractTreeModelStore<ProjectModel> {
   projects: ProjectModel[] = [];
   activeProject: string = '';
 
   private projectService = new ProjectService();
 
   constructor() {
-    makeAutoObservable(this);
+    super();
+    makeObservable(this, {
+      projects: observable,
+      activeProject: observable,
+      set: action,
+      get: action,
+      add: action,
+      setActiveProject: action,
+      restore: action,
+    });
   }
 
   set(projects: ProjectModel[]) {
     this.projects = projects;
     this.projectService.save(this.projects);
   }
 
-  get(projectId: string): ProjectModel | undefined {
-    return this.getRecursive(this.projects, projectId);
+  get(projectKey: string): ProjectModel | undefined {
+    function compare(project: ProjectModel) {
+      return project.key === projectKey;
+    }
+    return this.getItemRecursive(this.projects, compare);
   }
 
   add(project: ProjectModel) {
@@ -35,23 +49,4 @@ export default class ProjectStore {
     this.projects = this.projectService.getAll();
     this.activeProject = Object.keys(this.projects)[0];
   }
-
-  private getRecursive(
-    projects: ProjectModel[],
-    projectId: string
-  ): ProjectModel | undefined {
-    for (const projectKey in projects) {
-      const project = projects[projectKey];
-      if (project.key === projectId) {
-        return project;
-      }
-      if (Array.isArray(project.children)) {
-        const found = this.getRecursive(project.children, projectId);
-        if (found) {
-          return found;
-        }
-      }
-    }
-    return undefined;
-  }
 }

src/services/tasks/TaskStore.ts

@@ -1,15 +1,31 @@
-import { makeAutoObservable } from 'mobx';
+import { action, makeObservable, observable } from 'mobx';
+
 import TaskService from './TaskService';
 import TaskModel from '../../models/TaskModel';
 import TasksByProject from '../../models/TasksByProject';
+import AbstractTreeModelStore from '../../base/AbstractTreeModelStore';
 
-export default class TaskStore {
+export default class TaskStore extends AbstractTreeModelStore<TaskModel> {
   tasks: TasksByProject = {};
   activeTask: TaskModel | undefined;
   private tasksService = new TaskService();
 
   constructor() {
-    makeAutoObservable(this);
+    super();
+    makeObservable(this, {
+      tasks: observable,
+      activeTask: observable,
+      set: action,
+      getTasks: action,
+      getTaskByKey: action,
+      getTaskByDate: action,
+      add: action,
+      startTimer: action,
+      endTimer: action,
+      restore: action,
+      getCheckedKeys: action,
+      checkTasks: action,
+    });
   }
 
   set(projectId: string, tasks: TaskModel[]) {
@@ -27,7 +43,7 @@ export default class TaskStore {
     }
 
     for (const tasks of Object.values(this.tasks)) {
-      const found = this.findTaskRecursive(tasks, condition);
+      const found = this.getItemRecursive(tasks, condition);
       if (found) {
         return found;
       }
@@ -43,7 +59,7 @@ export default class TaskStore {
     }
 
     for (const tasks of Object.values(this.tasks)) {
-      this.findTasksRecursive(tasks, condition, result);
+      this.getItemsRecursive(tasks, condition, result);
     }
     return result;
   }
@@ -84,7 +100,7 @@ export default class TaskStore {
     }
     if (Array.isArray(this.tasks[projectId])) {
       const found: TaskModel[] = [];
-      this.findTasksRecursive(this.tasks[projectId], condition, found);
+      this.getItemsRecursive(this.tasks[projectId], condition, found);
       return found.map((f) => f.key);
     }
     return [];
@@ -113,7 +129,7 @@ export default class TaskStore {
       return task.active;
     }
 
-    return this.findTaskRecursive(tasks, condition);
+    return this.getItemRecursive(tasks, condition);
   }
 
   private checkTasksRecursive(tasks: TaskModel[], taskIds: string[]) {
@@ -124,38 +140,4 @@ export default class TaskStore {
       }
     });
   }
-
-  private findTaskRecursive(
-    tasks: TaskModel[],
-    condition: (task: TaskModel) => boolean
-  ): TaskModel | undefined {
-    for (const task of tasks) {
-      if (condition(task)) {
-        return task;
-      }
-      if (Array.isArray(task.children)) {
-        const found = this.findTaskRecursive(task.children, condition);
-        if (found) {
-          return found;
-        }
-      }
-    }
-    return undefined;
-  }
-
-  private findTasksRecursive(
-    tasks: TaskModel[],
-    condition: (task: TaskModel) => boolean,
-    result: TaskModel[]
-  ): TaskModel[] {
-    for (const task of tasks) {
-      if (condition(task)) {
-        result.push(task);
-      }
-      if (Array.isArray(task.children)) {
-        this.findTasksRecursive(task.children, condition, result);
-      }
-    }
-    return result;
-  }
 }

src/types/ITreeItem.ts

@@ -1,4 +1,4 @@
-export interface ITreeItem<T extends ITreeItem = ITreeItem<any>> {
+export interface ITreeItem<T extends ITreeItem<any> = ITreeItem<any>> {
   title: string;
   key: string;
   children?: T[];