Add new task list model.

src/app/core/entity/store.ts

@@ -0,0 +1,5 @@
+import { TaskList } from "./task-list";
+
+export interface Store {
+  taskLists: TaskList[];
+}

src/app/core/entity/task-list.ts

@@ -0,0 +1,7 @@
+import { Task } from "./task";
+
+export interface TaskList {
+  id: string;
+  name: string;
+  tasks: Task[];
+}

src/app/core/service/store-persistence.service.ts

@@ -0,0 +1,28 @@
+import { Injectable } from "@angular/core";
+import { CookieService } from "ngx-cookie-service";
+import { Store } from "../entity/store";
+
+const COOKIE_NAME = 'todo-store';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class StorePersistenceService {
+  constructor(
+    private _cookieService: CookieService
+  ) {}
+
+  save(store: Store): void {
+    const serializedStore = JSON.stringify(store);
+    this._cookieService.set(COOKIE_NAME, serializedStore);
+  }
+
+  load(): Store {
+    const serializedStore = this._cookieService.get(COOKIE_NAME);
+    try {
+      return JSON.parse(serializedStore);
+    } catch (jsonParseError) {
+      throw new Error(`JsonSerializationException: Invalid format for store in cookie "${COOKIE_NAME}".`);
+    }
+  }
+}

src/app/core/service/task-list.service.ts

@@ -0,0 +1,53 @@
+import { Injectable } from "@angular/core";
+import { BehaviorSubject } from "rxjs";
+import { Task } from "../entity/task";
+import { TaskList } from "../entity/task-list";
+import { StorePersistenceService } from "./store-persistence.service";
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class TaskListService {
+  private _activeTaskList: BehaviorSubject<TaskList> = new BehaviorSubject<TaskList>(undefined as unknown as TaskList);
+
+  constructor(
+    private _storePersistenceService: StorePersistenceService
+  ) {
+    this._activeTaskList.asObservable()
+        .subscribe(activeTaskList => {
+          const store = this._storePersistenceService.load();
+          const storedActiveList = store.taskLists.find(taskList => activeTaskList.id === taskList.id);
+          if (storedActiveList) {
+            storedActiveList.name = activeTaskList.name;
+            storedActiveList.tasks = activeTaskList.tasks;
+          } else {
+            store.taskLists.push(activeTaskList);
+          }
+          this._storePersistenceService.save(store);
+        });
+  }
+
+  addTask(task: Task): void {
+    const activeTaskList = this._activeTaskList.value;
+
+    if (!activeTaskList.tasks) {
+      activeTaskList.tasks = [];
+    }
+
+    activeTaskList.tasks.push(task);
+    this._activeTaskList.next(activeTaskList);
+  }
+
+  createTaskList(taskListName: string): void {
+    const newTaskList = {
+      id: taskListName,
+      name: taskListName,
+      tasks: []
+    } as TaskList;
+
+    const store = this._storePersistenceService.load();
+    store.taskLists.push(newTaskList);
+    this._storePersistenceService.save(store);
+  }
+}

todo.md

@@ -0,0 +1,14 @@
+# Fonctionnalités
+- Ajouter une tâche
+- Renommer la tâche
+- Terminer une tâche
+- Supprimer une tâche
+- Saisir la note d'une tâche
+- Ajouter des sous tâches à une autre
+- Renommer des sous tâches d'une autre
+- Terminer des sous tâches d'une autre
+- Supprimer des sous tâches d'une autre
+
+- J'aimerai "tagger" une tâche comme "asynchrone/bloquante" (où je dois attendre la fin, genre un build jenkins) et donc être notifié toutes les 5mins d'aller vérifier si la tâche est terminée. 
+- Quand je termine une sous tâche, je veux qu'elle soit archivée pour pouvoir la consulter à postériori
+- J'aimerai définir un e API sur laquelle je pourrais sauverader mes tâches, à la manière de git