Feat/migrate study levels & groups

package.json

@@ -29,6 +29,7 @@
     "@angular/forms": "^21.1.0",
     "@angular/platform-browser": "^21.1.0",
     "@angular/router": "^21.1.0",
+    "lucide-angular": "^0.575.0",
     "rxjs": "~7.8.0",
     "tslib": "^2.3.0"
   },
@@ -43,4 +44,4 @@
     "typescript": "~5.9.2",
     "vitest": "^4.0.8"
   }
-}
+}

src/app/app.routes.ts

@@ -1,3 +1,14 @@
-import { Routes } from '@angular/router';
+import {Routes} from '@angular/router';
+import {LevelComponent} from '@features/level/level.component';
 
-export const routes: Routes = [];
+export const routes: Routes = [
+  {
+    path: '',
+    redirectTo: 'level',
+    pathMatch: 'full',
+  },
+  {
+    path: 'level',
+    component: LevelComponent,
+  },
+];

src/app/core/domains/group/group.api.ts

@@ -0,0 +1,30 @@
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import {Observable} from 'rxjs';
+import {Group, GroupPost} from './group.model';
+
+@Injectable({ providedIn: 'root' })
+export class GroupApi {
+
+  constructor(private http: HttpClient) {}
+
+  getAllGroups(): Observable<Group[]> {
+    return this.http.get<Group[]>('/groups');
+  }
+
+  getGroupsByLevel(levelId: number): Observable<Group[]> {
+    return this.http.get<Group[]>(`/levels/${levelId}/groups`);
+  }
+
+  createGroup(group: GroupPost): Observable<Group> {
+    return this.http.post<Group>('/groups', group);
+  }
+
+  deleteGroup(id: number): Observable<void> {
+    return this.http.delete<void>(`/groups/${id}`);
+  }
+
+  updateGroup(id: number, updatedGroup: GroupPost) {
+    return this.http.put<Group>(`/groups/${id}`, updatedGroup);
+  }
+}

src/app/core/domains/group/group.model.ts

@@ -4,7 +4,6 @@ export interface Group {
   type: string;
   classe: string;
   size: number;
-  levelAbr: string;
   levelId: number;
 }
 

src/app/core/domains/group/group.service.ts

@@ -0,0 +1,95 @@
+import {Injectable} from '@angular/core';
+import {GroupApi} from './group.api';
+import {GroupStore} from './group.store';
+import {Group, GroupPost} from './group.model';
+import {catchError, finalize, tap} from 'rxjs/operators';
+import {throwError} from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class GroupService {
+
+  readonly groups$;
+  readonly isLoading$
+  readonly error$;
+
+  constructor(
+    private groupApi: GroupApi,
+    private groupStore: GroupStore
+  ) {
+    this.groups$ = this.groupStore.groups$;
+    this.isLoading$ = this.groupStore.isLoading$;
+    this.error$ = this.groupStore.error$;
+  }
+
+  loadAllGroups(): void {
+    this.groupStore.setLoading(true);
+    this.groupStore.setError(null);
+
+    this.groupApi.getAllGroups().pipe(
+      tap((groups: Group[]) => this.groupStore.setGroups(groups)),
+      catchError((error) => {
+        this.groupStore.setError('Erreur lors du chargement des groupes');
+        return throwError(() => error);
+      }),
+      finalize(() => this.groupStore.setLoading(false))
+    ).subscribe();
+  }
+
+  loadGroupsByLevel(levelId: number): void {
+    this.groupStore.setLoading(true);
+    this.groupStore.setError(null);
+
+    this.groupApi.getGroupsByLevel(levelId).pipe(
+      tap((groups: Group[]) => this.groupStore.setGroups(groups)),
+      catchError((error) => {
+        this.groupStore.setError('Erreur lors du chargement des groupes du niveau');
+        return throwError(() => error);
+      }),
+      finalize(() => this.groupStore.setLoading(false))
+    ).subscribe();
+  }
+
+  createGroup(newGroup: GroupPost): void {
+    this.groupStore.setLoading(true);
+
+    this.groupApi.createGroup(newGroup).pipe(
+      tap((createdGroup: Group) => {
+        this.groupStore.addGroup(createdGroup);
+      }),
+      catchError((error) => {
+        this.groupStore.setError('Erreur lors de la création du groupe');
+        return throwError(() => error);
+      }),
+      finalize(() => this.groupStore.setLoading(false))
+    ).subscribe();
+  }
+
+  updateGroup(id: number, updatedGroup: GroupPost): void {
+    this.groupStore.setLoading(true);
+
+    this.groupApi.updateGroup(id, updatedGroup).pipe(
+      tap((group: Group) => {
+        this.groupStore.updateGroup(id,group);
+      }),
+      catchError((error) => {
+        this.groupStore.setError('Erreur lors de la mise à jour du groupe');
+        return throwError(() => error);
+      }),
+      finalize(() => this.groupStore.setLoading(false))
+    ).subscribe();
+  }
+
+  deleteGroup(id: number): void {
+    this.groupApi.deleteGroup(id).pipe(
+      tap(() => {
+        this.groupStore.removeGroup(id);
+      }),
+      catchError((error) => {
+        this.groupStore.setError('Erreur lors de la suppression du groupe');
+        return throwError(() => error);
+      })
+    ).subscribe();
+  }
+}

