@cerema/cadriciel 0.5.0

package/_template/{{project}}-ihm/src/app/layout/service/app.layout.service.ts

@@ -0,0 +1,124 @@
+import { Injectable } from '@angular/core';
+import { MenuItem } from 'primeng/api';
+import { Subject } from 'rxjs';
+import { TabCloseEvent } from '../api/tabcloseevent';
+
+export interface AppConfig {
+  inputStyle: string;
+  colorScheme: string;
+  theme: string;
+  ripple: boolean;
+  menuMode: string;
+  layoutTheme: string;
+  scale: number;
+}
+
+interface LayoutState {
+  staticMenuDesktopInactive: boolean;
+  overlayMenuActive: boolean;
+  profileSidebarVisible: boolean;
+  configSidebarVisible: boolean;
+  staticMenuMobileActive: boolean;
+  menuHoverActive: boolean;
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LayoutService {
+
+  config: AppConfig = {
+    ripple: true,
+    inputStyle: 'filled',
+    menuMode: 'slim',
+    colorScheme: 'light',
+    theme: 'blue',
+    layoutTheme: 'primaryColor',
+    scale: 13
+  };
+
+  state: LayoutState = {
+    staticMenuDesktopInactive: false,
+    overlayMenuActive: false,
+    profileSidebarVisible: false,
+    configSidebarVisible: false,
+    staticMenuMobileActive: false,
+    menuHoverActive: false
+  };
+
+  tabs: MenuItem[] = [];
+
+  private configUpdate = new Subject<AppConfig>();
+
+  private overlayOpen = new Subject<any>();
+
+  private tabOpen = new Subject<MenuItem>();
+
+  private tabClose = new Subject<TabCloseEvent>();
+
+  configUpdate$ = this.configUpdate.asObservable();
+
+  overlayOpen$ = this.overlayOpen.asObservable();
+
+  tabOpen$ = this.tabOpen.asObservable();
+
+  tabClose$ = this.tabClose.asObservable();
+
+  onMenuToggle() {
+    if (this.isDesktop()) {
+      this.state.staticMenuDesktopInactive = !this.state.staticMenuDesktopInactive;
+    } else {
+      this.state.staticMenuMobileActive = !this.state.staticMenuMobileActive;
+
+      if (this.state.staticMenuMobileActive) {
+        this.overlayOpen.next(null);
+      }
+    }
+  }
+
+  onOverlaySubmenuOpen() {
+    this.overlayOpen.next(null);
+  }
+
+  showProfileSidebar() {
+    this.state.profileSidebarVisible = true;
+  }
+
+  showConfigSidebar() {
+    this.state.configSidebarVisible = true;
+  }
+
+  isDesktop() {
+    return window.innerWidth > 991;
+  }
+
+  isSlim() {
+    return this.config.menuMode === 'slim';
+  }
+
+  isMobile() {
+    return !this.isDesktop();
+  }
+
+  onConfigUpdate() {
+    this.configUpdate.next(this.config);
+  }
+
+  onTabOpen(value: MenuItem) {
+    this.tabOpen.next(value);
+  }
+
+  openTab(value: MenuItem) {
+    this.tabs = [...this.tabs, value];
+  }
+
+  onTabClose(value: MenuItem, index: number) {
+    this.tabClose.next({tab: value, index: index});
+  }
+
+  closeTab(index: number) {
+    this.tabs.splice(index, 1);
+    this.tabs = [...this.tabs];
+  }
+
+}

package/_template/{{project}}-ihm/src/app/shared/components/code/code.component.ts

@@ -0,0 +1,22 @@
+import { Component, Input, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HighlightModule } from "ngx-highlightjs";
+
+@Component({
+  selector: 'app-code',
+  template: `
+    <pre><code class="border-round" [highlight]="code"></code></pre>
+    `
+})
+export class AppCodeComponent {
+  @Input() code: string;
+
+}
+
+@NgModule({
+  imports: [CommonModule, HighlightModule],
+  exports: [AppCodeComponent],
+  declarations: [AppCodeComponent]
+})
+export class AppCodeModule {
+}

package/_template/{{project}}-ihm/src/app/shared/components/indic/indic.component.html

@@ -0,0 +1,8 @@
+<div class="grid p-card {{bgColor()}} p-0 mt-2 mb-3 col-12 md:col-offset-1 md:col-7 lg:col-5">
+  <div class="flex col-1 md:col-2 justify-content-center align-items-center">
+    <span class="pi {{icone()}} p-2" style="font-size: 2rem"></span>
+  </div>
+  <div class="flex col-10 ml-0 pl-0 align-items-center">
+    <ng-content></ng-content>
+  </div>
+</div>

package/_template/{{project}}-ihm/src/app/shared/components/indic/indic.component.spec.ts

@@ -0,0 +1,23 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { IndicComponent } from './indic.component';
+
+describe('IndicComponent', () => {
+  let component: IndicComponent;
+  let fixture: ComponentFixture<IndicComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ IndicComponent ]
+    })
+    .compileComponents();
+
+    fixture = TestBed.createComponent(IndicComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

package/_template/{{project}}-ihm/src/app/shared/components/indic/indic.component.ts

@@ -0,0 +1,61 @@
+import { Component, Input, OnInit } from '@angular/core';
+import { LayoutService } from "../../../layout/service/app.layout.service";
+
+@Component({
+  selector: 'app-indic',
+  templateUrl: './indic.component.html',
+  styleUrls: ['./indic.component.scss']
+})
+export class IndicComponent implements OnInit {
+  @Input() type: string;
+
+  constructor(public layoutService: LayoutService) {
+  }
+
+  ngOnInit(): void {
+  }
+
+  bgColor(): string {
+    const luminosite: string = this.layoutService.config.colorScheme === 'light' ? "200":"400";
+
+    const defaut: string = "bg-primary-" + luminosite;
+    if (!this.type) {
+      return defaut;
+    }
+    switch (this.type) {
+      case "astuce": {
+        return "bg-green-"+luminosite;
+      }
+      case "avertissement": {
+        return "bg-yellow-"+ luminosite;
+      }
+      case "danger": {
+        return "bg-red-"+luminosite;
+      }
+      default: {
+        return defaut;
+      }
+    }
+  }
+
+  icone(): string {
+    const defaut: string = "pi-comment";
+    if (!this.type) {
+      return defaut;
+    }
+    switch (this.type) {
+      case "astuce": {
+        return "pi-verified";
+      }
+      case "avertissement": {
+        return "pi-bolt";
+      }
+      case "danger": {
+        return "pi-ban";
+      }
+      default: {
+        return defaut;
+      }
+    }
+  }
+}

package/_template/{{project}}-ihm/src/app/shared/constants/dateFormat.constants.ts

@@ -0,0 +1 @@
+export const dateFormat = 'dd/MM/yyyy';

package/_template/{{project}}-ihm/src/app/shared/constants/mocks/user-mocks.constants.ts

@@ -0,0 +1,36 @@
+import {User} from '../../entities/user.model';
+import {Roles} from '../../enums/roles.enums';
+
+export const mockedUser: User = {
+  email: 'test@{{project}}.fr',
+  id: 1,
+  idDirectionCourante: 1,
+  roleActifList: [Roles.Admin{{projectID}}],
+  nbDirections: 0,
+};
+
+export const mockedUserAdmin{{projectID}}: User = {
+  email: 'test2@{{project}}.fr',
+  id: 2,
+  idDirectionCourante: 1,
+  roleActifList: [Roles.Admin{{projectID}}],
+  nbDirections: 0,
+};
+
+export const mockedUserOperateur: User = {
+  email: 'test3@{{project}}.fr',
+  id: 3,
+  idDirectionCourante: 1,
+  roleActifList: [Roles.Operateur],
+  nbDirections: 0,
+};
+
+export const mockedUserConsultant: User = {
+  email: 'test4@{{project}}.fr',
+  id: 4,
+  idDirectionCourante: 1,
+  roleActifList: [Roles.Consultant],
+  nbDirections: 0,
+};
+
+export const mockedAdmin{{projectID}}List: User[] = [mockedUser, mockedUserAdmin{{projectID}}];

package/_template/{{project}}-ihm/src/app/shared/constants/pagination.constants.ts

@@ -0,0 +1 @@
+export const LIGNES_PAR_PAGE = 5;

package/_template/{{project}}-ihm/src/app/shared/core/config/application-config.service.spec.ts

@@ -0,0 +1,16 @@
+import {TestBed} from '@angular/core/testing';
+
+import {ApplicationConfigService} from './application-config.service';
+
+describe('ApplicationConfigService', () => {
+  let service: ApplicationConfigService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ApplicationConfigService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/_template/{{project}}-ihm/src/app/shared/core/config/application-config.service.ts

@@ -0,0 +1,46 @@
+import {Injectable} from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ApplicationConfigService {
+  private _endpointPrefix = '';
+  private _endpointPrefixApiOpen = '';
+  private _endpointGeoApiGouvFr = '';
+
+  get endpointPrefix(): string {
+    return this._endpointPrefix;
+  }
+
+  set endpointPrefix(value: string) {
+    this._endpointPrefix = value;
+  }
+
+  get endpointPrefixApiOpen(): string {
+    return this._endpointPrefixApiOpen;
+  }
+
+  set endpointPrefixApiOpen(value: string) {
+    this._endpointPrefixApiOpen = value;
+  }
+
+  get endpointGeoApiGouvFr(): string {
+    return this._endpointGeoApiGouvFr;
+  }
+
+  set endpointGeoApiGouvFr(value: string) {
+    this._endpointGeoApiGouvFr = value;
+  }
+
+  getEndpointFor(api: string): string {
+    return `${this.endpointPrefix}${api}`;
+  }
+
+  getEndpointForApiOpen(api: string): string {
+    return `${this.endpointPrefixApiOpen}${api}`;
+  }
+
+  getEndpointGeoApiGouvFr(api: string): string {
+    return `${this.endpointGeoApiGouvFr}${api}`
+  }
+}

package/_template/{{project}}-ihm/src/app/shared/core/guard/can-modify.guard.spec.ts

@@ -0,0 +1,98 @@
+import {TestBed} from '@angular/core/testing';
+
+import {CanModifyGuard} from './can-modify.guard';
+import {HttpClientTestingModule} from '@angular/common/http/testing';
+import {ActivatedRoute, Router, RouterModule, UrlTree} from '@angular/router';
+import {UserService} from '../../service/user.service';
+import {User} from '../../entities/user.model';
+import {mockedUser} from '../../constants/mocks/user-mocks.constants';
+import {Roles} from '../../enums/roles.enums';
+import {Observable, of} from 'rxjs';
+import {HttpResponse} from '@angular/common/http';
+
+describe('CanModifyGuard', () => {
+  let guard: CanModifyGuard;
+  let userService: UserService;
+  let mockedCurrentUser: User = { ...mockedUser };
+  let router: Router;
+  let route: ActivatedRoute;
+  const routerStateSnapShotMock: any = {};
+  let resultat: boolean | UrlTree;
+  const mockUrlTree: UrlTree = new UrlTree();
+  let userHasRoleSpy: jasmine.Spy;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule, RouterModule.forRoot([])],
+    });
+    guard = TestBed.inject(CanModifyGuard);
+    router = TestBed.inject(Router);
+    userService = TestBed.inject(UserService);
+    route = TestBed.inject(ActivatedRoute);
+    spyOn(router, 'parseUrl').and.returnValue(mockUrlTree);
+    userHasRoleSpy = spyOn(userService, 'userHasRole');
+  });
+
+  it('should be created', () => {
+    expect(guard).toBeTruthy();
+  });
+
+  it('should redirect to accueil with role Consultant', () => {
+    mockedCurrentUser.roleActifList = [Roles.Consultant];
+    spyOnProperty(userService, 'currentUser').and.returnValue(mockedCurrentUser);
+    userHasRoleSpy.and.returnValue(false);
+
+    const resultat = guard.canActivate(route.snapshot, routerStateSnapShotMock);
+
+    expect(resultat).toBe(mockUrlTree);
+  });
+
+  it('should return true with role Admin{{projectID}}', () => {
+    mockedCurrentUser.roleActifList = [Roles.Admin{{projectID}}];
+    spyOnProperty(userService, 'currentUser').and.returnValue(mockedCurrentUser);
+    userHasRoleSpy.withArgs(Roles.Admin{{projectID}}).and.returnValue(true);
+
+    const resultat = guard.canActivate(route.snapshot, routerStateSnapShotMock);
+
+    expect(resultat).toBeTrue();
+  });
+
+  it('should return true with role Operateur', () => {
+    mockedCurrentUser.roleActifList = [Roles.Operateur];
+    spyOnProperty(userService, 'currentUser').and.returnValue(mockedCurrentUser);
+    userHasRoleSpy.withArgs(Roles.Admin{{projectID}}).and.returnValue(false);
+    userHasRoleSpy.withArgs(Roles.Operateur).and.returnValue(true);
+
+    const resultat = guard.canActivate(route.snapshot, routerStateSnapShotMock);
+
+    expect(resultat).toBeTrue();
+  });
+
+  it('should return observable of true with no current User and role Admin{{projectID}}', () => {
+    mockedCurrentUser.roleActifList = [Roles.Admin{{projectID}}];
+    spyOn(userService, 'getCurrentUser').and.returnValue(of(new HttpResponse({ body: mockedCurrentUser })));
+    userHasRoleSpy.withArgs(Roles.Admin{{projectID}}).and.returnValue(true);
+
+    const obs = guard.canActivate(route.snapshot, routerStateSnapShotMock) as Observable<boolean>;
+
+    obs.subscribe(b => {
+      resultat = b;
+    });
+
+    expect(resultat).toBeTrue();
+  });
+
+  it('should return observable of Urltree with no current User and role Consultant', () => {
+    mockedCurrentUser.roleActifList = [Roles.Consultant];
+    spyOn(userService, 'getCurrentUser').and.returnValue(of(new HttpResponse({ body: mockedCurrentUser })));
+    userHasRoleSpy.and.returnValue(false);
+
+    const obs = guard.canActivate(route.snapshot, routerStateSnapShotMock) as Observable<UrlTree>;
+
+    obs.subscribe(tree => {
+      resultat = tree;
+    });
+
+    expect(resultat).toBe(mockUrlTree);
+  });
+});

