src/app/profile/structure-edition-summary/structure-edition-summary.component.scss

 @import '../../../assets/scss/color';
 @import '../../../assets/scss/typography';
+@import '../../../assets/scss/breakpoint';
+@import '../../../assets/scss/layout';
+
+::ng-deep svg {
+  cursor: pointer;
+}
+
+::ng-deep .editButton {
+  width: 132px !important;
+}
+
+::ng-deep .buttons svg {
+  height: 1.4rem !important;
+}
 
 .container {
-  margin: 1rem auto;
-  width: 100%;
-  max-width: 980px;
-  padding: 2rem;
   background: $white;
   border-radius: 8px;
   border: 1px solid $grey-6;
-  .head {
-    cursor: pointer;
-  }
-  .summary {
-    width: 100%;
-    .h2 {
-      @include lato-regular-24;
+  box-sizing: border-box;
+  margin: 1rem auto;
+  padding: 2rem;
+  max-width: 980px;
+  height: calc(100% - $header-height - $footer-height);
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+
+  .scroll {
+    height: 90%;
+    overflow-y: scroll;
+    overflow-x: hidden;
+    padding-right: 5px;
+
+    p {
+      margin: 0;
     }
-    .itemSummary {
-      height: 40px;
-      cursor: pointer;
-      border-bottom: 1px solid $grey-6;
-      &:hover span {
-        text-decoration: underline;
+    .header {
+      display: flex;
+      align-items: center;
+      margin-bottom: 1.5rem;
+
+      h2 {
+        @include lato-regular-24;
+        margin: 0;
+        span {
+          color: $red;
+        }
       }
-      .invalidText {
-        @include lato-regular-13;
-        margin: 0 0.5rem;
-        color: $orange-warning;
+    }
+
+    .section {
+      margin-top: 1rem;
+
+      .sectionHeader {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        @include lato-bold-16;
+        p {
+          margin: 0;
+        }
       }
+      .content {
+        p {
+          margin: 0 0 4px 0;
+        }
+
+        .hours {
+          width: 200px;
+          margin-bottom: 8px;
+          display: flex;
+          flex-direction: row;
+          place-content: flex-start space-between;
+          .day {
+            color: $grey-3;
+            text-transform: capitalize;
+          }
+          .openingTime {
+            display: flex;
+            flex-direction: column;
+            gap: 4px;
+            align-items: flex-start;
+          }
+        }
+
+        .socials {
+          display: flex;
+          gap: 0.5rem;
+          margin-top: 0.5rem;
+        }
+
+        .list {
+          margin-bottom: 8px;
+          p {
+            display: list-item;
+            margin: 0 0 0 25px;
+          }
+        }
+
+        .formationDetails {
+          padding-top: 0.5rem;
+          .collapse {
+            margin-bottom: 13px;
+            @media #{$small-phone} {
+              width: 95% !important;
+            }
+            &.notCollapsed {
+              border-bottom: 2px solid $grey-8;
+              .logo {
+                .hide {
+                  display: none;
+                }
+                .show {
+                  display: block;
+                }
+              }
+            }
+            .titleCollapse {
+              width: 100%;
+              @include lato-regular-16;
+            }
+            .collapseHeader {
+              display: flex;
+              justify-content: space-between;
+              cursor: pointer;
+            }
+            .logo {
+              height: 24px;
+              width: 24px;
+              svg {
+                width: 100%;
+                height: 100%;
+                fill: $grey-1;
+              }
+            }
+            .logo,
+            .titleCollapse {
+              .hide {
+                display: block;
+              }
+              .show {
+                display: none;
+              }
+            }
+            .detailsContainer {
+              margin: 8px 0px;
+              padding: 8px 0;
+              background-color: $grey-8;
+              overflow: hidden;
+              border-radius: 4px;
+            }
+            .details {
+              padding: 8px 16px;
+            }
+          }
+        }
+      }
+    }
+  }
+  .footer {
+    border-top: 1px solid $grey-4;
+    p.warning {
+      color: $orange-warning;
+      margin: 1rem 0 0 0;
     }
-    .last {
-      border: none !important;
+    .buttons {
+      display: flex;
+      justify-content: center;
+      gap: 24px;
+      padding-top: 1rem;
     }
   }
 }

src/app/profile/structure-edition-summary/structure-edition-summary.component.ts

+import { animate, AUTO_STYLE, state, style, transition, trigger } from '@angular/animations';
 import { Component, OnInit } from '@angular/core';
 import { UntypedFormGroup } from '@angular/forms';
 import { ActivatedRoute, Router } from '@angular/router';
+import * as lodash from 'lodash';
+import { DateTime } from 'luxon';
 import { structureFormStep } from '../../form/form-view/structure-form/structureFormStep.enum';
 import { Structure } from '../../models/structure.model';
+import { NotificationService } from '../../services/notification.service';
+import { StructureService } from '../../services/structure.service';
+import { ButtonType } from '../../shared/components/button/buttonType.enum';
+import { Demarches } from '../../shared/enum/demarches.enum';
+import { FreeWorkshop } from '../../shared/enum/freeWorkshop.enum';
+import { OtherServices } from '../../shared/enum/otherServices.enum';
+import { AccessModality } from '../../structure-list/enum/access-modality.enum';
+import { Equipment } from '../../structure-list/enum/equipment.enum';
+import { PublicCategorie } from '../../structure-list/enum/public.enum';
+import { Category } from '../../structure-list/models/category.model';
+import { Module } from '../../structure-list/models/module.model';
+import { SearchService } from '../../structure-list/services/search.service';
 import { formUtils, IStructureSummary } from '../../utils/formUtils';
+import { Utils } from '../../utils/utils';
 
 @Component({
   selector: 'app-structure-edition-summary',
   templateUrl: './structure-edition-summary.component.html',
   styleUrls: ['./structure-edition-summary.component.scss'],
+  animations: [
+    trigger('show', [
+      state('true', style({ height: AUTO_STYLE, visibility: AUTO_STYLE, margin: '8px 0' })),
+      state('false', style({ height: '0px', visibility: 'hidden', margin: '0' })),
+      transition('true => false', animate('300ms ease-out')),
+      transition('false => true', animate('300ms ease-out')),
+    ]),
+  ],
 })
 export class StructureEditionSummaryComponent implements OnInit {
   public structure: Structure;
   public structureForm: UntypedFormGroup;
-  constructor(private route: ActivatedRoute, private router: Router) {}
   public summary: IStructureSummary[] = new formUtils().structureSummary;
   public structureFormStep = structureFormStep;
+  public buttonTypeEnum = ButtonType;
+  public equipmentEnum = Equipment;
+
+  //Digital learning
+  public baseSkillssReferentiel: Category;
+  public accessRightsReferentiel: Category;
+  public digitalCultureSecuritysReferentiel: Category;
+  public socialAndProfessionalsReferentiel: Category;
+  public parentingHelpsReferentiel: Category;
+  public baseSkills: Module[];
+  public accessRights: Module[];
+  public parentingHelp: Module[];
+  public socialAndProfessional: Module[];
+  public digitalCultureSecurity: Module[];
+  public showBaseSkills = false;
+  public showAccessRights = false;
+  public showParentingHelp = false;
+  public showSocialAndProfessional = false;
+  public showDigitalSecurity = false;
+
+  public mailHref: string;
+  // set to true when last updated date of a structure is > 6 months
+  public isUpdateStructure = false;
+
+  constructor(
+    private notificationService: NotificationService,
+    private route: ActivatedRoute,
+    private searchService: SearchService,
+    private structureService: StructureService,
+    private utils: Utils,
+    public router: Router
+  ) {}
 
   // There is a non-blocking error in console when open edit mode that occurs only in development mode, please refer https://angular.io/errors/NG0100 for more info
 
@@ -23,22 +78,199 @@ export class StructureEditionSummaryComponent implements OnInit {
     this.route.data.subscribe((data) => {
       if (data.structure) {
         this.structure = new Structure(data.structure);
-        this.structureForm = new formUtils().createStructureForm(this.structure);
+        this.structureForm = new formUtils().createStructureForm(this.structure, true);
+        if (this.structure.contactMail) this.mailHref = `mailto:${this.structure.contactMail}`;
+
+        const updatedAt = DateTime.fromISO(this.structure.updatedAt);
+        const sixMonthsAgo = DateTime.local().minus({ month: 6 });
+        if (updatedAt < sixMonthsAgo) this.isUpdateStructure = true;
       }
+      this.initForm();
     });
   }
+
   public goBack(): void {
     history.back();
   }
   public goToEdit(step: structureFormStep): void {
     this.router.navigate(['/form/structure', this.structure._id, structureFormStep[step]]);
   }
-  public isPageValid(page: IStructureSummary): boolean {
-    if (page.inputs) {
-      for (let input of page.inputs) {
-        if (!this.structureForm.get(input).valid) return false;
+
+  public isFormValid(): boolean {
+    for (const field in this.structure) {
+      if (!['_id', 'numero', 'createdAt', 'updatedAt'].includes(field)) {
+        if (this.structureForm.get(field)?.valid === false) return false;
       }
     }
     return true;
   }
+
+  public updateStructure(): void {
+    this.structureService.editStructure({}, this.structure._id).subscribe(() => {
+      this.notificationService.showSuccess('La structure a bien été mise à jour.', '');
+      this.isUpdateStructure = false;
+    });
+  }
+
+  public keepOriginalOrder = (a, _b) => a.key;
+
+  public formatAddress(): string {
+    let address = '';
+    if (this.structure.address.numero) address += `${this.structure.address.numero} `;
+    if (this.structure.address.street) address += `${this.structure.address.street}, `;
+    if (this.structure.address.commune) address += `${this.structure.address.commune}`;
+    return address;
+  }
+
+  public getAccessLabel(accessModality: AccessModality): string {
+    return this.utils.getAccessLabel(accessModality);
+  }
+
+  public containsHours(): boolean {
+    let contains = false;
+    for (const day in this.structure.hours) {
+      if (this.structure.hours[day].time.length) contains = true;
+    }
+    return contains;
+  }
+
+  public isFieldValid(field: string): boolean {
+    return this.structureForm.get([field]).valid;
+  }
+
+  public hasSocialNetworks(): boolean {
+    return this.utils.hasSocialNetwork(this.structure);
+  }
+
+  public hasWebsite(): boolean {
+    return this.utils.hasWebsite(this.structure);
+  }
+
+  public getPublicLabel(tagetPublic: PublicCategorie): string {
+    return this.utils.getPublicLabel(tagetPublic);
+  }
+
+  public containsDigitalHelp(): boolean {
+    return !!this.structure.proceduresAccompaniment.length;
+  }
+
+  public getDigitalHelpLabel(digitalHelp: Demarches): string {
+    return this.utils.getDigitalHelpLabel(digitalHelp);
+  }
+
+  // Digital learning
+  private async initForm(): Promise<void> {
+    this.searchService.getCategoriesTraining().subscribe((referentiels) => {
+      referentiels.forEach((referentiel) => {
+        if (referentiel.isBaseSkills()) {
+          this.baseSkillssReferentiel = referentiel;
+        } else if (referentiel.isRigthtsAccess()) {
+          this.accessRightsReferentiel = referentiel;
+        } else if (referentiel.isDigitalCultureSecurity()) {
+          this.digitalCultureSecuritysReferentiel = referentiel;
+        } else if (referentiel.isParentingHelp()) {
+          this.parentingHelpsReferentiel = referentiel;
+        } else if (referentiel.isSocialAndProfessional()) {
+          this.socialAndProfessionalsReferentiel = referentiel;
+        }
+      });
+      this.setServiceCategories();
+    });
+    const index = this.structure.proceduresAccompaniment.indexOf('autres');
+    if (index > -1) {
+      this.structure.proceduresAccompaniment.splice(index, 1);
+    }
+  }
+
+  public setServiceCategories(): void {
+    this.baseSkills = this.structure.baseSkills.map((skill) =>
+      lodash.find(this.baseSkillssReferentiel.modules, { id: skill })
+    );
+    this.accessRights = this.structure.accessRight.map((rights) =>
+      lodash.find(this.accessRightsReferentiel.modules, { id: rights })
+    );
+    this.parentingHelp = this.structure.parentingHelp.map((help) =>
+      lodash.find(this.parentingHelpsReferentiel.modules, { id: help })
+    );
+    this.socialAndProfessional = this.structure.socialAndProfessional.map((skill) =>
+      lodash.find(this.socialAndProfessionalsReferentiel.modules, { id: skill })
+    );
+    this.digitalCultureSecurity = this.structure.digitalCultureSecurity.map((skill) =>
+      lodash.find(this.digitalCultureSecuritysReferentiel.modules, { id: skill })
+    );
+  }
+  public isBaseSkills(): boolean {
+    return this.baseSkills && this.baseSkills[0] !== undefined;
+  }
+  public isAccessRights(): boolean {
+    return this.accessRights && this.accessRights[0] !== undefined;
+  }
+  public isParentingHelp(): boolean {
+    return this.parentingHelp && this.parentingHelp[0] !== undefined;
+  }
+  public isSocialAndProfessional(): boolean {
+    return this.socialAndProfessional && this.socialAndProfessional[0] !== undefined;
+  }
+  public isDigitalSecurity(): boolean {
+    return this.digitalCultureSecurity && this.digitalCultureSecurity[0] !== undefined;
+  }
+  public containsDigitalLearning(): boolean {
+    return (
+      this.isAccessRights() ||
+      this.isBaseSkills() ||
+      this.isDigitalSecurity() ||
+      this.isParentingHelp() ||
+      this.isSocialAndProfessional()
+    );
+  }
+  public toggleBaseSkills(): void {
+    this.showBaseSkills = !this.showBaseSkills;
+  }
+  public toggleAccessRights(): void {
+    this.showAccessRights = !this.showAccessRights;
+  }
+  public toggleParentingHelp(): void {
+    this.showParentingHelp = !this.showParentingHelp;
+  }
+  public toggleSocialAndProfessional(): void {
+    this.showSocialAndProfessional = !this.showSocialAndProfessional;
+  }
+  public toggleDigitalSecurity(): void {
+    this.showDigitalSecurity = !this.showDigitalSecurity;
+  }
+
+  public getWorkshopPricingLabel(freeWorkshop: FreeWorkshop): string {
+    return this.utils.getWorkshopPricingLabel(freeWorkshop);
+  }
+
+  public hasWifi(equipmentsAndServices: string[]) {
+    return this.utils.hasWifi(equipmentsAndServices);
+  }
+
+  public hasEquipments(structure: Structure): boolean {
+    return this.utils.hasEquipments(
+      structure.equipmentsAndServices,
+      structure.nbComputers,
+      structure.nbNumericTerminal,
+      structure.nbPrinters,
+      structure.nbScanners,
+      structure.nbTablets
+    );
+  }
+
+  public filterOnlyEquipments(equipmentsAndServices: string[]): string[] {
+    return this.utils.filterOnlyEquipments(equipmentsAndServices);
+  }
+
+  public getEquipmentsLabelAndValue(equipment: Equipment, number: number): string {
+    return this.utils.getEquipmentsLabelAndValue(equipment, number);
+  }
+
+  public filterOtherServices(equipmentsAndServices: string[]) {
+    return this.utils.filterOtherServices(equipmentsAndServices);
+  }
+
+  public getOtherServicesLabel(otherService: OtherServices) {
+    return this.utils.getOtherServicesLabel(otherService);
+  }
 }

src/app/services/auth.service.ts

@@ -36,7 +36,7 @@ export class AuthService {
 
   public isLoggedIn(): boolean {
     if (this.userValue) {
-      return new DateTime.local().setZone('Europe/Paris') < this.getExpiration();
+      return DateTime.local().setZone('Europe/Paris') < this.getExpiration();
     }
     return false;
   }

src/app/services/structure.service.ts

 import { HttpClient } from '@angular/common/http';
 import { Injectable } from '@angular/core';
-import { WeekDay } from '@angular/common';
+import * as _ from 'lodash';
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
-import * as _ from 'lodash';
-const { DateTime } = require('luxon');
-
-import { Structure } from '../models/structure.model';
-import { Day } from '../models/day.model';
 import { OpeningDay } from '../models/openingDay.model';
-import { Weekday } from '../structure-list/enum/weekday.enum';
-import { Time } from '../models/time.model';
-import { Filter } from '../structure-list/models/filter.model';
-import { User } from '../models/user.model';
+import { Structure } from '../models/structure.model';
 import { StructureWithOwners } from '../models/structureWithOwners.model';
 import { TempUser } from '../models/temp-user.model';
+import { User } from '../models/user.model';
+import { WeekDayEnum } from '../shared/enum/weekDay.enum';
+import { Weekday } from '../structure-list/enum/weekday.enum';
+import { Filter } from '../structure-list/models/filter.model';
+const { DateTime } = require('luxon');
 
 @Injectable({
   providedIn: 'root',
@@ -34,16 +31,17 @@ export class StructureService {
     return this.http.post(`${this.baseUrl}`, { structure, idUser }).pipe(map((item: Structure) => new Structure(item)));
   }
 
-  public editStructure(structure: Structure): Observable<Structure> {
+  public editStructure(structure: Partial<Structure>, structureId?: string): Observable<Structure> {
     structure.updatedAt = new Date().toString();
     if (structure.dataShareConsentDate) {
       structure.dataShareConsentDate = new Date().toString();
-    } else {
-      structure.dataShareConsentDate = null;
     }
-    const id = structure._id;
+    if (!structureId) structureId = structure._id;
+    // const id = structure._id;
     delete structure._id; // id should not be provided for update
-    return this.http.put(`${this.baseUrl}/${id}`, structure).pipe(map((item: Structure) => new Structure(item)));
+    return this.http
+      .patch(`${this.baseUrl}/${structureId}`, structure)
+      .pipe(map((item: Structure) => new Structure(item)));
   }
 
   public isClaimed(id: string, profile: User): Observable<boolean> {
@@ -151,7 +149,8 @@ export class StructureService {
           }
           // Return the next day > current day.
         } else if (
-          this.getEnumKeyByEnumValue(WeekDay, i) > this.getEnumKeyByEnumValue(WeekDay, this.numberToDay(dayOfWeek))
+          this.getEnumKeyByEnumValue(WeekDayEnum, i) >
+          this.getEnumKeyByEnumValue(WeekDayEnum, this.numberToDay(dayOfWeek))
         ) {
           return new OpeningDay(i, this.numberToHour(period.time[0].opening));
           // Return the next day < current day.

src/app/shared/components/password-form/password-form.component.ts

@@ -6,6 +6,7 @@ import { AuthService } from '../../../services/auth.service';
 import { CustomRegExp } from '../../../utils/CustomRegExp';
 import { MustMatch } from '../../validator/form';
 import { ButtonType } from '../button/buttonType.enum';
+
 @Component({
   selector: 'app-password-form',
   templateUrl: './password-form.component.html',

src/app/shared/components/svg-icon/svg-icon.component.ts

@@ -11,5 +11,4 @@ export class SvgIconComponent {
   @Input() type: string;
   @Input() iconColor: string = 'none';
   @Input() title: string = null;
-  constructor() {}
 }

src/app/shared/components/text-input-modal/text-input-modal.component.ts

@@ -13,7 +13,6 @@ export class TextInputModalComponent {
   @Output() newContent = new EventEmitter<{ content: string; shouldSend: boolean }>();
 
   public myContent: string;
-  constructor() {}
 
   public closeModal(shouldSend: boolean, content: string) {
     this.newContent.emit({ content, shouldSend });

src/app/shared/components/training-type-picker/training-type-picker.component.ts

@@ -53,6 +53,7 @@ export class TrainingTypePickerComponent implements OnInit {
         }
         cat.modules = cat.modules.filter((module) => selectedModulesId.includes(module.id));
       });
+      console.log('MOUNT ', this.selectedChoices);
     });
   }
 
@@ -77,7 +78,7 @@ export class TrainingTypePickerComponent implements OnInit {
 
   public pickChoice(categorie: Category, module: Module): void {
     const index = this.selectedChoices.findIndex((_categorie) => _categorie.id === categorie.id);
-    if (this.selectedChoices[index].modules.includes(module)) {
+    if (this.selectedChoices[index].modules.some((choices) => choices.id === module.id)) {
       remove(this.selectedChoices[index].modules, module);
     } else {
       this.selectedChoices[index].modules.push(module);

src/app/shared/enum/demarches.enum.ts

 export enum Demarches {
   accompagnantCaf = 'CAF',
+  autres = 'Autres',
   carsat = 'CARSAT',
   cpam = 'CPAM',
+  demarcheMetropolitaine = 'Démarches Métropolitaines',
   espacePublicNumeriqueepn = 'Espace public Numérique',
   impots = 'Impôts',
   logement = 'Logements',
   poleEmploi = 'Pôle Emploi',
-  autres = 'Autres',
 }

src/app/shared/enum/freeWorkshop.enum.ts

+export enum FreeWorkshop {
+  underCondition = 'Oui, sous condition',
+  true = 'Oui',
+  false = 'Non',
+}

src/app/shared/enum/otherServices.enum.ts

+export enum OtherServices {
+  accesLivresInformatiques = 'Accès à des revues ou livres informatiques et numériques',
+  donDeMateriels = 'Prêt / don de matériels',
+  reconditionnementsDeMateriel = 'Reconditionnements de matériel',
+  venteMaterielPrixSolidaire = 'Vente de matériel à prix solidaire',
+}

src/app/structure-list/services/search.service.ts

@@ -2,6 +2,7 @@ import { HttpClient } from '@angular/common/http';
 import { Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
+import { SearchResults } from '../../annuaire/models/searchQuery.model';
 import { Category } from '../models/category.model';
 import { Module } from '../models/module.model';
 
@@ -26,6 +27,25 @@ export class SearchService {
       .get('/api/categories/categoriesOthers')
       .pipe(map((data: any[]) => data.map((item) => new Category(item))));
   }
+  public getJobs(): Observable<string[]> {
+    return this.http.get('/api/jobs').pipe(map((data: any[]) => data.map((item) => item.name)));
+  }
+  public getEmployers(): Observable<string[]> {
+    return this.http.get('/api/employer').pipe(map((data: any[]) => data.map((item) => item.name)));
+  }
+  public searchUserRegistry(
+    searchTerm: string,
+    page: number,
+    jobs?: string[],
+    employers?: string[]
+  ): Observable<SearchResults> {
+    return this.http
+      .post<any>(`/api/userRegistry/?search=${searchTerm}`, { job: jobs, employer: employers, page: page })
+      .pipe();
+  }
+  public getUserRegistryCount(): Observable<number> {
+    return this.http.get<any>(`/api/userRegistry/count`).pipe();
+  }
   public getIndex(array: Module[], id: string, categ: string): number {
     return array.findIndex((m: Module) => m.id === id && m.text === categ);
   }

src/app/utils/formUtils.ts

@@ -71,6 +71,12 @@ export class formUtils {
       hideForEdit: true,
     },
   ];
+
+  /**
+   * @param structure
+   * @param isEditMode in edit mode, some validations are not required
+   * @returns
+   */
   public createStructureForm(structure: Structure, isEditMode?: boolean): UntypedFormGroup {
     return new UntypedFormGroup({
       _id: new UntypedFormControl(structure._id),

src/app/utils/utils.ts

 import { Injectable } from '@angular/core';
 import { UntypedFormGroup } from '@angular/forms';
+import { Structure } from '../models/structure.model';
 import { User } from '../models/user.model';
+import { Demarches } from '../shared/enum/demarches.enum';
+import { FreeWorkshop } from '../shared/enum/freeWorkshop.enum';
+import { OtherServices } from '../shared/enum/otherServices.enum';
+import { AccessModality } from '../structure-list/enum/access-modality.enum';
+import { Equipment } from '../structure-list/enum/equipment.enum';
+import { PublicCategorie } from '../structure-list/enum/public.enum';
 
 @Injectable({
   providedIn: 'root',
@@ -35,4 +42,117 @@ export class Utils {
     if (jobName && !employerName) return jobName;
     if (jobName && employerName) return `${jobName}, ${employerName}`;
   }
+
+  public getAccessLabel(accessModality: AccessModality): string {
+    switch (accessModality) {
+      case AccessModality.free:
+        return 'Accès libre';
+      case AccessModality.meeting:
+        return 'Sur rendez-vous';
+      case AccessModality.meetingOnly:
+        return 'Uniquement sur RDV';
+      case AccessModality.numeric:
+        return 'Téléphone / Visio';
+      default:
+        return null;
+    }
+  }
+
+  public hasSocialNetwork(structure: Structure): boolean {
+    return (
+      (structure.facebook !== null && structure.facebook !== '') ||
+      (structure.instagram !== null && structure.instagram !== '') ||
+      (structure.linkedin !== null && structure.linkedin !== '') ||
+      (structure.twitter !== null && structure.twitter !== '')
+    );
+  }
+
+  public hasWebsite(structure: Structure): boolean {
+    return structure.website !== null && structure.website !== '';
+  }
+
+  public getPublicLabel(tagetPublic: PublicCategorie): string {
+    switch (tagetPublic) {
+      case PublicCategorie.young:
+        return 'Jeunes (16 - 25 ans)';
+      case PublicCategorie.adult:
+        return 'Adultes';
+      case PublicCategorie.elderly:
+        return 'Séniors (+ de 65 ans)';
+      case PublicCategorie.all:
+        return 'Tout public';
+      case PublicCategorie.under16Years:
+        return 'Moins de 16 ans';
+      case PublicCategorie.women:
+        return 'Uniquement femmes';
+      default:
+        return null;
+    }
+  }
+
+  public getDigitalHelpLabel(digitalHelp: Demarches) {
+    return Demarches[digitalHelp];
+  }
+
+  public getWorkshopPricingLabel(freeWorkshop: FreeWorkshop) {
+    return FreeWorkshop[freeWorkshop];
+  }
+
+  public hasWifi(equipmentsAndServices: string[]) {
+    return equipmentsAndServices.includes('wifiEnAccesLibre');
+  }
+
+  /**
+   * Verify that a structure has equipments and checks that their value is > 0
+   */
+  public hasEquipments(
+    equipmentsAndServices: string[],
+    nbComputers: number,
+    nbNumericTerminal: number,
+    nbPrinters: number,
+    nbScanners: number,
+    nbTablets: number
+  ): boolean {
+    return equipmentsAndServices.length && nbComputers + nbPrinters + nbTablets + nbNumericTerminal + nbScanners > 0;
+  }
+
+  public filterOnlyEquipments(equipmentsAndServices: string[]): string[] {
+    return equipmentsAndServices.filter((equipment) =>
+      ['ordinateurs', 'tablettes', 'bornesNumeriques', 'imprimantes', 'scanners'].includes(equipment)
+    );
+  }
+
+  public getEquipmentsLabelAndValue(equipment: Equipment, number: number): string {
+    switch (equipment) {
+      case Equipment.wifi:
+        return 'Wifi en accès libre';
+      case Equipment.bornes:
+        return number > 1 ? `Bornes numériques : ${number}` : `Borne numérique : 1`;
+      case Equipment.printer:
+        return number > 1 ? `Imprimantes : ${number}` : `Imprimante : 1`;
+      case Equipment.tablet:
+        return number > 1 ? `Tablettes : ${number}` : `Tablette : 1`;
+      case Equipment.computer:
+        return number > 1 ? `Ordinateurs : ${number}` : `Ordinateur : 1`;
+      case Equipment.scanner:
+        return number > 1 ? `Scanners : ${number}` : `Scanner : 1`;
+      default:
+        return null;
+    }
+  }
+
+  public filterOtherServices(equipmentsAndServices: string[]): string[] {
+    return equipmentsAndServices.filter((equipment) =>
+      [
+        'reconditionnementsDeMateriel',
+        'accesLivresInformatiques',
+        'venteMaterielPrixSolidaire',
+        'donDeMateriels',
+      ].includes(equipment)
+    );
+  }
+
+  public getOtherServicesLabel(otherService: OtherServices) {
+    return OtherServices[otherService];
+  }
 }

src/assets/scss/_color.scss

@@ -41,3 +41,4 @@ $ram-hover-principal: $primary-color;
 $scrollbar-track: rgba($grey-8, 0.65);
 $scrollbar-thumb: $grey-4;
 $focus-color: $grey-1;
+$box-shadow-simple: 0px 4px 16px rgba(0, 0, 0, 0.25);

src/styles.scss

@@ -79,7 +79,7 @@ a {
 .ngx-toastr {
   &.toast-success {
     background: white;
-    box-shadow: 0px 4px 16px rgba(0, 0, 0, 0.25);
+    box-shadow: $box-shadow-simple;
     color: $grey-1;
     border: solid 3px $green-1;
     &::after {
@@ -91,7 +91,7 @@ a {
   }
   &.toast-error {
     background: white;
-    box-shadow: 0px 4px 16px rgba(0, 0, 0, 0.25);
+    box-shadow: $box-shadow-simple;
     color: $grey-1;
     border: solid 3px $red-error;
     &::after {
@@ -103,7 +103,7 @@ a {
   }
   &.toast-info {
     background: white;
-    box-shadow: 0px 4px 16px rgba(0, 0, 0, 0.25);
+    box-shadow: $box-shadow-simple;
     color: $grey-1;
     border: solid 3px $blue;
     &::after {
@@ -342,7 +342,7 @@ button {
     top: 50%;
     left: 50%;
     transform: translate(-50%, -50%);
-    box-shadow: 0px 4px 16px rgb(0 0 0 / 25%);
+    box-shadow: $box-shadow-simple;
   }
 }
 
@@ -434,7 +434,7 @@ button {
 
 .autocomplete-items {
   border: 0.0625rem solid #d4d4d4;
-  box-shadow: 0px 4px 16px rgba(0, 0, 0, 0.25);
+  box-shadow: $box-shadow-simple;
   box-sizing: border-box;
   border-top: none;
   border-bottom: none;