src/app/core/domains/group/group.store.ts

@@ -0,0 +1,48 @@
+import {Injectable} from '@angular/core';
+import {BehaviorSubject} from 'rxjs';
+import {Group, GroupPost} from './group.model';
+
+@Injectable({ providedIn: 'root' })
+export class GroupStore {
+
+  private readonly _groups = new BehaviorSubject<Group[]>([]);
+  private readonly _isLoading = new BehaviorSubject<boolean>(false);
+  private readonly _error = new BehaviorSubject<string | null>(null);
+
+  readonly groups$ = this._groups.asObservable();
+  readonly isLoading$ = this._isLoading.asObservable();
+  readonly error$ = this._error.asObservable();
+
+  setGroups(groups: Group[]) {
+    this._groups.next(groups);
+  }
+
+  addGroup(group: Group) {
+    const currentGroups = this._groups.getValue();
+    this._groups.next([...currentGroups, group]);
+  }
+
+  updateGroup(id: number, group: GroupPost) {
+    const currentGroups = this._groups.getValue();
+    const index = currentGroups.findIndex(g => g.id === id);
+    if (index !== -1) {
+      const updatedGroup: Group = { ...currentGroups[index], ...group };
+      const updatedGroups = [...currentGroups];
+      updatedGroups[index] = updatedGroup;
+      this._groups.next(updatedGroups);
+    }
+  }
+
+  removeGroup(id: number) {
+    const currentGroups = this._groups.getValue();
+    this._groups.next(currentGroups.filter(g => g.id !== id));
+  }
+
+  setLoading(isLoading: boolean) {
+    this._isLoading.next(isLoading);
+  }
+
+  setError(error: string | null) {
+    this._error.next(error);
+  }
+}

src/app/core/domains/level/level.api.ts

@@ -0,0 +1,55 @@
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import {delay, Observable, of} from 'rxjs';
+import {Level, LevelPost} from './level.model';
+import {mockLevels} from './level.mock';
+
+@Injectable({ providedIn: 'root' })
+export class LevelApi {
+  private readonly API_URL = '/levels';
+  private readonly USE_MOCK = true; // Mettre à false pour utiliser l'API réelle
+  private mockData: Level[] = [...mockLevels];
+
+  constructor(private http: HttpClient) {}
+
+  getAllLevels(): Observable<Level[]> {
+    if (this.USE_MOCK) {
+      return of(this.mockData).pipe(delay(500));
+    }
+    return this.http.get<Level[]>(this.API_URL);
+  }
+
+  createLevel(level: LevelPost): Observable<Level> {
+    if (this.USE_MOCK) {
+      const newLevel: Level = {
+        id: this.mockData.at(-1)?.id ? this.mockData.at(-1)!.id + 1 : 1,
+        name: level.name || '',
+        abr: level.abr || ''
+      };
+      this.mockData.push(newLevel);
+      return of(newLevel).pipe(delay(300));
+    }
+    return this.http.post<Level>(this.API_URL, level);
+  }
+
+  updateLevel(id: number, level: LevelPost): Observable<Level> {
+    if (this.USE_MOCK) {
+      const index = this.mockData.findIndex(l => l.id === id);
+      if (index !== -1) {
+        this.mockData[index] = { ...this.mockData[index], ...level };
+        return of(this.mockData[index]).pipe(delay(300));
+      } else {
+        throw new Error(`Level id ${id} not found`);
+      }
+    }
+    return this.http.put<Level>(`${this.API_URL}/${id}`, level);
+  }
+
+  deleteLevel(id: number): Observable<void> {
+    if (this.USE_MOCK) {
+      this.mockData = this.mockData.filter(level => level.id !== id);
+      return of(void 0).pipe(delay(300));
+    }
+    return this.http.delete<void>(`${this.API_URL}/${id}`);
+  }
+}

src/app/core/domains/level/level.mock.ts

@@ -0,0 +1,7 @@
+import {Level} from './level.model';
+
+export const mockLevels: Level[] = [
+  { id: 1, name: 'Niveau 1', abr: 'N1' },
+  { id: 2, name: 'Niveau 2', abr: 'N2' },
+  { id: 3, name: 'Niveau 3', abr: 'N3' }
+];