package/_template/{{project}}-ihm/src/app/shared/core/guard/can-modify.guard.ts

@@ -0,0 +1,36 @@
+import {Injectable} from '@angular/core';
+import {ActivatedRouteSnapshot, CanActivate, Router, RouterStateSnapshot, UrlTree} from '@angular/router';
+import {Observable, of} from 'rxjs';
+import {UserService} from '../../service/user.service';
+import {mergeMap} from 'rxjs/operators';
+import {Roles} from '../../enums/roles.enums';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CanModifyGuard implements CanActivate {
+  constructor(private userService: UserService, private router: Router) {}
+
+  canActivate(
+    route: ActivatedRouteSnapshot,
+    state: RouterStateSnapshot
+  ): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree {
+    if (this.userService.currentUser) {
+      if (this.userService.userHasRole(Roles.Admin{{projectID}}) || this.userService.userHasRole(Roles.Operateur)) {
+        return true;
+      }
+      return this.router.parseUrl('/');
+    }
+    return this.userService.getCurrentUser().pipe(
+      mergeMap(res => {
+        if (res.body) {
+          this.userService.currentUser = res.body;
+          if (this.userService.userHasRole(Roles.Admin{{projectID}}) || this.userService.userHasRole(Roles.Operateur)) {
+            return of(true);
+          }
+        }
+        return of(this.router.parseUrl('/'));
+      })
+    );
+  }
+}

