Added parent, refactoring

Author: Yadro

src/base/TreeModelHelper.ts

@@ -1,6 +1,19 @@
 import { ITreeItem } from '../types/ITreeItem';
 
 const TreeModelHelper = {
+  walkRecursive<T extends ITreeItem<any>>(
+    fn: (t: T, p?: T) => void,
+    treeItems: T[],
+    parent?: T
+  ) {
+    treeItems.forEach((item) => {
+      fn(item, parent);
+      if (item.children?.length) {
+        TreeModelHelper.walkRecursive(fn, item.children, item);
+      }
+    });
+  },
+
   modifyItemsWithIdsRecursive<T extends ITreeItem<any>>(
     treeItems: T[],
     ids: string[],

src/modules/tasks/TaskService.ts

@@ -1,7 +1,19 @@
+import { toJS } from 'mobx';
+
 import TaskRepository from './TaskRepository';
 import TaskFactory from './TaskFactory';
 import TasksByProject from './models/TasksByProject';
 import AbstractServiceWithProfile from '../../base/AbstractServiceWithProfile';
+import TreeModelHelper from '../../base/TreeModelHelper';
+import TaskModel from './models/TaskModel';
+
+const setParent = (item: TaskModel, parent?: TaskModel) => {
+  item.parent = parent || null;
+};
+
+const clearParent = (item: TaskModel) => {
+  item.parent = null;
+};
 
 export default class TaskService extends AbstractServiceWithProfile<
   TasksByProject
@@ -11,10 +23,25 @@ export default class TaskService extends AbstractServiceWithProfile<
 
   getAll(): TasksByProject {
     const data: TasksByProject = this.repository.restore({});
+    TaskService.fillParent(data);
     return this.factory.createTasks(data);
   }
 
   save(data: TasksByProject) {
-    this.repository.save(data);
+    const copyData = toJS(data);
+    TaskService.clearParent(copyData);
+    this.repository.save(copyData);
+  }
+
+  private static fillParent(data: TasksByProject) {
+    Object.values(data).forEach((projectTasks) => {
+      TreeModelHelper.walkRecursive(setParent, projectTasks);
+    });
+  }
+
+  private static clearParent(data: TasksByProject) {
+    Object.values(data).forEach((projectTasks) => {
+      TreeModelHelper.walkRecursive(clearParent, projectTasks);
+    });
   }
 }

src/modules/tasks/models/TaskModel.ts

@@ -1,9 +1,8 @@
 import { action, computed, makeObservable, observable } from 'mobx';
-import isSameDay from 'date-fns/isSameDay';
+import { isSameDay, startOfDay } from 'date-fns';
 
 import AbstractModel from '../../../base/AbstractModel';
 import { ITreeItem } from '../../../types/ITreeItem';
-import { startOfDay } from 'date-fns';
 
 export interface IJsonTimeRangeModel {
   start: string;
@@ -24,47 +23,55 @@ interface IJsonTaskModel extends ITreeItem<IJsonTaskModel> {
   expanded: boolean;
   time: string[][] | IJsonTimeRangeModel[];
   datesInProgress: string[];
-  children: IJsonTaskModel[];
   details: string[];
 }
 
+const parseTimeRageItems = (
+  timeItems: (string[] | IJsonTimeRangeModel | ITimeRangeModel)[]
+) => {
+  return timeItems.map(
+    (range: string[] | IJsonTimeRangeModel | ITimeRangeModel) => {
+      if (Array.isArray(range)) {
+        return {
+          start: new Date(range[0]),
+          end: range[1] ? new Date(range[1]) : undefined,
+          description: undefined,
+        };
+      } else {
+        return {
+          start: new Date(range.start),
+          end: range.end ? new Date(range.end) : undefined,
+          description: range.description,
+        };
+      }
+    }
+  );
+};
+
 export default class TaskModel extends AbstractModel {
   key: string = '';
   title: string = '';
   children: TaskModel[] = [];
+  parent: TaskModel | null = null;
   projectId: string = '';
   checked: boolean = false;
-  expanded: boolean = true;
   active: boolean = false;
+  expanded: boolean = true;
   time: ITimeRangeModel[] = [];
   datesInProgress: Date[] = [];
   details: string = '';
 
-  constructor(props: IJsonTaskModel) {
+  constructor(props: IJsonTaskModel | TaskModel) {
     super();
-    this.load(props);
-    this.children = props.children?.map((json) => new TaskModel(json)) || [];
-    this.time =
-      // @ts-ignore
-      props.time?.map<ITimeRangeModel>(
-        (range: string[] | IJsonTimeRangeModel) => {
-          if (Array.isArray(range)) {
-            return {
-              start: new Date(range[0]),
-              end: range[1] ? new Date(range[1]) : undefined,
-              description: undefined,
-            };
-          } else {
-            return {
-              start: new Date(range.start),
-              end: range.end ? new Date(range.end) : undefined,
-              description: range.description,
-            };
-          }
-        }
-      ) || [];
-    this.datesInProgress =
-      props.datesInProgress?.map((date) => new Date(date)) || [];
+    const newProps = {
+      ...props,
+      children: props.children?.map((json) => new TaskModel(json)) || [],
+      time: props.time ? parseTimeRageItems(props.time) : [],
+      datesInProgress:
+        props.datesInProgress?.map((date) => new Date(date)) || [],
+    };
+
+    this.load(newProps);
 
     makeObservable(this, {
       key: observable,
@@ -117,9 +124,10 @@ export default class TaskModel extends AbstractModel {
 
   start() {
     this.active = true;
-    this.addDateWhenWasInProgress(new Date());
+    const dateNow = new Date();
+    this.addDateWhenWasInProgress(dateNow);
     this.time.push({
-      start: new Date(),
+      start: dateNow,
       end: undefined,
       description: undefined,
     });