package/_template/{{project}}-ihm/src/app/shared/core/guard/login.guard.spec.ts

@@ -0,0 +1,21 @@
+import {TestBed} from '@angular/core/testing';
+
+import {LoginGuard} from './login.guard';
+import {OAuthModule} from 'angular-oauth2-oidc';
+import {HttpClientTestingModule} from '@angular/common/http/testing';
+
+describe('LoginGuard', () => {
+  let guard: LoginGuard;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [],
+      imports: [HttpClientTestingModule, OAuthModule.forRoot()],
+    });
+    guard = TestBed.inject(LoginGuard);
+  });
+
+  it('should be created', () => {
+    expect(guard).toBeTruthy();
+  });
+});

package/_template/{{project}}-ihm/src/app/shared/core/guard/login.guard.ts

@@ -0,0 +1,23 @@
+import {Injectable} from '@angular/core';
+import {ActivatedRouteSnapshot, CanActivate, RouterStateSnapshot, UrlTree} from '@angular/router';
+import {Observable} from 'rxjs';
+import {OAuthService} from 'angular-oauth2-oidc';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LoginGuard implements CanActivate {
+  constructor(private oauthService: OAuthService) {}
+
+  canActivate(
+    route: ActivatedRouteSnapshot,
+    state: RouterStateSnapshot
+  ): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree {
+    if (this.oauthService.hasValidAccessToken() && this.oauthService.hasValidIdToken()) {
+      return true;
+    } else {
+      this.oauthService.initLoginFlow();
+      return false;
+    }
+  }
+}

package/_template/{{project}}-ihm/src/app/shared/core/interceptor/handle-req.interceptor.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse, HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { Router } from "@angular/router";
+
+@Injectable()
+export class HandleReqInterceptor implements HttpInterceptor {
+  constructor(private router: Router) {
+  }
+
+  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    return next.handle(request).pipe(
+      tap({
+        error: (err: HttpErrorResponse) => {
+
+          //TODO :  A REFAIRE
+
+
+          let debugMessage = err.error?.errors[0]?.debugMessage?.match('"(.*)"');
+          let message: string = debugMessage === null || debugMessage === undefined ? err.error?.errors[0]?.message : debugMessage[1];
+          if (err?.status === 500) {
+          } else if (err.status === 401) {
+            sessionStorage.clear();
+            this.router.navigateByUrl('/deconnexion');
+          }
+        },
+      })
+    );
+  }
+}

package/_template/{{project}}-ihm/src/app/shared/core/interceptor/index.ts

@@ -0,0 +1,10 @@
+import {HTTP_INTERCEPTORS} from '@angular/common/http';
+import {HandleReqInterceptor} from './handle-req.interceptor';
+
+export const HttpInterceptorProviders = [
+  {
+    provide: HTTP_INTERCEPTORS,
+    useClass: HandleReqInterceptor,
+    multi: true,
+  },
+];

package/_template/{{project}}-ihm/src/app/shared/core/request/pageable.model.ts

@@ -0,0 +1,5 @@
+export interface Pageable {
+  page: number;
+  size: number;
+  sort?: string[];
+}

package/_template/{{project}}-ihm/src/app/shared/core/request/request-util.ts

@@ -0,0 +1,21 @@
+import {HttpParams} from '@angular/common/http';
+
+export const createRequestOption = (req?: any): HttpParams => {
+  let options: HttpParams = new HttpParams();
+
+  if (req) {
+    Object.keys(req).forEach(key => {
+      if (key !== 'sort' && req[key]) {
+        options = options.set(key, req[key]);
+      }
+    });
+  }
+
+  if (req.sort) {
+    req.sort.forEach((val: string) => {
+      options = options.append('sort', val);
+    });
+  }
+
+  return options;
+};

package/_template/{{project}}-ihm/src/app/shared/core/resolver/accueil.resolver.spec.ts

@@ -0,0 +1,21 @@
+import {TestBed} from '@angular/core/testing';
+
+import {AccueilResolver} from './accueil.resolver';
+import {HttpClientTestingModule} from '@angular/common/http/testing';
+import {CUSTOM_ELEMENTS_SCHEMA} from '@angular/core';
+
+describe('AccueilResolver', () => {
+  let resolver: AccueilResolver;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
+    });
+    resolver = TestBed.inject(AccueilResolver);
+  });
+
+  it('should be created', () => {
+    expect(resolver).toBeTruthy();
+  });
+});

package/_template/{{project}}-ihm/src/app/shared/core/resolver/accueil.resolver.ts

@@ -0,0 +1,18 @@
+import {Injectable} from '@angular/core';
+import {Resolve} from '@angular/router';
+import {Observable} from 'rxjs';
+import {User} from '../../entities/user.model';
+import {UserService} from '../../service/user.service';
+import {HttpResponse} from '@angular/common/http';
+import {take} from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class AccueilResolver implements Resolve<HttpResponse<User>> {
+  constructor(private userService: UserService) {}
+
+  resolve(): Observable<HttpResponse<User>> {
+    return this.userService.getCurrentUser().pipe(take(1));
+  }
+}

package/_template/{{project}}-ihm/src/app/shared/core/storage/MyLocalStorageService.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { OAuthStorage } from 'angular-oauth2-oidc';
+import { environment } from "../../../../environments/environment";
+
+@Injectable({
+  providedIn: 'root',
+})
+export class MyLocalStorageService {
+
+  private prefix: string = environment.clientId + '_';
+
+  getItem(key: string): string | null {
+    return localStorage.getItem(this.prefix + key);
+  }
+
+  removeItem(key: string): void {
+    localStorage.removeItem(this.prefix + key);
+  }
+
+  setItem(key: string, data: string): void {
+    localStorage.setItem(this.prefix + key, data);
+  }
+}